rask-ui 0.2.4 → 0.2.5

package/dist/tests/patchChildren.test.js

@@ -46,7 +46,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode("a");
             const newChild2 = new MockVNode("b");
             const parent = new MockParentVNode([]);
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2]));
             // New children should be mounted
             expect(newChild1.mountCalls).toBe(1);
             expect(newChild2.mountCalls).toBe(1);
@@ -54,17 +54,19 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(newChild2.parent).toBe(parent);
             // Result should be the new children (since old was empty)
             expect(result).toEqual([newChild1, newChild2]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should unmount all old children when new is empty", () => {
             const oldChild1 = new MockVNode("a");
             const oldChild2 = new MockVNode("b");
             const parent = new MockParentVNode([oldChild1, oldChild2]);
-            const result = parent.patchChildren(toVNodes([]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([]));
             // Old children should be unmounted
             expect(oldChild1.unmountCalls).toBe(1);
             expect(oldChild2.unmountCalls).toBe(1);
             // Result should be empty
             expect(result).toEqual([]);
+            expect(hasChangedStructure).toBe(true);
         });
     });
     describe("Patching with keys", () => {
@@ -76,7 +78,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode("a");
             const newChild2 = new MockVNode("b");
             const newChild3 = new MockVNode("c");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // OLD children should be patched with new children
             expect(oldChild1.patchCalls).toBe(1);
             expect(oldChild2.patchCalls).toBe(1);
@@ -94,6 +96,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild3.unmountCalls).toBe(0);
             // Result should still be the OLD children (reused)
             expect(result).toEqual([oldChild1, oldChild2, oldChild3]);
+            expect(hasChangedStructure).toBe(false);
         });
         it("should handle reordered children with keys", () => {
             const oldChild1 = new MockVNode("a");
@@ -104,7 +107,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode("c");
             const newChild2 = new MockVNode("a");
             const newChild3 = new MockVNode("b");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // Old nodes should be patched with corresponding new nodes by key
             expect(oldChild1.patchedWith).toBe(newChild2); // a->a
             expect(oldChild2.patchedWith).toBe(newChild3); // b->b
@@ -119,6 +122,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(result[0].key).toBe("c");
             expect(result[1].key).toBe("a");
             expect(result[2].key).toBe("b");
+            expect(hasChangedStructure).toBe(true);
         });
         it("should mount new children and unmount removed children", () => {
             const oldChild1 = new MockVNode("a");
@@ -129,7 +133,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode("a");
             const newChild2 = new MockVNode("c");
             const newChild3 = new MockVNode("d");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // a and c should be patched (reused)
             expect(oldChild1.patchedWith).toBe(newChild1);
             expect(oldChild3.patchedWith).toBe(newChild2);
@@ -143,6 +147,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(result).toContain(newChild3);
             expect(result).not.toContain(oldChild2);
             expect(result.length).toBe(3);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should replace all children when all keys change", () => {
             const oldChild1 = new MockVNode("a");
@@ -150,7 +155,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const parent = new MockParentVNode([oldChild1, oldChild2]);
             const newChild1 = new MockVNode("x");
             const newChild2 = new MockVNode("y");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2]));
             // All new children should be mounted
             expect(newChild1.mountCalls).toBe(1);
             expect(newChild2.mountCalls).toBe(1);
@@ -159,6 +164,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild2.unmountCalls).toBe(1);
             // Result should be the new children
             expect(result).toEqual([newChild1, newChild2]);
+            expect(hasChangedStructure).toBe(true);
         });
     });
     describe("Patching without keys (index-based)", () => {
@@ -170,7 +176,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode();
             const newChild2 = new MockVNode();
             const newChild3 = new MockVNode();
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // Should patch by index: 0->0, 1->1, 2->2
             expect(oldChild1.patchedWith).toBe(newChild1);
             expect(oldChild2.patchedWith).toBe(newChild2);
@@ -181,6 +187,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild3.unmountCalls).toBe(0);
             // Result should be old children (reused)
             expect(result).toEqual([oldChild1, oldChild2, oldChild3]);
+            expect(hasChangedStructure).toBe(false);
         });
         it("should mount new children when growing without keys", () => {
             const oldChild1 = new MockVNode();
@@ -190,7 +197,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild2 = new MockVNode();
             const newChild3 = new MockVNode();
             const newChild4 = new MockVNode();
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3, newChild4]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3, newChild4]));
             // First two should be patched (reused)
             expect(oldChild1.patchedWith).toBe(newChild1);
             expect(oldChild2.patchedWith).toBe(newChild2);
