@zenithbuild/runtime 0.2.1 → 0.5.0-beta.2.12

package/dist/index.js

@@ -1,505 +1,4 @@
-// Zenith Runtime
-// Ported from hydration_runtime.js
-// Internal reactivity state
-let cE = null;
-let cS = [];
-let bD = 0;
-let isFlushing = false;
-let flushScheduled = false;
-const pE = new Set();
-// Lifecycle State
-let isMounted = false;
-const unmountCallbacks = new Set();
-// Public Reactivity Utilities
-export const trackDependency = (s) => { if (cE) {
-    s.add(cE);
-    cE.dependencies.add(s);
-} };
-export const notifySubscribers = (s) => {
-    if (!s)
-        return;
-    const es = Array.from(s);
-    for (const e of es) {
-        if (e.isRunning)
-            continue;
-        if (bD > 0 || isFlushing)
-            pE.add(e);
-        else
-            e.run();
-    }
-};
-export const getCurrentContext = () => cE;
-export const pushContext = (e) => { cS.push(cE); cE = e; };
-export const popContext = () => { cE = cS.pop(); };
-export const cleanupContext = (e) => { for (const d of e.dependencies)
-    d.delete(e); e.dependencies.clear(); };
-export const startBatch = () => { bD++; };
-export const endBatch = () => { bD--; if (bD === 0)
-    flushEffects(); };
-export const isBatching = () => bD > 0;
-export const runUntracked = (fn) => {
-    pushContext(null);
-    try {
-        return fn();
-    }
-    finally {
-        popContext();
-    }
-};
-// Public Lifecycle Utilities
-export const triggerMount = () => { isMounted = true; };
-export const triggerUnmount = () => {
-    isMounted = false;
-    executeUnmountCallbacks();
-};
-export const executeUnmountCallbacks = () => {
-    for (const cb of unmountCallbacks) {
-        try {
-            cb();
-        }
-        catch (e) {
-            console.error('Error in unmount callback:', e);
-        }
-    }
-    unmountCallbacks.clear();
-};
-export const getIsMounted = () => isMounted;
-export const getUnmountCallbackCount = () => unmountCallbacks.size;
-export const resetMountState = () => { isMounted = false; };
-export const resetUnmountState = () => { unmountCallbacks.clear(); };
-if (typeof window !== 'undefined') {
-    window.__ZENITH_EXPRESSIONS__ = new Map();
-    window.__ZENITH_SCOPES__ = {};
-}
-// Phase A3: Post-Mount Execution Hook
-const mountedScopes = new Set();
-export function mountComponent(scopeId) {
-    if (mountedScopes.has(scopeId))
-        return;
-    mountedScopes.add(scopeId);
-    const scope = window.__ZENITH_SCOPES__[scopeId];
-    if (!scope)
-        return;
-    if (typeof scope.__run === 'function') {
-        scope.__run();
-    }
-}
-// Internal shorthand helpers (matching original compiled code requirements if any)
-const pC = pushContext;
-const oC = popContext;
-const tD = trackDependency;
-const nS = notifySubscribers;
-const cEf = cleanupContext;
-export function zenRoute() {
-    if (typeof window === 'undefined')
-        return { path: '/', slugs: [] };
-    const path = window.location.pathname;
-    return {
-        path: path,
-        slugs: path.split('/').filter(Boolean)
-    };
-}
-function scheduleFlush() {
-    if (flushScheduled)
-        return;
-    flushScheduled = true;
-    queueMicrotask(() => {
-        flushScheduled = false;
-        flushEffects();
-    });
-}
-function flushEffects() {
-    if (isFlushing || bD > 0)
-        return;
-    isFlushing = true;
-    try {
-        while (pE.size > 0) {
-            const efs = Array.from(pE);
-            pE.clear();
-            for (const e of efs) {
-                if (!e.isRunning)
-                    e.run();
-            }
-        }
-    }
-    finally {
-        isFlushing = false;
-    }
-}
-export const signal = function (v) {
-    const s = new Set();
-    function sig(nV) {
-        if (arguments.length === 0) {
-            tD(s);
-            return v;
-        }
-        if (nV !== v) {
-            v = nV;
-            nS(s);
-            scheduleFlush();
-        }
-        return v;
-    }
-    sig._isSignal = true;
-    sig.toString = () => String(v);
-    sig.valueOf = () => v;
-    return sig;
-};
-export const state = function (o) {
-    const subs = new Map();
-    function gS(p) { if (!subs.has(p))
-        subs.set(p, new Set()); return subs.get(p); }
-    function notify(p) { nS(gS(p)); scheduleFlush(); }
-    function subscribe(p, ef) { gS(p).add(ef); ef.dependencies.add(gS(p)); }
-    function cP(obj, pPath = '') {
-        if (obj === null || typeof obj !== 'object' || obj._isSignal)
-            return obj;
-        return new Proxy(obj, {
-            get(t, p) {
-                if (p === Symbol.for('zenith_notify'))
-                    return notify;
-                if (p === Symbol.for('zenith_subscribe'))
-                    return subscribe;
-                if (typeof p === 'symbol')
-                    return t[p];
-                const path = pPath ? `${pPath}.${String(p)}` : String(p);
-                tD(gS(path));
-                const v = t[p];
-                if (v !== null && typeof v === 'object' && !v._isSignal)
-                    return cP(v, path);
-                return v;
-            },
-            set(t, p, nV) {
-                if (typeof p === 'symbol') {
-                    t[p] = nV;
-                    return true;
-                }
-                const path = pPath ? `${pPath}.${String(p)}` : String(p);
-                const oV = t[p];
-                if (oV && typeof oV === 'function' && oV._isSignal)
-                    oV(nV);
-                else if (oV !== nV) {
-                    t[p] = nV;
-                    nS(gS(path));
-                    const pts = path.split('.');
-                    for (let i = pts.length - 1; i >= 0; i--) {
-                        const pp = pts.slice(0, i).join('.');
-                        if (pp)
-                            nS(gS(pp));
-                    }
-                    scheduleFlush();
-                }
-                return true;
-            }
-        });
-    }
-    return cP(o);
-};
-export const effect = function (fn, opts = {}) {
-    let cl, tm;
-    const ef = {
-        dependencies: new Set(),
-        isRunning: false,
-        run: () => {
-            if (ef.isRunning)
-                return;
-            const schedule = opts.scheduler || ((f) => f());
-            if (opts.debounce) {
-                if (tm)
-                    clearTimeout(tm);
-                tm = setTimeout(() => schedule(ex), opts.debounce);
-            }
-            else
-                schedule(ex);
-        }
-    };
-    function ex() {
-        if (ef.isRunning)
-            return;
-        ef.isRunning = true;
-        cEf(ef);
-        pC(ef);
-        try {
-            if (cl)
-                cl();
-            cl = fn();
-        }
-        finally {
-            oC();
-            ef.isRunning = false;
-        }
-    }
-    if (!opts.defer)
-        ex();
-    return () => { cEf(ef); if (cl)
-        cl(); };
-};
-export const memo = function (fn) {
-    const sig = signal(undefined);
-    effect(() => sig(fn()));
-    const m = () => sig();
-    m._isSignal = true;
-    return m;
-};
-export const batch = function (fn) {
-    startBatch();
-    try {
-        fn();
-    }
-    finally {
-        endBatch();
-    }
-};
-export const untrack = function (fn) {
-    return runUntracked(fn);
-};
-export const ref = (i) => ({ current: i || null });
-export const onMount = (cb) => {
-    if (typeof window !== 'undefined' && window.__zenith && window.__zenith.activeInstance) {
-        window.__zenith.activeInstance.mountHooks.push(cb);
-    }
-    else {
-        // Fallback for non-component context or SSR
-        if (isMounted)
-            cb();
-    }
-};
-export const onUnmount = (cb) => {
-    unmountCallbacks.add(cb);
-};
-// DOM Helper (hC)
-function hC(parent, child) {
-    if (child == null || child === false)
-        return;
-    let fn = child;
-    let id = null;
-    if (typeof child === 'object' && child.fn) {
-        fn = child.fn;
-        id = child.id;
-    }
-    const isTitle = parent && parent.tagName && parent.tagName.toLowerCase() === 'title';
-    if (typeof fn === 'function') {
-        if (isTitle) {
-            const val = fn();
-            if (val != null && val !== false) {
-                const text = String(val);
-                parent.appendChild(document.createTextNode(text));
-                document.title = text;
-            }
-            effect(() => {
-                const newVal = fn();
-                if (newVal != null && newVal !== false) {
-                    const newText = String(newVal);
-                    if (document.title !== newText) {
-                        parent.textContent = newText;
-                        document.title = newText;
-                    }
-                }
-            }, { id: id ? `title-${id}` : 'title-sync' });
-        }
-        else {
-            const ph = document.createComment('expr' + (id ? ':' + id : ''));
-            parent.appendChild(ph);
-            let curNodes = [];
-            effect(() => {
-                const r = fn();
-                curNodes.forEach(n => { if (n.parentNode)
-                    n.parentNode.removeChild(n); });
-                curNodes = [];
-                if (r == null || r === false)
-                    return;
-                const items = Array.isArray(r) ? r.flat(Infinity) : [r];
-                items.forEach(item => {
-                    if (item == null || item === false)
-                        return;
-                    const node = item instanceof Node ? item : document.createTextNode(String(item));
-                    if (ph.parentNode) {
-                        ph.parentNode.insertBefore(node, ph);
-                        curNodes.push(node);
-                    }
-                });
-            }, { id });
-        }
-    }
-    else if (Array.isArray(child)) {
-        child.flat(Infinity).forEach(c => hC(parent, c));
-    }
-    else {
-        parent.appendChild(child instanceof Node ? child : document.createTextNode(String(child)));
-    }
-}
-// Global Hydration
-export function hydrate(state, container = document, locals = {}) {
-    const ir = window.canonicalIR;
-    if (!ir)
-        return;
-    window.__ZENITH_STATE__ = state;
-    const rootScope = { state, props: {}, locals: locals };
-    const nodes = ir(rootScope);
-    function findTag(items, tag) {
-        const list = Array.isArray(items) ? items : [items];
-        for (const item of list) {
-            if (item instanceof Element && item.tagName.toLowerCase() === tag)
-                return item;
-            if (item instanceof DocumentFragment) {
-                const found = findTag(Array.from(item.childNodes), tag);
-                if (found)
-                    return found;
-            }
-        }
-        return null;
-    }
-    const headNode = findTag(nodes, 'head');
-    const bodyNode = findTag(nodes, 'body');
-    if (headNode) {
-        const headMount = document.head;
-        const newTitle = headNode.querySelector('title');
-        if (newTitle) {
-            let oldTitle = headMount.querySelector('title');
-            if (!oldTitle) {
-                oldTitle = document.createElement('title');
-                headMount.appendChild(oldTitle);
-            }
-            const titleContent = newTitle.childNodes.length > 0
-                ? Array.from(newTitle.childNodes).map((n) => n.textContent).join('')
-                : '';
-            oldTitle.textContent = titleContent;
-            document.title = titleContent;
-            effect(() => {
-                const text = oldTitle.textContent?.trim();
-                if (text && document.title !== text) {
-                    document.title = text;
-                }
-            }, { id: 'title-sync' });
-        }
-        headNode.querySelectorAll('meta').forEach((newMeta) => {
-            const name = newMeta.getAttribute('name');
-            if (name) {
-                const oldMeta = headMount.querySelector(`meta[name="${name}"]`);
-                if (oldMeta)
-                    oldMeta.setAttribute('content', newMeta.getAttribute('content'));
-                else
-                    headMount.appendChild(newMeta.cloneNode(true));
-            }
-        });
-        headNode.childNodes.forEach((n) => {
-            if (n.tagName === 'TITLE' || n.tagName === 'META')
-                return;
-            headMount.appendChild(n.cloneNode(true));
-        });
-    }
-    const bodyMount = container === document ? document.body : container;
-    if (bodyNode) {
-        bodyMount.innerHTML = '';
-        Array.from(bodyNode.childNodes).forEach(n => hC(bodyMount, n));
-    }
-    else {
-        bodyMount.innerHTML = '';
-        const items = Array.isArray(nodes) ? nodes : [nodes];
-        items.forEach(n => hC(bodyMount, n));
-    }
-    for (const scopeId in window.__ZENITH_SCOPES__) {
-        mountComponent(scopeId);
-    }
-    queueMicrotask(() => {
-        flushEffects();
-        const titleEl = document.querySelector('title');
-        if (titleEl && titleEl.textContent) {
-            const text = titleEl.textContent.trim();
-            if (text && document.title !== text) {
-                document.title = text;
-            }
-        }
-    });
-}
-// Ordered Effects
-export function order(fn) {
-    if (typeof fn === 'function')
-        fn();
-}
-// Hyperscript
-let currentNamespace = null;
-export function h(tag, props, children) {
-    const SVG_NS = 'http://www.w3.org/2000/svg';
-    const SVG_TAGS = new Set(['svg', 'path', 'circle', 'ellipse', 'line', 'polygon', 'polyline', 'rect', 'g', 'defs', 'clipPath', 'mask', 'use', 'symbol', 'text', 'tspan', 'textPath', 'image', 'foreignObject', 'switch', 'desc', 'title', 'metadata', 'linearGradient', 'radialGradient', 'stop', 'pattern', 'filter', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feFlood', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'feSpecularLighting', 'feTile', 'feTurbulence', 'animate', 'animateMotion', 'animateTransform', 'set', 'marker']);
-    const isSvgTag = SVG_TAGS.has(tag) || SVG_TAGS.has(tag.toLowerCase());
-    const useSvgNamespace = isSvgTag || currentNamespace === SVG_NS;
-    const el = useSvgNamespace ? document.createElementNS(SVG_NS, tag) : document.createElement(tag);
-    const previousNamespace = currentNamespace;
-    if (tag === 'svg' || tag === 'SVG') {
-        currentNamespace = SVG_NS;
-    }
-    if (props) {
-        const setClass = (element, value) => {
-            if (useSvgNamespace && 'className' in element && typeof element.className === 'object') {
-                element.className.baseVal = String(value || '');
-            }
-            else {
-                element.className = String(value || '');
-            }
-        };
-        for (const [k, v] of Object.entries(props)) {
-            if (k === 'ref') {
-                if (v && typeof v === 'object' && 'current' in v)
-                    v.current = el;
-                else if (typeof v === 'string') {
-                    const s = window.__ZENITH_STATE__;
-                    if (s && s[v] && typeof s[v] === 'object' && 'current' in s[v])
-                        s[v].current = el;
-                }
-            }
-            else if (k.startsWith('on')) {
-                let fn = v;
-                if (v && typeof v === 'object' && v.fn)
-                    fn = v.fn;
-                if (typeof fn === 'function') {
-                    el.addEventListener(k.slice(2).toLowerCase(), (e) => {
-                        const h = fn.call(el, e, el);
-                        if (typeof h === 'function')
-                            h.call(el, e, el);
-                    });
-                }
-            }
-            else {
-                let fn = v;
-                let id = null;
-                if (typeof v === 'object' && v.fn) {
-                    fn = v.fn;
-                    id = v.id;
-                }
-                if (typeof fn === 'function') {
-                    effect(() => {
-                        const val = fn();
-                        if (k === 'class' || k === 'className')
-                            setClass(el, val);
-                        else if (val == null || val === false)
-                            el.removeAttribute(k);
-                        else if (el.setAttribute)
-                            el.setAttribute(k, String(val));
-                    }, { id });
-                }
-                else {
-                    if (k === 'class' || k === 'className')
-                        setClass(el, v);
-                    else if (el.setAttribute)
-                        el.setAttribute(k, String(v));
-                }
-            }
-        }
-    }
-    if (children) {
-        const items = Array.isArray(children) ? children : [children];
-        items.forEach(c => hC(el, c));
-    }
-    currentNamespace = previousNamespace;
-    return el;
-}
-export function fragment(c) {
-    const f = document.createDocumentFragment();
-    const items = Array.isArray(c) ? c : [c];
-    items.forEach(i => hC(f, i));
-    return f;
-}
-export * from './dom-hydration.js';
-export * from './thin-runtime.js';
-//# sourceMappingURL=index.js.map
+export { signal } from './signal.js';
+export { state } from './state.js';
+export { zeneffect } from './zeneffect.js';
+export { hydrate } from './hydrate.js';

package/dist/ref.js

@@ -0,0 +1,23 @@
+// ---------------------------------------------------------------------------
+// ref.js — Zenith Runtime ref primitive
+// ---------------------------------------------------------------------------
+// A structural DOM pointer. NOT reactive.
+// ref.current is a plain property — no tracking, no proxies, no subscriptions.
+//
+// Contract:
+//   - ref() returns { current: null }
+//   - ref(initialValue) returns { current: initialValue }
+//   - .current is assigned by runtime at mount, before zenMount callbacks run
+//   - .current is set to null on component disposal
+//   - Reading .current does NOT register a dependency in zenEffect
+
+/**
+ * Create a deterministic ref for structural DOM binding.
+ *
+ * @template T
+ * @param {T} [initialValue]
+ * @returns {{ current: T | null }}
+ */
+export function ref(initialValue) {
+    return { current: initialValue ?? null };
+}

package/dist/runtime.js

@@ -0,0 +1,57 @@
+// ---------------------------------------------------------------------------
+// runtime.js — Zenith Runtime V0
+// ---------------------------------------------------------------------------
+// Backward-compatible mount wrapper around explicit hydrate(payload).
+// ---------------------------------------------------------------------------
+
+import { hydrate } from './hydrate.js';
+import { cleanup } from './cleanup.js';
+
+/**
+ * Mount a page module that already contains deterministic binding tables.
+ *
+ * @param {HTMLElement} container
+ * @param {object | function} pageModule
+ * @returns {() => void}
+ */
+export function mount(container, pageModule) {
+    if (!container || typeof container.querySelectorAll !== 'function') {
+        throw new Error('[Zenith Runtime] mount(container, pageModule) requires a DOM container');
+    }
+
+    const pageFactory = _resolvePageFactory(pageModule);
+    if (!pageFactory) {
+        throw new Error('[Zenith Runtime] mount(container, pageModule) requires default() or __zenith_page()');
+    }
+
+    const page = pageFactory();
+    if (!page || typeof page.html !== 'string') {
+        throw new Error('[Zenith Runtime] __zenith_page() must return an object with html');
+    }
+
+    container.innerHTML = page.html;
+
+    hydrate({
+        root: container,
+        ir_version: page.ir_version,
+        expressions: Array.isArray(page.expressions) ? page.expressions : [],
+        markers: Array.isArray(page.markers) ? page.markers : [],
+        events: Array.isArray(page.events) ? page.events : [],
+        state_values: Array.isArray(page.state_values) ? page.state_values : [],
+        signals: Array.isArray(page.signals) ? page.signals : [],
+        components: Array.isArray(page.components) ? page.components : []
+    });
+
+    return function unmount() {
+        cleanup();
+        container.innerHTML = '';
+    };
+}
+
+function _resolvePageFactory(pageModule) {
+    if (typeof pageModule === 'function') return pageModule;
+    if (!pageModule || typeof pageModule !== 'object') return null;
+    if (typeof pageModule.default === 'function') return pageModule.default;
+    if (typeof pageModule.__zenith_page === 'function') return pageModule.__zenith_page;
+    return null;
+}

package/dist/signal.js

@@ -0,0 +1,58 @@
+// ---------------------------------------------------------------------------
+// signal.js — Zenith Runtime V0
+// ---------------------------------------------------------------------------
+// Minimal explicit signal primitive.
+//
+// API:
+//   const count = signal(0);
+//   count.get();
+//   count.set(1);
+//   const unsubscribe = count.subscribe((value) => { ... });
+//
+// Constraints:
+//   - No proxy
+//   - No implicit dependency tracking
+//   - No scheduler
+//   - No async queue
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a deterministic signal with explicit subscription semantics.
+ *
+ * @param {*} initialValue
+ * @returns {{ get: () => *, set: (next: *) => *, subscribe: (fn: (value: *) => void) => () => void }}
+ */
+export function signal(initialValue) {
+    let value = initialValue;
+    const subscribers = new Set();
+
+    return {
+        get() {
+            return value;
+        },
+        set(nextValue) {
+            if (Object.is(value, nextValue)) {
+                return value;
+            }
+
+            value = nextValue;
+
+            const snapshot = [...subscribers];
+            for (let i = 0; i < snapshot.length; i++) {
+                snapshot[i](value);
+            }
+
+            return value;
+        },
+        subscribe(fn) {
+            if (typeof fn !== 'function') {
+                throw new Error('[Zenith Runtime] signal.subscribe(fn) requires a function');
+            }
+
+            subscribers.add(fn);
+            return function unsubscribe() {
+                subscribers.delete(fn);
+            };
+        }
+    };
+}