@simpreact/simpreact 0.0.7 → 0.0.9

package/core/unmounting.js

@@ -1,69 +1,61 @@
 import { noop } from '../shared/index.js';
-import { lifecycleEventBus } from './lifecycleEventBus.js';
-import { processStack, UNMOUNT_ENTER, UNMOUNT_EXIT } from './processStack.js';
+import { getLifecycleEventBus } from './lifecycleEventBus.js';
+import { acquireUnmountFrame, processStack, UNMOUNT_ENTER, UNMOUNT_EXIT, } from './processStack.js';
 import { unmountRef } from './ref.js';
-import { _pushUnmountChildrenFrame } from './unmountingChildren.js';
-import { _clearElementHostReference, bitScanForwardIndex } from './utils.js';
-const unmountHandlers = [
-    _unmountHostElement,
-    _unmountFunctionalElement,
-    noop,
-    _unmountPortalElement,
-    _unmountFragmentElement,
-];
+import { pushUnmountChildrenFrame } from './unmountingChildren.js';
+import { bitScanForwardIndex, clearElementHostReference } from './utils.js';
+const unmountEnterHandlers = [unmountHostEnter, unmountFCEnter, noop, unmountPortalElement, unmountFragmentElement];
+const unmountExitHandlers = [unmountHostExit, unmountFCExit, noop, noop, noop];
 export function unmount(element, renderRuntime) {
     if (renderRuntime.renderStack.length !== 0) {
         throw new Error('Cannot unmount while rendering.');
     }
-    _pushUnmountEnterFrame(element, { renderRuntime });
+    pushUnmountEnterFrame(element, renderRuntime);
     processStack(renderRuntime);
 }
