@simpreact/simpreact 0.0.8 → 0.0.9

package/core/patchingChildren.js

@@ -1,30 +1,14 @@
 import { SIMP_ELEMENT_CHILD_FLAG_ELEMENT, SIMP_ELEMENT_CHILD_FLAG_LIST, SIMP_ELEMENT_CHILD_FLAG_TEXT, } from './createElement.js';
-import { _pushHostOperationPlaceElement } from './hostOperations.js';
-import { _pushMountEnterFrame } from './mounting.js';
-import { _pushMountChildrenFrame } from './mountingChildren.js';
-import { _pushPatchEnterFrame } from './patching.js';
-import { PATCH_CHILDREN, PATCH_KEYED_CHILDREN, } from './processStack.js';
-import { _pushUnmountEnterFrame } from './unmounting.js';
-import { _pushUnmountChildrenFrame } from './unmountingChildren.js';
-import { _clearElementHostReference, getLongestIncreasingSubsequenceIndexes, isHostLike } from './utils.js';
-export function _pushPatchChildrenFrame(parent, meta) {
-    meta.renderRuntime.renderStack.push({
-        node: parent,
-        kind: PATCH_CHILDREN,
-        meta,
-    });
-}
-export function _pushPatchKeyedChildrenFrame(element, meta) {
-    meta.renderRuntime.renderStack.push({
-        node: element,
-        kind: PATCH_KEYED_CHILDREN,
-        meta,
-    });
-}
-export function _patchChildren(frame) {
-    const parentElement = frame.node;
-    const { renderRuntime, parentReference, context, hostNamespace, nextChildren, prevChildren, prevParentChildFlag, nextParentChildFlag, prevParentElement, } = frame.meta;
-    const subtreeRightBoundary = isHostLike(parentElement.flag) ? null : frame.meta.subtreeRightBoundary;
+import { pushHostOperationPlaceElement } from './hostOperations.js';
+import { pushMountEnterFrame } from './mounting.js';
+import { pushMountChildrenFrame } from './mountingChildren.js';
+import { pushPatchEnterFrame } from './patching.js';
+import { pushUnmountEnterFrame } from './unmounting.js';
+import { pushUnmountChildrenFrame } from './unmountingChildren.js';
+import { clearElementHostReference, getLongestIncreasingSubsequenceIndexes, isHostLike } from './utils.js';
+export function patchChildren(parentElement, meta) {
+    const { renderRuntime, parentReference, context, hostNamespace, nextChildren, prevChildren, prevParentChildFlag, nextParentChildFlag, prevParentElement, } = meta;
+    const subtreeRightBoundary = isHostLike(parentElement.flag) ? null : meta.subtreeRightBoundary;
     switch (prevParentChildFlag) {
         case SIMP_ELEMENT_CHILD_FLAG_LIST: {
             switch (nextParentChildFlag) {
@@ -32,7 +16,7 @@ export function _patchChildren(frame) {
                     for (const child of nextChildren) {
                         child.parent = parentElement;
                     }
-                    _pushPatchKeyedChildrenFrame(parentElement, {
+                    patchKeyedChildren(parentElement, {
                         prevChildren,
                         nextChildren,
                         subtreeRightBoundary,
@@ -48,7 +32,7 @@ export function _patchChildren(frame) {
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_ELEMENT: {
                     nextChildren.parent = parentElement;
-                    _pushPatchKeyedChildrenFrame(parentElement, {
+                    patchKeyedChildren(parentElement, {
                         prevChildren,
                         nextChildren,
                         subtreeRightBoundary,
@@ -63,12 +47,12 @@ export function _patchChildren(frame) {
                     break;
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_TEXT: {
-                    _pushUnmountChildrenFrame(prevParentElement, frame.meta);
+                    pushUnmountChildrenFrame(prevParentElement, renderRuntime);
                     renderRuntime.hostAdapter.setTextContent(parentReference, parentElement.props?.children);
                     break;
                 }
                 default: {
-                    _pushUnmountChildrenFrame(prevParentElement, frame.meta);
+                    pushUnmountChildrenFrame(prevParentElement, renderRuntime);
                     renderRuntime.hostAdapter.clearNode(parentReference);
                 }
             }
@@ -80,7 +64,7 @@ export function _patchChildren(frame) {
                     for (const child of nextChildren) {
                         child.parent = parentElement;
                     }
-                    _pushPatchKeyedChildrenFrame(parentElement, {
+                    patchKeyedChildren(parentElement, {
                         prevChildren,
                         nextChildren,
                         subtreeRightBoundary,
@@ -96,24 +80,17 @@ export function _patchChildren(frame) {
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_ELEMENT: {
                     nextChildren.parent = parentElement;
-                    _pushPatchEnterFrame(nextChildren, {
-                        prevElement: prevChildren,
-                        parentReference,
-                        renderRuntime,
-                        subtreeRightBoundary: subtreeRightBoundary,
-                        context,
-                        hostNamespace,
-                    });
+                    pushPatchEnterFrame(nextChildren, renderRuntime, prevChildren, parentReference, subtreeRightBoundary, context, hostNamespace);
                     break;
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_TEXT: {
-                    _pushUnmountChildrenFrame(prevParentElement, frame.meta);
+                    pushUnmountChildrenFrame(prevParentElement, renderRuntime);
                     renderRuntime.hostAdapter.setTextContent(parentReference, parentElement.props?.children);
                     break;
                 }
                 default: {
-                    _clearElementHostReference(prevChildren, parentReference, renderRuntime);
-                    _pushUnmountEnterFrame(prevChildren, frame.meta);
+                    clearElementHostReference(prevChildren, parentReference, renderRuntime);
+                    pushUnmountEnterFrame(prevChildren, renderRuntime);
                 }
             }
             break;
@@ -122,34 +99,20 @@ export function _patchChildren(frame) {
             switch (nextParentChildFlag) {
                 case SIMP_ELEMENT_CHILD_FLAG_LIST: {
                     renderRuntime.hostAdapter.clearNode(parentReference);
-                    _pushMountChildrenFrame(parentElement, {
-                        children: parentElement.children,
-                        context,
-                        hostNamespace,
-                        renderRuntime,
-                        subtreeRightBoundary,
-                        parentReference,
-                    });
+                    pushMountChildrenFrame(parentElement, renderRuntime, parentElement.children, parentReference, subtreeRightBoundary, context, hostNamespace);
                     break;
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_ELEMENT: {
                     renderRuntime.hostAdapter.clearNode(parentReference);
                     nextChildren.parent = parentElement;
-                    _pushMountEnterFrame(nextChildren, {
-                        parentReference,
-                        subtreeRightBoundary: subtreeRightBoundary,
-                        context,
-                        hostNamespace,
-                        renderRuntime,
-                        placeHolderElement: null,
-                    });
+                    pushMountEnterFrame(nextChildren, renderRuntime, parentReference, subtreeRightBoundary, context, hostNamespace, null);
                     break;
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_TEXT: {
-                    const prevChildren = prevParentElement.props?.children;
-                    const nextChildren = parentElement.props?.children;
-                    if (prevChildren !== nextChildren) {
-                        renderRuntime.hostAdapter.setTextContent(parentReference, nextChildren, true);
+                    const prevText = prevParentElement.props?.children;
+                    const nextText = parentElement.props?.children;
+                    if (prevText !== nextText) {
+                        renderRuntime.hostAdapter.setTextContent(parentReference, nextText, true);
                     }
                 }
             }
@@ -158,26 +121,12 @@ export function _patchChildren(frame) {
         default: {
             switch (nextParentChildFlag) {
                 case SIMP_ELEMENT_CHILD_FLAG_LIST: {
-                    _pushMountChildrenFrame(parentElement, {
-                        parentReference,
-                        subtreeRightBoundary,
-                        context,
-                        hostNamespace,
-                        renderRuntime,
-                        children: parentElement.children,
-                    });
+                    pushMountChildrenFrame(parentElement, renderRuntime, parentElement.children, parentReference, subtreeRightBoundary, context, hostNamespace);
                     break;
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_ELEMENT: {
                     nextChildren.parent = parentElement;
-                    _pushMountEnterFrame(nextChildren, {
-                        parentReference,
-                        context,
-                        hostNamespace,
-                        renderRuntime,
-                        placeHolderElement: null,
-                        subtreeRightBoundary: subtreeRightBoundary,
-                    });
+                    pushMountEnterFrame(nextChildren, renderRuntime, parentReference, subtreeRightBoundary, context, hostNamespace, null);
                     break;
                 }
                 case SIMP_ELEMENT_CHILD_FLAG_TEXT: {
@@ -187,19 +136,12 @@ export function _patchChildren(frame) {
         }
     }
 }
-export function _patchKeyedChildren(frame) {
-    const { parentReference, subtreeRightBoundary, context, hostNamespace, renderRuntime } = frame.meta;
-    const nextChildren = frame.meta.nextChildren;
-    const prevChildren = frame.meta.prevChildren;
+export function patchKeyedChildren(parentElement, meta) {
+    const { parentReference, subtreeRightBoundary, context, hostNamespace, renderRuntime } = meta;
+    const nextChildren = meta.nextChildren;
+    const prevChildren = meta.prevChildren;
     const nextLen = Array.isArray(nextChildren) ? nextChildren.length : 1;
     const prevLen = Array.isArray(prevChildren) ? prevChildren.length : 1;
-    const base = {
-        parentReference,
-        renderRuntime,
-        context,
-        hostNamespace,
-        placeHolderElement: null,
-    };
     const getRightSibling = (child) => {
         return child.index + 1 < nextLen ? getChild(nextChildren, child.index + 1) : subtreeRightBoundary;
     };
@@ -223,11 +165,7 @@ export function _patchKeyedChildren(frame) {
         for (let i = 0; i < nextStart; i++) {
             const nextChild = getChild(nextChildren, i);
             const prevChild = getChild(prevChildren, nextChild.index);
-            _pushPatchEnterFrame(nextChild, {
-                ...base,
-                prevElement: prevChild,
-                subtreeRightBoundary: getRightSibling(nextChild),
-            });
+            pushPatchEnterFrame(nextChild, renderRuntime, prevChild, parentReference, getRightSibling(nextChild), context, hostNamespace);
         }
     };
     const pushSuffixPatches = () => {
@@ -235,19 +173,15 @@ export function _patchKeyedChildren(frame) {
         for (let i = nextEnd + 1; i < nextLen; i++) {
             const nextChild = getChild(nextChildren, i);
             const prevChild = getChild(prevChildren, nextChild.index - delta);
-            _pushPatchEnterFrame(nextChild, {
-                ...base,
-                prevElement: prevChild,
-                subtreeRightBoundary: getRightSibling(nextChild),
-            });
+            pushPatchEnterFrame(nextChild, renderRuntime, prevChild, parentReference, getRightSibling(nextChild), context, hostNamespace);
         }
     };
     if (nextStart > nextEnd) {
         pushPrefixPatches();
         for (let i = prevStart; i <= prevEnd; i++) {
             const child = getChild(prevChildren, i);
-            _clearElementHostReference(child, parentReference, renderRuntime);
-            _pushUnmountEnterFrame(child, frame.meta);
+            clearElementHostReference(child, parentReference, renderRuntime);
+            pushUnmountEnterFrame(child, renderRuntime);
         }
         pushSuffixPatches();
         return;
@@ -256,32 +190,31 @@ export function _patchKeyedChildren(frame) {
         pushPrefixPatches();
         for (let i = nextStart; i <= nextEnd; i++) {
             const nextChild = getChild(nextChildren, i);
-            _pushMountEnterFrame(nextChild, {
-                ...base,
-                subtreeRightBoundary: getRightSibling(nextChild),
-            });
+            pushMountEnterFrame(nextChild, renderRuntime, parentReference, getRightSibling(nextChild), context, hostNamespace, null);
         }
         pushSuffixPatches();
         return;
     }
-    const keyToPrevChild = new Map();
+    const keyToPrevChild = Object.create(null);
     for (let i = prevStart; i <= prevEnd; i++) {
         const prevChild = getChild(prevChildren, i);
         const key = prevChild.key;
         if (key != null) {
-            keyToPrevChild.set(key, prevChild);
+            keyToPrevChild[key] = prevChild;
         }
     }
     const middleLen = nextEnd - nextStart + 1;
     const newIndexToOldIndex = new Int32Array(middleLen);
+    const matchedPrev = new Uint8Array(prevEnd - prevStart + 1);
     let moved = false;
     let maxPrevIndexSoFar = -1;
     for (let i = nextStart; i <= nextEnd; i++) {
         const nextChild = getChild(nextChildren, i);
-        const prevChild = keyToPrevChild.get(nextChild.key);
+        const prevChild = nextChild.key != null ? keyToPrevChild[nextChild.key] : undefined;
         if (prevChild != null) {
             const prevIndex = prevChild.index;
             newIndexToOldIndex[nextChild.index - nextStart] = prevIndex + 1;
+            matchedPrev[prevIndex - prevStart] = 1;
             if (prevIndex < maxPrevIndexSoFar) {
                 moved = true;
             }
@@ -291,50 +224,46 @@ export function _patchKeyedChildren(frame) {
         }
     }
     pushPrefixPatches();
-    const matchedPrev = new Uint8Array(prevEnd - prevStart + 1);
-    for (let i = 0; i < middleLen; i++) {
-        const oldIndex = newIndexToOldIndex[i];
-        if (oldIndex !== 0) {
-            matchedPrev[oldIndex - 1 - prevStart] = 1;
-        }
-    }
     for (let i = prevStart; i <= prevEnd; i++) {
         if (!matchedPrev[i - prevStart]) {
             const child = getChild(prevChildren, i);
-            _clearElementHostReference(child, parentReference, renderRuntime);
-            _pushUnmountEnterFrame(child, frame.meta);
+            clearElementHostReference(child, parentReference, renderRuntime);
+            pushUnmountEnterFrame(child, renderRuntime);
         }
     }
-    const stableNewIndexes = moved ? getLongestIncreasingSubsequenceIndexes(newIndexToOldIndex) : new Int32Array(0);
-    let stableCursor = 0;
-    for (let i = nextStart; i <= nextEnd; i++) {
-        const nextChild = getChild(nextChildren, i);
-        const newIndex = nextChild.index - nextStart;
-        const oldIndex = newIndexToOldIndex[newIndex];
-        if (oldIndex === 0) {
-            _pushMountEnterFrame(nextChild, {
-                ...base,
-                subtreeRightBoundary: getRightSibling(nextChild),
-            });
-            continue;
-        }
-        const prevChild = getChild(prevChildren, oldIndex - 1);
-        const isStable = moved && stableNewIndexes[stableCursor] === newIndex;
-        if (isStable) {
-            stableCursor++;
+    if (moved) {
+        const stableNewIndexes = getLongestIncreasingSubsequenceIndexes(newIndexToOldIndex);
+        let stableCursor = 0;
+        for (let i = nextStart; i <= nextEnd; i++) {
+            const nextChild = getChild(nextChildren, i);
+            const newIndex = nextChild.index - nextStart;
+            const oldIndex = newIndexToOldIndex[newIndex];
+            if (oldIndex === 0) {
+                pushMountEnterFrame(nextChild, renderRuntime, parentReference, getRightSibling(nextChild), context, hostNamespace, null);
+                continue;
+            }
+            const prevChild = getChild(prevChildren, oldIndex - 1);
+            if (stableNewIndexes[stableCursor] === newIndex) {
+                stableCursor++;
+            }
+            else {
+                pushHostOperationPlaceElement(nextChild, renderRuntime, parentReference, getRightSibling(nextChild));
+            }
+            pushPatchEnterFrame(nextChild, renderRuntime, prevChild, parentReference, null, context, hostNamespace);
         }
-        else if (moved) {
-            _pushHostOperationPlaceElement(nextChild, {
-                parentReference,
-                renderRuntime,
-                subtreeRightBoundary: getRightSibling(nextChild),
-            });
+    }
+    else {
+        for (let i = nextStart; i <= nextEnd; i++) {
+            const nextChild = getChild(nextChildren, i);
+            const newIndex = nextChild.index - nextStart;
+            const oldIndex = newIndexToOldIndex[newIndex];
+            if (oldIndex === 0) {
+                pushMountEnterFrame(nextChild, renderRuntime, parentReference, getRightSibling(nextChild), context, hostNamespace, null);
+                continue;
+            }
+            const prevChild = getChild(prevChildren, oldIndex - 1);
+            pushPatchEnterFrame(nextChild, renderRuntime, prevChild, parentReference, null, context, hostNamespace);
         }
-        _pushPatchEnterFrame(nextChild, {
-            ...base,
-            prevElement: prevChild,
-            subtreeRightBoundary: null,
-        });
     }
     pushSuffixPatches();
 }

package/core/portal.js

@@ -10,7 +10,7 @@ export function createPortal(children, container) {
         children: null,
         className: null,
         reference: null,
-        store: null,
+        hostNamespace: null,
         context: null,
         ref: container,
         unmounted: null,

package/core/processStack.js

@@ -1,75 +1,145 @@
-import { _mount } from './mounting.js';
-import { _mountChildren } from './mountingChildren.js';
-import { _patch } from './patching.js';
-import { _patchChildren, _patchKeyedChildren } from './patchingChildren.js';
-import { _unmount } from './unmounting.js';
-import { _unmountChildren } from './unmountingChildren.js';
+import { mountEnter, mountExit } from './mounting.js';
+import { mountChildren } from './mountingChildren.js';
+import { patchEnter, patchExit } from './patching.js';
+import { unmountEnter, unmountExit } from './unmounting.js';
+import { unmountChildren } from './unmountingChildren.js';
 import { placeElementBeforeAnchor, resolveAnchorReference } from './utils.js';
 export const MOUNT_ENTER = 10;
 export const MOUNT_EXIT = 11;
 export const MOUNT_CHILDREN_ENTER = 12;
 export const PATCH_ENTER = 20;
 export const PATCH_EXIT = 21;
-export const PATCH_CHILDREN = 22;
-export const PATCH_KEYED_CHILDREN = 24;
 export const UNMOUNT_ENTER = 30;
 export const UNMOUNT_EXIT = 31;
 export const UNMOUNT_CHILDREN_ENTER = 32;
 export const HOST_OPS_PLACE_ELEMENT_BEFORE_ANCHOR = 40;
 export const HOST_OPS_REPLACE_CHILD = 42;
+function createFrame() {
+    return {
+        kind: 0,
+        node: null,
+        renderRuntime: null,
+        parentReference: null,
+        subtreeRightBoundary: null,
+        context: null,
+        hostNamespace: null,
+        prevElement: null,
+        children: null,
+        placeHolderElement: null,
+    };
+}
+export function acquireMountFrame(renderRuntime, element, kind, parentReference, subtreeRightBoundary, context, hostNamespace, placeHolderElement) {
+    const frame = renderRuntime.framePool.pop() ?? createFrame();
+    frame.kind = kind;
+    frame.node = element;
+    frame.renderRuntime = renderRuntime;
+    frame.parentReference = parentReference;
+    frame.subtreeRightBoundary = subtreeRightBoundary;
+    frame.context = context;
+    frame.hostNamespace = hostNamespace;
+    frame.placeHolderElement = placeHolderElement;
+    return frame;
+}
+export function acquireMountChildrenFrame(renderRuntime, parent, children, parentReference, subtreeRightBoundary, context, hostNamespace) {
+    const frame = renderRuntime.framePool.pop() ?? createFrame();
+    frame.kind = MOUNT_CHILDREN_ENTER;
+    frame.node = parent;
+    frame.renderRuntime = renderRuntime;
+    frame.children = children;
+    frame.parentReference = parentReference;
+    frame.subtreeRightBoundary = subtreeRightBoundary;
+    frame.context = context;
+    frame.hostNamespace = hostNamespace;
+    return frame;
+}
+export function acquirePatchFrame(renderRuntime, element, kind, prevElement, parentReference, subtreeRightBoundary, context, hostNamespace) {
+    const frame = renderRuntime.framePool.pop() ?? createFrame();
+    frame.kind = kind;
+    frame.node = element;
+    frame.renderRuntime = renderRuntime;
+    frame.prevElement = prevElement;
+    frame.parentReference = parentReference;
+    frame.subtreeRightBoundary = subtreeRightBoundary;
+    frame.context = context;
+    frame.hostNamespace = hostNamespace;
+    return frame;
+}
+export function acquireUnmountFrame(renderRuntime, element, kind) {
+    const frame = renderRuntime.framePool.pop() ?? createFrame();
+    frame.kind = kind;
+    frame.node = element;
+    frame.renderRuntime = renderRuntime;
+    return frame;
+}
+export function acquireUnmountChildrenFrame(renderRuntime, parent) {
+    const frame = renderRuntime.framePool.pop() ?? createFrame();
+    frame.kind = UNMOUNT_CHILDREN_ENTER;
+    frame.node = parent;
+    frame.renderRuntime = renderRuntime;
+    return frame;
+}
+export function acquirePlaceFrame(renderRuntime, element, parentReference, subtreeRightBoundary) {
+    const frame = renderRuntime.framePool.pop() ?? createFrame();
+    frame.kind = HOST_OPS_PLACE_ELEMENT_BEFORE_ANCHOR;
+    frame.node = element;
+    frame.renderRuntime = renderRuntime;
+    frame.parentReference = parentReference;
+    frame.subtreeRightBoundary = subtreeRightBoundary;
+    return frame;
+}
+export function acquireReplaceFrame(renderRuntime, element, parentReference, prevElement) {
+    const frame = renderRuntime.framePool.pop() ?? createFrame();
+    frame.kind = HOST_OPS_REPLACE_CHILD;
+    frame.node = element;
+    frame.renderRuntime = renderRuntime;
+    frame.parentReference = parentReference;
+    frame.prevElement = prevElement;
+    return frame;
+}
 export function processStack(renderRuntime) {
     const stack = renderRuntime.renderStack;
+    const pool = renderRuntime.framePool;
     while (stack.length > 0) {
         const frame = stack.pop();
         switch (frame.kind) {
-            case MOUNT_ENTER: {
-                _mount(frame);
-                break;
-            }
-            case MOUNT_CHILDREN_ENTER: {
-                _mountChildren(frame);
-                break;
-            }
-            case MOUNT_EXIT: {
-                _mount(frame);
+            case MOUNT_ENTER:
+                mountEnter(frame);
                 break;
-            }
-            case PATCH_ENTER: {
-                _patch(frame);
+            case MOUNT_EXIT:
+                mountExit(frame);
                 break;
-            }
-            case PATCH_EXIT: {
-                _patch(frame);
+            case MOUNT_CHILDREN_ENTER:
+                mountChildren(frame);
                 break;
-            }
-            case PATCH_CHILDREN: {
-                _patchChildren(frame);
+            case PATCH_ENTER:
+                patchEnter(frame);
                 break;
-            }
-            case PATCH_KEYED_CHILDREN: {
-                _patchKeyedChildren(frame);
+            case PATCH_EXIT:
+                patchExit(frame);
                 break;
-            }
-            case UNMOUNT_ENTER: {
-                _unmount(frame);
+            case UNMOUNT_ENTER:
+                unmountEnter(frame);
                 break;
-            }
-            case UNMOUNT_EXIT: {
-                _unmount(frame);
+            case UNMOUNT_EXIT:
+                unmountExit(frame);
                 break;
-            }
-            case UNMOUNT_CHILDREN_ENTER: {
-                _unmountChildren(frame);
+            case UNMOUNT_CHILDREN_ENTER:
+                unmountChildren(frame);
                 break;
-            }
             case HOST_OPS_PLACE_ELEMENT_BEFORE_ANCHOR: {
-                const anchor = resolveAnchorReference(frame.meta.subtreeRightBoundary);
-                placeElementBeforeAnchor(frame.node, anchor, frame.meta.parentReference, renderRuntime);
+                const anchor = resolveAnchorReference(frame.subtreeRightBoundary);
+                placeElementBeforeAnchor(frame.node, anchor, frame.parentReference, renderRuntime);
                 break;
             }
-            case HOST_OPS_REPLACE_CHILD: {
-                renderRuntime.hostAdapter.replaceChild(frame.meta.parentReference, frame.node.reference, frame.meta.prevElement.reference);
-            }
+            case HOST_OPS_REPLACE_CHILD:
+                renderRuntime.hostAdapter.replaceChild(frame.parentReference, frame.node.reference, frame.prevElement.reference);
+                break;
         }
+        frame.node = null;
+        frame.prevElement = null;
+        frame.children = null;
+        frame.subtreeRightBoundary = null;
+        frame.placeHolderElement = null;
+        pool.push(frame);
     }
 }

package/core/ref.js

@@ -4,6 +4,7 @@ export function unmountRef(element) {
     }
     if (typeof element.ref.cleanup === 'function') {
         element.ref.cleanup();
+        element.ref.cleanup = null;
     }
     if (typeof element.ref.value !== 'function') {
         element.ref.value.current = null;

package/core/rerender.js

@@ -1,4 +1,4 @@
-import { lifecycleEventBus } from './lifecycleEventBus.js';
+import { registerLifecyclePlugin } from './lifecycleEventBus.js';
 import { patch } from './patching.js';
 import { findParentReferenceFromElement } from './utils.js';
 const rerenderSpecificDataByRuntime = new WeakMap();
@@ -15,12 +15,14 @@ function getRerenderSpecificData(renderRuntime) {
     }
     return data;
 }
-lifecycleEventBus.subscribe(event => {
-    const data = getRerenderSpecificData(event.renderRuntime);
-    if (event.type === 'afterRender' || event.type === 'errored' || event.type === 'unmounted') {
-        data.asyncQueue.delete(event.element.store);
-        data.syncQueue.delete(event.element.store);
-    }
+registerLifecyclePlugin(bus => {
+    bus.subscribe(event => {
+        if (event.type === 'afterRender' || event.type === 'errored' || event.type === 'unmounted') {
+            const data = getRerenderSpecificData(event.renderRuntime);
+            data.asyncQueue.delete(event.element);
+            data.syncQueue.delete(event.element);
+        }
+    });
 });
 function scheduleAsyncFlush(renderRuntime) {
     const data = getRerenderSpecificData(renderRuntime);
@@ -38,19 +40,21 @@ function scheduleAsyncFlush(renderRuntime) {
     };
     queueMicrotask(process);
 }
-export function rerender(store, renderRuntime) {
+export function rerender(element, renderRuntime) {
     const data = getRerenderSpecificData(renderRuntime);
-    const element = store.latestElement;
     if (element.unmounted) {
         console.warn('The component is unmounted.');
         return;
     }
-    lifecycleEventBus.publish({ type: 'triedToRerender', element, renderRuntime });
+    if (renderRuntime.activeRenderElement === element) {
+        renderRuntime.pendingRerenderFlag = true;
+        return;
+    }
     if (data.syncLockDepth > 0) {
-        data.syncQueue.add(store);
+        data.syncQueue.add(element);
         return;
     }
-    data.asyncQueue.add(store);
+    data.asyncQueue.add(element);
     scheduleAsyncFlush(renderRuntime);
 }
 export function withSyncRerender(renderRuntime, callback) {
@@ -67,17 +71,11 @@ export function withSyncRerender(renderRuntime, callback) {
     }
 }
 function flushQueue(queue, renderRuntime) {
-    for (const store of queue) {
-        queue.delete(store);
-        performRerender(store.latestElement, renderRuntime);
+    for (const element of queue) {
+        queue.delete(element);
+        performRerender(element, renderRuntime);
     }
 }
 function performRerender(element, renderRuntime) {
-    element.store.forceRerender = true;
-    try {
-        patch(element, element, findParentReferenceFromElement(element), null, element.context || null, element.store.hostNamespace, renderRuntime);
-    }
-    finally {
-        element.store.forceRerender = false;
-    }
+    patch(element, element, findParentReferenceFromElement(element), null, element.context || null, element.hostNamespace, renderRuntime);
 }

package/core/runtime.js

@@ -1,2 +1,10 @@
-export const MOUNTING_PHASE = 0;
-export const UPDATING_PHASE = 1;
+export function createRenderRuntime(hostAdapter, renderer) {
+    return {
+        hostAdapter,
+        renderer,
+        renderStack: [],
+        framePool: [],
+        activeRenderElement: null,
+        pendingRerenderFlag: false,
+    };
+}