@vmz/core 0.2.4 → 0.2.6

package/dist/browser/diagnostics/precision-trace.d.ts

@@ -0,0 +1,47 @@
+import type { PrecisionState } from '../dom-core.types.js';
+export declare function pushTrace(kind: any, stableKind: any, stableId: any, dep?: any): void;
+export declare function bumpMap(map: any, key: any, n?: number): void;
+export declare const precision: PrecisionState;
+export declare function __vmzPrecisionEnable(on?: boolean): void;
+export declare function __vmzTraceEnable(on?: boolean): void;
+export declare function __vmzPrecisionReset(): void;
+export declare function __vmzTraceReset(): void;
+export declare function __vmzTraceSnapshot(): {
+    schema: string;
+    events: {
+        stableId: {
+            kind: string;
+            id: string;
+        };
+        kind: string;
+        dep?: string;
+        t?: number;
+        chunkId?: string | null;
+    }[];
+    status: string;
+};
+export declare function __vmzPrecisionSnapshot(): {
+    enabled: boolean;
+    writes: number;
+    bindingEvals: number;
+    patchExecs: number;
+    domCreates: number;
+    domMoves: number;
+    domRemoves: number;
+    componentExecs: number;
+    writesByRoot: {
+        [x: string]: number;
+    };
+    bindingEvalsByDep: {
+        [x: string]: number;
+    };
+    patchesByDep: {
+        [x: string]: number;
+    };
+    bindingEvalsByBinding: {
+        [x: string]: number;
+    };
+    patchesByBinding: {
+        [x: string]: number;
+    };
+};

package/dist/browser/diagnostics/precision-trace.js

@@ -0,0 +1,86 @@
+export function pushTrace(kind, stableKind, stableId, dep = null) {
+    if (!traceBuf.enabled && !precision.enabled)
+        return;
+    traceBuf.events.push({
+        kind,
+        stableId: { kind: stableKind, id: String(stableId) },
+        dep: dep == null ? undefined : String(dep),
+        t: Date.now(),
+    });
+    if (traceBuf.events.length > TRACE_CAP) {
+        traceBuf.events.splice(0, traceBuf.events.length - TRACE_CAP);
+    }
+}
+export function bumpMap(map, key, n = 1) {
+    if (key == null || key === '')
+        return;
+    map[key] = (map[key] || 0) + n;
+}
+export const precision = {
+    enabled: false,
+    writes: 0,
+    bindingEvals: 0,
+    patchExecs: 0,
+    domCreates: 0,
+    domMoves: 0,
+    domRemoves: 0,
+    componentExecs: 0,
+    writesByRoot: Object.create(null),
+    bindingEvalsByDep: Object.create(null),
+    patchesByDep: Object.create(null),
+    bindingEvalsByBinding: Object.create(null),
+    patchesByBinding: Object.create(null),
+};
+const TRACE_CAP = 256;
+const traceBuf = {
+    enabled: false,
+    events: [],
+};
+export function __vmzPrecisionEnable(on = true) {
+    precision.enabled = !!on;
+}
+export function __vmzTraceEnable(on = true) {
+    traceBuf.enabled = !!on;
+}
+export function __vmzPrecisionReset() {
+    precision.writes = 0;
+    precision.bindingEvals = 0;
+    precision.patchExecs = 0;
+    precision.domCreates = 0;
+    precision.domMoves = 0;
+    precision.domRemoves = 0;
+    precision.componentExecs = 0;
+    precision.writesByRoot = Object.create(null);
+    precision.bindingEvalsByDep = Object.create(null);
+    precision.patchesByDep = Object.create(null);
+    precision.bindingEvalsByBinding = Object.create(null);
+    precision.patchesByBinding = Object.create(null);
+}
+export function __vmzTraceReset() {
+    traceBuf.events = [];
+}
+export function __vmzTraceSnapshot() {
+    const events = traceBuf.events.map((e) => ({ ...e, stableId: { ...e.stableId } }));
+    return {
+        schema: 'vmz.dx.trace.v0',
+        events,
+        status: events.length ? 'ready' : 'empty',
+    };
+}
+export function __vmzPrecisionSnapshot() {
+    return {
+        enabled: precision.enabled,
+        writes: precision.writes,
+        bindingEvals: precision.bindingEvals,
+        patchExecs: precision.patchExecs,
+        domCreates: precision.domCreates,
+        domMoves: precision.domMoves,
+        domRemoves: precision.domRemoves,
+        componentExecs: precision.componentExecs,
+        writesByRoot: { ...precision.writesByRoot },
+        bindingEvalsByDep: { ...precision.bindingEvalsByDep },
+        patchesByDep: { ...precision.patchesByDep },
+        bindingEvalsByBinding: { ...precision.bindingEvalsByBinding },
+        patchesByBinding: { ...precision.patchesByBinding },
+    };
+}

