@lvce-editor/virtual-dom-worker 5.2.0 → 6.0.0

package/dist/index.d.ts

@@ -50,8 +50,7 @@ export interface RemovePatch {
 	readonly type: 5;
 }
 export interface ReplacePatch {
-	readonly index: number;
-	readonly node: VirtualDomNode;
+	readonly nodes: readonly VirtualDomNode[];
 	readonly type: 2;
 }
 export interface TextPatch {
@@ -60,6 +59,7 @@ export interface TextPatch {
 }
 export type Patch = TextPatch | AttributePatch | ReplacePatch | RemoveAttributePatch | RemovePatch | AddPatch | NavigateChildPatch | NavigateParentPatch | RemoveChildPatch | NavigateSiblingPatch;
 export declare const diff: (oldNodes: readonly VirtualDomNode[], newNodes: readonly VirtualDomNode[]) => readonly Patch[];
+export declare const diffTree: (oldNodes: readonly VirtualDomNode[], newNodes: readonly VirtualDomNode[]) => readonly Patch[];
 
 declare namespace AriaLive {
 	export { Polite };

package/dist/parts/Main/Main.js

@@ -4,3 +4,4 @@ export * from "../MergeClassNames/MergeClassNames.js";
 export * from "../Px/Px.js";
 export * from "../Text/Text.js";
 export { diff } from "../VirtualDomDiff/VirtualDomDiff.js";
+export { diffTree } from "../VirtualDomDiffTree/VirtualDomDiffTree.js";

package/dist/parts/VirtualDomDiffTree/AddNavigationPatches.js

@@ -0,0 +1,39 @@
+import * as PatchType from "../PatchType/PatchType.js";
+export const addNavigationPatches = (patches, path, currentIndex, currentPath = []) => {
+    // Only add navigation if we're not at the root
+    if (path.length === 0 && currentIndex === 0) {
+        return;
+    }
+    // The target path is path + currentIndex
+    // But if path already includes the current position, we need to check differently
+    // When comparing nodes at path [0, 0], we're already at [0, 0]
+    // So if path is [0, 0] and currentIndex is 0, the target is [0, 0] (not [0, 0, 0])
+    // We're comparing the node at path, not its child
+    const targetPath = [...path];
+    // If we're already at the target path, don't add navigation
+    if (currentPath.length === targetPath.length &&
+        currentPath.every((val, idx) => val === targetPath[idx])) {
+        // Only add sibling navigation if needed
+        if (currentIndex > 0) {
+            patches.push({
+                type: PatchType.NavigateSibling,
+                index: currentIndex,
+            });
+        }
+        return;
+    }
+    // Navigate to the correct position
+    for (let i = 0; i < path.length; i++) {
+        patches.push({
+            type: PatchType.NavigateChild,
+            index: path[i],
+        });
+    }
+    // Navigate to sibling if needed
+    if (currentIndex > 0) {
+        patches.push({
+            type: PatchType.NavigateSibling,
+            index: currentIndex,
+        });
+    }
+};

package/dist/parts/VirtualDomDiffTree/CompareNodes.js

@@ -0,0 +1,45 @@
+import { VirtualDomElements } from '@lvce-editor/constants';
+import * as GetKeys from "../GetKeys/GetKeys.js";
+import * as PatchType from "../PatchType/PatchType.js";
+export const compareNodes = (oldNode, newNode) => {
+    const patches = [];
+    // Check if node type changed - return null to signal incompatible nodes
+    // (caller should handle this with a Replace operation)
+    if (oldNode.type !== newNode.type) {
+        return null;
+    }
+    // Handle text nodes
+    if (oldNode.type === VirtualDomElements.Text &&
+        newNode.type === VirtualDomElements.Text) {
+        if (oldNode.text !== newNode.text) {
+            patches.push({
+                type: PatchType.SetText,
+                value: newNode.text,
+            });
+        }
+        return patches;
+    }
+    // Compare attributes
+    const oldKeys = GetKeys.getKeys(oldNode);
+    const newKeys = GetKeys.getKeys(newNode);
+    // Check for attribute changes
+    for (const key of newKeys) {
+        if (oldNode[key] !== newNode[key]) {
+            patches.push({
+                type: PatchType.SetAttribute,
+                key,
+                value: newNode[key],
+            });
+        }
+    }
+    // Check for removed attributes
+    for (const key of oldKeys) {
+        if (!(key in newNode)) {
+            patches.push({
+                type: PatchType.RemoveAttribute,
+                key,
+            });
+        }
+    }
+    return patches;
+};

package/dist/parts/VirtualDomDiffTree/DiffTrees.js

@@ -0,0 +1,140 @@
+import * as PatchType from "../PatchType/PatchType.js";
+import * as CompareNodes from "./CompareNodes.js";
+import * as TreeToArray from "./TreeToArray.js";
+const diffChildren = (oldChildren, newChildren, patches) => {
+    const maxLength = Math.max(oldChildren.length, newChildren.length);
+    // Track where we are: -1 means at parent, >= 0 means at child index
+    let currentChildIndex = -1;
+    // Collect indices of children to remove (we'll add these patches at the end in reverse order)
+    const indicesToRemove = [];
+    for (let i = 0; i < maxLength; i++) {
+        const oldNode = oldChildren[i];
+        const newNode = newChildren[i];
+        if (!oldNode && !newNode) {
+            continue;
+        }
+        if (!oldNode) {
+            // Add new node - we should be at the parent
+            if (currentChildIndex >= 0) {
+                // Navigate back to parent
+                patches.push({
+                    type: PatchType.NavigateParent,
+                });
+                currentChildIndex = -1;
+            }
+            // Flatten the entire subtree so renderInternal can handle it
+            const flatNodes = TreeToArray.treeToArray(newNode);
+            patches.push({
+                type: PatchType.Add,
+                nodes: flatNodes,
+            });
+        }
+        else if (newNode) {
+            // Compare nodes to see if we need any patches
+            const nodePatches = CompareNodes.compareNodes(oldNode.node, newNode.node);
+            // If nodePatches is null, the node types are incompatible - need to replace
+            if (nodePatches === null) {
+                // Navigate to this child
+                if (currentChildIndex === -1) {
+                    patches.push({
+                        type: PatchType.NavigateChild,
+                        index: i,
+                    });
+                    currentChildIndex = i;
+                }
+                else if (currentChildIndex !== i) {
+                    patches.push({
+                        type: PatchType.NavigateSibling,
+                        index: i,
+                    });
+                    currentChildIndex = i;
+                }
+                // Replace the entire subtree
+                const flatNodes = TreeToArray.treeToArray(newNode);
+                patches.push({
+                    type: PatchType.Replace,
+                    nodes: flatNodes,
+                });
+                // After replace, we're at the new element (same position)
+                continue;
+            }
+            // Check if we need to recurse into children
+            const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+            // Only navigate to this element if we need to do something
+            if (nodePatches.length > 0 || hasChildrenToCompare) {
+                // Navigate to this child if not already there
+                if (currentChildIndex === -1) {
+                    patches.push({
+                        type: PatchType.NavigateChild,
+                        index: i,
+                    });
+                    currentChildIndex = i;
+                }
+                else if (currentChildIndex !== i) {
+                    patches.push({
+                        type: PatchType.NavigateSibling,
+                        index: i,
+                    });
+                    currentChildIndex = i;
+                }
+                // Apply node patches (these apply to the current element, not children)
+                if (nodePatches.length > 0) {
+                    patches.push(...nodePatches);
+                }
+                // Compare children recursively
+                if (hasChildrenToCompare) {
+                    diffChildren(oldNode.children, newNode.children, patches);
+                }
+            }
+        }
+        else {
+            // Remove old node - collect the index for later removal
+            indicesToRemove.push(i);
+        }
+    }
+    // Navigate back to parent if we ended at a child
+    if (currentChildIndex >= 0) {
+        patches.push({
+            type: PatchType.NavigateParent,
+        });
+        currentChildIndex = -1;
+    }
+    // Add remove patches in reverse order (highest index first)
+    // This ensures indices remain valid as we remove
+    for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+        patches.push({
+            type: PatchType.RemoveChild,
+            index: indicesToRemove[j],
+        });
+    }
+};
+export const diffTrees = (oldTree, newTree, patches, path) => {
+    // At the root level (path.length === 0), we're already AT the element
+    // So we compare the root node directly, then compare its children
+    if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+        const oldNode = oldTree[0];
+        const newNode = newTree[0];
+        // Compare root nodes
+        const nodePatches = CompareNodes.compareNodes(oldNode.node, newNode.node);
+        // If nodePatches is null, the root node types are incompatible - need to replace
+        if (nodePatches === null) {
+            const flatNodes = TreeToArray.treeToArray(newNode);
+            patches.push({
+                type: PatchType.Replace,
+                nodes: flatNodes,
+            });
+            return;
+        }
+        if (nodePatches.length > 0) {
+            patches.push(...nodePatches);
+        }
+        // Compare children
+        if (oldNode.children.length > 0 || newNode.children.length > 0) {
+            diffChildren(oldNode.children, newNode.children, patches);
+        }
+    }
+    else {
+        // Non-root level or multiple root elements - use the regular comparison
+        diffChildren(oldTree, newTree, patches);
+    }
+};