@@ -202,6 +209,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild2.unmountCalls).toBe(0);
             // Result should be [oldChild1, oldChild2, newChild3, newChild4]
             expect(result).toEqual([oldChild1, oldChild2, newChild3, newChild4]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should unmount old children when shrinking without keys", () => {
             const oldChild1 = new MockVNode();
@@ -216,7 +224,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             ]);
             const newChild1 = new MockVNode();
             const newChild2 = new MockVNode();
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2]));
             // First two should be patched
             expect(oldChild1.patchedWith).toBe(newChild1);
             expect(oldChild2.patchedWith).toBe(newChild2);
@@ -228,6 +236,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild2.unmountCalls).toBe(0);
             // Result should be [oldChild1, oldChild2]
             expect(result).toEqual([oldChild1, oldChild2]);
+            expect(hasChangedStructure).toBe(true);
         });
     });
     describe("Mixed keys and indices", () => {
@@ -239,7 +248,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode("a"); // key: "a"
             const newChild2 = new MockVNode(); // key: undefined -> index 1
             const newChild3 = new MockVNode("c"); // key: "c"
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // Keyed children should patch by key
             expect(oldChild1.patchedWith).toBe(newChild1);
             expect(oldChild3.patchedWith).toBe(newChild3);
@@ -251,6 +260,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild3.unmountCalls).toBe(0);
             // Result should be old children (reused)
             expect(result).toEqual([oldChild1, oldChild2, oldChild3]);
+            expect(hasChangedStructure).toBe(false);
         });
     });
     describe("Real-world scenarios", () => {
@@ -259,7 +269,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const parent = new MockParentVNode([oldChild1]);
             const newChild1 = new MockVNode("title");
             const newChild2 = new MockVNode("details");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2]));
             // Title should be patched (reused)
             expect(oldChild1.patchedWith).toBe(newChild1);
             // Details should be mounted
@@ -268,13 +278,14 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild1.unmountCalls).toBe(0);
             // Result should be [oldChild1, newChild2]
             expect(result).toEqual([oldChild1, newChild2]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should handle conditional rendering (component -> null)", () => {
             const oldChild1 = new MockVNode("title");
             const oldChild2 = new MockVNode("details");
             const parent = new MockParentVNode([oldChild1, oldChild2]);
             const newChild1 = new MockVNode("title");
-            const result = parent.patchChildren(toVNodes([newChild1]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1]));
             // Title should be patched (reused)
             expect(oldChild1.patchedWith).toBe(newChild1);
             // Details should be unmounted
@@ -283,6 +294,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild1.unmountCalls).toBe(0);
             // Result should be [oldChild1]
             expect(result).toEqual([oldChild1]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should handle list with items added at beginning", () => {
             const oldChild1 = new MockVNode("item-1");
@@ -291,7 +303,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode("item-0"); // New item at start
             const newChild2 = new MockVNode("item-1");
             const newChild3 = new MockVNode("item-2");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // New item should be mounted
             expect(newChild1.mountCalls).toBe(1);
             // Existing items should be patched (reused)
@@ -302,6 +314,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild2.unmountCalls).toBe(0);
             // Result should be [newChild1, oldChild1, oldChild2]
             expect(result).toEqual([newChild1, oldChild1, oldChild2]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should handle list with items added at end", () => {
             const oldChild1 = new MockVNode("item-1");
@@ -310,7 +323,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const newChild1 = new MockVNode("item-1");
             const newChild2 = new MockVNode("item-2");
             const newChild3 = new MockVNode("item-3"); // New item at end
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // Existing items should be patched (reused)
             expect(oldChild1.patchedWith).toBe(newChild1);
             expect(oldChild2.patchedWith).toBe(newChild2);
@@ -321,6 +334,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild2.unmountCalls).toBe(0);
             // Result should be [oldChild1, oldChild2, newChild3]
             expect(result).toEqual([oldChild1, oldChild2, newChild3]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should handle list with item removed from middle", () => {
             const oldChild1 = new MockVNode("item-1");
@@ -329,7 +343,7 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const parent = new MockParentVNode([oldChild1, oldChild2, oldChild3]);
             const newChild1 = new MockVNode("item-1");
             const newChild2 = new MockVNode("item-3"); // item-2 removed
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2]));
             // item-1 and item-3 should be patched (reused)
             expect(oldChild1.patchedWith).toBe(newChild1);
             expect(oldChild3.patchedWith).toBe(newChild2);
