494 lines
14 KiB
JavaScript
494 lines
14 KiB
JavaScript
// sigpro 1.2.0
|
|
const isFunc = f => typeof f === "function"
|
|
const isObj = o => o && typeof o === "object"
|
|
const isArr = Array.isArray
|
|
const doc = typeof document !== "undefined" ? document : null
|
|
const ensureNode = n => n?._isRuntime ? n.container : (n instanceof Node ? n : doc.createTextNode(n == null ? "" : String(n)))
|
|
|
|
let activeEffect = null
|
|
let activeOwner = null
|
|
let isFlushing = false
|
|
const effectQueue = new Set()
|
|
const MOUNTED_NODES = new WeakMap()
|
|
|
|
// effect cleanup
|
|
const dispose = eff => {
|
|
if (!eff || eff._disposed) return
|
|
eff._disposed = true
|
|
const stack = [eff]
|
|
while (stack.length) {
|
|
const e = stack.pop()
|
|
if (e._cleanups) {
|
|
e._cleanups.forEach(fn => fn())
|
|
e._cleanups.clear()
|
|
}
|
|
if (e._children) {
|
|
e._children.forEach(child => stack.push(child))
|
|
e._children.clear()
|
|
}
|
|
if (e._deps) {
|
|
e._deps.forEach(depSet => depSet.delete(e))
|
|
e._deps.clear()
|
|
}
|
|
}
|
|
}
|
|
|
|
// helpers
|
|
const onMount = fn => {
|
|
if (activeOwner) (activeOwner._mounts ||= []).push(fn)
|
|
}
|
|
|
|
const onUnmount = fn => {
|
|
if (activeOwner) (activeOwner._cleanups ||= new Set()).add(fn)
|
|
}
|
|
|
|
const set = (signal, path, value) => {
|
|
if (value === undefined) return signal(isFunc(path) ? path(signal()) : path)
|
|
const keys = path.split('.'), root = { ...signal() }
|
|
let acc = root, k
|
|
for (k of keys.slice(0, -1)) acc = acc[k] = { ...(acc[k] || {}) }
|
|
acc[keys.at(-1)] = value
|
|
signal(root)
|
|
}
|
|
|
|
const untrack = fn => {
|
|
const p = activeEffect
|
|
activeEffect = null
|
|
try { return fn() } finally { activeEffect = p }
|
|
}
|
|
|
|
// effect creation
|
|
const createEffect = (fn, isComputed = false) => {
|
|
const effect = () => {
|
|
if (effect._disposed) return
|
|
if (effect._deps) effect._deps.forEach(s => s.delete(effect))
|
|
if (effect._cleanups) {
|
|
effect._cleanups.forEach(c => c())
|
|
effect._cleanups.clear()
|
|
}
|
|
const prevEffect = activeEffect
|
|
const prevOwner = activeOwner
|
|
activeEffect = activeOwner = effect
|
|
try {
|
|
return effect._result = fn()
|
|
} catch (e) {
|
|
console.error("[SigPro]", e)
|
|
} finally {
|
|
activeEffect = prevEffect
|
|
activeOwner = prevOwner
|
|
}
|
|
}
|
|
effect._deps = effect._cleanups = effect._children = null
|
|
effect._disposed = false
|
|
effect._isComputed = isComputed
|
|
effect._depth = activeEffect ? activeEffect._depth + 1 : 0
|
|
effect._mounts = []
|
|
effect._parent = activeOwner
|
|
if (activeOwner) (activeOwner._children ||= new Set()).add(effect)
|
|
return effect
|
|
}
|
|
|
|
const flush = () => {
|
|
if (isFlushing) return
|
|
isFlushing = true
|
|
const sorted = Array.from(effectQueue).sort((a, b) => a._depth - b._depth)
|
|
effectQueue.clear()
|
|
for (const e of sorted) if (!e._disposed) e()
|
|
isFlushing = false
|
|
}
|
|
|
|
const trackUpdate = (subs, trigger = false) => {
|
|
if (!trigger && activeEffect && !activeEffect._disposed) {
|
|
subs.add(activeEffect)
|
|
; (activeEffect._deps ||= new Set()).add(subs)
|
|
} else if (trigger) {
|
|
let hasQueue = false
|
|
subs.forEach(e => {
|
|
if (e === activeEffect || e._disposed) return
|
|
if (e._isComputed) {
|
|
e._dirty = true
|
|
if (e._subs) trackUpdate(e._subs, true)
|
|
} else {
|
|
effectQueue.add(e)
|
|
hasQueue = true
|
|
}
|
|
})
|
|
if (hasQueue && !isFlushing) queueMicrotask(flush)
|
|
}
|
|
}
|
|
|
|
// signal creation
|
|
const $ = (val, key = null) => {
|
|
const subs = new Set()
|
|
if (isFunc(val)) {
|
|
let cache, dirty = true
|
|
const computed = () => {
|
|
if (dirty) {
|
|
const prev = activeEffect
|
|
activeEffect = computed
|
|
try {
|
|
const next = val()
|
|
if (!Object.is(cache, next)) {
|
|
cache = next
|
|
dirty = false
|
|
trackUpdate(subs, true)
|
|
}
|
|
} finally { activeEffect = prev }
|
|
}
|
|
trackUpdate(subs)
|
|
return cache
|
|
}
|
|
computed._isComputed = true
|
|
computed._subs = subs
|
|
computed._dirty = true
|
|
computed._deps = null
|
|
computed._disposed = false
|
|
computed.markDirty = () => { dirty = true }
|
|
computed.stop = () => {
|
|
computed._disposed = true
|
|
if (computed._deps) {
|
|
computed._deps.forEach(depSet => depSet.delete(computed))
|
|
computed._deps.clear()
|
|
}
|
|
subs.clear()
|
|
}
|
|
if (activeOwner) onUnmount(computed.stop)
|
|
return computed
|
|
}
|
|
if (key) try { val = JSON.parse(localStorage.getItem(key)) ?? val } catch (e) { }
|
|
return (...args) => {
|
|
if (args.length) {
|
|
const next = isFunc(args[0]) ? args[0](val) : args[0]
|
|
if (!Object.is(val, next)) {
|
|
val = next
|
|
if (key) localStorage.setItem(key, JSON.stringify(val))
|
|
trackUpdate(subs, true)
|
|
}
|
|
}
|
|
trackUpdate(subs)
|
|
return val
|
|
}
|
|
}
|
|
|
|
// create Watch
|
|
const Watch = (sources, cb) => {
|
|
if (cb === undefined) {
|
|
const effect = createEffect(sources)
|
|
effect()
|
|
return () => dispose(effect)
|
|
}
|
|
const effect = createEffect(() => {
|
|
const vals = Array.isArray(sources) ? sources.map(s => s()) : sources()
|
|
untrack(() => cb(vals))
|
|
})
|
|
effect()
|
|
return () => dispose(effect)
|
|
}
|
|
|
|
const cleanupNode = node => {
|
|
if (node._cleanups) {
|
|
node._cleanups.forEach(fn => fn())
|
|
node._cleanups.clear()
|
|
}
|
|
if (node._ownerEffect) dispose(node._ownerEffect)
|
|
if (node.childNodes) node.childNodes.forEach(cleanupNode)
|
|
}
|
|
|
|
const DANGEROUS_PROTOCOL = /^\s*(javascript|data|vbscript):/i
|
|
const isDangerousAttr = key => key === 'src' || key === 'href' || key.startsWith('on')
|
|
|
|
const validateAttr = (key, val) => {
|
|
if (val == null || val === false) return null
|
|
if (isDangerousAttr(key)) {
|
|
const sVal = String(val)
|
|
if (DANGEROUS_PROTOCOL.test(sVal)) {
|
|
console.warn(`[SigPro] Bloqueado protocolo peligroso en ${key}`)
|
|
return '#'
|
|
}
|
|
}
|
|
return val
|
|
}
|
|
|
|
// create Tag
|
|
const Tag = (tag, props = {}, children = []) => {
|
|
if (props instanceof Node || isArr(props) || !isObj(props)) {
|
|
children = props
|
|
props = {}
|
|
}
|
|
if (isFunc(tag)) {
|
|
const ctx = { _mounts: [], _cleanups: new Set() }
|
|
const effect = createEffect(() => {
|
|
const result = tag(props, {
|
|
children,
|
|
emit: (ev, ...args) => props[`on${ev[0].toUpperCase()}${ev.slice(1)}`]?.(...args)
|
|
})
|
|
effect._result = result
|
|
return result
|
|
})
|
|
effect()
|
|
|
|
const result = effect._result
|
|
if (result == null) return null
|
|
|
|
const node = (result instanceof Node || (isArr(result) && result.every(n => n instanceof Node)))
|
|
? result
|
|
: doc.createTextNode(String(result))
|
|
|
|
const attach = n => {
|
|
if (isObj(n) && !n._isRuntime) {
|
|
n._mounts = effect._mounts || []
|
|
n._cleanups = effect._cleanups || new Set()
|
|
n._ownerEffect = effect
|
|
}
|
|
}
|
|
|
|
isArr(node) ? node.forEach(attach) : attach(node)
|
|
return node
|
|
}
|
|
const isSVG = /^(svg|path|circle|rect|line|polyline|polygon|g|defs|text|tspan|use)$/.test(tag)
|
|
const el = isSVG ? doc.createElementNS("http://www.w3.org/2000/svg", tag) : doc.createElement(tag)
|
|
el._cleanups = new Set()
|
|
|
|
for (let k in props) {
|
|
if (!props.hasOwnProperty(k)) continue
|
|
let v = props[k]
|
|
if (k === "ref") {
|
|
isFunc(v) ? v(el) : (v.current = el)
|
|
continue
|
|
}
|
|
if (k.startsWith("on")) {
|
|
const ev = k.slice(2).toLowerCase()
|
|
el.addEventListener(ev, v)
|
|
const off = () => el.removeEventListener(ev, v)
|
|
el._cleanups.add(off)
|
|
onUnmount(off)
|
|
} else if (isFunc(v)) {
|
|
const effect = createEffect(() => {
|
|
const val = validateAttr(k, v())
|
|
if (k === "class") el.className = val || ""
|
|
else if (val == null) el.removeAttribute(k)
|
|
else if (k in el && !isSVG) el[k] = val
|
|
else el.setAttribute(k, val === true ? "" : val)
|
|
})
|
|
effect()
|
|
el._cleanups.add(() => dispose(effect))
|
|
onUnmount(() => dispose(effect))
|
|
if (/^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName) && (k === "value" || k === "checked")) {
|
|
const evType = k === "checked" ? "change" : "input"
|
|
el.addEventListener(evType, ev => v(ev.target[k]))
|
|
}
|
|
} else {
|
|
const val = validateAttr(k, v)
|
|
if (val != null) {
|
|
if (k in el && !isSVG) el[k] = val
|
|
else el.setAttribute(k, val === true ? "" : val)
|
|
}
|
|
}
|
|
}
|
|
|
|
const append = c => {
|
|
if (isArr(c)) return c.forEach(append)
|
|
if (isFunc(c)) {
|
|
const anchor = doc.createTextNode("")
|
|
el.appendChild(anchor)
|
|
let currentNodes = []
|
|
const effect = createEffect(() => {
|
|
const res = c()
|
|
const next = (isArr(res) ? res : [res]).map(ensureNode)
|
|
currentNodes.forEach(n => {
|
|
if (n._isRuntime) n.destroy()
|
|
else cleanupNode(n)
|
|
if (n.parentNode) n.remove()
|
|
})
|
|
let ref = anchor
|
|
for (let i = next.length - 1; i >= 0; i--) {
|
|
const node = next[i]
|
|
if (node.parentNode !== ref.parentNode) ref.parentNode?.insertBefore(node, ref)
|
|
if (node._mounts) node._mounts.forEach(fn => fn())
|
|
ref = node
|
|
}
|
|
currentNodes = next
|
|
})
|
|
effect()
|
|
el._cleanups.add(() => dispose(effect))
|
|
onUnmount(() => dispose(effect))
|
|
} else {
|
|
const node = ensureNode(c)
|
|
el.appendChild(node)
|
|
if (node._mounts) node._mounts.forEach(fn => fn())
|
|
}
|
|
}
|
|
append(children)
|
|
return el
|
|
}
|
|
|
|
// create Render
|
|
const Render = renderFn => {
|
|
const cleanups = new Set()
|
|
const mounts = []
|
|
const previousOwner = activeOwner
|
|
const previousEffect = activeEffect
|
|
const container = doc.createElement("div")
|
|
container.style.display = "contents"
|
|
container.setAttribute("role", "presentation") // ← único cambio real
|
|
activeOwner = { _cleanups: cleanups, _mounts: mounts }
|
|
activeEffect = null
|
|
|
|
const processResult = result => {
|
|
if (!result) return
|
|
if (result._isRuntime) {
|
|
cleanups.add(result.destroy)
|
|
container.appendChild(result.container)
|
|
} else if (isArr(result)) {
|
|
result.forEach(processResult)
|
|
} else {
|
|
container.appendChild(result instanceof Node ? result : doc.createTextNode(String(result == null ? "" : result)))
|
|
}
|
|
}
|
|
|
|
try {
|
|
processResult(renderFn({ onCleanup: fn => cleanups.add(fn) }))
|
|
} finally {
|
|
activeOwner = previousOwner
|
|
activeEffect = previousEffect
|
|
}
|
|
|
|
mounts.forEach(fn => fn())
|
|
return {
|
|
_isRuntime: true,
|
|
container,
|
|
destroy: () => {
|
|
cleanups.forEach(fn => fn())
|
|
cleanupNode(container)
|
|
container.remove()
|
|
}
|
|
}
|
|
}
|
|
|
|
// create If
|
|
const If = (cond, ifYes, ifNot = null, trans = null) => {
|
|
const anchor = doc.createTextNode("")
|
|
const root = Tag("div", { style: "display:contents" }, [anchor])
|
|
let currentView = null
|
|
let last = null
|
|
let exitPromise = null
|
|
|
|
Watch(
|
|
() => !!(isFunc(cond) ? cond() : cond),
|
|
show => {
|
|
if (show === last) return
|
|
last = show
|
|
|
|
const disposeView = () => {
|
|
if (currentView) {
|
|
currentView.destroy()
|
|
currentView = null
|
|
}
|
|
}
|
|
|
|
if (currentView && !show && trans?.out) {
|
|
if (exitPromise && exitPromise.cancel) exitPromise.cancel()
|
|
const anim = trans.out(currentView.container, disposeView)
|
|
exitPromise = anim
|
|
if (anim && anim.finished) anim.finished.then(disposeView)
|
|
else disposeView()
|
|
} else {
|
|
disposeView()
|
|
}
|
|
|
|
const content = show ? ifYes : ifNot
|
|
if (content) {
|
|
currentView = Render(() => isFunc(content) ? content() : content)
|
|
root.insertBefore(currentView.container, anchor)
|
|
if (trans?.in) trans.in(currentView.container)
|
|
}
|
|
}
|
|
)
|
|
return root
|
|
}
|
|
|
|
// create For
|
|
const For = (src, itemFn, keyFn) => {
|
|
const anchor = doc.createTextNode("")
|
|
const root = Tag("div", { style: "display:contents" }, [anchor])
|
|
let cache = new Map()
|
|
Watch(() => (isFunc(src) ? src() : src) || [], items => {
|
|
const nextCache = new Map()
|
|
const nextOrder = []
|
|
const newItems = items || []
|
|
for (let i = 0; i < newItems.length; i++) {
|
|
const item = newItems[i]
|
|
const key = keyFn ? keyFn(item, i) : (item?.id ?? i)
|
|
let view = cache.get(key)
|
|
if (!view) view = Render(() => itemFn(item, i))
|
|
else cache.delete(key)
|
|
nextCache.set(key, view)
|
|
nextOrder.push(view)
|
|
}
|
|
cache.forEach(view => view.destroy())
|
|
let lastRef = anchor
|
|
for (let i = nextOrder.length - 1; i >= 0; i--) {
|
|
const view = nextOrder[i]
|
|
const node = view.container
|
|
if (node.nextSibling !== lastRef) root.insertBefore(node, lastRef)
|
|
lastRef = node
|
|
}
|
|
cache = nextCache
|
|
})
|
|
return root
|
|
}
|
|
|
|
// create Router
|
|
const Router = routes => {
|
|
const getHash = () => window.location.hash.slice(1) || "/"
|
|
const path = $(getHash())
|
|
const handler = () => path(getHash())
|
|
window.addEventListener("hashchange", handler)
|
|
onUnmount(() => window.removeEventListener("hashchange", handler))
|
|
const hook = Tag("div", { class: "router-hook" })
|
|
let currentView = null
|
|
Watch([path], () => {
|
|
const cur = path()
|
|
const route = routes.find(r => {
|
|
const p1 = r.path.split("/").filter(Boolean)
|
|
const p2 = cur.split("/").filter(Boolean)
|
|
return p1.length === p2.length && p1.every((p, i) => p[0] === ":" || p === p2[i])
|
|
}) || routes.find(r => r.path === "*")
|
|
if (route) {
|
|
currentView?.destroy()
|
|
const params = {}
|
|
route.path.split("/").filter(Boolean).forEach((p, i) => {
|
|
if (p[0] === ":") params[p.slice(1)] = cur.split("/").filter(Boolean)[i]
|
|
})
|
|
Router.params(params)
|
|
currentView = Render(() => isFunc(route.component) ? route.component(params) : route.component)
|
|
hook.replaceChildren(currentView.container)
|
|
}
|
|
})
|
|
return hook
|
|
}
|
|
Router.params = $({})
|
|
Router.to = p => window.location.hash = p.replace(/^#?\/?/, "#/")
|
|
Router.back = () => window.history.back()
|
|
Router.path = () => window.location.hash.replace(/^#/, "") || "/"
|
|
|
|
const Mount = (comp, target) => {
|
|
const t = typeof target === "string" ? doc.querySelector(target) : target
|
|
if (!t) return
|
|
if (MOUNTED_NODES.has(t)) MOUNTED_NODES.get(t).destroy()
|
|
const inst = Render(isFunc(comp) ? comp : () => comp)
|
|
t.replaceChildren(inst.container)
|
|
MOUNTED_NODES.set(t, inst)
|
|
return inst
|
|
}
|
|
|
|
const SigPro = Object.freeze({ $, Watch, Tag, Render, If, For, Router, Mount, onMount, onUnmount, set })
|
|
|
|
if (typeof window !== "undefined") {
|
|
Object.assign(window, SigPro)
|
|
"div span p h1 h2 h3 h4 h5 h6 br hr section article aside nav main header footer ul ol li a em strong pre code form label input textarea select button img svg"
|
|
.split(" ").forEach(t => window[t[0].toUpperCase() + t.slice(1)] = (p, c) => SigPro.Tag(t, p, c))
|
|
}
|
|
|
|
export { $, Watch, Tag, Render, If, For, Router, Mount, onMount, onUnmount, set }
|
|
export default SigPro |