@simpreact/simpreact 0.0.1 → 0.0.3

package/core/mounting.js

@@ -1,8 +1,9 @@
-import { emptyMap, emptyObject } from '../shared';
-import { hostAdapter } from './hostAdapter';
-import { createTextElement, normalizeRoot } from './createElement';
-import { applyRef } from './ref';
-import { lifecycleEventBus } from './lifecycleEventBus';
+import { emptyMap, emptyObject } from '../shared/index.js';
+import { hostAdapter } from './hostAdapter.js';
+import { createTextElement, normalizeRoot } from './createElement.js';
+import { applyRef } from './ref.js';
+import { lifecycleEventBus } from './lifecycleEventBus.js';
+import { batchingRerenderLocker } from './rerender.js';
 export function mount(element, parentReference, nextReference, contextMap, hostNamespace) {
     if (element.flag === 'TEXT') {
         mountTextElement(element, parentReference, nextReference);
@@ -37,9 +38,6 @@ export function mountHostElement(element, parentReference, nextReference, contex
     hostNamespace = hostNamespaces?.self;
     const hostReference = (element.reference = hostAdapter.createReference(element.type, hostNamespace));
     hostAdapter.attachElementToReference(element, hostReference);
-    if (parentReference) {
-        hostAdapter.insertOrAppend(parentReference, hostReference, nextReference);
-    }
     // HOST element always has Maybe<Many<SimpElement>> children due to normalization process.
     const children = element.children;
     if (Array.isArray(children)) {
@@ -51,10 +49,17 @@ export function mountHostElement(element, parentReference, nextReference, contex
     }
     if (element.props) {
         hostAdapter.mountProps(hostReference, element, hostNamespace);
+        // HOST elements can have either children elements or string children in the props due to normalization.
+        if (typeof element.props.children === 'string') {
+            hostAdapter.setTextContent(hostReference, element.props.children);
+        }
     }
     if (element.className) {
         hostAdapter.setClassname(hostReference, element.className, hostNamespace);
     }
+    if (parentReference) {
+        hostAdapter.insertOrAppend(parentReference, hostReference, nextReference);
+    }
     applyRef(element);
 }
 export function mountFunctionalElement(element, parentReference, nextReference, contextMap, hostNamespace) {
@@ -70,15 +75,41 @@ export function mountFunctionalElement(element, parentReference, nextReference,
     }
     // FC element always has Maybe<SimpElement> children due to normalization process.
     let children;
+    let triedToRerenderUnsubscribe;
     try {
-        lifecycleEventBus.publish({ type: 'beforeRender', element, phase: 'mounting' });
-        children = normalizeRoot(element.type(element.props || emptyObject), false);
-        lifecycleEventBus.publish({ type: 'afterRender', phase: 'mounting' });
+        let triedToRerender = false;
+        let rerenderCounter = 0;
+        triedToRerenderUnsubscribe = lifecycleEventBus.subscribe(event => {
+            if (event.type === 'triedToRerender' && event.element === element) {
+                triedToRerender = true;
+            }
+        });
+        do {
+            triedToRerender = false;
+            if (++rerenderCounter >= 25) {
+                lifecycleEventBus.publish({
+                    type: 'errored',
+                    element,
+                    error: new Error('Too many re-renders. SimpReact limits the number of renders to prevent an infinite loop.'),
+                    phase: 'mounting',
+                });
+                return;
+            }
+            lifecycleEventBus.publish({ type: 'beforeRender', element, phase: 'mounting' });
+            batchingRerenderLocker.lock();
+            children = element.type(element.props || emptyObject);
+            batchingRerenderLocker.flush();
+            lifecycleEventBus.publish({ type: 'afterRender', element, phase: 'mounting' });
+        } while (triedToRerender);
+        children = normalizeRoot(children, false);
     }
     catch (error) {
         lifecycleEventBus.publish({ type: 'errored', element, error, phase: 'mounting' });
         return;
     }
+    finally {
+        triedToRerenderUnsubscribe();
+    }
     if (children) {
         children.parent = element;
         mount((element.children = children), parentReference, nextReference, contextMap, hostNamespace);

package/core/patching.d.ts

@@ -1,7 +1,7 @@
-import type { Maybe, Nullable } from '../shared';
-import type { SimpElement } from './createElement';
-import type { HostReference } from './hostAdapter';
-import type { SimpContextMap } from './context';
+import type { Maybe, Nullable } from '../shared/index.js';
+import type { SimpElement } from './createElement.js';
+import type { HostReference } from './hostAdapter.js';
+import type { SimpContextMap } from './context.js';
 export declare function patch(prevElement: SimpElement, nextElement: SimpElement, parentReference: HostReference, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
 export declare function patchPortal(prevElement: SimpElement, nextElement: SimpElement, contextMap: Nullable<SimpContextMap>): void;
 export declare function updateFunctionalComponent(element: SimpElement, parentReference: HostReference, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;

package/core/patching.js

@@ -1,10 +1,11 @@
-import { emptyMap, emptyObject } from '../shared';
-import { normalizeRoot } from './createElement';
-import { hostAdapter } from './hostAdapter';
-import { clearElementHostReference, remove, unmount } from './unmounting';
-import { mount, mountArrayChildren } from './mounting';
-import { applyRef } from './ref';
-import { lifecycleEventBus } from './lifecycleEventBus';
+import { emptyMap, emptyObject } from '../shared/index.js';
+import { normalizeRoot } from './createElement.js';
+import { hostAdapter } from './hostAdapter.js';
+import { clearElementHostReference, remove, unmount } from './unmounting.js';
+import { mount, mountArrayChildren } from './mounting.js';
+import { applyRef } from './ref.js';
+import { lifecycleEventBus } from './lifecycleEventBus.js';
+import { batchingRerenderLocker } from './rerender.js';
 export function patch(prevElement, nextElement, parentReference, nextReference, contextMap, hostNamespace) {
     if (prevElement.type !== nextElement.type || prevElement.key !== nextElement.key) {
         replaceWithNewElement(prevElement, nextElement, parentReference, contextMap, hostNamespace);
@@ -51,7 +52,7 @@ function patchHostElement(prevElement, nextElement, contextMap, hostNamespace) {
     hostNamespace = hostNamespaces?.self;
     nextElement.reference = prevElement.reference;
     hostAdapter.attachElementToReference(nextElement, nextElement.reference);
-    patchChildren(prevElement.children, nextElement.children, nextElement.reference, null, nextElement, contextMap, hostNamespaces?.children);
+    patchChildren(prevElement.children || prevElement.props?.children, nextElement.children || nextElement.props?.children, nextElement.reference, null, nextElement, contextMap, hostNamespaces?.children);
     hostAdapter.patchProps(nextElement.reference, prevElement, nextElement, hostNamespace);
     if (prevElement.className !== nextElement.className) {
         hostAdapter.setClassname(nextElement.reference, nextElement.className, hostNamespace);
@@ -59,29 +60,69 @@ function patchHostElement(prevElement, nextElement, contextMap, hostNamespace) {
     applyRef(nextElement);
 }
 function patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference, contextMap, hostNamespace) {
-    (nextElement.store = prevElement.store ||= {}).latestElement = nextElement;
+    const prevStore = !prevElement.store || prevElement.unmounted
+        ? { hostNamespace: prevElement.store?.hostNamespace }
+        : prevElement.store;
+    prevStore.latestElement = nextElement;
+    nextElement.store = prevStore;
     if (hostNamespace) {
         nextElement.store.hostNamespace = hostNamespace;
     }
     if (contextMap) {
         nextElement.contextMap = contextMap;
     }
+    // FC element always has Maybe<SimpElement> children due to normalization process.
     let nextChildren;
+    let triedToRerenderUnsubscribe;
     try {
-        lifecycleEventBus.publish({ type: 'beforeRender', element: nextElement, phase: 'updating' });
-        nextChildren = normalizeRoot(nextElement.type(nextElement.props || emptyObject), false);
-        lifecycleEventBus.publish({ type: 'afterRender', phase: 'updating' });
+        let triedToRerender = false;
+        let rerenderCounter = 0;
+        triedToRerenderUnsubscribe = lifecycleEventBus.subscribe(event => {
+            if (event.type === 'triedToRerender' && event.element === nextElement) {
+                triedToRerender = true;
+            }
+        });
+        do {
+            triedToRerender = false;
+            if (++rerenderCounter >= 25) {
+                lifecycleEventBus.publish({
+                    type: 'errored',
+                    element: nextElement,
+                    error: new Error('Too many re-renders. SimpReact limits the number of renders to prevent an infinite loop.'),
+                    phase: 'updating',
+                });
+                return;
+            }
+            lifecycleEventBus.publish({ type: 'beforeRender', element: nextElement, phase: 'updating' });
+            batchingRerenderLocker.lock();
+            nextChildren = nextElement.type(nextElement.props || emptyObject);
+            batchingRerenderLocker.flush();
+            lifecycleEventBus.publish({ type: 'afterRender', element: nextElement, phase: 'updating' });
+        } while (triedToRerender);
+        nextChildren = normalizeRoot(nextChildren, false);
     }
     catch (error) {
         lifecycleEventBus.publish({ type: 'errored', element: nextElement, error, phase: 'updating' });
         return;
     }
+    finally {
+        triedToRerenderUnsubscribe();
+    }
     const prevChildren = prevElement.children;
     if (nextChildren) {
         nextElement.children = nextChildren;
     }
-    patchChildren(prevChildren, nextChildren, parentReference, nextReference, nextElement, contextMap, hostNamespace);
-    lifecycleEventBus.publish({ type: 'updated', element: nextElement });
+    if (!prevElement.unmounted) {
+        patchChildren(prevChildren, nextChildren, parentReference, nextReference, nextElement, contextMap, hostNamespace);
+        lifecycleEventBus.publish({ type: 'updated', element: nextElement });
+        return;
+    }
+    prevElement.unmounted = false;
+    if (nextChildren) {
+        nextChildren.parent = nextElement;
+        mount(nextChildren, parentReference, nextReference, contextMap, hostNamespace);
+    }
+    lifecycleEventBus.publish({ type: 'mounted', element: nextElement });
 }
 function patchTextElement(prevElement, nextElement) {
     nextElement.reference = prevElement.reference;
@@ -134,6 +175,10 @@ function patchChildren(prevChildren, nextChildren, parentReference, nextReferenc
             }
             patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference, contextMap, hostNamespace);
         }
+        else if (typeof nextChildren === 'string') {
+            unmount(prevChildren);
+            hostAdapter.setTextContent(parentReference, nextChildren);
+        }
         else if (nextChildren) {
             patchKeyedChildren(prevChildren, [nextChildren], parentReference, nextReference, contextMap, hostNamespace);
         }
@@ -142,23 +187,48 @@ function patchChildren(prevChildren, nextChildren, parentReference, nextReferenc
             hostAdapter.clearNode(parentReference);
         }
     }
+    else if (typeof prevChildren === 'string') {
+        if (Array.isArray(nextChildren)) {
+            hostAdapter.clearNode(parentReference);
+            mountArrayChildren(nextChildren, parentReference, nextReference, contextMap, nextElement, hostNamespace);
+        }
+        else if (typeof nextChildren === 'string') {
+            if (prevChildren !== nextChildren) {
+                hostAdapter.setTextContent(nextElement.reference, nextChildren, true);
+            }
+        }
+        else if (nextChildren) {
+            hostAdapter.clearNode(parentReference);
+            nextChildren.parent = nextElement;
+            mount(nextChildren, parentReference, nextReference, contextMap, hostNamespace);
+        }
+        else {
+            hostAdapter.clearNode(parentReference);
+        }
+    }
     else if (prevChildren) {
         if (Array.isArray(nextChildren)) {
             patchKeyedChildren([prevChildren], nextChildren, parentReference, nextReference, contextMap, hostNamespace);
         }
+        else if (typeof nextChildren === 'string') {
+            unmount(prevChildren);
+            hostAdapter.setTextContent(parentReference, nextChildren);
+        }
         else if (nextChildren) {
             nextChildren.parent = nextElement;
             patch(prevChildren, nextChildren, parentReference, nextReference, contextMap, hostNamespace);
         }
         else {
-            unmount(prevChildren);
-            hostAdapter.clearNode(parentReference);
+            remove(prevChildren, parentReference);
         }
     }
     else {
         if (Array.isArray(nextChildren)) {
             mountArrayChildren(nextChildren, parentReference, nextReference, contextMap, nextElement, hostNamespace);
         }
+        else if (typeof nextChildren === 'string') {
+            hostAdapter.setTextContent(parentReference, nextChildren);
+        }
         else if (nextChildren) {
             nextChildren.parent = nextElement;
             mount(nextChildren, parentReference, nextReference, contextMap, hostNamespace);
@@ -186,7 +256,7 @@ export function patchKeyedChildren(prevChildren, nextChildren, parentReference,
     }
     // Step 3: Mount new nodes if prev list is exhausted
     if (prevStart > prevEnd) {
-        const before = nextChildren[nextEnd + 1]?.reference || nextReference;
+        const before = findHostReferenceFromElement(nextChildren[nextEnd + 1]) || nextReference;
         for (let i = nextStart; i <= nextEnd; i++) {
             mount(nextChildren[i], parentReference, before, contextMap, hostNamespace);
         }
@@ -221,7 +291,7 @@ export function patchKeyedChildren(prevChildren, nextChildren, parentReference,
                 usedIndices.add(prevIndex);
             }
             else {
-                mount(nextChild, parentReference, nextChildren[i + 1]?.reference || nextReference, contextMap, hostNamespace);
+                mount(nextChild, parentReference, findHostReferenceFromElement(nextChildren[i + 1]) || nextReference, contextMap, hostNamespace);
                 toMove[i - nextStart] = -1;
             }
         }
@@ -234,7 +304,7 @@ export function patchKeyedChildren(prevChildren, nextChildren, parentReference,
         // Insert in correct order
         for (let i = nextEnd; i >= nextStart; i--) {
             const currentChild = nextChildren[i];
-            const reference = nextChildren[i + 1]?.reference || nextReference;
+            const reference = findHostReferenceFromElement(nextChildren[i + 1]) || nextReference;
             if (toMove[i - nextStart] !== -1) {
                 hostAdapter.insertBefore(parentReference, currentChild.reference, reference);
             }

package/core/portal.d.ts

@@ -1,2 +1,2 @@
-import type { SimpElement, SimpNode } from './createElement';
+import type { SimpElement, SimpNode } from './createElement.js';
 export declare function createPortal(children: SimpNode, container: any): SimpElement;

package/core/portal.js

@@ -1,4 +1,4 @@
-import { normalizeRoot } from './createElement';
+import { normalizeRoot } from './createElement.js';
 export function createPortal(children, container) {
     const element = { flag: 'PORTAL', parent: null };
     if ((children = normalizeRoot(children, false))) {

package/core/ref.d.ts

@@ -1,17 +1,17 @@
-import type { SimpElement } from './createElement';
+import type { SimpElement } from './createElement.js';
 interface RefSimpElement extends SimpElement {
     ref?: {
         value: NonNullable<Ref<unknown>>;
         cleanup?: () => void;
     };
 }
-export interface RefObject<T> {
+export type RefObject<T> = {
     current: T;
-}
+};
 export type RefCallback<T> = {
-    bivarianceHack(instance: T | null): (() => void) | void;
+    bivarianceHack(instance: T): (() => void | undefined) | void;
 }['bivarianceHack'];
-export type Ref<T> = RefCallback<T> | RefObject<T> | null;
+export type Ref<T> = RefCallback<T> | RefObject<T | null> | null;
 export declare function unmountRef(element: RefSimpElement): void;
 export declare function applyRef(element: RefSimpElement): void;
 export {};

package/core/rerender.d.ts

@@ -1,13 +1,13 @@
-import type { SimpElement } from './createElement';
+import type { SimpElement } from './createElement.js';
 export declare function rerender(element: SimpElement): void;
 interface IRendererLocker {
     _isLocked: boolean;
     _elements: Set<SimpElement>;
-    isLocked: boolean;
+    _track(element: SimpElement): void;
+    _untrack(element: SimpElement): void;
     lock(): void;
-    track(element: SimpElement): void;
     flush(): void;
 }
-export declare const syncRerenderLocker: IRendererLocker;
-export declare const asyncRerenderLocker: IRendererLocker;
+export declare const batchingRerenderLocker: IRendererLocker;
+export declare const renderingRerenderLocker: IRendererLocker;
 export {};

package/core/rerender.js

@@ -1,61 +1,74 @@
-import { findParentReferenceFromElement, updateFunctionalComponent } from './patching';
+import { findParentReferenceFromElement, updateFunctionalComponent } from './patching.js';
+import { lifecycleEventBus } from './lifecycleEventBus.js';
+lifecycleEventBus.subscribe(event => {
+    if (event.type === 'afterRender') {
+        batchingRerenderLocker._untrack(event.element);
+        renderingRerenderLocker._untrack(event.element);
+    }
+});
 export function rerender(element) {
     if (element.flag !== 'FC') {
         throw new TypeError('Re-rendering is only supported for FC elements.');
     }
     if (element.unmounted) {
-        console.warn('The component unmounted.');
+        console.warn('The component is unmounted.');
     }
-    if (syncRerenderLocker.isLocked) {
-        syncRerenderLocker.track(element);
+    lifecycleEventBus.publish({ type: 'triedToRerender', element });
+    if (batchingRerenderLocker._isLocked) {
+        batchingRerenderLocker._track(element);
         return;
     }
-    else if (asyncRerenderLocker.isLocked) {
-        asyncRerenderLocker.track(element);
-    }
-    else {
-        asyncRerenderLocker.lock();
-        updateFunctionalComponent(element, findParentReferenceFromElement(element), null, element.contextMap || null, element.store.hostNamespace);
-        asyncRerenderLocker.flush();
+    if (renderingRerenderLocker._isLocked) {
+        renderingRerenderLocker._track(element);
+        return;
     }
+    renderingRerenderLocker.lock();
+    updateFunctionalComponent(element, findParentReferenceFromElement(element), null, element.contextMap || null, element.store.hostNamespace);
+    renderingRerenderLocker.flush();
 }
-export const syncRerenderLocker = {
+export const batchingRerenderLocker = {
     _isLocked: false,
     _elements: new Set(),
-    get isLocked() {
-        return this._isLocked;
+    _track(element) {
+        this._elements.add(element);
+    },
+    _untrack(element) {
+        this._elements.delete(element);
     },
     lock() {
         this._isLocked = true;
     },
-    track(element) {
-        this._elements.add(element);
-    },
     flush() {
         this._isLocked = false;
+        if (this._elements.size === 0) {
+            return;
+        }
         for (const element of this._elements) {
-            this._elements.delete(element);
+            this._untrack(element);
             rerender(element.store.latestElement);
         }
     },
 };
-export const asyncRerenderLocker = {
+export const renderingRerenderLocker = {
     _isLocked: false,
     _elements: new Set(),
-    get isLocked() {
-        return this._isLocked;
+    _track(element) {
+        this._elements.add(element);
+    },
+    _untrack(element) {
+        this._elements.delete(element);
     },
     lock() {
         this._isLocked = true;
     },
-    track(element) {
-        this._elements.add(element);
-    },
     flush() {
         this._isLocked = false;
+        if (this._elements.size === 0) {
+            return;
+        }
         queueMicrotask(() => {
             for (const element of this._elements) {
-                this._elements.delete(element);
+                this._untrack(element);
                 rerender(element.store.latestElement);
             }
         });

package/core/unmounting.d.ts

@@ -1,6 +1,6 @@
-import type { Many, Maybe } from '../shared';
-import type { SimpElement } from './createElement';
-import type { HostReference } from './hostAdapter';
+import type { Many, Maybe } from '../shared/index.js';
+import type { SimpElement } from './createElement.js';
+import type { HostReference } from './hostAdapter.js';
 export declare function unmount(element: Many<SimpElement>): void;
 export declare function clearElementHostReference(element: Maybe<SimpElement>, parentHostReference: HostReference): void;
 export declare function remove(element: SimpElement, parentReference: HostReference): void;

package/core/unmounting.js

@@ -1,6 +1,6 @@
-import { hostAdapter } from './hostAdapter';
-import { unmountRef } from './ref';
-import { lifecycleEventBus } from './lifecycleEventBus';
+import { hostAdapter } from './hostAdapter.js';
+import { unmountRef } from './ref.js';
+import { lifecycleEventBus } from './lifecycleEventBus.js';
 export function unmount(element) {
     if (Array.isArray(element)) {
         for (const child of element) {
@@ -9,6 +9,10 @@ export function unmount(element) {
         return;
     }
     if (element.flag === 'FC') {
+        // Skip — element is already unmounted.
+        if (element.unmounted) {
+            return;
+        }
         // FC element always has Maybe<SimpElement> due to normalization.
         if (element.children) {
             unmount(element.children);

package/dom/attach-element-to-dom.d.ts

@@ -1,4 +1,4 @@
-import type { Nullable } from '../shared';
+import type { Nullable } from '../shared/index.js';
 import type { SimpElement } from '../core/internal.js';
 export declare function attachElementToDom(element: SimpElement, dom: Node): void;
 export declare function getElementFromDom(target: Nullable<EventTarget>): Nullable<SimpElement>;

package/dom/attach-element-to-dom.js

@@ -1,6 +1,6 @@
 const elementPropertyName = '__SIMP_ELEMENT__';
 export function attachElementToDom(element, dom) {
-    if (dom.nodeType !== Node.TEXT_NODE) {
+    if (element.flag !== 'TEXT') {
         Object.defineProperty(dom, elementPropertyName, { value: element, writable: true });
     }
 }

package/dom/domAdapter.d.ts

@@ -1,3 +1,3 @@
 import type { HostAdapter } from '../core/internal.js';
-import type { Namespace } from './namespace';
+import type { Namespace } from './namespace.js';
 export declare const domAdapter: HostAdapter<HTMLElement | SVGElement, Text, Namespace>;

package/dom/domAdapter.js

@@ -1,6 +1,6 @@
-import { attachElementToDom } from './attach-element-to-dom';
-import { mountProps, patchProps, unmountProps } from './props';
-import { defaultNamespace } from './namespace';
+import { attachElementToDom } from './attach-element-to-dom.js';
+import { mountProps, patchProps, unmountProps } from './props/index.js';
+import { defaultNamespace } from './namespace.js';
 export const domAdapter = {
     createReference(type, namespace) {
         if (namespace) {
@@ -33,8 +33,13 @@ export const domAdapter = {
             reference.className = className;
         }
     },
-    setTextContent(reference, text) {
-        reference.textContent = text;
+    setTextContent(reference, text, referenceHasOnlyTextElement) {
+        if (referenceHasOnlyTextElement) {
+            reference.firstChild.nodeValue = text;
+        }
+        else {
+            reference.textContent = text;
+        }
     },
     appendChild(parent, child) {
         parent.appendChild(child);

package/dom/events.d.ts

@@ -1,10 +1,13 @@
-import type { Nullable } from '../shared';
+import type { Nullable } from '../shared/index.js';
 type DelegatedEventType = 'click' | 'dblclick' | 'mousedown' | 'mouseup' | 'mousemove' | 'pointerdown' | 'pointerup' | 'pointermove' | 'touchstart' | 'touchmove' | 'touchend' | 'keydown' | 'keyup' | 'focusin' | 'focusout';
 export declare class SyntheticEvent {
     nativeEvent: Event;
     currentTarget: Nullable<EventTarget>;
     isPropagationStopped: boolean;
     isDefaultPrevented: boolean;
+    button?: number;
+    buttons?: number;
+    pointerId?: number;
     constructor(event: Event);
     get target(): EventTarget | null;
     get type(): string;

package/dom/events.js

@@ -1,5 +1,5 @@
-import { syncRerenderLocker } from '../core/internal.js';
-import { getElementFromDom } from './attach-element-to-dom';
+import { batchingRerenderLocker } from '../core/internal.js';
+import { getElementFromDom } from './attach-element-to-dom.js';
 const eventNameByTypes = {
     click: 'onClick',
     dblclick: 'onDblClick',
@@ -40,8 +40,14 @@ export class SyntheticEvent {
     currentTarget = null;
     isPropagationStopped = false;
     isDefaultPrevented = false;
+    button;
+    buttons;
+    pointerId;
     constructor(event) {
         this.nativeEvent = event;
+        this.button = event.button;
+        this.buttons = event.buttons;
+        this.pointerId = event.pointerId;
     }
     get target() {
         return this.nativeEvent.target;
@@ -59,7 +65,7 @@ export class SyntheticEvent {
     }
 }
 export function dispatchDelegatedEvent(event) {
-    syncRerenderLocker.lock();
+    batchingRerenderLocker.lock();
     const syntheticEvent = new SyntheticEvent(event);
     const captureHandlers = [];
     const bubbleHandlers = [];
@@ -91,7 +97,7 @@ export function dispatchDelegatedEvent(event) {
             return;
         }
     }
-    syncRerenderLocker.flush();
+    batchingRerenderLocker.flush();
 }
 const captureRegex = /Capture/;
 export function patchEvent(name, prevValue, nextValue, dom) {

package/dom/index.d.ts

@@ -1,5 +1,5 @@
-import type { RefAttributes, SimpElement, SimpNode } from '../core';
-import type { Nullable } from '../shared';
+import type { RefAttributes, SimpElement, SimpNode } from '../core/index.js';
+import type { Nullable } from '../shared/index.js';
 
 import type { PropertiesHyphen } from 'csstype';
 

package/dom/index.js

@@ -1,3 +1,3 @@
-import { createRoot, render } from './render';
-export { createRoot, render } from './render';
+import { createRoot, render } from './render.js';
+export { createRoot, render } from './render.js';
 export default { createRoot, render };

package/dom/props/controlled/index.d.ts

@@ -1,5 +1,5 @@
 import type { SimpElement } from '../../../core/internal.js';
-import type { Dict } from '../../../shared';
+import type { Dict } from '../../../shared/index.js';
 export declare function isEventNameIgnored(element: SimpElement, eventName: string): boolean;
 export declare function isFormElementControlled(props: Dict): boolean;
 export declare function addControlledFormElementEventHandlers(element: SimpElement): void;

package/dom/props/controlled/index.js

@@ -1,6 +1,6 @@
-import { addControlledInputEventHandlers, isEventNameIgnored as isEventNameIgnoredInput, removeControlledInputEventHandlers, syncControlledInputProps, } from './input';
-import { addControlledSelectEventHandlers, isEventNameIgnored as isEventNameIgnoredSelect, removeControlledSelectEventHandlers, syncControlledSelectProps, } from './select';
-import { addControlledTextareaEventHandlers, isEventNameIgnored as isEventNameIgnoredTextarea, removeControlledTextareaEventHandlers, syncControlledTextareaProps, } from './textarea';
+import { addControlledInputEventHandlers, isEventNameIgnored as isEventNameIgnoredInput, removeControlledInputEventHandlers, syncControlledInputProps, } from './input.js';
+import { addControlledSelectEventHandlers, isEventNameIgnored as isEventNameIgnoredSelect, removeControlledSelectEventHandlers, syncControlledSelectProps, } from './select.js';
+import { addControlledTextareaEventHandlers, isEventNameIgnored as isEventNameIgnoredTextarea, removeControlledTextareaEventHandlers, syncControlledTextareaProps, } from './textarea.js';
 export function isEventNameIgnored(element, eventName) {
     if (element.type === 'input') {
         return isEventNameIgnoredInput(element.props, eventName);

package/dom/props/controlled/input.d.ts

@@ -1,5 +1,5 @@
 import type { SimpElement } from '../../../core/internal.js';
-import type { Dict } from '../../../shared';
+import type { Dict } from '../../../shared/index.js';
 export declare function isCheckedType(type: string): boolean;
 export declare function isEventNameIgnored(props: Dict, eventName: string): boolean;
 export declare function addControlledInputEventHandlers(dom: HTMLInputElement): void;