@thyn/core 0.0.228 → 0.0.232

package/dist/element.d.ts

@@ -1,6 +1,6 @@
 export declare function mount(app: any, parent: any): void;
 export declare function collectEffect(effectFn: any): void;
-export declare function createReactiveTextNode(v: any): any;
+export declare function createReactiveTextNode(v: any): Text;
 export declare function component(name: any, props?: any): any;
 export declare function setAttribute(el: any, key: any, val: any): any;
 export declare function setProperty(el: any, key: any, val: any): any;

package/dist/element.js

@@ -9,15 +9,21 @@ export function collectEffect(effectFn) {
     }
     collectingHead = effectFn;
 }
+// export function createReactiveTextNode(v) {
+//   let n;
+//   staticEffect(() => {
+//     if (n) {
+//       n.nodeValue = v();
+//     } else {
+//       n = document.createTextNode(v());
+//     }
+//   });
+//   return n;
+// }
 export function createReactiveTextNode(v) {
-    let n;
+    const n = document.createTextNode(v());
     staticEffect(() => {
-        if (n) {
-            n.nodeValue = v();
-        }
-        else {
-            n = document.createTextNode(v());
-        }
+        n.nodeValue = v();
     });
     return n;
 }
@@ -75,7 +81,7 @@ export function setReactiveAttribute(el, key, val) {
             return;
         }
         if (v !== undefined)
-            el.setAttribute(key, val());
+            el.setAttribute(key, v);
         ran = true;
     }));
 }
