@zenithbuild/runtime 0.7.3 → 0.7.5

package/dist/presence.js

@@ -0,0 +1,297 @@
+// @ts-nocheck
+import { zenOn } from './platform.js';
+/**
+ * @typedef {'hidden' | 'entering' | 'present' | 'exiting'} ZenPresencePhase
+ */
+function isRefLike(value) {
+    return !!value && typeof value === 'object' && 'current' in value;
+}
+function normalizeOptions(options) {
+    if (options === undefined || options === null) {
+        return {
+            timeoutMs: undefined,
+            onPhaseChange: null
+        };
+    }
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new Error('[Zenith Runtime] zenPresence(ref, options) requires an options object when provided');
+    }
+    if (options.timeoutMs !== undefined) {
+        if (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0) {
+            throw new Error('[Zenith Runtime] zenPresence options.timeoutMs must be a non-negative number');
+        }
+    }
+    if (options.onPhaseChange !== undefined && typeof options.onPhaseChange !== 'function') {
+        throw new Error('[Zenith Runtime] zenPresence options.onPhaseChange must be a function when provided');
+    }
+    return {
+        timeoutMs: options.timeoutMs === undefined ? undefined : Math.floor(options.timeoutMs),
+        onPhaseChange: typeof options.onPhaseChange === 'function' ? options.onPhaseChange : null
+    };
+}
+function parseCssTimeToken(token) {
+    const value = String(token || '').trim();
+    if (value.length === 0) {
+        return 0;
+    }
+    if (value.endsWith('ms')) {
+        const ms = Number.parseFloat(value.slice(0, -2));
+        return Number.isFinite(ms) ? Math.max(0, ms) : 0;
+    }
+    if (value.endsWith('s')) {
+        const seconds = Number.parseFloat(value.slice(0, -1));
+        return Number.isFinite(seconds) ? Math.max(0, seconds * 1000) : 0;
+    }
+    const numeric = Number.parseFloat(value);
+    return Number.isFinite(numeric) ? Math.max(0, numeric) : 0;
+}
+function parseCssTimeList(value) {
+    return String(value || '')
+        .split(',')
+        .map((token) => parseCssTimeToken(token))
+        .filter((candidate) => Number.isFinite(candidate));
+}
+function computeMaxCssTotal(durations, delays) {
+    if (!Array.isArray(durations) || durations.length === 0) {
+        return 0;
+    }
+    let maxTotal = 0;
+    for (let index = 0; index < durations.length; index += 1) {
+        const duration = durations[index] || 0;
+        const delay = Array.isArray(delays) && delays.length > 0
+            ? delays[index % delays.length] || 0
+            : 0;
+        const total = duration + delay;
+        if (total > maxTotal) {
+            maxTotal = total;
+        }
+    }
+    return maxTotal;
+}
+function resolveFallbackTimeoutMs(node, explicitTimeoutMs) {
+    if (Number.isFinite(explicitTimeoutMs)) {
+        return explicitTimeoutMs;
+    }
+    const activeWindow = node?.ownerDocument?.defaultView;
+    if (!activeWindow || typeof activeWindow.getComputedStyle !== 'function') {
+        return 34;
+    }
+    const styles = activeWindow.getComputedStyle(node);
+    const transitionTotal = computeMaxCssTotal(parseCssTimeList(styles.transitionDuration), parseCssTimeList(styles.transitionDelay));
+    const animationTotal = computeMaxCssTotal(parseCssTimeList(styles.animationDuration), parseCssTimeList(styles.animationDelay));
+    const total = Math.max(transitionTotal, animationTotal);
+    return total > 0 ? Math.ceil(total + 34) : 34;
+}
+function getTimerApi(node) {
+    const activeWindow = node?.ownerDocument?.defaultView;
+    if (activeWindow && typeof activeWindow.setTimeout === 'function' && typeof activeWindow.clearTimeout === 'function') {
+        return {
+            setTimeout: activeWindow.setTimeout.bind(activeWindow),
+            clearTimeout: activeWindow.clearTimeout.bind(activeWindow)
+        };
+    }
+    return {
+        setTimeout: globalThis.setTimeout.bind(globalThis),
+        clearTimeout: globalThis.clearTimeout.bind(globalThis)
+    };
+}
+function isOwnedEvent(event, node) {
+    return !!event && event.target === node;
+}
+/**
+ * Ref-owned presence controller for always-mounted nodes.
+ *
+ * Canonical pattern:
+ * - create once per ref
+ * - call `presence.mount()` inside `zenMount`
+ * - drive `presence.setPresent(next)` from reactive state
+ *
+ * @template {Element} T
+ * @param {{ current?: T | null }} ref
+ * @param {{ timeoutMs?: number, onPhaseChange?: ((phase: ZenPresencePhase, context: { node: T | null, previousPhase: ZenPresencePhase | null, present: boolean }) => void) } | null | undefined} [options]
+ * @returns {{
+ *   mount: () => () => void,
+ *   destroy: () => void,
+ *   getPhase: () => ZenPresencePhase,
+ *   setPresent: (nextPresent: boolean) => void
+ * }}
+ */
+export function zenPresence(ref, options = null) {
+    if (!isRefLike(ref)) {
+        throw new Error('[Zenith Runtime] zenPresence(ref, options) requires a ref-like object with current');
+    }
+    const normalizedOptions = normalizeOptions(options);
+    let desiredPresent = false;
+    /** @type {ZenPresencePhase} */
+    let currentPhase = 'hidden';
+    let mounted = false;
+    let mountEpoch = 0;
+    let pendingCompletion = null;
+    function getNode() {
+        const candidate = ref.current;
+        if (!candidate || typeof candidate !== 'object' || typeof candidate.nodeType !== 'number') {
+            return null;
+        }
+        return candidate;
+    }
+    function notifyPhaseChange(previousPhase) {
+        if (typeof normalizedOptions.onPhaseChange !== 'function') {
+            return;
+        }
+        normalizedOptions.onPhaseChange(currentPhase, {
+            node: getNode(),
+            previousPhase,
+            present: desiredPresent
+        });
+    }
+    function applyPhaseToNode() {
+        const node = getNode();
+        if (!node) {
+            return;
+        }
+        node.setAttribute('data-zen-presence', currentPhase);
+    }
+    function setPhase(nextPhase, forceApply = false) {
+        const previousPhase = currentPhase;
+        const changed = previousPhase !== nextPhase;
+        if (!changed && !forceApply) {
+            return;
+        }
+        currentPhase = nextPhase;
+        applyPhaseToNode();
+        if (changed) {
+            notifyPhaseChange(previousPhase);
+        }
+    }
+    function cancelPendingCompletion() {
+        if (!pendingCompletion) {
+            return;
+        }
+        pendingCompletion.cancel();
+        pendingCompletion = null;
+    }
+    function scheduleCompletion(targetPhase, node) {
+        cancelPendingCompletion();
+        if (!mounted || !node) {
+            setPhase(targetPhase);
+            return;
+        }
+        const timerApi = getTimerApi(node);
+        const timeoutMs = resolveFallbackTimeoutMs(node, normalizedOptions.timeoutMs);
+        const disposers = [];
+        let settled = false;
+        let timeoutId = null;
+        const settle = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            while (disposers.length > 0) {
+                const dispose = disposers.pop();
+                try {
+                    dispose();
+                }
+                catch {
+                }
+            }
+            if (timeoutId !== null) {
+                timerApi.clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            pendingCompletion = null;
+            setPhase(targetPhase);
+        };
+        const handleEnd = (event) => {
+            if (!isOwnedEvent(event, node)) {
+                return;
+            }
+            settle();
+        };
+        disposers.push(zenOn(node, 'transitionend', handleEnd));
+        disposers.push(zenOn(node, 'animationend', handleEnd));
+        timeoutId = timerApi.setTimeout(settle, timeoutMs);
+        pendingCompletion = {
+            cancel() {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                while (disposers.length > 0) {
+                    const dispose = disposers.pop();
+                    try {
+                        dispose();
+                    }
+                    catch {
+                    }
+                }
+                if (timeoutId !== null) {
+                    timerApi.clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+            }
+        };
+    }
+    function reconcile() {
+        if (!mounted) {
+            return;
+        }
+        const node = getNode();
+        if (!node) {
+            cancelPendingCompletion();
+            return;
+        }
+        if (desiredPresent) {
+            if (currentPhase === 'entering' || currentPhase === 'present') {
+                return;
+            }
+            setPhase('entering');
+            scheduleCompletion('present', node);
+            return;
+        }
+        if (currentPhase === 'hidden' || currentPhase === 'exiting') {
+            return;
+        }
+        setPhase('exiting');
+        scheduleCompletion('hidden', node);
+    }
+    function destroyCurrentMount() {
+        mounted = false;
+        cancelPendingCompletion();
+        currentPhase = 'hidden';
+        const node = getNode();
+        if (node) {
+            node.removeAttribute('data-zen-presence');
+        }
+    }
+    return {
+        mount() {
+            mountEpoch += 1;
+            const activeMount = mountEpoch;
+            mounted = true;
+            setPhase(currentPhase, true);
+            reconcile();
+            return () => {
+                if (activeMount !== mountEpoch) {
+                    return;
+                }
+                destroyCurrentMount();
+            };
+        },
+        destroy() {
+            mountEpoch += 1;
+            destroyCurrentMount();
+        },
+        getPhase() {
+            return currentPhase;
+        },
+        setPresent(nextPresent) {
+            desiredPresent = nextPresent === true;
+            reconcile();
+        }
+    };
+}
+/**
+ * @alias zenPresence
+ * @description Optional secondary alias for the canonical zenPresence helper.
+ */
+export const presence = zenPresence;

package/dist/reactivity-core.d.ts

@@ -0,0 +1,3 @@
+export declare function _nextReactiveId(): number;
+export declare function _trackDependency(source: any): void;
+export declare function runWithDependencyCollector(collector: any, callback: any): any;

package/dist/reactivity-core.js

@@ -0,0 +1,22 @@
+// @ts-nocheck
+let _activeDependencyCollector = null;
+let _reactiveIdCounter = 0;
+export function _nextReactiveId() {
+    _reactiveIdCounter += 1;
+    return _reactiveIdCounter;
+}
+export function _trackDependency(source) {
+    if (typeof _activeDependencyCollector === 'function') {
+        _activeDependencyCollector(source);
+    }
+}
+export function runWithDependencyCollector(collector, callback) {
+    const previousCollector = _activeDependencyCollector;
+    _activeDependencyCollector = typeof collector === 'function' ? collector : null;
+    try {
+        return callback();
+    }
+    finally {
+        _activeDependencyCollector = previousCollector;
+    }
+}

package/dist/render.d.ts

@@ -0,0 +1,3 @@
+export function _applyMarkerValue(nodes: any, marker: any, value: any): void;
+export function _createContextualFragment(parent: any, html: any): any;
+export function _coerceText(value: any, path?: string): string;

package/dist/render.js

@@ -0,0 +1,340 @@
+import { rethrowZenithRuntimeError, throwZenithRuntimeError, DOCS_LINKS } from './diagnostics.js';
+import { createFragmentRegion } from './fragment-patch.js';
+import { _isHtmlFragment } from './markup.js';
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+const BOOLEAN_ATTRIBUTES = new Set([
+    'disabled', 'checked', 'selected', 'readonly', 'multiple',
+    'hidden', 'autofocus', 'required', 'open'
+]);
+export function _applyMarkerValue(nodes, marker, value) {
+    const markerPath = `marker[${marker.index}]`;
+    for (let i = 0; i < nodes.length; i++) {
+        try {
+            const node = nodes[i];
+            if (marker.kind === 'text') {
+                if (node && node.nodeType === 8) {
+                    _applyCommentMarkerValue(node, value, `${markerPath}.text`);
+                    continue;
+                }
+                if (_isStructuralFragment(value)) {
+                    _mountStructuralFragment(node, value, `${markerPath}.text`);
+                    continue;
+                }
+                const html = _renderFragmentValue(value, `${markerPath}.text`);
+                if (html !== null) {
+                    node.innerHTML = html;
+                }
+                else {
+                    node.textContent = _coerceText(value, `${markerPath}.text`);
+                }
+                continue;
+            }
+            if (marker.kind === 'attr') {
+                _applyAttribute(node, marker.attr, value);
+            }
+        }
+        catch (error) {
+            rethrowZenithRuntimeError(error, {
+                phase: 'bind',
+                code: 'BINDING_APPLY_FAILED',
+                message: `Failed to apply ${marker.kind} binding at marker ${marker.index}`,
+                marker: {
+                    type: marker.kind === 'attr' ? `attr:${marker.attr}` : marker.kind,
+                    id: marker.index
+                },
+                path: marker.kind === 'attr'
+                    ? `${markerPath}.attr.${marker.attr}`
+                    : `${markerPath}.${marker.kind}`,
+                hint: 'Check the binding value type and marker mapping.',
+                docsLink: DOCS_LINKS.markerTable,
+                source: marker.source
+            });
+        }
+    }
+}
+function _applyCommentMarkerValue(anchor, value, rootPath) {
+    if (_isStructuralFragment(value)) {
+        _mountStructuralFragmentIntoCommentRange(anchor, value, rootPath);
+        return;
+    }
+    const end = _clearCommentPlaceholderContent(anchor);
+    const parent = end.parentNode;
+    if (!parent) {
+        return;
+    }
+    const html = _renderFragmentValue(value, rootPath);
+    if (html !== null) {
+        parent.insertBefore(_createContextualFragment(parent, html), end);
+        return;
+    }
+    const textNode = (parent.ownerDocument || document).createTextNode(_coerceText(value, rootPath));
+    parent.insertBefore(textNode, end);
+}
+export function _createContextualFragment(parent, html) {
+    const doc = parent.ownerDocument || document;
+    if (!doc || typeof doc.createRange !== 'function') {
+        throw new Error('[Zenith Runtime] comment placeholder HTML rendering requires Range#createContextualFragment');
+    }
+    const range = doc.createRange();
+    range.selectNode(parent);
+    return range.createContextualFragment(html);
+}
+function _isStructuralFragment(value) {
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            if (_isStructuralFragment(value[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return value && typeof value === 'object' && value.__zenith_fragment === true && typeof value.mount === 'function';
+}
+function _ensureCommentPlaceholderEnd(anchor) {
+    let end = anchor.__z_range_end || null;
+    if (end && end.parentNode === anchor.parentNode) {
+        return end;
+    }
+    const parent = anchor.parentNode;
+    if (!parent) {
+        return null;
+    }
+    end = (anchor.ownerDocument || document).createComment(`/ ${anchor.data}`);
+    parent.insertBefore(end, anchor.nextSibling);
+    anchor.__z_range_end = end;
+    return end;
+}
+function _clearCommentPlaceholderContent(anchor) {
+    if (anchor.__z_unmounts) {
+        for (let i = 0; i < anchor.__z_unmounts.length; i++) {
+            try {
+                anchor.__z_unmounts[i]();
+            }
+            catch {
+            }
+        }
+    }
+    anchor.__z_unmounts = [];
+    const end = _ensureCommentPlaceholderEnd(anchor);
+    if (!end) {
+        return anchor;
+    }
+    let current = anchor.nextSibling;
+    while (current && current !== end) {
+        const next = current.nextSibling;
+        if (current.parentNode) {
+            current.parentNode.removeChild(current);
+        }
+        current = next;
+    }
+    return end;
+}
+function _mountStructuralFragmentIntoCommentRange(anchor, value, rootPath = 'renderable') {
+    let region = anchor.__z_fragment_region;
+    if (region && anchor.__z_fragment_region_active) {
+        try {
+            region.update(value, { parent: anchor.parentNode, insertBefore: anchor.__z_range_end, rootPath });
+        }
+        catch (error) {
+            rethrowZenithRuntimeError(error, {
+                phase: 'render',
+                code: 'FRAGMENT_MOUNT_FAILED',
+                message: 'Fragment update failed',
+                path: rootPath,
+                hint: 'Verify fragment values and nested renderable arrays.',
+                docsLink: DOCS_LINKS.markerTable
+            });
+        }
+        return;
+    }
+    const end = _clearCommentPlaceholderContent(anchor);
+    const parent = end.parentNode;
+    if (!parent) {
+        return;
+    }
+    region = createFragmentRegion();
+    anchor.__z_fragment_region = region;
+    anchor.__z_fragment_region_active = true;
+    try {
+        region.mount(value, { parent, insertBefore: end, rootPath });
+    }
+    catch (error) {
+        rethrowZenithRuntimeError(error, {
+            phase: 'render',
+            code: 'FRAGMENT_MOUNT_FAILED',
+            message: 'Fragment mount failed',
+            path: rootPath,
+            hint: 'Verify fragment values and nested renderable arrays.',
+            docsLink: DOCS_LINKS.markerTable
+        });
+    }
+    anchor.__z_unmounts = [() => {
+            anchor.__z_fragment_region_active = false;
+            region.destroy();
+        }];
+}
+function _mountStructuralFragment(container, value, rootPath = 'renderable') {
+    let region = container.__z_fragment_region;
+    if (region && container.__z_fragment_region_active) {
+        try {
+            region.update(value, { parent: container, insertBefore: null, rootPath });
+        }
+        catch (error) {
+            rethrowZenithRuntimeError(error, {
+                phase: 'render',
+                code: 'FRAGMENT_MOUNT_FAILED',
+                message: 'Fragment update failed',
+                path: rootPath,
+                hint: 'Verify fragment values and nested renderable arrays.',
+                docsLink: DOCS_LINKS.markerTable
+            });
+        }
+        return;
+    }
+    if (container.__z_unmounts) {
+        for (let i = 0; i < container.__z_unmounts.length; i++) {
+            try {
+                container.__z_unmounts[i]();
+            }
+            catch {
+            }
+        }
+    }
+    container.innerHTML = '';
+    region = createFragmentRegion();
+    container.__z_fragment_region = region;
+    container.__z_fragment_region_active = true;
+    try {
+        region.mount(value, { parent: container, insertBefore: null, rootPath });
+    }
+    catch (error) {
+        rethrowZenithRuntimeError(error, {
+            phase: 'render',
+            code: 'FRAGMENT_MOUNT_FAILED',
+            message: 'Fragment mount failed',
+            path: rootPath,
+            hint: 'Verify fragment values and nested renderable arrays.',
+            docsLink: DOCS_LINKS.markerTable
+        });
+    }
+    container.__z_unmounts = [() => {
+            container.__z_fragment_region_active = false;
+            region.destroy();
+        }];
+}
+export function _coerceText(value, path = 'renderable') {
+    if (value === null || value === undefined || value === false || value === true) {
+        return '';
+    }
+    if (typeof value === 'function') {
+        throwZenithRuntimeError({
+            phase: 'render',
+            code: 'NON_RENDERABLE_VALUE',
+            message: `Zenith Render Error: non-renderable function at ${path}. Use map() to render fields.`,
+            path,
+            hint: 'Convert functions into explicit event handlers or renderable text.',
+            docsLink: DOCS_LINKS.expressionScope
+        });
+    }
+    if (value && typeof value === 'object') {
+        throwZenithRuntimeError({
+            phase: 'render',
+            code: 'NON_RENDERABLE_VALUE',
+            message: `Zenith Render Error: non-renderable object at ${path}. Use map() to render fields.`,
+            path,
+            hint: 'Use map() to render object fields into nodes.',
+            docsLink: DOCS_LINKS.expressionScope
+        });
+    }
+    return String(value);
+}
+function _renderFragmentValue(value, path = 'renderable') {
+    if (value === null || value === undefined || value === false || value === true) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        let out = '';
+        for (let i = 0; i < value.length; i++) {
+            const itemPath = `${path}[${i}]`;
+            const piece = _renderFragmentValue(value[i], itemPath);
+            if (piece !== null) {
+                out += piece;
+                continue;
+            }
+            out += _escapeHtml(_coerceText(value[i], itemPath));
+        }
+        return out;
+    }
+    if (_isHtmlFragment(value)) {
+        return value.html;
+    }
+    return null;
+}
+function _escapeHtml(input) {
+    return String(input)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function _applyAttribute(node, attrName, value) {
+    if (typeof attrName === 'string' && attrName.toLowerCase() === 'innerhtml') {
+        throwZenithRuntimeError({
+            phase: 'bind',
+            code: 'UNSAFE_HTML_REQUIRES_EXPLICIT_BOUNDARY',
+            message: 'innerHTML bindings are forbidden in Zenith',
+            path: `attr:${attrName}`,
+            hint: 'Use unsafeHTML={value} for explicit raw HTML insertion, or embedded markup expressions for compiler-owned fragments.'
+        });
+    }
+    if (typeof attrName === 'string' && attrName.toLowerCase() === 'unsafehtml') {
+        node.innerHTML = value === null || value === undefined || value === false ? '' : String(value);
+        return;
+    }
+    if (attrName === 'class' || attrName === 'className') {
+        const classValue = value === null || value === undefined || value === false ? '' : String(value);
+        if (node && node.namespaceURI === SVG_NAMESPACE && typeof node.setAttribute === 'function') {
+            node.setAttribute('class', classValue);
+            return;
+        }
+        node.className = classValue;
+        return;
+    }
+    if (attrName === 'style') {
+        if (value === null || value === undefined || value === false) {
+            node.removeAttribute('style');
+            return;
+        }
+        if (typeof value === 'string') {
+            node.setAttribute('style', value);
+            return;
+        }
+        if (typeof value === 'object') {
+            const entries = Object.entries(value);
+            let styleText = '';
+            for (let i = 0; i < entries.length; i++) {
+                const [key, rawValue] = entries[i];
+                styleText += `${key}: ${rawValue};`;
+            }
+            node.setAttribute('style', styleText);
+            return;
+        }
+        node.setAttribute('style', String(value));
+        return;
+    }
+    if (BOOLEAN_ATTRIBUTES.has(attrName)) {
+        if (value) {
+            node.setAttribute(attrName, '');
+        }
+        else {
+            node.removeAttribute(attrName);
+        }
+        return;
+    }
+    if (value === null || value === undefined || value === false) {
+        node.removeAttribute(attrName);
+        return;
+    }
+    node.setAttribute(attrName, String(value));
+}

package/dist/scanner.d.ts

@@ -0,0 +1 @@
+export function createNodeResolver(root: any): (selector: any, index: any, kind: any, source?: undefined) => any;