@@ -340,32 +354,35 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             expect(oldChild3.unmountCalls).toBe(0);
             // Result should be [oldChild1, oldChild3]
             expect(result).toEqual([oldChild1, oldChild3]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should handle empty -> multiple children", () => {
             const parent = new MockParentVNode([]);
             const newChild1 = new MockVNode("a");
             const newChild2 = new MockVNode("b");
             const newChild3 = new MockVNode("c");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2, newChild3]));
             // All should be mounted
             expect(newChild1.mountCalls).toBe(1);
             expect(newChild2.mountCalls).toBe(1);
             expect(newChild3.mountCalls).toBe(1);
             // Result should be the new children
             expect(result).toEqual([newChild1, newChild2, newChild3]);
+            expect(hasChangedStructure).toBe(true);
         });
         it("should handle multiple children -> empty", () => {
             const oldChild1 = new MockVNode("a");
             const oldChild2 = new MockVNode("b");
             const oldChild3 = new MockVNode("c");
             const parent = new MockParentVNode([oldChild1, oldChild2, oldChild3]);
-            const result = parent.patchChildren(toVNodes([]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([]));
             // All should be unmounted
             expect(oldChild1.unmountCalls).toBe(1);
             expect(oldChild2.unmountCalls).toBe(1);
             expect(oldChild3.unmountCalls).toBe(1);
             // Result should be empty
             expect(result).toEqual([]);
+            expect(hasChangedStructure).toBe(true);
         });
     });
     describe("Object reference preservation", () => {
@@ -375,13 +392,14 @@ describe("patchChildren (new approach: keep old, patch in new)", () => {
             const parent = new MockParentVNode([oldChild1, oldChild2]);
             const newChild1 = new MockVNode("a");
             const newChild2 = new MockVNode("b");
-            const result = parent.patchChildren(toVNodes([newChild1, newChild2]));
+            const { children: result, hasChangedStructure } = parent.patchChildren(toVNodes([newChild1, newChild2]));
             // The result should contain the EXACT SAME object references as the old children
             expect(result[0]).toBe(oldChild1); // Same object reference
             expect(result[1]).toBe(oldChild2); // Same object reference
             // NOT the new children
             expect(result[0]).not.toBe(newChild1);
             expect(result[1]).not.toBe(newChild2);
+            expect(hasChangedStructure).toBe(false);
         });
     });
 });

package/dist/vdom/AbstractVNode.d.ts

@@ -17,6 +17,9 @@ export declare abstract class AbstractVNode {
     getElements(): Node[];
     getParentElement(): HTMLElement;
     protected canPatch(oldNode: VNode, newNode: VNode): boolean;
-    patchChildren(newChildren: VNode[]): VNode[];
+    patchChildren(newChildren: VNode[]): {
+        children: VNode[];
+        hasChangedStructure: boolean;
+    };
 }
 //# sourceMappingURL=AbstractVNode.d.ts.map

package/dist/vdom/AbstractVNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/AbstractVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,aAAa;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC;IACnB,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,EAAE;IAC7C,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI;IACpC,QAAQ,CAAC,OAAO,IAAI,IAAI;IACxB,QAAQ,CAAC,QAAQ,IAAI,IAAI;IACzB,SAAS,CAAC,cAAc;IAOxB;;OAEG;IACH,WAAW,IAAI,IAAI,EAAE;IAWrB,gBAAgB,IAAI,WAAW;IAiB/B,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,GAAG,OAAO;IAoB3D,aAAa,CAAC,WAAW,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE;CA2D7C"}
+{"version":3,"file":"AbstractVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/AbstractVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,aAAa;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC;IACnB,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,EAAE;IAC7C,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI;IACpC,QAAQ,CAAC,OAAO,IAAI,IAAI;IACxB,QAAQ,CAAC,QAAQ,IAAI,IAAI;IACzB,SAAS,CAAC,cAAc;IAOxB;;OAEG;IACH,WAAW,IAAI,IAAI,EAAE;IAWrB,gBAAgB,IAAI,WAAW;IAiB/B,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,GAAG,OAAO;IAoB3D,aAAa,CAAC,WAAW,EAAE,KAAK,EAAE,GAAG;QACnC,QAAQ,EAAE,KAAK,EAAE,CAAC;QAClB,mBAAmB,EAAE,OAAO,CAAC;KAC9B;CAqEF"}

package/dist/vdom/AbstractVNode.js