package/dist/browser/dom/attributes.d.ts

@@ -0,0 +1,5 @@
+export declare const BOOLEAN_HTML_ATTRS: Set<string>;
+export declare function applyDomAttr(el: any, name: any, value: any): void;
+export declare function eventPropHandlerName(name: any): string;
+export declare function emitComponentEvent(inst: any, eventName: any, ...payload: any[]): void;
+export declare function isEventPropName(name: any): boolean;

package/dist/browser/dom/attributes.js

@@ -0,0 +1,102 @@
+import { mergeClassParts, mergeStyleParts } from '../../shared/dom-attr-normalize.js';
+export const BOOLEAN_HTML_ATTRS = new Set([
+    'disabled',
+    'checked',
+    'selected',
+    'readonly',
+    'required',
+    'multiple',
+    'hidden',
+    'autofocus',
+    'autoplay',
+    'controls',
+    'loop',
+    'muted',
+    'open',
+    'novalidate',
+    'formnovalidate',
+    'defer',
+    'async',
+    'ismap',
+    'default',
+    'inert',
+]);
+export function applyDomAttr(el, name, value) {
+    const key = name === 'className' ? 'class' : name;
+    if (key === 'class') {
+        const s = mergeClassParts(value);
+        if (s)
+            el.setAttribute('class', s);
+        else
+            el.removeAttribute('class');
+        return;
+    }
+    if (key === 'style') {
+        const s = mergeStyleParts(value);
+        if (s)
+            el.setAttribute('style', s);
+        else
+            el.removeAttribute('style');
+        return;
+    }
+    if (BOOLEAN_HTML_ATTRS.has(String(key).toLowerCase())) {
+        const on = value === true || value === '';
+        if (key === 'checked' && el && el.tagName === 'INPUT' && String(el.type || '').toLowerCase() === 'checkbox') {
+            if (el.checked !== on)
+                el.checked = on;
+        }
+        if (value === false || value == null || value === '') {
+            el.removeAttribute(key);
+        }
+        else {
+            el.setAttribute(key, value === true ? '' : String(value));
+        }
+        return;
+    }
+    // <textarea value="??> as an attribute does not update visible text; INPUT/SELECT
+    // also need the IDL `.value` property so controlled updates stay in sync after switches.
+    // linkedom `<select>.value` is getter-only ??sync via `option.selected` instead of throwing.
+    if (key === 'value' && el && (el.tagName === 'TEXTAREA' || el.tagName === 'INPUT' || el.tagName === 'SELECT')) {
+        const next = value == null || value === false ? '' : String(value);
+        if (el.tagName === 'SELECT') {
+            const opts = el.options || el.querySelectorAll?.('option') || [];
+            for (const opt of opts) {
+                opt.selected = String(opt.value ?? '') === next;
+            }
+        }
+        else if (el.value !== next) {
+            el.value = next;
+        }
+        if (value == null || value === false)
+            el.removeAttribute('value');
+        else
+            el.setAttribute('value', next);
+        return;
+    }
+    if (value == null || value === false)
+        el.removeAttribute(key);
+    else
+        el.setAttribute(key, value === true ? '' : String(value));
+}
+export function eventPropHandlerName(name) {
+    if (typeof name !== 'string' || !name)
+        return null;
+    if (/^on[A-Z]/.test(name))
+        return name;
+    return null;
+}
+export function emitComponentEvent(inst, eventName, ...payload) {
+    if (!inst || typeof eventName !== 'string' || !eventName)
+        return;
+    const bag = inst.__vmzComponentListeners;
+    const list = bag && bag[eventName];
+    if (!Array.isArray(list) || list.length === 0)
+        return;
+    for (const fn of list) {
+        if (typeof fn === 'function')
+            fn(...payload);
+    }
+}
+export function isEventPropName(name) {
+    return eventPropHandlerName(name) != null;
+}

package/dist/browser/dom/component.d.ts