package/dist/parts/VirtualDomDiffTree/RemoveTrailingNavigationPatches.js

@@ -0,0 +1,18 @@
+import * as PatchType from "../PatchType/PatchType.js";
+export const removeTrailingNavigationPatches = (patches) => {
+    // Find the last non-navigation patch
+    let lastNonNavigationIndex = -1;
+    for (let i = patches.length - 1; i >= 0; i--) {
+        const patch = patches[i];
+        if (patch.type !== PatchType.NavigateChild &&
+            patch.type !== PatchType.NavigateParent &&
+            patch.type !== PatchType.NavigateSibling) {
+            lastNonNavigationIndex = i;
+            break;
+        }
+    }
+    // Return patches up to and including the last non-navigation patch
+    return lastNonNavigationIndex === -1
+        ? []
+        : patches.slice(0, lastNonNavigationIndex + 1);
+};

package/dist/parts/VirtualDomDiffTree/TreeToArray.js

@@ -0,0 +1,7 @@
+export const treeToArray = (node) => {
+    const result = [node.node];
+    for (const child of node.children) {
+        result.push(...treeToArray(child));
+    }
+    return result;
+};

package/dist/parts/VirtualDomDiffTree/VirtualDomDiffTree.js

@@ -0,0 +1,13 @@
+import * as VirtualDomTree from "../VirtualDomTree/VirtualDomTree.js";
+import * as DiffTrees from "./DiffTrees.js";
+import * as RemoveTrailingNavigationPatches from "./RemoveTrailingNavigationPatches.js";
+export const diffTree = (oldNodes, newNodes) => {
+    // Step 1: Convert flat arrays to tree structures
+    const oldTree = VirtualDomTree.arrayToTree(oldNodes);
+    const newTree = VirtualDomTree.arrayToTree(newNodes);
+    // Step 3: Compare the trees
+    const patches = [];
+    DiffTrees.diffTrees(oldTree, newTree, patches, []);
+    // Remove trailing navigation patches since they serve no purpose
+    return RemoveTrailingNavigationPatches.removeTrailingNavigationPatches(patches);
+};

package/dist/parts/VirtualDomTree/VirtualDomTree.js

@@ -0,0 +1,37 @@
+export const arrayToTree = (nodes) => {
+    const result = [];
+    let i = 0;
+    while (i < nodes.length) {
+        const node = nodes[i];
+        const { children, nodesConsumed } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
+        result.push({
+            node,
+            children,
+        });
+        i += 1 + nodesConsumed;
+    }
+    return result;
+};
+const getChildrenWithCount = (nodes, startIndex, childCount) => {
+    if (childCount === 0) {
+        return { children: [], nodesConsumed: 0 };
+    }
+    const children = [];
+    let i = startIndex;
+    let remaining = childCount;
+    let totalConsumed = 0;
+    while (remaining > 0 && i < nodes.length) {
+        const node = nodes[i];
+        const nodeChildCount = node.childCount || 0;
+        const { children: nodeChildren, nodesConsumed } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
+        children.push({
+            node,
+            children: nodeChildren,
+        });
+        const nodeSize = 1 + nodesConsumed;
+        i += nodeSize;
+        totalConsumed += nodeSize;
+        remaining--;
+    }
+    return { children, nodesConsumed: totalConsumed };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/virtual-dom-worker",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lvce-editor/virtual-dom.git"