@@ -57,19 +57,23 @@ export class AbstractVNode {
         // When there are only new children, we just mount them
         if (newChildren && prevChildren.length === 0) {
             newChildren.forEach((child) => child.mount(this));
-            return newChildren;
+            return { children: newChildren, hasChangedStructure: true };
         }
         // If we want to remove all children, we just unmount the previous ones
         if (!newChildren.length && prevChildren.length) {
             prevChildren.forEach((child) => child.unmount());
-            return [];
+            return { children: [], hasChangedStructure: true };
         }
         const oldKeys = {};
         prevChildren.forEach((prevChild, index) => {
-            oldKeys[prevChild.key || index] = prevChild;
+            oldKeys[prevChild.key || index] = {
+                vnode: prevChild,
+                index,
+            };
         });
         // Build result array in the NEW order
         const result = [];
+        let hasChangedStructure = false;
         newChildren.forEach((newChild, index) => {
             const key = newChild.key || index;
             const prevChild = oldKeys[key];
@@ -77,30 +81,35 @@ export class AbstractVNode {
                 // New child - mount and add to result
                 newChild.mount(this);
                 result.push(newChild);
+                hasChangedStructure = true;
             }
-            else if (prevChild === newChild) {
+            else if (prevChild?.vnode === newChild) {
                 // Same instance - no patching needed, just reuse
-                result.push(prevChild);
+                result.push(prevChild.vnode);
                 delete oldKeys[key];
+                hasChangedStructure = hasChangedStructure || prevChild.index !== index;
             }
-            else if (this.canPatch(prevChild, newChild)) {
+            else if (this.canPatch(prevChild.vnode, newChild)) {
                 // Compatible types - patch and reuse old VNode
-                prevChild.patch(newChild);
-                result.push(prevChild);
+                prevChild.vnode.patch(newChild);
+                result.push(prevChild.vnode);
                 delete oldKeys[key];
+                hasChangedStructure = hasChangedStructure || prevChild.index !== index;
             }
             else {
                 // Incompatible types - replace completely
                 newChild.mount(this);
-                prevChild.unmount();
+                prevChild.vnode.unmount();
                 result.push(newChild);
                 delete oldKeys[key];
+                hasChangedStructure = true;
             }
         });
         // Unmount any old children that weren't reused
         for (const key in oldKeys) {
-            oldKeys[key].unmount();
+            oldKeys[key].vnode.unmount();
+            hasChangedStructure = true;
         }
-        return result;
+        return { children: result, hasChangedStructure };
     }
 }

package/dist/vdom/ComponentVNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComponentVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/ComponentVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,QAAQ,EAAU,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGvC,MAAM,MAAM,cAAc,GACtB,KAAK,GACL,MAAM,GACN,IAAI,GACJ,MAAM,GACN,SAAS,GACT,OAAO,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,cAAc,EAAE,CAAC;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,KAAK,IACjC,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,iBAAiB,CAAC,GACvC,CAAC,MAAM,MAAM,iBAAiB,CAAC,CAAC;AAEpC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACtC,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC5B,UAAU,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACnC,CAAC;AAKF,wBAAgB,mBAAmB,sBAYlC;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,QAYrC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,QAYvC;AAED,qBAAa,cAAe,SAAQ,aAAa;IAC/C,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1B,KAAK,EAAE,KAAK,CAAC;IAEb,QAAQ,EAAE,KAAK,EAAE,CAAM;IACvB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;gBAE3B,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,EACzB,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,KAAK,EAAE,EACjB,GAAG,CAAC,EAAE,MAAM;IAWd,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;IAyI7B,KAAK,CAAC,OAAO,EAAE,cAAc;IAW7B,OAAO;CAcR"}
+{"version":3,"file":"ComponentVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/ComponentVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,QAAQ,EAAU,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGvC,MAAM,MAAM,cAAc,GACtB,KAAK,GACL,MAAM,GACN,IAAI,GACJ,MAAM,GACN,SAAS,GACT,OAAO,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,cAAc,EAAE,CAAC;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,KAAK,IACjC,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,iBAAiB,CAAC,GACvC,CAAC,MAAM,MAAM,iBAAiB,CAAC,CAAC;AAEpC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACtC,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC5B,UAAU,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACnC,CAAC;AAKF,wBAAgB,mBAAmB,sBAYlC;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,QAYrC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,QAYvC;AAED,qBAAa,cAAe,SAAQ,aAAa;IAC/C,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1B,KAAK,EAAE,KAAK,CAAC;IAEb,QAAQ,EAAE,KAAK,EAAE,CAAM;IACvB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;gBAE3B,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,EACzB,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,KAAK,EAAE,EACjB,GAAG,CAAC,EAAE,MAAM;IAWd,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;IAmI7B,KAAK,CAAC,OAAO,EAAE,cAAc;IAW7B,OAAO;CAcR"}

package/dist/vdom/ComponentVNode.js

@@ -4,7 +4,6 @@ import { FragmentVNode } from "./FragmentVNode";
 import { RootVNode } from "./RootVNode";
 import { normalizeChildren } from "./utils";
 import { currentRoot } from "./RootVNode";
-import { ElementVNode } from "./ElementVNode";
 export function getCurrentComponent() {
     if (!currentRoot) {
         throw new Error("No current root");
@@ -97,15 +96,9 @@ export class ComponentVNode extends AbstractVNode {
                     this.root?.setAsCurrent();
                     const newChildren = executeRender();
                     const prevChildren = this.children;
-                    this.children = this.patchChildren(newChildren);
-                    // Typically components return a single element, which does
-                    // not require the parent to apply elements to the DOM again
-                    const canSelfUpdate = prevChildren.length === 1 &&
-                        this.children.length === 1 &&
-                        prevChildren[0] instanceof ElementVNode &&
-                        this.children[0] instanceof ElementVNode &&
-                        this.canPatch(prevChildren[0], this.children[0]);
-                    if (!canSelfUpdate) {
+                    const { children, hasChangedStructure } = this.patchChildren(newChildren);
+                    this.children = children;
+                    if (hasChangedStructure) {
                         this.parent?.rerender();
                     }
                     this.root?.clearCurrent();

package/dist/vdom/ElementVNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ElementVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/ElementVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAUvC,qBAAa,YAAa,SAAQ,aAAa;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,GAAG,CAAC,CAA0D;IACtE,OAAO,CAAC,cAAc,CAAC,CAA6B;gBAElD,GAAG,EAAE,MAAM,EACX,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,EACxB,QAAQ,EAAE,KAAK,EAAE,EACjB,GAAG,CAAC,EAAE,MAAM;IASd,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI;IAkC3B;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,YAAY;IAM3B,OAAO;IAYP,OAAO,CAAC,OAAO,CAoCb;IACF,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,gBAAgB;IAgBxB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAyBxB"}
+{"version":3,"file":"ElementVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/ElementVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAUvC,qBAAa,YAAa,SAAQ,aAAa;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,GAAG,CAAC,CAA0D;IACtE,OAAO,CAAC,cAAc,CAAC,CAA6B;gBAElD,GAAG,EAAE,MAAM,EACX,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,EACxB,QAAQ,EAAE,KAAK,EAAE,EACjB,GAAG,CAAC,EAAE,MAAM;IASd,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI;IAkC3B;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,YAAY;IAY3B,OAAO;IAYP,OAAO,CAAC,OAAO,CAoCb;IACF,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,gBAAgB;IAgBxB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAyBxB"}

package/dist/vdom/ElementVNode.js

@@ -57,8 +57,11 @@ export class ElementVNode extends AbstractVNode {
     patch(newNode) {
         this.patchProps(newNode.props);
         this.props = newNode.props;
-        this.children = this.patchChildren(newNode.children);
-        this.syncDOMChildren();
+        const { children, hasChangedStructure } = this.patchChildren(newNode.children);
+        this.children = children;
+        if (hasChangedStructure) {
+            this.syncDOMChildren();
+        }
     }
     unmount() {
         this.children.forEach((child) => child.unmount());

package/dist/vdom/FragmentVNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FragmentVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/FragmentVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,eAAO,MAAM,QAAQ,eAAqB,CAAC;AAE3C,qBAAa,aAAc,SAAQ,aAAa;IAC9C,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;gBAED,QAAQ,EAAE,KAAK,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM;IAK3C,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;IAW7B,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,OAAO,EAAE,aAAa;IAG5B,OAAO;CAMR"}
+{"version":3,"file":"FragmentVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/FragmentVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,eAAO,MAAM,QAAQ,eAAqB,CAAC;AAE3C,qBAAa,aAAc,SAAQ,aAAa;IAC9C,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;gBAED,QAAQ,EAAE,KAAK,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM;IAK3C,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;IAW7B,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,OAAO,EAAE,aAAa;IAS5B,OAAO;CAMR"}

package/dist/vdom/FragmentVNode.js

@@ -23,7 +23,11 @@ export class FragmentVNode extends AbstractVNode {
         this.parent?.rerender();
     }
     patch(newNode) {
-        this.children = this.patchChildren(newNode.children);
+        const { children, hasChangedStructure } = this.patchChildren(newNode.children);
+        this.children = children;
+        if (hasChangedStructure) {
+            this.rerender();
+        }
     }
     unmount() {
         this.children.forEach((child) => child.unmount());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rask-ui",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",