@@ -246,7 +252,9 @@ export function list(props, terminal = false) {
     const teardownNode = terminal ? shallowTeardown : teardown;
     let parent;
     let outlet = document.createDocumentFragment();
-    let prevItems;
+    // State
+    let prevItems = [];
+    let rowNodes = []; // The "Shadow Array" - avoids reading DOM
     const startBookend = document.createComment("");
     const endBookend = document.createComment("");
     startBookend.$frag = outlet;
@@ -254,171 +262,151 @@ export function list(props, terminal = false) {
     const render = props.render;
     staticEffect(() => {
         parent = startBookend.parentNode;
+        // 1. Initialization / First Render
         if (!parent) {
-            prevItems = props.items();
-            outlet.append(startBookend, ...prevItems.map(render), endBookend);
+            const items = props.items();
+            // Render all items
+            const newNodes = items.map(render);
+            outlet.append(startBookend, ...newNodes, endBookend);
+            // Save state
+            prevItems = items;
+            rowNodes = newNodes;
             return;
         }
-        let nextItems = props.items();
-        let newLength = nextItems.length;
+        const nextItems = props.items();
+        const newLength = nextItems.length;
         let oldLength = prevItems.length;
-        if (!oldLength && newLength) {
-            endBookend.before(...nextItems.map(render));
-            prevItems = nextItems;
-            nextItems = null;
-            return;
-        }
-        const childNodes = [];
-        let ptr = startBookend.nextSibling;
-        while (ptr !== endBookend) {
-            childNodes.push(ptr);
-            ptr = ptr.nextSibling;
-        }
-        const offset = 0;
-        if (!newLength) {
-            const removalQueue = [];
-            const end = prevItems.length + offset;
-            for (let i = offset; i < end; i++) {
-                const ch = childNodes[i];
-                teardownNode(ch);
-                removalQueue.push(ch);
-            }
-            for (const ch of removalQueue) {
-                remove(ch);
+        // 2. Fast Path: Clear All
+        if (newLength === 0) {
+            if (oldLength !== 0) {
+                for (let i = 0; i < oldLength; i++) {
+                    teardownNode(rowNodes[i]);
+                    remove(rowNodes[i]);
+                }
+                rowNodes = [];
+                prevItems = [];
             }
-            prevItems = nextItems;
-            nextItems = null;
-            return;
-        }
-        let start = nextItems.findIndex((item, index) => prevItems[index] !== item);
-        if (start === oldLength) {
-            endBookend.before(...nextItems.slice(start).map(render));
-            prevItems = nextItems;
-            nextItems = null;
             return;
         }
-        if (start < 0) {
-            for (let i = nextItems.length; i < oldLength; i++) {
-                const e = childNodes[offset + --oldLength];
-                teardownNode(e);
-                remove(e);
-            }
+        // 3. Fast Path: Create All (from empty)
+        if (oldLength === 0) {
+            const newNodes = nextItems.map(render);
+            endBookend.before(...newNodes);
+            rowNodes = newNodes;
             prevItems = nextItems;
-            nextItems = null;
             return;
         }
-        if (start >= newLength) {
-            while (start < oldLength) {
-                const e = childNodes[offset + --oldLength];
-                teardownNode(e);
-                remove(e);
-            }
-            prevItems = nextItems;
-            nextItems = null;
-            return;
-        }
-        // suffix
-        for (oldLength--, newLength--; newLength > start &&
-            oldLength >= start &&
-            nextItems[newLength] === prevItems[oldLength]; oldLength--, newLength--)
-            ;
-        const nextKeys = new Set(nextItems);
-        const removalQueue = [];
-        for (let i = start; i <= oldLength; i++) {
-            if (!nextKeys.has(prevItems[i])) {
-                const ch = childNodes[i + offset];
-                teardownNode(ch);
-                removalQueue.push(ch);
-                childNodes[i + offset] = null;
-            }
-        }
-        for (const e of removalQueue) {
-            remove(e);
+        // 4. Reconciliation
+        let start = 0;
+        let minLen = Math.min(oldLength, newLength);
+        // Prefix Scan (Cheaper JS Array read vs DOM read)
+        while (start < minLen && prevItems[start] === nextItems[start]) {
+            start++;
         }
-        if (oldLength - start === removalQueue.length) {
+        // Optimization: Append only
+        if (start === oldLength && newLength > oldLength) {
+            const newPart = nextItems.slice(start);
+            const newNodes = newPart.map(render);
+            endBookend.before(...newNodes);
+            rowNodes = rowNodes.concat(newNodes);
             prevItems = nextItems;
-            nextItems = null;
             return;
         }
-        let keyMap = new Map();
-        for (let i = start; i <= oldLength; i++) {
-            if (childNodes[i + offset] &&
-                (!nextItems[i] ||
-                    prevItems[i] !== nextItems[i])) {
-                keyMap.set(prevItems[i], {
-                    el: childNodes[i + offset],
-                    item: prevItems[i],
-                });
+        // Optimization: Truncate only
+        if (start === newLength && oldLength > newLength) {
+            for (let i = start; i < oldLength; i++) {
+                teardownNode(rowNodes[i]);
+                remove(rowNodes[i]);
             }
-        }
-        if (newLength === oldLength && keyMap.size > (newLength - start + 1) / 2) {
-            const lastOrdered = start > 0 ? childNodes[start + offset - 1] : startBookend;
-            const set = [];
-            for (let i = start; i <= newLength; i++) {
-                set.push(keyMap.get(nextItems[i])?.el ?? childNodes[i + offset]);
-            }
-            lastOrdered.after(...set);
+            rowNodes.length = newLength; // JS Array Truncate
             prevItems = nextItems;
-            keyMap = null;
-            nextItems = null;
             return;
         }
-        let cursor = startBookend.nextSibling;
+        // Suffix Scan
+        let end = 0;
+        // We stop if the suffix hits the prefix
+        while (newLength - 1 - end >= start &&
+            oldLength - 1 - end >= start &&
+            nextItems[newLength - 1 - end] === prevItems[oldLength - 1 - end]) {
+            end++;
+        }
+        // 5. Complex Diff (The Middle)
+        const oldStart = start;
+        const oldEnd = oldLength - end;
+        const newEnd = newLength - end;
+        // A. Build Map of existing items in the "changed" region
+        // key -> { node, index }
+        const keyMap = new Map();
+        for (let i = oldStart; i < oldEnd; i++) {
+            const item = prevItems[i];
+            // If duplicate items exist, first one wins or logic needs to be more robust.
+            // Assuming unique keys for simplicity or using last-write-wins:
+            // if (!keyMap.has(item)) {
+            keyMap.set(item, rowNodes[i]);
+            // } else {
+            // Handle duplicates by removing the extra immediately? 
+            // Or handle collision. For now, assume distinct items or standard behavior.
+            // }
+        }
+        // B. Setup for new node list construction
+        const nextRowNodes = new Array(newLength);
+        // Copy Prefix
         for (let i = 0; i < start; i++) {
-            cursor = cursor.nextSibling;
-        }
-        while (start <= newLength) {
-            const newChd = nextItems[start];
-            const oldChd = prevItems[start];
-            if (newChd === oldChd) {
-                start++;
-                cursor = cursor.nextSibling;
-                continue;
+            nextRowNodes[i] = rowNodes[i];
+        }
+        // Copy Suffix
+        for (let i = 0; i < end; i++) {
+            nextRowNodes[newLength - 1 - i] = rowNodes[oldLength - 1 - i];
+        }
+        // C. Find anchor for insertions
+        // We insert before the first node of the suffix, or the endBookend.
+        const anchor = (end > 0) ? rowNodes[oldLength - end] : endBookend;
+        // D. Iterate new middle
+        for (let i = oldStart; i < newEnd; i++) {
+            const newItem = nextItems[i];
+            let node;
+            if (keyMap.has(newItem)) {
+                // Reuse existing
+                node = keyMap.get(newItem);
+                keyMap.delete(newItem);
+                // DOM Move: 
+                // We always insertBefore the anchor. 
+                // Since we are iterating forward, "anchor" isn't static.
+                // Actually, simply inserting before the *current* anchor works if we 
+                // process carefully, but standard "place and move cursor" is safer.
+                parent.insertBefore(node, anchor);
             }
-            if (oldChd === undefined) {
-                parent.insertBefore(render(newChd), endBookend);
-                start++;
-                continue;
-            }
-            const mappedOld = keyMap.get(newChd);
-            if (mappedOld) {
-                const oldDom = cursor;
-                const { el, item } = mappedOld;
-                if (oldDom !== el) {
-                    const tmp = el.nextSibling;
-                    parent.insertBefore(el, oldDom);
-                    parent.insertBefore(oldDom, tmp);
-                    cursor = el.nextSibling;
-                }
-                else if (item !== newChd) {
-                    const next = el.nextSibling;
-                    replaceWith(newChd, el, render);
-                    cursor = next;
-                }
-                else {
-                    cursor = el.nextSibling;
-                }
-                keyMap.delete(newChd);
-            }
-            else if (oldChd !== newChd) {
-                parent.insertBefore(render(newChd), cursor);
+            else {
+                // Create new
+                node = render(newItem);
+                parent.insertBefore(node, anchor);
             }
-            start++;
-        }
-        for (const { el } of keyMap.values()) {
-            teardownNode(el);
-            remove(el);
-        }
-        keyMap = null;
+            nextRowNodes[i] = node;
+        }
+        // E. Cleanup
+        // Anything remaining in keyMap is gone
+        for (const node of keyMap.values()) {
+            teardownNode(node);
+            remove(node);
+        }
+        // Handle "middle" items that weren't in keyMap (duplicates logic) 
+        // or implicit removals handled by the map logic.
+        // Specifically: We iterated [oldStart...oldEnd] to build the map.
+        // If an item was in that range but NOT in the new range, it's in the map.
+        // If it WAS in the new range, we removed it from the map.
+        // So map.values() is exactly what needs to die. 
+        // Update State
+        rowNodes = nextRowNodes;
         prevItems = nextItems;
-        nextItems = null;
     });
     return outlet;
 }
 export function isolatedTerminalList(props) {
     let parent;
     let outlet = document.createDocumentFragment();
-    let prevItems;
+    // State
+    let prevItems = [];
+    let rowNodes = []; // The "Shadow Array"
     const startBookend = document.createComment("");
     const endBookend = document.createComment("");
     startBookend.$frag = outlet;
@@ -426,157 +414,121 @@ export function isolatedTerminalList(props) {
     const render = props.render;
     staticEffect(() => {
         parent = startBookend.parentNode;
+        // 1. Initialization
         if (!parent) {
-            prevItems = props.items();
-            outlet.append(startBookend, ...prevItems.map(render), endBookend);
-            return;
-        }
-        let nextItems = props.items();
-        let newLength = nextItems.length;
-        let oldLength = prevItems.length;
-        if (!oldLength && newLength) {
-            endBookend.before(...nextItems.map(render));
-            prevItems = nextItems;
-            nextItems = null;
-            return;
-        }
-        const childNodeList = parent.childNodes;
-        if (!newLength) {
-            const end = childNodeList.length - 1;
-            for (let i = 1; i < end; i++) {
-                shallowTeardown(childNodeList[i]);
-            }
-            parent.textContent = "";
-            parent.append(startBookend, endBookend);
-            prevItems = nextItems;
-            nextItems = null;
-            return;
-        }
-        let start = nextItems.findIndex((item, index) => prevItems[index] !== item);
-        if (start === oldLength) {
-            endBookend.before(...nextItems.slice(start).map(render));
-            prevItems = nextItems;
-            nextItems = null;
-            return;
-        }
-        let childNodes = Array.from(childNodeList);
-        if (start < 0) {
-            for (let i = nextItems.length; i < oldLength; i++) {
-                const e = childNodes[1 + --oldLength];
-                shallowTeardown(e);
-                e.remove();
-            }
-            prevItems = nextItems;
-            nextItems = null;
-            childNodes = null;
+            const items = props.items();
+            const newNodes = items.map(render);
+            outlet.append(startBookend, ...newNodes, endBookend);
+            prevItems = items;
+            rowNodes = newNodes;
             return;
         }
-        if (start >= newLength) {
-            while (start < oldLength) {
-                const e = childNodes[1 + --oldLength];
-                shallowTeardown(e);
-                e.remove();
+        const nextItems = props.items();
+        const newLength = nextItems.length;
+        const oldLength = prevItems.length;
+        // 2. Fast Path: Clear All
+        if (newLength === 0) {
+            if (oldLength !== 0) {
+                // Optimization: If the parent only contains our list (between bookends),
+                // we might want to use textContent = "". However, to be safe with 
+                // bookends logic, we remove specifically known nodes.
+                for (let i = 0; i < oldLength; i++) {
+                    const node = rowNodes[i];
+                    shallowTeardown(node);
+                    // node.remove();
+                }
+                parent.textContent = "";
+                parent.append(startBookend, endBookend);
+                rowNodes = [];
+                prevItems = [];
             }
-            prevItems = nextItems;
-            nextItems = null;
-            childNodes = null;
             return;
         }
-        // suffix
-        for (oldLength--, newLength--; newLength > start &&
-            oldLength >= start &&
-            nextItems[newLength] === prevItems[oldLength]; oldLength--, newLength--)
-            ;
-        const nextKeys = new Set(nextItems);
-        const removalQueue = [];
-        for (let i = start; i <= oldLength; i++) {
-            if (!nextKeys.has(prevItems[i])) {
-                const ch = childNodes[i + 1];
-                shallowTeardown(ch);
-                removalQueue.push(ch);
-                childNodes[i + 1] = null;
-            }
-        }
-        if (removalQueue.length === prevItems.length) {
-            parent.textContent = "";
-            parent.append(startBookend, ...nextItems.map(render), endBookend);
+        // 3. Fast Path: Create All
+        if (oldLength === 0) {
+            const newNodes = nextItems.map(render);
+            endBookend.before(...newNodes);
+            rowNodes = newNodes;
             prevItems = nextItems;
-            nextItems = null;
-            childNodes = null;
             return;
         }
-        for (const e of removalQueue) {
-            e.remove();
+        // 4. Reconciliation
+        let start = 0;
+        const minLen = Math.min(oldLength, newLength);
+        // Prefix Scan
+        while (start < minLen && prevItems[start] === nextItems[start]) {
+            start++;
         }
-        if (oldLength - start === removalQueue.length) {
+        // Optimization: Append Suffix
+        if (start === oldLength && newLength > oldLength) {
+            const newPart = nextItems.slice(start);
+            const newNodes = newPart.map(render);
+            endBookend.before(...newNodes);
+            rowNodes = rowNodes.concat(newNodes);
             prevItems = nextItems;
-            nextItems = null;
-            childNodes = null;
             return;
         }
-        let keyMap = new Map();
-        for (let i = start; i <= oldLength; i++) {
-            if (childNodes[i + 1] &&
-                (!nextItems[i] ||
-                    prevItems[i] !== nextItems[i])) {
-                keyMap.set(prevItems[i], {
-                    el: childNodes[i + 1],
-                    item: prevItems[i],
-                });
-            }
-        }
-        if (newLength === oldLength && keyMap.size > (newLength - start + 1) / 2) {
-            const lastOrdered = childNodes[start];
-            const set = [];
-            for (let i = start; i <= newLength; i++) {
-                set.push(keyMap.get(nextItems[i])?.el ?? childNodes[i + 1]);
+        // Optimization: Truncate Suffix
+        if (start === newLength && oldLength > newLength) {
+            for (let i = start; i < oldLength; i++) {
+                const node = rowNodes[i];
+                shallowTeardown(node);
+                node.remove();
             }
-            lastOrdered.after(...set);
+            rowNodes.length = newLength;
             prevItems = nextItems;
-            keyMap = null;
-            nextItems = null;
-            childNodes = null;
             return;
         }
-        while (start <= newLength) {
-            const newChd = nextItems[start];
-            const oldChd = prevItems[start];
-            if (newChd === oldChd) {
-                start++;
-                continue;
-            }
-            if (oldChd === undefined) {
-                parent.insertBefore(render(newChd), endBookend);
-                start++;
-                continue;
-            }
-            const mappedOld = keyMap.get(newChd);
-            if (mappedOld) {
-                const oldDom = childNodeList[start + 1];
-                const { el, item } = mappedOld;
-                if (oldDom !== el) {
-                    const tmp = el.nextSibling;
-                    parent.insertBefore(el, oldDom);
-                    parent.insertBefore(oldDom, tmp);
-                }
-                else if (item !== newChd) {
-                    replaceWith(newChd, el, render);
-                }
-                keyMap.delete(newChd);
+        // Suffix Scan
+        let end = 0;
+        while (newLength - 1 - end >= start &&
+            oldLength - 1 - end >= start &&
+            nextItems[newLength - 1 - end] === prevItems[oldLength - 1 - end]) {
+            end++;
+        }
+        // 5. Complex Diff (The Middle)
+        const oldStart = start;
+        const oldEnd = oldLength - end;
+        const newEnd = newLength - end;
+        // A. Build Map
+        const keyMap = new Map();
+        for (let i = oldStart; i < oldEnd; i++) {
+            const item = prevItems[i];
+            keyMap.set(item, rowNodes[i]);
+        }
+        const nextRowNodes = new Array(newLength);
+        // Copy Prefix
+        for (let i = 0; i < start; i++) {
+            nextRowNodes[i] = rowNodes[i];
+        }
+        // Copy Suffix
+        for (let i = 0; i < end; i++) {
+            nextRowNodes[newLength - 1 - i] = rowNodes[oldLength - 1 - i];
+        }
+        // Determine Anchor (The first node of the suffix, or the end bookend)
+        const anchor = (end > 0) ? rowNodes[oldLength - end] : endBookend;
+        // B. Process Middle
+        for (let i = oldStart; i < newEnd; i++) {
+            const newItem = nextItems[i];
+            if (keyMap.has(newItem)) {
+                const node = keyMap.get(newItem);
+                keyMap.delete(newItem);
+                parent.insertBefore(node, anchor);
+                nextRowNodes[i] = node;
             }
-            else if (oldChd !== newChd) {
-                parent.insertBefore(render(newChd), childNodeList[start + 1]);
+            else {
+                const node = render(newItem);
+                parent.insertBefore(node, anchor);
+                nextRowNodes[i] = node;
             }
-            start++;
         }
-        for (const { el } of keyMap.values()) {
-            shallowTeardown(el);
-            el.remove();
+        // C. Cleanup Unused
+        for (const node of keyMap.values()) {
+            shallowTeardown(node);
+            node.remove();
         }
-        keyMap = null;
+        rowNodes = nextRowNodes;
         prevItems = nextItems;
-        nextItems = null;
-        childNodes = null;
     });
     return outlet;
 }

package/dist/signals.js

@@ -84,7 +84,6 @@ export function $effect(fn) {
     return fn;
 }
 export function staticEffect(fn) {
-    fn.td = null;
     const prev = currentEffect;
     currentEffect = fn;
     fn();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thyn/core",
-  "version": "0.0.228",
+  "version": "0.0.232",
   "scripts": {
     "build": "tsc",
     "pub": "tsc && npm version patch -f && npm -f publish --access=public",