-export function _unmount(frame) {
-    unmountHandlers[bitScanForwardIndex(frame.node.flag)](frame);
+export function unmountEnter(frame) {
+    unmountEnterHandlers[bitScanForwardIndex(frame.node.flag)](frame);
 }
-export function _pushUnmountEnterFrame(element, meta) {
-    meta.renderRuntime.renderStack.push({
-        node: element,
-        kind: UNMOUNT_ENTER,
-        meta,
-    });
+export function unmountExit(frame) {
+    unmountExitHandlers[bitScanForwardIndex(frame.node.flag)](frame);
 }
-export function _pushUnmountExitFrame(element, meta) {
-    meta.renderRuntime.renderStack.push({
-        node: element,
-        kind: UNMOUNT_EXIT,
-        meta,
-    });
+export function pushUnmountEnterFrame(element, renderRuntime) {
+    renderRuntime.renderStack.push(acquireUnmountFrame(renderRuntime, element, UNMOUNT_ENTER));
+}
+function pushUnmountExitFrame(element, renderRuntime) {
+    renderRuntime.renderStack.push(acquireUnmountFrame(renderRuntime, element, UNMOUNT_EXIT));
 }
-function _unmountFunctionalElement(frame) {
+function unmountFCEnter(frame) {
     const current = frame.node;
     if (current.unmounted) {
         return;
     }
-    if (frame.kind === UNMOUNT_EXIT) {
-        current.unmounted = true;
-        lifecycleEventBus.publish({ type: 'unmounted', element: current, renderRuntime: frame.meta.renderRuntime });
-        current.store = null;
-        return;
-    }
-    _pushUnmountExitFrame(current, frame.meta);
-    _pushUnmountChildrenFrame(current, frame.meta);
+    pushUnmountExitFrame(current, frame.renderRuntime);
+    pushUnmountChildrenFrame(current, frame.renderRuntime);
 }
-function _unmountHostElement(frame) {
+function unmountFCExit(frame) {
     const current = frame.node;
-    if (frame.kind === UNMOUNT_EXIT) {
-        unmountRef(current);
-        frame.meta.renderRuntime.hostAdapter.unmountProps(current.reference, current, frame.meta.renderRuntime);
-        frame.meta.renderRuntime.hostAdapter.detachElementFromReference(current.reference, frame.meta.renderRuntime);
-        return;
-    }
-    _pushUnmountExitFrame(current, frame.meta);
-    _pushUnmountChildrenFrame(current, frame.meta);
+    current.unmounted = true;
+    getLifecycleEventBus(frame.renderRuntime).publish({
+        type: 'unmounted',
+        element: current,
+        renderRuntime: frame.renderRuntime,
+    });
+}
+function unmountHostEnter(frame) {
+    pushUnmountExitFrame(frame.node, frame.renderRuntime);
+    pushUnmountChildrenFrame(frame.node, frame.renderRuntime);
+}
+function unmountHostExit(frame) {
+    const current = frame.node;
+    unmountRef(current);
+    frame.renderRuntime.hostAdapter.unmountProps(current.reference, current, frame.renderRuntime);
+    frame.renderRuntime.hostAdapter.detachElementFromReference(current.reference, frame.renderRuntime);
 }
-function _unmountPortalElement(frame) {
-    _clearElementHostReference(frame.node.children, frame.node.ref, frame.meta.renderRuntime);
-    _pushUnmountChildrenFrame(frame.node, frame.meta);
+function unmountPortalElement(frame) {
+    clearElementHostReference(frame.node.children, frame.node.ref, frame.renderRuntime);
+    pushUnmountChildrenFrame(frame.node, frame.renderRuntime);
 }
-function _unmountFragmentElement(frame) {
-    _pushUnmountChildrenFrame(frame.node, frame.meta);
+function unmountFragmentElement(frame) {
+    pushUnmountChildrenFrame(frame.node, frame.renderRuntime);
 }

package/core/unmountingChildren.js

@@ -1,23 +1,20 @@
 import { SIMP_ELEMENT_CHILD_FLAG_ELEMENT, SIMP_ELEMENT_CHILD_FLAG_LIST } from './createElement.js';
-import { UNMOUNT_CHILDREN_ENTER } from './processStack.js';
-import { _pushUnmountEnterFrame } from './unmounting.js';
-export function _pushUnmountChildrenFrame(parent, meta) {
-    meta.renderRuntime.renderStack.push({
-        node: parent,
-        kind: UNMOUNT_CHILDREN_ENTER,
-        meta,
-    });
+import { acquireUnmountChildrenFrame } from './processStack.js';
+import { pushUnmountEnterFrame } from './unmounting.js';
+export function pushUnmountChildrenFrame(parent, renderRuntime) {
+    renderRuntime.renderStack.push(acquireUnmountChildrenFrame(renderRuntime, parent));
 }
-export function _unmountChildren(frame) {
+export function unmountChildren(frame) {
     switch (frame.node.childFlag) {
-        case SIMP_ELEMENT_CHILD_FLAG_LIST:
+        case SIMP_ELEMENT_CHILD_FLAG_LIST: {
             const children = frame.node.children;
             for (let i = children.length - 1; i >= 0; i -= 1) {
-                _pushUnmountEnterFrame(children[i], frame.meta);
+                pushUnmountEnterFrame(children[i], frame.renderRuntime);
             }
             break;
+        }
         case SIMP_ELEMENT_CHILD_FLAG_ELEMENT:
-            _pushUnmountEnterFrame(frame.node.children, frame.meta);
+            pushUnmountEnterFrame(frame.node.children, frame.renderRuntime);
             break;
     }
 }

package/core/utils.js

@@ -1,4 +1,4 @@
-import { SIMP_ELEMENT_CHILD_FLAG_ELEMENT, SIMP_ELEMENT_CHILD_FLAG_LIST, SIMP_ELEMENT_FLAG_FC, SIMP_ELEMENT_FLAG_FRAGMENT, SIMP_ELEMENT_FLAG_HOST, SIMP_ELEMENT_FLAG_PORTAL, SIMP_ELEMENT_FLAG_TEXT, } from './createElement.js';
+import { SIMP_ELEMENT_CHILD_FLAG_ELEMENT, SIMP_ELEMENT_CHILD_FLAG_EMPTY, SIMP_ELEMENT_CHILD_FLAG_LIST, SIMP_ELEMENT_FLAG_FC, SIMP_ELEMENT_FLAG_FRAGMENT, SIMP_ELEMENT_FLAG_HOST, SIMP_ELEMENT_FLAG_PORTAL, SIMP_ELEMENT_FLAG_TEXT, } from './createElement.js';
 export function bitScanForwardIndex(flag) {
     const lsb = (flag & -flag) >>> 0;
     return 31 - Math.clz32(lsb);
@@ -20,10 +20,9 @@ export function findParentReferenceFromElement(element) {
     }
     return null;
 }
-const placeStack = [];
 export function placeElementBeforeAnchor(element, anchor, parentReference, renderRuntime) {
     const { hostAdapter } = renderRuntime;
-    placeStack.push(element);
+    const placeStack = [element];
     let nextAnchor = anchor;
     while (placeStack.length !== 0) {
         const current = placeStack.pop();
@@ -98,24 +97,25 @@ function findNextLogicalElement(element) {
     }
 }
 export function getLongestIncreasingSubsequenceIndexes(sequence) {
-    const predecessors = new Int32Array(sequence.length);
-    const result = [];
+    const n = sequence.length;
+    const predecessors = new Int32Array(n);
     predecessors.fill(-1);
-    for (let i = 0; i < sequence.length; i++) {
+    const result = new Int32Array(n);
+    let resultLen = 0;
+    for (let i = 0; i < n; i++) {
         const value = sequence[i];
         if (value === 0) {
             continue;
         }
-        const lastResultIndex = result[result.length - 1];
-        if (lastResultIndex == null || sequence[lastResultIndex] < value) {
-            if (lastResultIndex != null) {
-                predecessors[i] = lastResultIndex;
+        if (resultLen === 0 || sequence[result[resultLen - 1]] < value) {
+            if (resultLen > 0) {
+                predecessors[i] = result[resultLen - 1];
             }
-            result.push(i);
+            result[resultLen++] = i;
             continue;
         }
         let start = 0;
-        let end = result.length - 1;
+        let end = resultLen - 1;
         while (start < end) {
             const middle = (start + end) >> 1;
             if (sequence[result[middle]] < value) {
@@ -132,8 +132,8 @@ export function getLongestIncreasingSubsequenceIndexes(sequence) {
             result[start] = i;
         }
     }
-    let resultIndex = result.length;
-    let sequenceIndex = result[resultIndex - 1] ?? -1;
+    let resultIndex = resultLen;
+    let sequenceIndex = resultLen > 0 ? result[resultLen - 1] : -1;
     const indexes = new Int32Array(resultIndex);
     while (resultIndex-- > 0) {
         indexes[resultIndex] = sequenceIndex;
@@ -141,7 +141,29 @@ export function getLongestIncreasingSubsequenceIndexes(sequence) {
     }
     return indexes;
 }
-export function _clearElementHostReference(element, parentHostReference, renderRuntime) {
+export function detachElementFromParent(element) {
+    const parent = element.parent;
+    if (!parent)
+        return;
+    if (parent.childFlag === SIMP_ELEMENT_CHILD_FLAG_LIST) {
+        const list = parent.children;
+        list.splice(element.index, 1);
+        if (list.length === 1) {
+            parent.children = list[0];
+            parent.childFlag = SIMP_ELEMENT_CHILD_FLAG_ELEMENT;
+        }
+        else {
+            for (let i = element.index; i < list.length; i++) {
+                list[i].index = i;
+            }
+        }
+    }
+    else {
+        parent.childFlag = SIMP_ELEMENT_CHILD_FLAG_EMPTY;
+        parent.children = null;
+    }
+}
+export function clearElementHostReference(element, parentHostReference, renderRuntime) {
     while (element != null) {
         if (isHostLike(element.flag)) {
             renderRuntime.hostAdapter.removeChild(parentHostReference, element.reference);
@@ -157,7 +179,7 @@ export function _clearElementHostReference(element, parentHostReference, renderR
             switch (childFlag) {
                 case SIMP_ELEMENT_CHILD_FLAG_LIST:
                     for (let i = 0, len = children.length; i < len; ++i) {
-                        _clearElementHostReference(children[i], parentHostReference, renderRuntime);
+                        clearElementHostReference(children[i], parentHostReference, renderRuntime);
                     }
                     return;
                 case SIMP_ELEMENT_CHILD_FLAG_ELEMENT:

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

@@ -1,23 +1,31 @@
-import { SIMP_ELEMENT_FLAG_TEXT } from '../core/internal.js';
+import { isText } from '../core/internal.js';
+const domElementMaps = new WeakMap();
+function getDomMap(renderRuntime) {
+    let map = domElementMaps.get(renderRuntime);
+    if (!map) {
+        map = new Map();
+        domElementMaps.set(renderRuntime, map);
+    }
+    return map;
+}
 export function attachElementToDom(element, dom, renderRuntime) {
-    if ((element.flag & SIMP_ELEMENT_FLAG_TEXT) === 0) {
-        renderRuntime.elementToHostMap.set(dom, element);
+    if (!isText(element)) {
+        getDomMap(renderRuntime).set(dom, element);
     }
 }
 export function getElementFromDom(target, renderRuntime) {
     if (!target) {
         return null;
     }
-    while (target && !renderRuntime.elementToHostMap.has(target)) {
+    const map = getDomMap(renderRuntime);
+    while (target && !map.has(target)) {
         target = target.parentElement;
     }
     if (!target) {
         return null;
     }
-    return renderRuntime.elementToHostMap.get(target);
+    return map.get(target);
 }
 export function detachElementFromDom(dom, renderRuntime) {
-    if (renderRuntime.elementToHostMap.has(dom)) {
-        renderRuntime.elementToHostMap.delete(dom);
-    }
+    getDomMap(renderRuntime).delete(dom);
 }

package/dom/events.js

@@ -1,4 +1,4 @@
-import { SIMP_ELEMENT_FLAG_HOST } from '../core/internal.js';
+import { isHost } from '../core/internal.js';
 const eventNameByTypes = {
     click: 'onClick',
     dblclick: 'onDblClick',
@@ -57,21 +57,17 @@ export class SyntheticEvent {
     currentTarget = null;
     isPropagationStopped = false;
     _isDefaultPrevented = false;
-    button;
-    buttons;
-    pointerId;
-    altKey;
-    ctrlKey;
-    shiftKey;
-    metaKey;
     constructor(event) {
         this.nativeEvent = event;
-        this.button = event.button;
-        this.buttons = event.buttons;
-        this.pointerId = event.pointerId;
-        this.altKey = event.altKey;
-        this.ctrlKey = event.ctrlKey;
-        this.metaKey = event.metaKey;
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                const val = event[prop];
+                return typeof val === 'function' ? val.bind(event) : val;
+            },
+        });
     }
     get target() {
         return this.nativeEvent.target;
@@ -97,7 +93,7 @@ export function dispatchDelegatedEvent(event, renderRuntime) {
     const bubbleHandlers = [];
     let element = renderRuntime.hostAdapter.getElementFromReference(event.target, renderRuntime);
     while (element) {
-        if ((element.flag & SIMP_ELEMENT_FLAG_HOST) !== 0) {
+        if (isHost(element)) {
             const captureHandler = element.props?.[eventNameByTypes[event.type] + 'Capture'];
             const bubbleHandler = element.props?.[eventNameByTypes[event.type]];
             if (captureHandler) {

package/dom/index.d.ts

@@ -1,5 +1,4 @@
-import type { RefAttributes, SimpElement, SimpNode, SimpRenderRuntime } from '../core/index.js';
-import type { HostAdapter } from '../core/internal.js';
+import type { HostAdapter, RefAttributes, SimpElement, SimpNode, SimpRenderRuntime } from '../core/index.js';
 import type { Nullable } from '../shared/index.js';
 
 import type { PropertiesHyphen } from 'csstype';
@@ -17,15 +16,15 @@ export interface SimpRoot {
   unmount(): void;
 }
 
-declare function createCreateRoot(
+export declare function createCreateRoot(
   renderRuntime: SimpRenderRuntime
 ): (container: Element | DocumentFragment) => SimpRoot;
 
-declare function createRenderer(
+export declare function createRenderer(
   renderRuntime: SimpRenderRuntime
 ): (element: SimpElement, parentReference: Nullable<HTMLElement>) => void;
 
-declare const domAdapter: HostAdapter;
+export declare const domAdapter: HostAdapter;
 
 export interface SimpReactHTMLElement<T extends HTMLElement>
   extends DetailedSimpReactHTMLElement<AllHTMLAttributes<T>, T> {}
@@ -659,6 +658,7 @@ export interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
 
 export interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
   form?: string | undefined;
+  for?: string | undefined;
   htmlFor?: string | undefined;
 }
 
@@ -760,6 +760,7 @@ export interface OptionHTMLAttributes<T> extends HTMLAttributes<T> {
 
 export interface OutputHTMLAttributes<T> extends HTMLAttributes<T> {
   form?: string | undefined;
+  for?: string | undefined;
   htmlFor?: string | undefined;
   name?: string | undefined;
 }

package/dom/props/attrMaps.js

@@ -0,0 +1,90 @@
+export const htmlAttrAlias = {
+    class: 'className',
+    for: 'htmlFor',
+};
+export const svgCamelToHyphen = {
+    accentHeight: 'accent-height',
+    alignmentBaseline: 'alignment-baseline',
+    arabicForm: 'arabic-form',
+    baselineShift: 'baseline-shift',
+    capHeight: 'cap-height',
+    clipPath: 'clip-path',
+    clipRule: 'clip-rule',
+    colorInterpolation: 'color-interpolation',
+    colorInterpolationFilters: 'color-interpolation-filters',
+    colorProfile: 'color-profile',
+    colorRendering: 'color-rendering',
+    dominantBaseline: 'dominant-baseline',
+    enableBackground: 'enable-background',
+    fillOpacity: 'fill-opacity',
+    fillRule: 'fill-rule',
+    floodColor: 'flood-color',
+    floodOpacity: 'flood-opacity',
+    fontFamily: 'font-family',
+    fontSize: 'font-size',
+    fontSizeAdjust: 'font-size-adjust',
+    fontStretch: 'font-stretch',
+    fontStyle: 'font-style',
+    fontVariant: 'font-variant',
+    fontWeight: 'font-weight',
+    glyphName: 'glyph-name',
+    glyphOrientationHorizontal: 'glyph-orientation-horizontal',
+    glyphOrientationVertical: 'glyph-orientation-vertical',
+    horizAdvX: 'horiz-adv-x',
+    horizOriginX: 'horiz-origin-x',
+    imageRendering: 'image-rendering',
+    letterSpacing: 'letter-spacing',
+    lightingColor: 'lighting-color',
+    markerEnd: 'marker-end',
+    markerMid: 'marker-mid',
+    markerStart: 'marker-start',
+    overlinePosition: 'overline-position',
+    overlineThickness: 'overline-thickness',
+    paintOrder: 'paint-order',
+    panose1: 'panose-1',
+    pointerEvents: 'pointer-events',
+    renderingIntent: 'rendering-intent',
+    shapeRendering: 'shape-rendering',
+    stopColor: 'stop-color',
+    stopOpacity: 'stop-opacity',
+    strikethroughPosition: 'strikethrough-position',
+    strikethroughThickness: 'strikethrough-thickness',
+    strokeDasharray: 'stroke-dasharray',
+    strokeDashoffset: 'stroke-dashoffset',
+    strokeLinecap: 'stroke-linecap',
+    strokeLinejoin: 'stroke-linejoin',
+    strokeMiterlimit: 'stroke-miterlimit',
+    strokeOpacity: 'stroke-opacity',
+    strokeWidth: 'stroke-width',
+    textAnchor: 'text-anchor',
+    textDecoration: 'text-decoration',
+    textRendering: 'text-rendering',
+    underlinePosition: 'underline-position',
+    underlineThickness: 'underline-thickness',
+    unicodeBidi: 'unicode-bidi',
+    unicodeRange: 'unicode-range',
+    unitsPerEm: 'units-per-em',
+    vAlphabetic: 'v-alphabetic',
+    vHanging: 'v-hanging',
+    vIdeographic: 'v-ideographic',
+    vMathematical: 'v-mathematical',
+    vectorEffect: 'vector-effect',
+    vertAdvY: 'vert-adv-y',
+    vertOriginX: 'vert-origin-x',
+    vertOriginY: 'vert-origin-y',
+    wordSpacing: 'word-spacing',
+    writingMode: 'writing-mode',
+    xHeight: 'x-height',
+};
+export const svgAttrsNamespaces = {
+    'xlink:actuate': 'http://www.w3.org/1999/xlink',
+    'xlink:arcrole': 'http://www.w3.org/1999/xlink',
+    'xlink:href': 'http://www.w3.org/1999/xlink',
+    'xlink:role': 'http://www.w3.org/1999/xlink',
+    'xlink:show': 'http://www.w3.org/1999/xlink',
+    'xlink:title': 'http://www.w3.org/1999/xlink',
+    'xlink:type': 'http://www.w3.org/1999/xlink',
+    'xml:base': 'http://www.w3.org/XML/1998/namespace',
+    'xml:lang': 'http://www.w3.org/XML/1998/namespace',
+    'xml:space': 'http://www.w3.org/XML/1998/namespace',
+};

package/dom/props/controlled/select.js

@@ -1,4 +1,4 @@
-import { SIMP_ELEMENT_CHILD_FLAG_ELEMENT, SIMP_ELEMENT_CHILD_FLAG_LIST, withSyncRerender } from '../../../core/internal.js';
+import { hasElementChild, hasListChildren, withSyncRerender, } from '../../../core/internal.js';
 import { emptyObject } from '../../../shared/index.js';
 export function isEventNameIgnored(eventName) {
     return eventName === 'onChange';
@@ -61,15 +61,13 @@ function updateOptions(element, value) {
         return;
     }
     const children = element.children;
-    const childFlag = element.childFlag;
-    switch (childFlag) {
-        case SIMP_ELEMENT_CHILD_FLAG_LIST:
-            for (let i = 0, len = children.length; i < len; ++i) {
-                updateOptions(children[i], value);
-            }
-            break;
-        case SIMP_ELEMENT_CHILD_FLAG_ELEMENT:
-            updateOptions(children, value);
+    if (hasListChildren(element)) {
+        for (let i = 0, len = children.length; i < len; ++i) {
+            updateOptions(children[i], value);
+        }
+    }
+    else if (hasElementChild(element)) {
+        updateOptions(children, value);
     }
 }
 function updateOption(element, value) {

package/dom/props/props.js

@@ -1,6 +1,7 @@
 import { emptyObject } from '../../shared/index.js';
 import { isPropNameEventName, patchEvent } from '../events.js';
 import { defaultNamespace } from '../namespace.js';
+import { htmlAttrAlias, svgAttrsNamespaces, svgCamelToHyphen } from './attrMaps.js';
 import { addControlledFormElementEventHandlers, isEventNameIgnored, isFormElementControlled, removeControlledFormElementEventHandlers, syncControlledFormElementPropsWithAttrs, } from './controlled/index.js';
 import { patchDangerInnerHTML } from './dangerInnerHTML.js';
 import { patchStyle } from './style.js';
@@ -76,6 +77,7 @@ export function patchProps(dom, prevElement, nextElement, namespace, renderRunti
     }
 }
 function patchFormElementsPropAndAttrs(propName, dom, element, isControlled, prevValue, nextValue, renderRuntime) {
+    propName = htmlAttrAlias[propName] ?? propName;
     switch (propName) {
         case 'children':
         case 'className':
@@ -123,6 +125,7 @@ function patchFormElementsPropAndAttrs(propName, dom, element, isControlled, pre
     }
 }
 function patchDefaultElementPropAndAttrs(propName, dom, nextElement, prevValue, nextValue, namespace, renderRuntime) {
+    propName = htmlAttrAlias[propName] ?? propName;
     switch (propName) {
         case 'children':
         case 'className':
@@ -155,6 +158,9 @@ function patchDefaultElementPropAndAttrs(propName, dom, nextElement, prevValue,
         case 'dangerouslySetInnerHTML':
             patchDangerInnerHTML(prevValue, nextValue, nextElement, dom);
             break;
+        case 'htmlFor':
+            patchDomAttr(dom, nextValue, 'for', namespace);
+            break;
         default:
             if (isPropNameEventName(propName)) {
                 patchEvent(propName, prevValue, nextValue, dom, renderRuntime);
@@ -175,26 +181,19 @@ function patchDomAttr(dom, value, propName, namespace = defaultNamespace) {
         dom.removeAttribute(propName);
     }
     else {
-        if (namespace === 'http://www.w3.org/2000/svg' && svgAttrsNamespaces[propName]) {
-            dom.setAttributeNS(svgAttrsNamespaces[propName], propName, value);
+        if (namespace === 'http://www.w3.org/2000/svg') {
+            if (svgAttrsNamespaces[propName]) {
+                dom.setAttributeNS(svgAttrsNamespaces[propName], propName, value);
+            }
+            else {
+                dom.setAttribute(svgCamelToHyphen[propName] ?? propName, value);
+            }
         }
         else {
             dom.setAttribute(propName, value);
         }
     }
 }
-const svgAttrsNamespaces = {
-    'xlink:actuate': 'http://www.w3.org/1999/xlink',
-    'xlink:arcrole': 'http://www.w3.org/1999/xlink',
-    'xlink:href': 'http://www.w3.org/1999/xlink',
-    'xlink:role': 'http://www.w3.org/1999/xlink',
-    'xlink:show': 'http://www.w3.org/1999/xlink',
-    'xlink:title': 'http://www.w3.org/1999/xlink',
-    'xlink:type': 'http://www.w3.org/1999/xlink',
-    'xml:base': 'http://www.w3.org/XML/1998/namespace',
-    'xml:lang': 'http://www.w3.org/XML/1998/namespace',
-    'xml:space': 'http://www.w3.org/XML/1998/namespace',
-};
 function isFormElement(element) {
     return element.type === 'input' || element.type === 'textarea' || element.type === 'select';
 }

package/hooks/index.d.ts

@@ -1,8 +1,5 @@
 import type { RefObject, SimpRenderRuntime } from '../core/index.js';
-
-export type Cleanup = () => void;
-export type Effect = () => void | Cleanup;
-export type DependencyList = readonly unknown[];
+import type { DependencyList, Effect } from '../shared/index.js';
 
 export type Dispatch<A> = (value: A) => void;
 export type SetStateAction<S> = S | ((prevState: S) => S);
@@ -12,18 +9,26 @@ export interface UseRef {
   <T>(initialValue: T | null): RefObject<T | null>;
   <T = undefined>(initialValue?: T): RefObject<T | undefined>;
 }
-declare function createUseRef(renderRuntime: SimpRenderRuntime): UseRef;
+export declare function createUseRef(renderRuntime: SimpRenderRuntime): UseRef;
 
-declare function createUseRerender(renderRuntime: SimpRenderRuntime): () => void;
+export declare function createUseRerender(renderRuntime: SimpRenderRuntime): () => void;
 
 export interface UseState {
   <S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
   <S>(): [S | undefined, Dispatch<SetStateAction<S | undefined>>];
+  <S = undefined>(
+    initialState: undefined | (() => undefined)
+  ): [S | undefined, Dispatch<SetStateAction<S | undefined>>];
 }
-declare function createUseState(renderRuntime: SimpRenderRuntime): useState;
+export declare function createUseState(renderRuntime: SimpRenderRuntime): UseState;
 
-declare function createUseEffect(renderRuntime: SimpRenderRuntime): (effect: Effect, deps?: DependencyList) => void;
+export declare function createUseEffect(
+  renderRuntime: SimpRenderRuntime
+): (effect: Effect, deps?: DependencyList) => void;
 
-declare function createUseCatch(renderRuntime: SimpRenderRuntime): (cb: (error: any) => void) => void;
+export declare function createUseCatch(renderRuntime: SimpRenderRuntime): (cb: (error: any) => void) => void;
 
-declare function areDepsEqual(nextDeps: DependencyList | undefined, prevDeps: DependencyList | undefined): boolean;
+export declare function areDepsEqual(
+  nextDeps: DependencyList | undefined,
+  prevDeps: DependencyList | undefined
+): boolean;