assign-gingerly 0.0.53 → 0.0.55

package/handlers/lazyLoad.js

@@ -0,0 +1,212 @@
+/**
+ * builtIns.lazyLoad handler for assignFrom.
+ *
+ * Conditionally clones a template into a target element, using comment markers
+ * to track the inserted content. Supports show/hide and show/remove modes.
+ *
+ * This handler is auto-loaded by processHandlerCommands when `do: 'builtIns.lazyLoad'`
+ * is encountered — no explicit import is needed.
+ *
+ * @example
+ * assignFrom(document.body, {
+ *     '?.querySelector?..mainView =>': {
+ *         do: 'builtIns.lazyLoad',
+ *         resolve: {
+ *             if: '?.isHappy',
+ *             instantiate: 'globalThis://happyMood',
+ *         }
+ *     }
+ * }, { withMethods: ['querySelector'], from: myVM });
+ */
+import { withTransition, ensureHideStyle, DEFAULT_HIDE_CLASS } from '../transitionHelper.js';
+const MARKER_START_PREFIX = '?start name="';
+const MARKER_END = '?end';
+/**
+ * Get the marker name from a template element (uses its id).
+ */
+function getMarkerName(templateEl) {
+    if (templateEl instanceof HTMLTemplateElement) {
+        return templateEl.id || 'anonymous';
+    }
+    if (typeof templateEl === 'string') {
+        return templateEl;
+    }
+    return 'anonymous';
+}
+/**
+ * Find existing start/end comment markers in a target element.
+ * Returns [startMarker, endMarker] or [null, null] if not found.
+ */
+function findMarkers(target, name) {
+    const startText = `${MARKER_START_PREFIX}${name}"`;
+    let startMarker = null;
+    let endMarker = null;
+    const walker = document.createTreeWalker(target, NodeFilter.SHOW_COMMENT);
+    let node;
+    while ((node = walker.nextNode())) {
+        if (!startMarker && node.data === startText) {
+            startMarker = node;
+        }
+        else if (startMarker && !endMarker && node.data === MARKER_END) {
+            endMarker = node;
+            break;
+        }
+    }
+    return [startMarker, endMarker];
+}
+/**
+ * Create start/end markers and insert them into the target.
+ */
+function createMarkers(target, name, method) {
+    const startMarker = document.createComment(`${MARKER_START_PREFIX}${name}"`);
+    const endMarker = document.createComment(MARKER_END);
+    if (method === 'prepend') {
+        target.prepend(endMarker);
+        target.prepend(startMarker);
+    }
+    else {
+        target.appendChild(startMarker);
+        target.appendChild(endMarker);
+    }
+    return [startMarker, endMarker];
+}
+/**
+ * Get all nodes between start and end markers.
+ */
+function getNodesBetweenMarkers(start, end) {
+    const nodes = [];
+    let current = start.nextSibling;
+    while (current && current !== end) {
+        nodes.push(current);
+        current = current.nextSibling;
+    }
+    return nodes;
+}
+/**
+ * LazyLoadHandler — built-in handler for conditional template instantiation.
+ *
+ * Exported so it can be subclassed for custom behavior.
+ */
+export class LazyLoadHandler {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async assign(lhsTarget, resolvedParams) {
+        const { if: condition, instantiate, method = 'appendChild', forget = false, transitional = false, hideClass = DEFAULT_HIDE_CLASS } = resolvedParams;
+        if (!(lhsTarget instanceof Element)) {
+            throw new Error('builtIns.lazyLoad: lhsTarget must be a DOM Element');
+        }
+        const name = getMarkerName(instantiate);
+        let [startMarker, endMarker] = findMarkers(lhsTarget, name);
+        if (condition) {
+            if (startMarker && endMarker) {
+                const nodes = getNodesBetweenMarkers(startMarker, endMarker);
+                if (nodes.length > 0) {
+                    withTransition(startMarker, 'show', transitional, () => {
+                        for (const node of nodes) {
+                            if (node instanceof Element) {
+                                if (transitional) {
+                                    node.classList.remove(hideClass);
+                                } else {
+                                    node.removeAttribute('hidden');
+                                }
+                            }
+                        }
+                    });
+                }
+                else {
+                    if (transitional) {
+                        ensureHideStyle(lhsTarget.getRootNode());
+                        withTransition(startMarker, 'show', true, () => {
+                            this.cloneAndInsertSync(instantiate, startMarker, endMarker, lhsTarget, resolvedParams);
+                        });
+                    } else {
+                        await this.cloneAndInsert(instantiate, startMarker, endMarker, lhsTarget, resolvedParams);
+                    }
+                }
+            }
+            else {
+                [startMarker, endMarker] = createMarkers(lhsTarget, name, method);
+                if (transitional) {
+                    ensureHideStyle(lhsTarget.getRootNode());
+                    withTransition(startMarker, 'show', true, () => {
+                        this.cloneAndInsertSync(instantiate, startMarker, endMarker, lhsTarget, resolvedParams);
+                    });
+                } else {
+                    await this.cloneAndInsert(instantiate, startMarker, endMarker, lhsTarget, resolvedParams);
+                }
+            }
+        }
+        else {
+            if (startMarker && endMarker) {
+                const nodes = getNodesBetweenMarkers(startMarker, endMarker);
+                if (nodes.length === 0) return;
+                if (forget) {
+                    withTransition(startMarker, 'hide', transitional, () => {
+                        for (const node of nodes) {
+                            node.parentNode?.removeChild(node);
+                        }
+                    });
+                }
+                else {
+                    withTransition(startMarker, 'hide', transitional, () => {
+                        for (const node of nodes) {
+                            if (node instanceof Element) {
+                                if (transitional) {
+                                    ensureHideStyle(lhsTarget.getRootNode(), hideClass);
+                                    node.classList.add(hideClass);
+                                } else {
+                                    node.setAttribute('hidden', '');
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    }
+    cloneAndInsertSync(templateEl, startMarker, endMarker, lhsTarget, resolvedParams) {
+        let content;
+        if (templateEl instanceof HTMLTemplateElement) {
+            content = templateEl.content.cloneNode(true);
+        }
+        else if (templateEl instanceof DocumentFragment) {
+            content = templateEl.cloneNode(true);
+        }
+        else {
+            throw new Error(`builtIns.lazyLoad: instantiate must resolve to an HTMLTemplateElement or DocumentFragment`);
+        }
+        const nodes = Array.from(content.childNodes);
+        endMarker.parentNode.insertBefore(content, endMarker);
+        return nodes;
+    }
+    async cloneAndInsert(templateEl, startMarker, endMarker, lhsTarget, resolvedParams) {
+        let content;
+        if (templateEl instanceof HTMLTemplateElement) {
+            content = templateEl.content.cloneNode(true);
+        }
+        else if (templateEl instanceof DocumentFragment) {
+            content = templateEl.cloneNode(true);
+        }
+        else {
+            throw new Error(`builtIns.lazyLoad: instantiate must resolve to an HTMLTemplateElement or DocumentFragment`);
+        }
+        const nodes = Array.from(content.childNodes);
+        endMarker.parentNode.insertBefore(content, endMarker);
+        await this.onCloneInserted(nodes, lhsTarget, resolvedParams);
+        if (resolvedParams.onInstantiated && typeof resolvedParams.onInstantiated === 'function') {
+            const ctx = {
+                nodes,
+                target: lhsTarget,
+                config: this.config,
+                resolvedParams
+            };
+            await resolvedParams.onInstantiated(ctx);
+        }
+        return nodes;
+    }
+    async onCloneInserted(nodes, lhsTarget, resolvedParams) {
+        // No-op by default. Subclasses override.
+    }
+}

package/handlers/lazyLoad.ts

@@ -0,0 +1,307 @@
+/**
+ * builtIns.lazyLoad handler for assignFrom.
+ * 
+ * Conditionally clones a template into a target element, using comment markers
+ * to track the inserted content. Supports show/hide and show/remove modes.
+ * 
+ * This handler is auto-loaded by processHandlerCommands when `do: 'builtIns.lazyLoad'`
+ * is encountered — no explicit import is needed.
+ * 
+ * @example
+ * assignFrom(document.body, {
+ *     '?.querySelector?..mainView =>': {
+ *         do: 'builtIns.lazyLoad',
+ *         resolve: {
+ *             if: '?.isHappy',
+ *             instantiate: 'globalThis://happyMood',
+ *         }
+ *     }
+ * }, { withMethods: ['querySelector'], from: myVM });
+ */
+
+import type { AssignFromHandler } from '../assignFrom.js';
+import { withTransition, ensureHideStyle, DEFAULT_HIDE_CLASS } from '../transitionHelper.js';
+
+const MARKER_START_PREFIX = '?start name="';
+const MARKER_END = '?end';
+
+/**
+ * Context passed to onInstantiated callbacks.
+ */
+export interface LazyLoadInstantiatedContext {
+    /** The inserted child nodes */
+    nodes: Node[];
+    /** The target element containing the markers */
+    target: Element;
+    /** The full handler config */
+    config: any;
+    /** The resolved parameters */
+    resolvedParams: Record<string, any>;
+}
+
+/**
+ * Get the marker name from a template element (uses its id).
+ */
+function getMarkerName(templateEl: any): string {
+    if (templateEl instanceof HTMLTemplateElement) {
+        return templateEl.id || 'anonymous';
+    }
+    if (typeof templateEl === 'string') {
+        return templateEl;
+    }
+    return 'anonymous';
+}
+
+/**
+ * Find existing start/end comment markers in a target element.
+ * Returns [startMarker, endMarker] or [null, null] if not found.
+ */
+function findMarkers(target: Element, name: string): [Comment | null, Comment | null] {
+    const startText = `${MARKER_START_PREFIX}${name}"`;
+    let startMarker: Comment | null = null;
+    let endMarker: Comment | null = null;
+
+    const walker = document.createTreeWalker(target, NodeFilter.SHOW_COMMENT);
+    let node: Comment | null;
+    while ((node = walker.nextNode() as Comment | null)) {
+        if (!startMarker && node.data === startText) {
+            startMarker = node;
+        } else if (startMarker && !endMarker && node.data === MARKER_END) {
+            endMarker = node;
+            break;
+        }
+    }
+
+    return [startMarker, endMarker];
+}
+
+/**
+ * Create start/end markers and insert them into the target.
+ */
+function createMarkers(target: Element, name: string, method: string): [Comment, Comment] {
+    const startMarker = document.createComment(`${MARKER_START_PREFIX}${name}"`);
+    const endMarker = document.createComment(MARKER_END);
+
+    if (method === 'prepend') {
+        target.prepend(endMarker);
+        target.prepend(startMarker);
+    } else {
+        // Default: appendChild
+        target.appendChild(startMarker);
+        target.appendChild(endMarker);
+    }
+
+    return [startMarker, endMarker];
+}
+
+/**
+ * Get all nodes between start and end markers.
+ */
+function getNodesBetweenMarkers(start: Comment, end: Comment): Node[] {
+    const nodes: Node[] = [];
+    let current: Node | null = start.nextSibling;
+    while (current && current !== end) {
+        nodes.push(current);
+        current = current.nextSibling;
+    }
+    return nodes;
+}
+
+/**
+ * LazyLoadHandler — built-in handler for conditional template instantiation.
+ * 
+ * Exported so it can be subclassed for custom behavior.
+ */
+export class LazyLoadHandler implements AssignFromHandler {
+    config: any;
+
+    constructor(config: any) {
+        this.config = config;
+    }
+
+    async assign(lhsTarget: any, resolvedParams: Record<string, any>): Promise<void> {
+        const {
+            if: condition,
+            instantiate,
+            method = 'appendChild',
+            forget = false,
+            transitional = false,
+            hideClass = DEFAULT_HIDE_CLASS,
+        } = resolvedParams;
+
+        if (!(lhsTarget instanceof Element)) {
+            throw new Error('builtIns.lazyLoad: lhsTarget must be a DOM Element');
+        }
+
+        const name = getMarkerName(instantiate);
+
+        // Find or create markers
+        let [startMarker, endMarker] = findMarkers(lhsTarget, name);
+
+        if (condition) {
+            // SHOW
+            if (startMarker && endMarker) {
+                // Markers exist — check if content is hidden or removed
+                const nodes = getNodesBetweenMarkers(startMarker, endMarker);
+                if (nodes.length > 0) {
+                    // Content exists — show it
+                    withTransition(startMarker, 'show', transitional, () => {
+                        for (const node of nodes) {
+                            if (node instanceof Element) {
+                                if (transitional) {
+                                    node.classList.remove(hideClass);
+                                } else {
+                                    node.removeAttribute('hidden');
+                                }
+                            }
+                        }
+                    });
+                } else {
+                    // Content was removed (forget mode) — re-clone
+                    if (transitional) {
+                        ensureHideStyle(lhsTarget.getRootNode());
+                        withTransition(startMarker, 'show', true, () => {
+                            // cloneAndInsert is async but the transition callback is sync
+                            // For transitions with clone, we insert synchronously
+                            this.cloneAndInsertSync(instantiate, startMarker!, endMarker!, lhsTarget, resolvedParams);
+                        });
+                    } else {
+                        await this.cloneAndInsert(instantiate, startMarker, endMarker, lhsTarget, resolvedParams);
+                    }
+                }
+            } else {
+                // No markers — first time. Create markers and clone template.
+                [startMarker, endMarker] = createMarkers(lhsTarget, name, method);
+                if (transitional) {
+                    ensureHideStyle(lhsTarget.getRootNode());
+                    withTransition(startMarker, 'show', true, () => {
+                        this.cloneAndInsertSync(instantiate, startMarker!, endMarker!, lhsTarget, resolvedParams);
+                    });
+                } else {
+                    await this.cloneAndInsert(instantiate, startMarker, endMarker, lhsTarget, resolvedParams);
+                }
+            }
+        } else {
+            // HIDE or REMOVE
+            if (startMarker && endMarker) {
+                const nodes = getNodesBetweenMarkers(startMarker, endMarker);
+                if (nodes.length === 0) return;
+
+                if (forget) {
+                    // Remove nodes entirely (markers persist for re-insertion)
+                    withTransition(startMarker, 'hide', transitional, () => {
+                        for (const node of nodes) {
+                            node.parentNode?.removeChild(node);
+                        }
+                    });
+                } else {
+                    // Hide nodes
+                    withTransition(startMarker, 'hide', transitional, () => {
+                        for (const node of nodes) {
+                            if (node instanceof Element) {
+                                if (transitional) {
+                                    ensureHideStyle(lhsTarget.getRootNode(), hideClass);
+                                    node.classList.add(hideClass);
+                                } else {
+                                    node.setAttribute('hidden', '');
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+            // If no markers exist and condition is false, do nothing (never loaded)
+        }
+    }
+
+    /**
+     * Clone a template and insert its content between the markers (synchronous version).
+     * Used inside view transition callbacks which must be synchronous.
+     * Does not call async hooks (onCloneInserted, onInstantiated).
+     */
+    protected cloneAndInsertSync(
+        templateEl: any,
+        startMarker: Comment,
+        endMarker: Comment,
+        lhsTarget: Element,
+        resolvedParams: Record<string, any>
+    ): Node[] {
+        let content: DocumentFragment;
+
+        if (templateEl instanceof HTMLTemplateElement) {
+            content = templateEl.content.cloneNode(true) as DocumentFragment;
+        } else if (templateEl instanceof DocumentFragment) {
+            content = templateEl.cloneNode(true) as DocumentFragment;
+        } else {
+            throw new Error(
+                `builtIns.lazyLoad: instantiate must resolve to an HTMLTemplateElement or DocumentFragment`
+            );
+        }
+
+        const nodes = Array.from(content.childNodes);
+        endMarker.parentNode!.insertBefore(content, endMarker);
+        return nodes;
+    }
+
+    /**
+     * Clone a template and insert its content between the markers.
+     * Calls onCloneInserted hook and onInstantiated callback after insertion.
+     */
+    protected async cloneAndInsert(
+        templateEl: any,
+        startMarker: Comment,
+        endMarker: Comment,
+        lhsTarget: Element,
+        resolvedParams: Record<string, any>
+    ): Promise<Node[]> {
+        let content: DocumentFragment;
+
+        if (templateEl instanceof HTMLTemplateElement) {
+            content = templateEl.content.cloneNode(true) as DocumentFragment;
+        } else if (templateEl instanceof DocumentFragment) {
+            content = templateEl.cloneNode(true) as DocumentFragment;
+        } else {
+            throw new Error(
+                `builtIns.lazyLoad: instantiate must resolve to an HTMLTemplateElement or DocumentFragment`
+            );
+        }
+
+        // Capture nodes before insertion (childNodes empties after insertBefore)
+        const nodes = Array.from(content.childNodes);
+
+        // Insert before endMarker
+        endMarker.parentNode!.insertBefore(content, endMarker);
+
+        // Call protected hook (for subclass overrides)
+        await this.onCloneInserted(nodes, lhsTarget, resolvedParams);
+
+        // Call onInstantiated callback if provided (resolved from VM)
+        if (resolvedParams.onInstantiated && typeof resolvedParams.onInstantiated === 'function') {
+            const ctx: LazyLoadInstantiatedContext = {
+                nodes,
+                target: lhsTarget,
+                config: this.config,
+                resolvedParams
+            };
+            await resolvedParams.onInstantiated(ctx);
+        }
+
+        return nodes;
+    }
+
+    /**
+     * Hook called after template content is cloned and inserted.
+     * Override in subclasses for custom post-clone logic.
+     * 
+     * @param nodes - The inserted child nodes
+     * @param lhsTarget - The target element
+     * @param resolvedParams - The resolved parameters
+     */
+    protected async onCloneInserted(
+        nodes: Node[],
+        lhsTarget: Element,
+        resolvedParams: Record<string, any>
+    ): Promise<void> {
+        // No-op by default. Subclasses override.
+    }
+}

package/handlers/lazyLoadSwitch.js

@@ -0,0 +1,58 @@
+/**
+ * builtIns.lazyLoadSwitch handler for assignFrom.
+ *
+ * Extends LazyLoadHandler with a comparison-based condition instead of a
+ * pre-computed boolean. Evaluates `lhs op rhs` to determine whether to
+ * show or hide the template content.
+ *
+ * This handler is auto-loaded by processHandlerCommands when
+ * `do: 'builtIns.lazyLoadSwitch'` is encountered — no explicit import is needed.
+ *
+ * Useful for routing and multi-way conditional rendering where multiple
+ * handlers in an array represent different "cases."
+ *
+ * @example
+ * assignFrom(el, {
+ *     '?.querySelector?..routerOutlet =>': [
+ *         { do: 'builtIns.lazyLoadSwitch', resolve: { lhs: '?.route', rhs: 'home', instantiate: 'globalThis://homeView' } },
+ *         { do: 'builtIns.lazyLoadSwitch', resolve: { lhs: '?.route', rhs: 'settings', instantiate: 'globalThis://settingsView' } },
+ *     ]
+ * }, { withMethods: ['querySelector'], from: vm, protocols: { globalThis: k => globalThis[k] } });
+ */
+import { LazyLoadHandler } from './lazyLoad.js';
+/**
+ * Evaluate a comparison operation.
+ *
+ * @param lhs - Left-hand side value
+ * @param op - Operator string (default: '===')
+ * @param rhs - Right-hand side value
+ * @returns Boolean result of the comparison
+ */
+function evaluateOp(lhs, op, rhs) {
+    switch (op) {
+        case '===': return lhs === rhs;
+        case '!==': return lhs !== rhs;
+        case '==': return lhs == rhs;
+        case '!=': return lhs != rhs;
+        case '<': return lhs < rhs;
+        case '>': return lhs > rhs;
+        case '<=': return lhs <= rhs;
+        case '>=': return lhs >= rhs;
+        default:
+            throw new Error(`builtIns.lazyLoadSwitch: unsupported operator "${op}"`);
+    }
+}
+/**
+ * LazyLoadSwitchHandler — comparison-based conditional template instantiation.
+ *
+ * Extends LazyLoadHandler by evaluating `lhs op rhs` to compute the condition,
+ * then delegating all DOM logic to the parent class.
+ */
+export class LazyLoadSwitchHandler extends LazyLoadHandler {
+    async assign(lhsTarget, resolvedParams) {
+        const { lhs, op = '===', rhs, ...rest } = resolvedParams;
+        const condition = evaluateOp(lhs, op, rhs);
+        // Delegate to parent with computed condition
+        return super.assign(lhsTarget, { ...rest, if: condition });
+    }
+}

package/handlers/lazyLoadSwitch.ts

@@ -0,0 +1,63 @@
+/**
+ * builtIns.lazyLoadSwitch handler for assignFrom.
+ * 
+ * Extends LazyLoadHandler with a comparison-based condition instead of a
+ * pre-computed boolean. Evaluates `lhs op rhs` to determine whether to
+ * show or hide the template content.
+ * 
+ * This handler is auto-loaded by processHandlerCommands when
+ * `do: 'builtIns.lazyLoadSwitch'` is encountered — no explicit import is needed.
+ * 
+ * Useful for routing and multi-way conditional rendering where multiple
+ * handlers in an array represent different "cases."
+ * 
+ * @example
+ * assignFrom(el, {
+ *     '?.querySelector?..routerOutlet =>': [
+ *         { do: 'builtIns.lazyLoadSwitch', resolve: { lhs: '?.route', rhs: 'home', instantiate: 'globalThis://homeView' } },
+ *         { do: 'builtIns.lazyLoadSwitch', resolve: { lhs: '?.route', rhs: 'settings', instantiate: 'globalThis://settingsView' } },
+ *     ]
+ * }, { withMethods: ['querySelector'], from: vm, protocols: { globalThis: k => globalThis[k] } });
+ */
+
+import { LazyLoadHandler } from './lazyLoad.js';
+import type { AssignFromHandler } from '../assignFrom.js';
+
+/**
+ * Evaluate a comparison operation.
+ * 
+ * @param lhs - Left-hand side value
+ * @param op - Operator string (default: '===')
+ * @param rhs - Right-hand side value
+ * @returns Boolean result of the comparison
+ */
+function evaluateOp(lhs: any, op: string, rhs: any): boolean {
+    switch (op) {
+        case '===': return lhs === rhs;
+        case '!==': return lhs !== rhs;
+        case '==':  return lhs == rhs;
+        case '!=':  return lhs != rhs;
+        case '<':   return lhs < rhs;
+        case '>':   return lhs > rhs;
+        case '<=':  return lhs <= rhs;
+        case '>=':  return lhs >= rhs;
+        default:
+            throw new Error(`builtIns.lazyLoadSwitch: unsupported operator "${op}"`);
+    }
+}
+
+/**
+ * LazyLoadSwitchHandler — comparison-based conditional template instantiation.
+ * 
+ * Extends LazyLoadHandler by evaluating `lhs op rhs` to compute the condition,
+ * then delegating all DOM logic to the parent class.
+ */
+export class LazyLoadSwitchHandler extends LazyLoadHandler implements AssignFromHandler {
+
+    async assign(lhsTarget: any, resolvedParams: Record<string, any>): Promise<void> {
+        const { lhs, op = '===', rhs, ...rest } = resolvedParams;
+        const condition = evaluateOp(lhs, op, rhs);
+        // Delegate to parent with computed condition
+        return super.assign(lhsTarget, { ...rest, if: condition });
+    }
+}