@@ -0,0 +1,11 @@
+export declare function mount(Component: any, container: any, props?: any): Promise<any>;
+export declare function settlePendingChildMounts(inst: any): Promise<void>;
+export declare function runDirectCreate(Component: any, inst: any): any;
+export declare function findOwnedDefaultSlot(root: any): any;
+export declare function findOwnedDefaultSlotTarget(root: any): any;
+export declare function createInstance(Component: any, props?: any): any;
+export declare function destroy(inst: any): void;
+export declare function disposeDomTree(root: any): void;
+export declare function snapshotInstanceState(inst: any): {};
+export declare function applyPreservedState(inst: any, state: any): void;
+export declare function stripFns(obj: any): {};

package/dist/browser/dom/component.js

@@ -0,0 +1,255 @@
+import { precision } from '../diagnostics/precision-trace.js';
+import { emitComponentEvent } from './attributes.js';
+import { directApi } from './direct-api.js';
+import { __vmzCancelTasks } from './lifecycle.js';
+import { flushPending } from '../reactivity/patch-scheduler.js';
+import { __vmzAllowShared, __vmzArrayItemCompoundStride, __vmzArrayMutate, __vmzListTranspose, __vmzReadPath, __vmzTakeShared, __vmzWritePath, __vmzWritePathCompound, __vmzWritePathCompoundItem, __vmzWritePathItem, __vmzWritePathLogical, makeReactive, } from '../reactivity/write-barrier.js';
+export async function mount(Component, container, props = {}) {
+    if (container.__vmzInst) {
+        destroy(container.__vmzInst);
+        container.__vmzInst = null;
+    }
+    const inst = createInstance(Component, props);
+    inst.__vmzBinders = Object.create(null);
+    inst.__vmzBindings = Object.create(null);
+    inst.__vmzDepToBindings = Object.create(null);
+    container.replaceChildren();
+    const node = await createFromComponent(Component, inst);
+    if (node) {
+        inst.__vmzDomRoot = node;
+        container.appendChild(node);
+    }
+    if (typeof inst.onMount === 'function') {
+        await inst.onMount();
+    }
+    await settlePendingChildMounts(inst);
+    container.__vmzInst = inst;
+    return inst;
+}
+export async function settlePendingChildMounts(inst) {
+    if (!inst || !Array.isArray(inst.__vmzPendingChildMounts) || !inst.__vmzPendingChildMounts.length)
+        return;
+    await Promise.all(inst.__vmzPendingChildMounts);
+    inst.__vmzPendingChildMounts = [];
+    const hosts = [];
+    const root = inst.__vmzDomRoot;
+    if (root && root.nodeType === 1) {
+        if (root.__vmzInst)
+            hosts.push(root.__vmzInst);
+        for (const el of root.querySelectorAll('[data-vmz]')) {
+            if (el.__vmzInst)
+                hosts.push(el.__vmzInst);
+        }
+    }
+    for (const child of hosts) {
+        await flushPending(child);
+        await settlePendingChildMounts(child);
+    }
+}
+async function createFromComponent(Component, inst) {
+    if (Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function') {
+        return runDirectCreate(Component, inst);
+    }
+    throw new Error(`vmz:dom mount requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+}
+export function runDirectCreate(Component, inst) {
+    // Nested component creates (e.g. Button inside parent ifBlock branch) must not
+    // leak bindAttr/bindText into the parent's `_branchBinds` / `_itemPatches` sink ??    // that steals numeric BindingIds (0) and corrupts parent deps (density ??type).
+    const prevInst = directApi._inst;
+    const prevBranch = directApi._branchBinds;
+    const prevItems = directApi._itemPatches;
+    const prevEach = directApi._eachCtx;
+    directApi._inst = inst;
+    directApi._branchBinds = null;
+    directApi._itemPatches = null;
+    directApi._eachCtx = null;
+    try {
+        return Component.__vmzCreate.call(inst, directApi);
+    }
+    finally {
+        directApi._inst = prevInst;
+        directApi._branchBinds = prevBranch;
+        directApi._itemPatches = prevItems;
+        directApi._eachCtx = prevEach;
+    }
+}
+export function findOwnedDefaultSlot(root) {
+    if (!root || root.nodeType !== 1)
+        return null;
+    const tag = String(root.tagName || '').toLowerCase();
+    if (tag === 'slot' && !root.getAttribute('name'))
+        return root;
+    const kids = root.children;
+    if (!kids || !kids.length)
+        return null;
+    for (let i = 0; i < kids.length; i++) {
+        const c = kids[i];
+        if (c.nodeType !== 1)
+            continue;
+        if (c.hasAttribute('data-vmz'))
+            continue;
+        const hit = findOwnedDefaultSlot(c);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+export function findOwnedDefaultSlotTarget(root) {
+    const slot = findOwnedDefaultSlot(root);
+    if (slot)
+        return slot;
+    if (!root || root.nodeType !== 1)
+        return null;
+    const walk = (el) => {
+        if (!el || el.nodeType !== 1)
+            return null;
+        const tag = String(el.tagName || '').toLowerCase();
+        if ((tag === 'button' || tag === 'a') && el.getAttribute('data-vmz-ui') === 'button')
+            return el;
+        if (el.hasAttribute('data-vmz'))
+            return null;
+        const kids = el.children;
+        if (!kids || !kids.length)
+            return null;
+        for (let i = 0; i < kids.length; i++) {
+            const hit = walk(kids[i]);
+            if (hit)
+                return hit;
+        }
+        return null;
+    };
+    return walk(root);
+}
+export function createInstance(Component, props = {}) {
+    if (precision.enabled)
+        precision.componentExecs++;
+    const inst = new Component(props || {});
+    if (typeof inst.__vmzApplyProps === 'function' && !Component.__vmzCtorAppliesProps) {
+        inst.__vmzApplyProps(props || {});
+    }
+    inst.__vmzBinders = Object.create(null);
+    inst.__vmzBindings = Object.create(null);
+    inst.__vmzDepToBindings = Object.create(null);
+    inst.__vmzComponentListeners = Object.create(null);
+    // Compiler intrinsic surface: `this.emit('submit', payload)` ??not a string bus.
+    inst.emit = function emit(eventName, ...payload) {
+        return emitComponentEvent(inst, eventName, ...payload);
+    };
+    makeReactive(inst, Component.__vmzState || []);
+    makeReactive(inst, Component.__vmzProps || []);
+    // WriteBarrier: install Component helpers once (no import needed in emitted code).
+    if (!Component.__vmzWBInstalled) {
+        Component.__vmzWBInstalled = true;
+        Component.__vmzWritePath = __vmzWritePath;
+        Component.__vmzWritePathItem = __vmzWritePathItem;
+        Component.__vmzWritePathCompound = __vmzWritePathCompound;
+        Component.__vmzWritePathCompoundItem = __vmzWritePathCompoundItem;
+        Component.__vmzWritePathLogical = __vmzWritePathLogical;
+        Component.__vmzReadPath = __vmzReadPath;
+        Component.__vmzArrayMutate = __vmzArrayMutate;
+        Component.__vmzArrayItemCompoundStride = __vmzArrayItemCompoundStride;
+        Component.__vmzListTranspose = __vmzListTranspose;
+        Component.__vmzAllowShared = __vmzAllowShared;
+        Component.__vmzTakeShared = __vmzTakeShared;
+    }
+    return inst;
+}
+export function destroy(inst) {
+    if (!inst || inst.__vmzDestroyed)
+        return;
+    inst.__vmzDestroyed = true;
+    inst.__vmzFlushScheduled = false;
+    // async cancel: abort in-flight tasks before tearing down DOM.
+    __vmzCancelTasks(inst);
+    if (inst.__vmzDomRoot) {
+        disposeDomTree(inst.__vmzDomRoot);
+        inst.__vmzDomRoot = null;
+    }
+    if (inst.__vmzDirtyNotices)
+        inst.__vmzDirtyNotices.length = 0;
+    if (inst.__vmzDirtyTrie)
+        inst.__vmzDirtyTrie = Object.create(null);
+    if (inst.__vmzDirty)
+        inst.__vmzDirty.clear();
+    inst.__vmzBinders = Object.create(null);
+    inst.__vmzBindings = Object.create(null);
+    inst.__vmzDepToBindings = Object.create(null);
+    if (typeof inst.onDestroy === 'function') {
+        try {
+            inst.onDestroy();
+        }
+        catch (err) {
+            console.error('vmz:dom onDestroy', err);
+        }
+    }
+}
+export function disposeDomTree(root) {
+    if (!root)
+        return;
+    const seen = new Set();
+    const visit = (node) => {
+        if (!node || seen.has(node))
+            return;
+        seen.add(node);
+        if (typeof node.__vmzDispose === 'function') {
+            try {
+                node.__vmzDispose();
+            }
+            catch (err) {
+                console.error('vmz:dom __vmzDispose', err);
+            }
+            node.__vmzDispose = null;
+        }
+        if (node.__vmzInst) {
+            const child = node.__vmzInst;
+            node.__vmzInst = null;
+            destroy(child);
+        }
+        let child = node.firstChild;
+        while (child) {
+            const next = child.nextSibling;
+            visit(child);
+            child = next;
+        }
+    };
+    visit(root);
+}
+export function snapshotInstanceState(inst) {
+    if (!inst || inst.__vmzDestroyed)
+        return null;
+    const Ctor = inst.constructor;
+    const keys = [...(Ctor.__vmzState || []), ...(Ctor.__vmzProps || [])];
+    const out = {};
+    for (const key of keys) {
+        if (!key || String(key).startsWith('__'))
+            continue;
+        try {
+            out[key] = inst[key];
+        }
+        catch {
+            /* ignore accessors that throw */
+        }
+    }
+    return out;
+}
+export function applyPreservedState(inst, state) {
+    if (!inst || !state)
+        return;
+    for (const [key, value] of Object.entries(state)) {
+        try {
+            inst[key] = value;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function stripFns(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj || {})) {
+        if (typeof v === 'function')
+            continue;
+        out[k] = v;
+    }
+    return out;
+}

package/dist/browser/dom/direct-api.d.ts

@@ -0,0 +1,66 @@
+import type { BindingId, DirectInstance, PatchFn } from '../direct-api.types.js';
+import type { EachCtx, ResumeAdoptCtx } from '../dom-core.types.js';
+export declare const directApi: {
+    _inst: DirectInstance | null;
+    _branchBinds: Array<{
+        deps: string[];
+        fn: PatchFn;
+        bindingId?: BindingId;
+    }> | null;
+    _itemPatches: PatchFn[] | null;
+    _eachCtx: EachCtx | null;
+    _resumeAdopt: ResumeAdoptCtx | null;
+    el(tag: any): any;
+    elNS(ns: any, tag: any): Element;
+    text(value: any): Text;
+    adoptEnter(node: any): boolean;
+    adoptLeave(): void;
+    frag(): DocumentFragment;
+    comment(value: any): Comment;
+    insertBefore(parent: any, node: any, ref: any): void;
+    removeNode(node: any): void;
+    /**
+     * Register a generated per-binding patch (0.2.0). No generic get/cf interpreter.
+     */
+    trackPatch(inst: any, deps: any, patch: any, bindingId?: any): void;
+    untrackPatch(inst: any, deps: any, patch: any, bindingId?: any): void;
+    disposeTree(root: any): void;
+    attr(el: any, name: any, value: any): void;
+    mergeClass(...parts: any[]): string;
+    mergeStyle(...parts: any[]): string;
+    on(el: any, type: any, handler: any): void;
+    /**
+     * Bind a named instance method (no arrow / Function#toString).
+     * Learns `skipFlush` after a sync invocation that schedules no dirty work
+     * (stride / transpose self-apply DOM).
+     */
+    onMethod(el: any, type: any, methodName: any, opts: any): void;
+    /**
+     * Specialized single-field attr bind (0.1.29): compile-time field name, no generic get closure in artifact.
+     */
+    specFieldAttr(inst: any, bindingId: any, fieldName: any, el: any, name: any): void;
+    /**
+     * Specialized single-field text bind (0.1.29): compile-time field name in generated artifact.
+     */
+    specFieldText(inst: any, bindingId: any, fieldName: any, textNode: any): void;
+    setHtml(el: any, value: any): void;
+    bindHtml(inst: any, bindingId: any, deps: any, get: any, el: any): void;
+    /**
+     * Nested component (sync Direct child or island schedule).
+     */
+    component(hostInst: any, nameOrCtor: any, props: any, client: any): any;
+    /**
+     * Subscribe to a child component event (`@submit` ??event name `submit`).
+     * Orthogonal to function props (`:on-submit` ??prop `onSubmit`).
+     */
+    onComponentEvent(hostEl: any, eventName: any, handler: any): void;
+    /**
+     * Keep nested Direct child props live with parent field writes.
+     */
+    bindComponentProp(hostInst: any, hostEl: any, propName: any, deps: any, get: any): void;
+    /**
+     * Project parent children into nested Direct component default `<slot>`.
+     * Uses {@link findOwnedDefaultSlot} so nested Button/Link slots are not stolen.
+     */
+    projectDefaultSlot(hostEl: any, node: any): void;
+};