@simpreact/simpreact 0.0.5 → 0.0.6

package/dom/props/props.js

@@ -1,36 +1,39 @@
 import { emptyObject } from '../../shared/index.js';
+import { isPropNameEventName, patchEvent } from '../events.js';
 import { defaultNamespace } from '../namespace.js';
 import { addControlledFormElementEventHandlers, isEventNameIgnored, isFormElementControlled, removeControlledFormElementEventHandlers, syncControlledFormElementPropsWithAttrs, } from './controlled/index.js';
-import { isPropNameEventName, patchEvent } from '../events.js';
-import { patchStyle } from './style.js';
 import { patchDangerInnerHTML } from './dangerInnerHTML.js';
-export function mountProps(dom, element, namespace) {
+import { patchStyle } from './style.js';
+export function mountProps(dom, element, namespace, renderRuntime) {
     if (!isFormElement(element)) {
         for (const propName in element.props) {
-            patchDefaultElementPropAndAttrs(propName, dom, null, element, null, element.props[propName], namespace);
+            patchDefaultElementPropAndAttrs(propName, dom, null, element, null, element.props[propName], namespace, renderRuntime);
         }
         return;
     }
     const isControlled = isFormElementControlled(element.props);
     for (const propName in element.props) {
-        patchFormElementsPropAndAttrs(propName, dom, element, isControlled, null, element.props[propName]);
+        patchFormElementsPropAndAttrs(propName, dom, element, isControlled, null, element.props[propName], renderRuntime);
     }
     if (isControlled) {
-        addControlledFormElementEventHandlers(element);
+        addControlledFormElementEventHandlers(element, renderRuntime);
         syncControlledFormElementPropsWithAttrs(element, element.props, true);
     }
 }
-export function unmountProps(dom, element) {
+export function unmountProps(dom, element, renderRuntime) {
     if (!element.props) {
         return;
     }
+    if (isFormElement(element) && isFormElementControlled(element.props)) {
+        removeControlledFormElementEventHandlers(element, renderRuntime);
+    }
     for (const propName in element.props) {
         if (isPropNameEventName(propName)) {
-            patchEvent(propName, element.props[propName], null, dom);
+            patchEvent(propName, element.props[propName], null, dom, renderRuntime);
         }
     }
 }
-export function patchProps(dom, prevElement, nextElement, namespace) {
+export function patchProps(dom, prevElement, nextElement, namespace, renderRuntime) {
     const prevProps = prevElement.props || emptyObject;
     const nextProps = nextElement.props || emptyObject;
     if (!isFormElement(nextElement)) {
@@ -38,12 +41,12 @@ export function patchProps(dom, prevElement, nextElement, namespace) {
             const prevValue = prevProps[propName];
             const nextValue = nextProps[propName];
             if (prevValue !== nextValue) {
-                patchDefaultElementPropAndAttrs(propName, dom, prevElement, nextElement, prevValue, nextValue, namespace);
+                patchDefaultElementPropAndAttrs(propName, dom, prevElement, nextElement, prevValue, nextValue, namespace, renderRuntime);
             }
         }
         for (const propName in prevProps) {
             if (nextProps[propName] == null && prevProps[propName] != null) {
-                patchDefaultElementPropAndAttrs(propName, dom, prevElement, nextElement, prevProps[propName], null, namespace);
+                patchDefaultElementPropAndAttrs(propName, dom, prevElement, nextElement, prevProps[propName], null, namespace, renderRuntime);
             }
         }
         return;
@@ -54,25 +57,25 @@ export function patchProps(dom, prevElement, nextElement, namespace) {
         const prevValue = prevProps[propName];
         const nextValue = nextProps[propName];
         if (prevValue !== nextValue) {
-            patchFormElementsPropAndAttrs(propName, dom, nextElement, isNextElementControlled, prevValue, nextValue);
+            patchFormElementsPropAndAttrs(propName, dom, nextElement, isNextElementControlled, prevValue, nextValue, renderRuntime);
         }
     }
     for (const propName in prevProps) {
         if (nextProps[propName] == null && prevProps[propName] != null) {
-            patchFormElementsPropAndAttrs(propName, dom, prevElement, isPrevElementControlled, prevProps[propName], null);
+            patchFormElementsPropAndAttrs(propName, dom, prevElement, isPrevElementControlled, prevProps[propName], null, renderRuntime);
         }
     }
     if (!isPrevElementControlled && isNextElementControlled) {
-        addControlledFormElementEventHandlers(nextElement);
+        addControlledFormElementEventHandlers(nextElement, renderRuntime);
     }
     else if (isPrevElementControlled && !isNextElementControlled) {
-        removeControlledFormElementEventHandlers(prevElement);
+        removeControlledFormElementEventHandlers(prevElement, renderRuntime);
     }
     if (isNextElementControlled) {
         syncControlledFormElementPropsWithAttrs(nextElement, nextProps);
     }
 }
-function patchFormElementsPropAndAttrs(propName, dom, element, isControlled, prevValue, nextValue) {
+function patchFormElementsPropAndAttrs(propName, dom, element, isControlled, prevValue, nextValue, renderRuntime) {
     switch (propName) {
         case 'children':
         case 'className':
@@ -109,17 +112,17 @@ function patchFormElementsPropAndAttrs(propName, dom, element, isControlled, pre
         default:
             if (isPropNameEventName(propName)) {
                 if (isControlled && isEventNameIgnored(element, propName)) {
-                    patchEvent(propName, prevValue, null, dom);
+                    patchEvent(propName, prevValue, null, dom, renderRuntime);
                     break;
                 }
-                patchEvent(propName, prevValue, nextValue, dom);
+                patchEvent(propName, prevValue, nextValue, dom, renderRuntime);
             }
             else {
                 patchDomAttr(dom, nextValue, propName);
             }
     }
 }
-function patchDefaultElementPropAndAttrs(propName, dom, prevElement, nextElement, prevValue, nextValue, namespace) {
+function patchDefaultElementPropAndAttrs(propName, dom, prevElement, nextElement, prevValue, nextValue, namespace, renderRuntime) {
     switch (propName) {
         case 'children':
         case 'className':
@@ -150,11 +153,11 @@ function patchDefaultElementPropAndAttrs(propName, dom, prevElement, nextElement
             patchStyle(prevValue, nextValue, dom);
             break;
         case 'dangerouslySetInnerHTML':
-            patchDangerInnerHTML(prevValue, nextValue, prevElement, nextElement, dom);
+            patchDangerInnerHTML(prevValue, nextValue, prevElement, nextElement, dom, renderRuntime);
             break;
         default:
             if (isPropNameEventName(propName)) {
-                patchEvent(propName, prevValue, nextValue, dom);
+                patchEvent(propName, prevValue, nextValue, dom, renderRuntime);
             }
             else {
                 patchDomAttr(dom, nextValue, propName, namespace);

package/dom/render.d.ts

@@ -1,9 +1,8 @@
-import { type SimpElement } from '../core/internal.js';
+import { type SimpElement, type SimpRenderRuntime } from '../core/internal.js';
 import type { Nullable } from '../shared/index.js';
-export declare function render(element: Nullable<SimpElement>, container: Nullable<Element | DocumentFragment>): void;
-interface SimpRoot {
+export declare function createRenderer(renderRuntime: SimpRenderRuntime): (element: Nullable<SimpElement>, container: Nullable<Element | DocumentFragment>) => void;
+export interface SimpRoot {
     render(element: SimpElement): void;
     unmount(): void;
 }
-export declare function createRoot(container: Element | DocumentFragment): SimpRoot;
-export {};
+export declare function createCreateRoot(renderRuntime: SimpRenderRuntime): (container: Element | DocumentFragment) => SimpRoot;

package/dom/render.js

@@ -1,41 +1,45 @@
-import { renderingRerenderLocker, hostAdapter, mount, patch, provideHostAdapter, remove, } from '../core/internal.js';
-import { domAdapter } from './domAdapter.js';
-import { attachElementToDom, getElementFromDom } from './attach-element-to-dom.js';
-provideHostAdapter(domAdapter);
-export function render(element, container) {
-    if (!container) {
-        return;
-    }
-    const currentRootElement = getElementFromDom(container);
-    renderingRerenderLocker.lock();
-    if (!currentRootElement) {
-        if (element) {
-            hostAdapter.clearNode(container);
-            attachElementToDom((element.parent = { flag: 'HOST', reference: container, children: element, parent: null }), container);
-            mount(element, container, null, null, hostAdapter.getHostNamespaces(element, undefined)?.self);
+import { createElement, mount, patch, unmount } from '../core/internal.js';
+export function createRenderer(renderRuntime) {
+    return (element, container) => {
+        if (!container) {
+            return;
         }
-    }
-    else {
-        if (!element) {
-            remove(currentRootElement.children, container);
-            currentRootElement.children = null;
+        const currentRootElement = renderRuntime.hostAdapter.getElementFromReference(container, renderRuntime);
+        if (!currentRootElement) {
+            if (element) {
+                renderRuntime.hostAdapter.clearNode(container);
+                element.parent = createElement('', null, element);
+                element.parent.type = null;
+                element.parent.reference = container;
+                renderRuntime.hostAdapter.attachElementToReference(element.parent, container, renderRuntime);
+                mount(element, container, null, null, renderRuntime.hostAdapter.getHostNamespaces(element, undefined)?.self, renderRuntime);
+            }
         }
         else {
-            const prevChildren = currentRootElement.children;
-            currentRootElement.children = element;
-            element.parent = currentRootElement;
-            patch(prevChildren, element, container, null, null, hostAdapter.getHostNamespaces(element, undefined)?.self);
+            if (!element) {
+                unmount(currentRootElement.children, renderRuntime);
+                renderRuntime.hostAdapter.detachElementFromReference(container, renderRuntime);
+                renderRuntime.hostAdapter.clearNode(container);
+            }
+            else {
+                const prevChildren = currentRootElement.children;
+                currentRootElement.children = element;
+                element.parent = currentRootElement;
+                patch(prevChildren, element, container, null, null, renderRuntime.hostAdapter.getHostNamespaces(element, undefined)?.self, renderRuntime);
+            }
         }
-    }
-    renderingRerenderLocker.flush();
+    };
 }
-export function createRoot(container) {
-    return {
-        render(element) {
-            render(element, container);
-        },
-        unmount() {
-            render(null, container);
-        },
+export function createCreateRoot(renderRuntime) {
+    const render = createRenderer(renderRuntime);
+    return (container) => {
+        return {
+            render(element) {
+                render(element, container);
+            },
+            unmount() {
+                render(null, container);
+            },
+        };
     };
 }

package/hooks/index.d.ts

@@ -1,4 +1,4 @@
-import type { RefObject } from '../core/index.js';
+import type { RefObject, SimpRenderRuntime } from '../core/index.js';
 
 export type Cleanup = () => void;
 export type Effect = () => void | Cleanup;
@@ -7,21 +7,23 @@ export type DependencyList = readonly unknown[];
 export type Dispatch<A> = (value: A) => void;
 export type SetStateAction<S> = S | ((prevState: S) => S);
 
-declare function useRef<T>(initialValue: T): RefObject<T>;
-declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
-declare function useRef<T>(initialValue: T | undefined): RefObject<T | undefined>;
+export interface UseRef {
+  <T>(initialValue: T): RefObject<T>;
+  <T>(initialValue: T | null): RefObject<T | null>;
+  <T = undefined>(initialValue?: T): RefObject<T | undefined>;
+}
+declare function createUseRef(renderRuntime: SimpRenderRuntime): UseRef;
 
-declare function useRerender(): () => void;
+declare function createUseRerender(renderRuntime: SimpRenderRuntime): () => void;
 
-export function useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
-export function useState<S = undefined>(): [S | undefined, Dispatch<SetStateAction<S | undefined>>];
+export interface UseState {
+  <S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
+  <S>(): [S | undefined, Dispatch<SetStateAction<S | undefined>>];
+}
+declare function createUseState(renderRuntime: SimpRenderRuntime): useState;
 
-declare function useEffect(effect: Effect, deps?: DependencyList): void;
+declare function createUseEffect(renderRuntime: SimpRenderRuntime): (effect: Effect, deps?: DependencyList) => void;
 
-declare function useMounted(effect: Effect): void;
-
-declare function useUnmounted(cleanup: Cleanup): void;
-
-declare function useCatch(cb: (error: any) => void): void;
+declare function createUseCatch(renderRuntime: SimpRenderRuntime): (cb: (error: any) => void) => void;
 
 declare function areDepsEqual(nextDeps: DependencyList | undefined, prevDeps: DependencyList | undefined): boolean;

package/hooks/index.js

@@ -1,194 +1,190 @@
-import { lifecycleEventBus, rerender as _rerender } from '../core/internal.js';
-import { callOrGet, noop } from '../shared/index.js';
-let currentIndex = 0;
-// In runtime this is a nullable variable.
-let currentElement;
+import { rerender as _rerender, lifecycleEventBus, SIMP_ELEMENT_FLAG_FC, } from '../core/internal.js';
+import { callOrGet, shallowEqual, } from '../shared/index.js';
+const hooksSpecificStoreByElementStore = new WeakMap();
+function getHooksSpecificStore(store) {
+    let hooksSpecificStore = hooksSpecificStoreByElementStore.get(store);
+    if (!hooksSpecificStore) {
+        hooksSpecificStore = { hooksIndex: 0, hookStates: null, effectsHookStates: null, catchHandlers: null };
+        hooksSpecificStoreByElementStore.set(store, hooksSpecificStore);
+    }
+    return hooksSpecificStore;
+}
 lifecycleEventBus.subscribe(event => {
-    if (event.type === 'beforeRender') {
-        currentElement = event.element;
-        if (currentElement.store?.catchHandlers) {
-            currentElement.store.catchHandlers = undefined;
+    if ((event.element.flag & SIMP_ELEMENT_FLAG_FC) === 0) {
+        return;
+    }
+    let store = getHooksSpecificStore(event.element.store);
+    switch (event.type) {
+        case 'beforeRender': {
+            store.hooksIndex = 0;
+            store.catchHandlers = null;
+            store.effectsHookStates = null;
+            break;
         }
-        if (currentElement.store?.effectsHookStates) {
-            currentElement.store.effectsHookStates = undefined;
+        case 'afterRender': {
+            store.hooksIndex = 0;
+            break;
         }
-    }
-    if (event.type === 'afterRender' || event.type === 'errored') {
-        currentElement = null;
-        currentIndex = 0;
-    }
-    if (event.type === 'mounted') {
-        const element = event.element;
-        if (element.store?.effectsHookStates) {
-            const effects = element.store.effectsHookStates;
-            element.store.effectsHookStates = undefined;
+        case 'mounted': {
+            if (!store.effectsHookStates) {
+                break;
+            }
+            const effects = store.effectsHookStates;
+            store.effectsHookStates = null;
             for (const state of effects) {
-                state.cleanup = state.effect() || undefined;
+                state.cleanup = state.effect() || null;
             }
+            break;
         }
-    }
-    if (event.type === 'updated') {
-        const element = event.element;
-        if (element.store?.effectsHookStates) {
-            const effects = element.store.effectsHookStates;
-            element.store.effectsHookStates = undefined;
+        case 'updated': {
+            if (!store.effectsHookStates) {
+                break;
+            }
+            const effects = store.effectsHookStates;
+            store.effectsHookStates = null;
             for (const state of effects) {
                 if (typeof state.cleanup === 'function') {
                     state.cleanup();
                 }
-                state.cleanup = state.effect() || undefined;
+                state.cleanup = state.effect() || null;
             }
+            break;
         }
-    }
-    if (event.type === 'unmounted') {
-        const element = event.element;
-        if (element.store?.hookStates) {
-            const hookStates = element.store.hookStates;
-            element.store.hookStates = undefined;
+        case 'unmounted': {
+            if (!store.hookStates) {
+                break;
+            }
+            const hookStates = store.hookStates;
+            store.hookStates = null;
             for (const state of hookStates) {
                 if (state && 'cleanup' in state && typeof state.cleanup === 'function') {
                     state.cleanup();
                 }
             }
+            break;
         }
-    }
-    if (event.type === 'errored') {
-        function handleError(element, error) {
-            element = findElementWithCatchHandlers(element);
-            if (!element) {
-                throw new Error('Error occurred during rendering a component', { cause: error });
+        case 'errored': {
+            store.hooksIndex = 0;
+            if (event.handled) {
+                break;
             }
-            try {
-                for (const state of element.store.catchHandlers) {
-                    state(error);
+            let element = event.element;
+            let curError = event.error;
+            let catchers = null;
+            while (element) {
+                if ((element.flag & SIMP_ELEMENT_FLAG_FC) === 0) {
+                    element = element.parent;
+                    continue;
+                }
+                store = getHooksSpecificStore(element.store);
+                catchers = store.catchHandlers;
+                if (!catchers) {
+                    element = element.parent;
+                    continue;
+                }
+                try {
+                    for (let i = 0; i < catchers.length; i++) {
+                        catchers[i](curError);
+                    }
+                    event.handled = true;
+                    break;
+                }
+                catch (error) {
+                    element = element.parent;
+                    curError = error;
                 }
-            }
-            catch (error) {
-                handleError(element.parent, error);
             }
         }
-        handleError(event.element, event.error);
     }
 });
-function findElementWithCatchHandlers(element) {
-    let temp = element;
-    while (temp != null) {
-        if (temp.store?.catchHandlers) {
-            return temp;
+export function createUseRef(renderRuntime) {
+    return initialValue => {
+        const store = getHooksSpecificStore(renderRuntime.currentRenderingFCElement.store);
+        const hookStates = getOrCreateHookStates(store);
+        if (!hookStates[store.hooksIndex]) {
+            hookStates[store.hooksIndex] = { current: initialValue };
         }
-        temp = temp.parent;
-    }
-    return null;
+        return hookStates[store.hooksIndex++];
+    };
 }
-export function useRef(initialValue) {
-    const hookStates = getOrCreateHookStates(currentElement);
-    if (!hookStates[currentIndex]) {
-        hookStates[currentIndex] = { current: initialValue };
-    }
-    return hookStates[currentIndex++];
-}
-export function useRerender() {
-    const hookStates = getOrCreateHookStates(currentElement);
-    if (!hookStates[currentIndex]) {
-        const elementStore = currentElement.store;
-        hookStates[currentIndex] = function rerender() {
-            elementStore.forceRender = true;
-            _rerender(elementStore.latestElement);
-        };
-    }
-    return hookStates[currentIndex++];
-}
-export function useState(initialState) {
-    const hookStates = getOrCreateHookStates(currentElement);
-    if (!hookStates[currentIndex]) {
-        const elementStore = currentElement.store;
-        const state = (hookStates[currentIndex] = [undefined, undefined]);
-        state[0] = callOrGet(initialState);
-        state[1] = function dispatch(action) {
-            const nextValue = callOrGet(action, state[0]);
-            if (Object.is(state[0], nextValue)) {
-                return;
-            }
-            state[0] = nextValue;
-            elementStore.forceRender = true;
-            _rerender(elementStore.latestElement);
-        };
-    }
-    return hookStates[currentIndex++];
-}
-export function useEffect(effect, deps) {
-    const hookStates = getOrCreateHookStates(currentElement);
-    let state = hookStates[currentIndex];
-    if (!state) {
-        state = hookStates[currentIndex] = { effect };
-    }
-    if (!areDepsEqual(deps, state.deps)) {
-        state.effect = effect;
-        state.deps = deps;
-        getOrCreateEffectHookStates(currentElement).push(state);
-    }
-    currentIndex++;
-}
-export function useMounted(effect) {
-    const hookStates = getOrCreateHookStates(currentElement);
-    if (!hookStates[currentIndex]) {
-        hookStates[currentIndex] = { effect };
-        getOrCreateEffectHookStates(currentElement).push(hookStates[currentIndex]);
-    }
-    currentIndex++;
+export function createUseRerender(renderRuntime) {
+    return () => {
+        const store = getHooksSpecificStore(renderRuntime.currentRenderingFCElement.store);
+        const hookStates = getOrCreateHookStates(store);
+        if (!hookStates[store.hooksIndex]) {
+            const elementStore = renderRuntime.currentRenderingFCElement.store;
+            hookStates[store.hooksIndex] = function rerender() {
+                _rerender(elementStore, renderRuntime);
+            };
+        }
+        return hookStates[store.hooksIndex++];
+    };
 }
-export function useUnmounted(cleanup) {
-    const hookStates = getOrCreateHookStates(currentElement);
-    if (!hookStates[currentIndex]) {
-        hookStates[currentIndex] = { cleanup, effect: noop };
-    }
-    currentIndex++;
+export function createUseState(renderRuntime) {
+    return (initialState => {
+        const store = getHooksSpecificStore(renderRuntime.currentRenderingFCElement.store);
+        const hookStates = getOrCreateHookStates(store);
+        if (!hookStates[store.hooksIndex]) {
+            const elementStore = renderRuntime.currentRenderingFCElement.store;
+            const state = (hookStates[store.hooksIndex] = [undefined, undefined]);
+            state[0] = callOrGet(initialState);
+            state[1] = function dispatch(action) {
+                const nextValue = callOrGet(action, state[0]);
+                if (Object.is(state[0], nextValue)) {
+                    return;
+                }
+                state[0] = nextValue;
+                _rerender(elementStore, renderRuntime);
+            };
+        }
+        return hookStates[store.hooksIndex++];
+    });
 }
-export function useCatch(cb) {
-    if (!currentElement.store) {
-        currentElement.store = {};
-    }
-    if (!currentElement.store.catchHandlers) {
-        currentElement.store.catchHandlers = [];
-    }
-    currentElement.store.catchHandlers.push(cb);
+export function createUseEffect(renderRuntime) {
+    return (effect, deps) => {
+        const store = getHooksSpecificStore(renderRuntime.currentRenderingFCElement.store);
+        const hookStates = getOrCreateHookStates(store);
+        let state = hookStates[store.hooksIndex];
+        if (!state) {
+            state = hookStates[store.hooksIndex] = {
+                effect,
+                deps: null,
+                cleanup: null,
+            };
+        }
+        if (!shallowEqual(deps, state.deps)) {
+            state.effect = effect;
+            state.deps = deps || null;
+            getOrCreateEffectHookStates(store).push(state);
+        }
+        store.hooksIndex++;
+    };
 }
-export function areDepsEqual(nextDeps, prevDeps) {
-    if (nextDeps == null || prevDeps == null || nextDeps.length !== prevDeps.length) {
-        return false;
-    }
-    for (let i = 0; i < prevDeps.length; i++) {
-        if (!Object.is(nextDeps[i], prevDeps[i])) {
-            return false;
+export function createUseCatch(renderRuntime) {
+    return cb => {
+        const store = getHooksSpecificStore(renderRuntime.currentRenderingFCElement.store);
+        if (!store.catchHandlers) {
+            store.catchHandlers = [];
         }
-    }
-    return true;
+        store.catchHandlers.push(cb);
+    };
 }
-function getOrCreateHookStates(element) {
-    if (!element.store) {
-        element.store = {};
+function getOrCreateHookStates(store) {
+    if (!store.hookStates) {
+        store.hookStates = [];
     }
-    if (!element.store.hookStates) {
-        element.store.hookStates = [];
-    }
-    return element.store.hookStates;
+    return store.hookStates;
 }
-function getOrCreateEffectHookStates(element) {
-    if (!element.store) {
-        element.store = {};
-    }
-    if (!element.store.effectsHookStates) {
-        element.store.effectsHookStates = [];
+function getOrCreateEffectHookStates(store) {
+    if (!store.effectsHookStates) {
+        store.effectsHookStates = [];
     }
-    return element.store.effectsHookStates;
+    return store.effectsHookStates;
 }
 export default {
-    useRef,
-    useRerender,
-    useState,
-    useEffect,
-    useMounted,
-    useUnmounted,
-    useCatch,
-    areDepsEqual,
+    createUseRef,
+    createUseRerender,
+    createUseState,
+    createUseEffect,
+    createUseCatch,
 };

package/jsx-runtime/index.d.ts

@@ -1,5 +1,4 @@
 import type { FC, Fragment as FragmentType, Key, SimpElement } from '../core/index.js';
-import type { Maybe } from '../shared/index.js';
 import type {
   AnchorHTMLAttributes,
   AreaHTMLAttributes,
@@ -55,6 +54,7 @@ import type {
   VideoHTMLAttributes,
   WebViewHTMLAttributes,
 } from '../dom/index.js';
+import type { Maybe } from '../shared/index.js';
 
 declare function jsx<P = {}>(type: string | FC<P>, props?: P, key?: Maybe<Key>): SimpElement<P>;
 
@@ -64,6 +64,7 @@ export { jsx as jsxs, jsx as jsxDEV };
 export { Fragment };
 
 declare global {
+  // biome-ignore lint/style/noNamespace: React-like API requirement.
   namespace JSX {
     interface IntrinsicElements {
       // HTML

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simpreact/simpreact",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "",
   "homepage": "https://github.com/dPaskhin/simpreact#readme",
   "main": "./core/index.js",
@@ -17,6 +17,14 @@
     "./compat/*": {
       "import": "./compat/index.js"
     },
+    "./component": {
+      "import": "./component/index.js",
+      "types": "./component/index.d.ts"
+    },
+    "./context/*": {
+      "import": "./context/index.js",
+      "types": "./context/index.d.ts"
+    },
     "./internal": {
       "import": "./core/internal.js",
       "types": "./core/internal.d.ts"