@simpreact/simpreact 0.0.6 → 0.0.8

package/compat/context.d.ts

@@ -1,8 +1,7 @@
-import * as SimpReactContext from '../context/index.js';
-export declare const createContext: SimpReactContext.CreateContext;
-export declare const useContext: SimpReactContext.UseContext;
+export declare const createContext: import("../context/index.js").CreateContext;
+export declare const useContext: import("../context/index.js").UseContext;
 declare const _default: {
-    createContext: SimpReactContext.CreateContext;
-    useContext: SimpReactContext.UseContext;
+    createContext: import("../context/index.js").CreateContext;
+    useContext: import("../context/index.js").UseContext;
 };
 export default _default;

package/compat/context.js

@@ -1,7 +1,7 @@
-import * as SimpReactContext from '../context/index.js';
+import { createCreateContext, createUseContext } from '../context/index.js';
 import { renderRuntime } from './renderRuntime.js';
-export const createContext = SimpReactContext.createCreateContext(renderRuntime);
-export const useContext = SimpReactContext.createUseContext(renderRuntime);
+export const createContext = createCreateContext(renderRuntime);
+export const useContext = createUseContext(renderRuntime);
 export default {
     createContext,
     useContext,

package/compat/core.d.ts

@@ -1,46 +1,47 @@
-import * as SimpReactInternal from '../core/internal.js';
+import type { Ref, SimpElement, SimpNode } from '../core/index.js';
+import { createElement as _createElement, createPortal as _createPortal, Fragment as _Fragment, memo as _memo } from '../core/index.js';
 export declare const Children: {
-    map(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
-    forEach(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => void): void;
-    count(children: SimpReactInternal.SimpNode): number;
-    toArray(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
-    only(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpElement;
+    map(children: SimpNode, fn: (child: SimpNode, index: number) => SimpNode): SimpNode[];
+    forEach(children: SimpNode, fn: (child: SimpNode, index: number) => void): void;
+    count(children: SimpNode): number;
+    toArray(children: SimpNode): SimpNode[];
+    only(children: SimpNode): SimpElement;
 };
-export declare function cloneElement(element: SimpReactInternal.SimpElement, props?: any, ...children: SimpReactInternal.SimpNode[]): SimpReactInternal.SimpElement;
-export declare function isValidElement(element: unknown): element is SimpReactInternal.SimpElement;
+export declare function cloneElement(element: SimpElement, props?: any, ...children: SimpNode[]): SimpElement;
+export declare function isValidElement(element: unknown): element is SimpElement;
 export declare function Suspense(props: {
-    fallback: SimpReactInternal.SimpNode;
-    children: SimpReactInternal.SimpNode;
-}): SimpReactInternal.SimpNode;
+    fallback: SimpNode;
+    children: SimpNode;
+}): SimpNode;
 export declare function StrictMode(props: {
-    children: SimpReactInternal.SimpNode;
-}): SimpReactInternal.SimpNode;
-export declare function forwardRef<P, T>(Component: (props: P, ref: SimpReactInternal.Ref<T>) => any): (props: P) => any;
-export declare const Fragment: SimpReactInternal.Fragment;
-export declare const createElement: typeof SimpReactInternal.createElement;
-export declare const createPortal: typeof SimpReactInternal.createPortal;
-export declare const memo: typeof SimpReactInternal.memo;
+    children: SimpNode;
+}): SimpNode;
+export declare function forwardRef<P, T>(Component: (props: P, ref: Ref<T>) => any): (props: P) => any;
+export declare const Fragment: _Fragment;
+export declare const createElement: typeof _createElement;
+export declare const createPortal: typeof _createPortal;
+export declare const memo: typeof _memo;
 export declare const flushSync: (value: any) => any;
 export declare class Component {
     constructor();
 }
 declare const _default: {
     Children: {
-        map(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
-        forEach(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => void): void;
-        count(children: SimpReactInternal.SimpNode): number;
-        toArray(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
-        only(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpElement;
+        map(children: SimpNode, fn: (child: SimpNode, index: number) => SimpNode): SimpNode[];
+        forEach(children: SimpNode, fn: (child: SimpNode, index: number) => void): void;
+        count(children: SimpNode): number;
+        toArray(children: SimpNode): SimpNode[];
+        only(children: SimpNode): SimpElement;
     };
     cloneElement: typeof cloneElement;
     isValidElement: typeof isValidElement;
     Suspense: typeof Suspense;
     StrictMode: typeof StrictMode;
     forwardRef: typeof forwardRef;
-    Fragment: SimpReactInternal.Fragment;
-    createElement: typeof SimpReactInternal.createElement;
-    createPortal: typeof SimpReactInternal.createPortal;
-    memo: typeof SimpReactInternal.memo;
+    Fragment: _Fragment;
+    createElement: typeof _createElement;
+    createPortal: typeof _createPortal;
+    memo: typeof _memo;
     flushSync: (value: any) => any;
     Component: typeof Component;
 };

package/compat/core.js

@@ -1,4 +1,5 @@
-import * as SimpReactInternal from '../core/internal.js';
+import { createElement as _createElement, createPortal as _createPortal, Fragment as _Fragment, memo as _memo, } from '../core/index.js';
+import { SIMP_ELEMENT_FLAG_FRAGMENT, SIMP_ELEMENT_FLAG_PORTAL } from '../core/internal.js';
 import { useCatch, useState } from './hooks.js';
 export const Children = {
     map(children, fn) {
@@ -39,10 +40,10 @@ export function cloneElement(element, props, ...children) {
     if (!isValidElement(element)) {
         throw new Error(`cloneElement: expected a SimpElement, got ${element}`);
     }
-    if ((element.flag & SimpReactInternal.SIMP_ELEMENT_FLAG_PORTAL) !== 0) {
+    if ((element.flag & SIMP_ELEMENT_FLAG_PORTAL) !== 0) {
         throw new Error('cloneElement: the argument must be a SimpElement, but you passed a portal instead.');
     }
-    return SimpReactInternal.createElement((element.flag & SimpReactInternal.SIMP_ELEMENT_FLAG_FRAGMENT) !== 0 ? SimpReactInternal.Fragment : element.type, Object.assign({}, element.props, props), arguments.length > 2 ? children : props.children || element.children);
+    return createElement((element.flag & SIMP_ELEMENT_FLAG_FRAGMENT) !== 0 ? Fragment : element.type, Object.assign({}, element.props, props), arguments.length > 2 ? children : props.children || element.children);
 }
 export function isValidElement(element) {
     return typeof element === 'object' && element !== null && 'flag' in element;
@@ -69,10 +70,10 @@ export function forwardRef(Component) {
         return Component(props, props?.ref || null);
     };
 }
-export const Fragment = SimpReactInternal.Fragment;
-export const createElement = SimpReactInternal.createElement;
-export const createPortal = SimpReactInternal.createPortal;
-export const memo = SimpReactInternal.memo;
+export const Fragment = _Fragment;
+export const createElement = _createElement;
+export const createPortal = _createPortal;
+export const memo = _memo;
 export const flushSync = (value) => value;
 export class Component {
     constructor() {

package/compat/dom.d.ts

@@ -1,10 +1,10 @@
-import * as SimpReactShared from '../shared/index.js';
-export declare const hydrate: typeof SimpReactShared.noop;
-export declare const render: (element: SimpReactShared.Nullable<import("../core/createElement.js").SimpElement>, container: SimpReactShared.Nullable<Element | DocumentFragment>) => void;
+import { noop } from '../shared/index.js';
+export declare const hydrate: typeof noop;
+export declare const render: (element: import("../shared/index.js").Nullable<import("../core/createElement.js").SimpElement>, container: import("../shared/index.js").Nullable<Element | DocumentFragment>) => void;
 export declare const createRoot: (container: Element | DocumentFragment) => import("../dom/render.js").SimpRoot;
 declare const _default: {
-    hydrate: typeof SimpReactShared.noop;
-    render: (element: SimpReactShared.Nullable<import("../core/createElement.js").SimpElement>, container: SimpReactShared.Nullable<Element | DocumentFragment>) => void;
+    hydrate: typeof noop;
+    render: (element: import("../shared/index.js").Nullable<import("../core/createElement.js").SimpElement>, container: import("../shared/index.js").Nullable<Element | DocumentFragment>) => void;
     createRoot: (container: Element | DocumentFragment) => import("../dom/render.js").SimpRoot;
 };
 export default _default;

package/compat/dom.js

@@ -1,9 +1,9 @@
-import * as SimpReactDOM from '../dom/index.js';
-import * as SimpReactShared from '../shared/index.js';
+import { createCreateRoot, createRenderer } from '../dom/index.js';
+import { noop } from '../shared/index.js';
 import { renderRuntime } from './renderRuntime.js';
-export const hydrate = SimpReactShared.noop;
-export const render = SimpReactDOM.createRenderer(renderRuntime);
-export const createRoot = SimpReactDOM.createCreateRoot(renderRuntime);
+export const hydrate = noop;
+export const render = createRenderer(renderRuntime);
+export const createRoot = createCreateRoot(renderRuntime);
 export default {
     hydrate,
     render,

package/compat/hooks.d.ts

@@ -1,10 +1,9 @@
-import { type DependencyList } from '../hooks/index.js';
-import * as SimpReactShared from '../shared/index.js';
+import { type DependencyList } from '../shared/index.js';
 export declare const useRerender: () => () => void;
 export declare const useState: import("../hooks/index.js").UseState;
-export declare const useEffect: (effect: SimpReactShared.Effect, deps?: SimpReactShared.DependencyList) => void;
-export declare const useLayoutEffect: (effect: SimpReactShared.Effect, deps?: SimpReactShared.DependencyList) => void;
-export declare const useInsertionEffect: (effect: SimpReactShared.Effect, deps?: SimpReactShared.DependencyList) => void;
+export declare const useEffect: (effect: import("../shared/index.js").Effect, deps?: DependencyList) => void;
+export declare const useLayoutEffect: (effect: import("../shared/index.js").Effect, deps?: DependencyList) => void;
+export declare const useInsertionEffect: (effect: import("../shared/index.js").Effect, deps?: DependencyList) => void;
 export declare const useRef: import("../hooks/index.js").UseRef;
 export declare const useCatch: (cb: (error: any) => void) => void;
 export declare function useSyncExternalStore<T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T): T;
@@ -19,9 +18,9 @@ declare const _default: {
     useMemo: typeof useMemo;
     useCallback: typeof useCallback;
     useState: import("../hooks/index.js").UseState;
-    useEffect: (effect: SimpReactShared.Effect, deps?: SimpReactShared.DependencyList) => void;
-    useLayoutEffect: (effect: SimpReactShared.Effect, deps?: SimpReactShared.DependencyList) => void;
-    useInsertionEffect: (effect: SimpReactShared.Effect, deps?: SimpReactShared.DependencyList) => void;
+    useEffect: (effect: import("../shared/index.js").Effect, deps?: DependencyList) => void;
+    useLayoutEffect: (effect: import("../shared/index.js").Effect, deps?: DependencyList) => void;
+    useInsertionEffect: (effect: import("../shared/index.js").Effect, deps?: DependencyList) => void;
     useRef: import("../hooks/index.js").UseRef;
 };
 export default _default;

package/compat/hooks.js

@@ -1,5 +1,5 @@
-import { createUseCatch, createUseEffect, createUseRef, createUseRerender, createUseState, } from '../hooks/index.js';
-import * as SimpReactShared from '../shared/index.js';
+import { createUseCatch, createUseEffect, createUseRef, createUseRerender, createUseState } from '../hooks/index.js';
+import { shallowEqual } from '../shared/index.js';
 import { renderRuntime } from './renderRuntime.js';
 export const useRerender = createUseRerender(renderRuntime);
 export const useState = createUseState(renderRuntime);
@@ -56,7 +56,7 @@ export function useMemo(factory, deps) {
         deps: undefined,
         value: undefined,
     });
-    if (!SimpReactShared.shallowEqual(ref.current.deps, deps)) {
+    if (!shallowEqual(ref.current.deps, deps)) {
         ref.current.value = factory();
         ref.current.deps = deps;
     }

package/compat/index.d.ts

@@ -1,44 +1,101 @@
-export * from './context.js';
-export * from './core.js';
-export * from './dom.js';
-export * from './hooks.js';
-export * from './jsx-runtime.js';
-declare const _default: {
-    jsx: typeof import("../jsx-runtime/index.js").jsx;
-    jsxDEV: typeof import("../jsx-runtime/index.js").jsx;
-    jsxs: typeof import("../jsx-runtime/index.js").jsx;
-    useSyncExternalStore: typeof import("./hooks.js").useSyncExternalStore;
-    useReducer: typeof import("./hooks.js").useReducer;
-    useId: typeof import("./hooks.js").useId;
-    useMemo: typeof import("./hooks.js").useMemo;
-    useCallback: typeof import("./hooks.js").useCallback;
-    useState: import("../hooks/index.js").UseState;
-    useEffect: (effect: import("../shared/public.js").Effect, deps?: import("../shared/public.js").DependencyList) => void;
-    useLayoutEffect: (effect: import("../shared/public.js").Effect, deps?: import("../shared/public.js").DependencyList) => void;
-    useInsertionEffect: (effect: import("../shared/public.js").Effect, deps?: import("../shared/public.js").DependencyList) => void;
-    useRef: import("../hooks/index.js").UseRef;
-    hydrate: typeof import("../shared/utils.js").noop;
-    render: (element: import("../shared/public.js").Nullable<import("../core/createElement.js").SimpElement>, container: import("../shared/public.js").Nullable<Element | DocumentFragment>) => void;
-    createRoot: (container: Element | DocumentFragment) => import("../dom/render.js").SimpRoot;
-    Children: {
-        map(children: import("../core/createElement.js").SimpNode, fn: (child: import("../core/createElement.js").SimpNode, index: number) => import("../core/createElement.js").SimpNode): import("../core/createElement.js").SimpNode[];
-        forEach(children: import("../core/createElement.js").SimpNode, fn: (child: import("../core/createElement.js").SimpNode, index: number) => void): void;
-        count(children: import("../core/createElement.js").SimpNode): number;
-        toArray(children: import("../core/createElement.js").SimpNode): import("../core/createElement.js").SimpNode[];
-        only(children: import("../core/createElement.js").SimpNode): import("../core/createElement.js").SimpElement;
-    };
-    cloneElement: typeof import("./core.js").cloneElement;
-    isValidElement: typeof import("./core.js").isValidElement;
-    Suspense: typeof import("./core.js").Suspense;
-    StrictMode: typeof import("./core.js").StrictMode;
-    forwardRef: typeof import("./core.js").forwardRef;
-    Fragment: import("../core/fragment.js").Fragment;
-    createElement: typeof import("../core/createElement.js").createElement;
-    createPortal: typeof import("../core/portal.js").createPortal;
-    memo: typeof import("../core/memo.js").memo;
-    flushSync: (value: any) => any;
-    Component: typeof import("./core.js").Component;
-    createContext: import("../context/index.js").CreateContext;
-    useContext: import("../context/index.js").UseContext;
+import type { SimpContext } from '../context/index.js';
+import type {
+  Attributes,
+  FC,
+  FunctionalComponent,
+  Key,
+  Ref,
+  RefAttributes,
+  RefObject,
+  SimpElement,
+  SimpNode,
+  SimpRenderRuntime,
+} from '../core/index.js';
+import type { SimpRoot } from '../dom/index.js';
+import type { Dispatch, SetStateAction } from '../hooks/index.js';
+import type { DependencyList, Effect, Maybe, Nullable } from '../shared/index.js';
+
+export type { SimpContext } from '../context/index.js';
+export type {
+  Attributes,
+  FC,
+  FunctionalComponent,
+  Key,
+  Ref,
+  RefAttributes,
+  RefObject,
+  SimpElement,
+  SimpNode,
+  SimpRenderRuntime,
+} from '../core/index.js';
+export type { SimpRoot } from '../dom/index.js';
+export type { Dispatch, SetStateAction } from '../hooks/index.js';
+export type { DependencyList, Effect, Maybe, Nullable } from '../shared/index.js';
+
+export declare const renderRuntime: SimpRenderRuntime;
+
+export declare function jsx<P = {}>(type: string | FC<P>, props?: P, key?: Maybe<Key>): SimpElement<P>;
+export declare function jsxs<P = {}>(type: string | FC<P>, props?: P, key?: Maybe<Key>): SimpElement<P>;
+export declare function jsxDEV<P = {}>(type: string | FC<P>, props?: P, key?: Maybe<Key>): SimpElement<P>;
+
+export declare function useSyncExternalStore<T>(
+  subscribe: (callback: () => void) => () => void,
+  getSnapshot: () => T
+): T;
+export declare function useReducer<R extends (state: any, action: any) => any, I>(
+  reducer: R,
+  initializerArg: I,
+  initializer?: (arg: I) => ReturnType<R>
+): [ReturnType<R>, (action: Parameters<R>[1]) => void];
+export declare function useId(prefix?: string): string;
+export declare function useMemo<T>(factory: () => T, deps: DependencyList): T;
+export declare function useCallback<T>(cb: T, deps: DependencyList): T;
+export declare function useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
+export declare function useState<S>(): [S | undefined, Dispatch<SetStateAction<S | undefined>>];
+export declare function useEffect(effect: Effect, deps?: DependencyList): void;
+export declare function useLayoutEffect(effect: Effect, deps?: DependencyList): void;
+export declare function useInsertionEffect(effect: Effect, deps?: DependencyList): void;
+export declare function useRef<T>(initialValue: T): RefObject<T>;
+export declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
+export declare function useRef<T = undefined>(initialValue?: T): RefObject<T | undefined>;
+export declare function useCatch(errorBoundary: FC): [Error | null, (error: Error) => void];
+
+export declare function hydrate(): void;
+export declare function render(element: SimpElement, parentReference: Nullable<HTMLElement>): void;
+export declare function createRoot(container: Element | DocumentFragment): SimpRoot;
+
+export declare const Children: {
+  map(children: SimpNode, fn: (child: SimpNode, index: number) => SimpNode): SimpNode[];
+  forEach(children: SimpNode, fn: (child: SimpNode, index: number) => void): void;
+  count(children: SimpNode): number;
+  toArray(children: SimpNode): SimpNode[];
+  only(children: SimpNode): SimpElement;
 };
-export default _default;
+
+export declare function cloneElement(element: SimpElement, props?: any, ...children: SimpNode[]): SimpElement;
+export declare function isValidElement(element: unknown): element is SimpElement;
+export declare function Suspense(props: { fallback: SimpNode; children: SimpNode }): SimpNode;
+export declare function StrictMode(props: { children: SimpNode }): SimpNode;
+export declare function forwardRef<P, T>(Component: (props: P, ref: Ref<T>) => any): FC;
+export declare function Fragment(props: { children?: SimpNode }): SimpNode;
+
+export declare function createElement<P extends {}, T>(
+  type: string,
+  props?: (RefAttributes<T> & P) | null,
+  ...children: SimpNode[]
+): SimpElement<P>;
+export declare function createElement<P extends {}>(
+  type: FunctionalComponent<P>,
+  props?: (Attributes & P) | null,
+  ...children: SimpNode[]
+): SimpElement<P>;
+
+export declare function createPortal(children: SimpNode, container: any): SimpElement;
+
+export declare function memo(Component: FC, compare: (objA: any, objB: any) => boolean): FC;
+export declare function flushSync(value: any): any;
+
+export declare class Component {}
+
+export declare function createContext<T>(defaultValue: T): SimpContext<T>;
+export declare function useContext<T>(context: SimpContext<T>): T;

package/compat/index.js

@@ -3,15 +3,18 @@ import coreDefault from './core.js';
 import domDefault from './dom.js';
 import hooksDefault from './hooks.js';
 import jsxRuntimeDefault from './jsx-runtime.js';
+import renderRuntimeDefault from './renderRuntime.js';
 export * from './context.js';
 export * from './core.js';
 export * from './dom.js';
 export * from './hooks.js';
 export * from './jsx-runtime.js';
+export * from './renderRuntime.js';
 export default {
     ...contextDefault,
     ...coreDefault,
     ...domDefault,
     ...hooksDefault,
     ...jsxRuntimeDefault,
+    ...renderRuntimeDefault,
 };

package/compat/jsx-runtime.d.ts

@@ -1,10 +1,10 @@
-import * as SimpReactJSXRuntime from '../jsx-runtime/index.js';
-export declare const jsx: typeof SimpReactJSXRuntime.jsx;
-export declare const jsxDEV: typeof SimpReactJSXRuntime.jsx;
-export declare const jsxs: typeof SimpReactJSXRuntime.jsx;
+import { jsx as _jsx } from '../jsx-runtime/index.js';
+export declare const jsx: typeof _jsx;
+export declare const jsxDEV: typeof _jsx;
+export declare const jsxs: typeof _jsx;
 declare const _default: {
-    jsx: typeof SimpReactJSXRuntime.jsx;
-    jsxDEV: typeof SimpReactJSXRuntime.jsx;
-    jsxs: typeof SimpReactJSXRuntime.jsx;
+    jsx: typeof _jsx;
+    jsxDEV: typeof _jsx;
+    jsxs: typeof _jsx;
 };
 export default _default;

package/compat/jsx-runtime.js

@@ -1,7 +1,7 @@
-import * as SimpReactJSXRuntime from '../jsx-runtime/index.js';
-export const jsx = SimpReactJSXRuntime.jsx;
-export const jsxDEV = SimpReactJSXRuntime.jsxDEV;
-export const jsxs = SimpReactJSXRuntime.jsxs;
+import { jsx as _jsx, jsxDEV as _jsxDEV, jsxs as _jsxs } from '../jsx-runtime/index.js';
+export const jsx = _jsx;
+export const jsxDEV = _jsxDEV;
+export const jsxs = _jsxs;
 export default {
     jsx,
     jsxDEV,

package/compat/renderRuntime.d.ts

@@ -1,2 +1,6 @@
 import type { SimpRenderRuntime } from '../core/internal.js';
 export declare const renderRuntime: SimpRenderRuntime;
+declare const _default: {
+    renderRuntime: SimpRenderRuntime;
+};
+export default _default;

package/compat/renderRuntime.js

@@ -10,5 +10,8 @@ export const renderRuntime = {
     currentRenderingFCElement: null,
     renderPhase: null,
 };
+export default {
+    renderRuntime,
+};
 // TODO
 window.__SIMP_RUNTIME__ = renderRuntime;

package/component/index.d.ts

@@ -1,8 +1,5 @@
-import type { FC, SimpNode } from '../core/index.js';
-
-export type Cleanup = () => void;
-export type Effect = () => void | Cleanup;
-export type DependencyList = readonly unknown[];
+import type { FC, SimpElement, SimpNode } from '../core/index.js';
+import type { DependencyList, Effect } from '../shared/index.js';
 
 export interface ComponentRenderContext<S = {}> {
   state: S;
@@ -11,6 +8,8 @@ export interface ComponentRenderContext<S = {}> {
   catchers: Array<(error: any) => void>;
 }
 
-declare function component<P = {}, S = {}>(Component: (props: P, ctx: ComponentRenderContext<S>) => SimpNode): FC<P>;
+export declare function component<P = {}, S = {}>(
+  Component: (props: P, ctx: ComponentRenderContext<S>) => SimpNode
+): FC<P>;
 
-export function componentRenderer(component: FC, element: SimpElement): SimpNode;
+export declare function componentRenderer(component: FC, element: SimpElement): SimpNode;

package/context/index.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionalComponent, SimpNode } from '../core/index.js';
+import type { FC, SimpNode, SimpRenderRuntime } from '../core/index.js';
 
 export interface ProviderProps<T> {
   value: T;
@@ -16,16 +16,16 @@ export type SimpContext<T> = {
 
 export type ContextType<C extends SimpContext<any>> = C extends SimpContext<infer T> ? T : never;
 
-export type Provider<T> = FunctionalComponent<ProviderProps<T>>;
-export type Consumer<T> = FunctionalComponent<ConsumerProps<T>>;
+export type Provider<T> = FC<ProviderProps<T>>;
+export type Consumer<T> = FC<ConsumerProps<T>>;
 
 export interface CreateContext {
   <T>(defaultValue: T): SimpContext<T>;
 }
 
-declare function createCreateContext(renderRuntime: SimpRenderRuntime): CreateContext;
+export declare function createCreateContext(renderRuntime: SimpRenderRuntime): CreateContext;
 
 export interface UseContext {
   <T>(context: SimpContext<T>): T;
 }
-declare function createUseContext(renderRuntime: SimpRenderRuntime): UseContext;
+export declare function createUseContext(renderRuntime: SimpRenderRuntime): UseContext;

package/context/index.js

@@ -18,7 +18,7 @@ export function createCreateContext(renderRuntime) {
                 if (!contextMap) {
                     currentElement.context = contextMap = new Map();
                 }
-                if (contextMap && renderPhase === MOUNTING_PHASE) {
+                else if (renderPhase === MOUNTING_PHASE) {
                     currentElement.context = contextMap = new Map(currentElement.context);
                 }
                 if (renderPhase === MOUNTING_PHASE) {

package/core/index.d.ts

@@ -1,5 +1,7 @@
-import type { HostReference, TraversalStack } from './internal.js';
-import type { Maybe, Nullable, SimpText } from '../shared/index.js';
+import type { Nullable, SimpText } from '../shared/index.js';
+import type { HostAdapter } from './hostAdapter.js';
+
+export { HostAdapter } from './hostAdapter.js';
 
 export type ComponentType<P = {}> = FunctionalComponent<P>;
 
@@ -27,46 +29,42 @@ export interface SimpElement<P = unknown, T extends string | FunctionalComponent
 
 export type SimpNode = SimpElement | SimpText | Array<SimpNode> | boolean | null | undefined;
 
-declare function createElement<P extends {}, T>(
+export declare function createElement<P extends {}, T>(
   type: string,
   props?: (RefAttributes<T> & P) | null,
   ...children: SimpNode[]
 ): SimpElement<P>;
-declare function createElement<P extends {}>(
+export declare function createElement<P extends {}>(
   type: FunctionalComponent<P>,
   props?: (Attributes & P) | null,
   ...children: SimpNode[]
 ): SimpElement<P>;
 
-declare function createPortal<HostRef = {}>(children: SimpNode, container: HostRef): SimpElement;
+export declare function createPortal<HostRef = {}>(children: SimpNode, container: HostRef): SimpElement;
 
-declare function Fragment(props: PropsWithChildren): SimpElement;
+export declare function Fragment(props: PropsWithChildren): SimpElement;
 
 export type FunctionalComponent<P = {}> = (props: P) => SimpNode;
 export type FC<P = {}> = FunctionalComponent<P>;
 
 export type PropsWithChildren<P = {}> = P & { children?: SimpNode | undefined };
 
-declare function memo<P = {}>(Component: FC<P>, compare?: (objA: Readonly<P>, objB: Readonly<P>) => boolean): FC<P>;
+export declare function memo<P = {}>(
+  Component: FC<P>,
+  compare?: (objA: Readonly<P>, objB: Readonly<P>) => boolean
+): FC<P>;
+
+export declare function withSyncRerender(runtime: SimpRenderRuntime, callback: () => void): void;
 
 export interface SimpRuntimeFCRenderer {
   (component: FC, element: SimpElement): SimpNode;
 }
 
-export interface RenderMeta {
-  prevElement: Nullable<SimpElement>;
-  parentReference: HostReference;
-  parentAnchorReference: HostReference;
-  rightSibling: Nullable<SimpElement>;
-  context: unknown;
-  hostNamespace: Maybe<string>;
-  renderRuntime: SimpRenderRuntime;
-  placeHolderElement: Nullable<SimpElement>;
-}
-
 export interface SimpRenderRuntime {
   hostAdapter: HostAdapter;
   renderer: SimpRuntimeFCRenderer;
-  renderStack: TraversalStack<SimpElement, RenderMeta>;
+  renderStack: Array<{ node: SimpElement; kind: number; meta: any }>;
   elementToHostMap: Map<unknown, SimpElement>;
+  currentRenderingFCElement: Nullable<SimpElement>;
+  renderPhase: Nullable<number>;
 }

package/core/index.js

@@ -2,5 +2,6 @@ import { createElement } from './createElement.js';
 import { Fragment } from './fragment.js';
 import { memo } from './memo.js';
 import { createPortal } from './portal.js';
-export { createElement, Fragment, memo, createPortal };
-export default { createElement, Fragment, memo, createPortal };
+import { withSyncRerender } from './rerender.js';
+export { createElement, Fragment, memo, createPortal, withSyncRerender };
+export default { createElement, Fragment, memo, createPortal, withSyncRerender };

package/core/internal.d.ts

@@ -4,6 +4,7 @@ export * from './hostAdapter.js';
 export * from './lifecycleEventBus.js';
 export * from './memo.js';
 export * from './mounting.js';
+export * from './mountingChildren.js';
 export * from './patching.js';
 export * from './patchingChildren.js';
 export * from './portal.js';
@@ -12,3 +13,4 @@ export * from './ref.js';
 export * from './rerender.js';
 export * from './runtime.js';
 export * from './unmounting.js';
+export * from './unmountingChildren.js';

package/core/internal.js

@@ -4,6 +4,7 @@ export * from './hostAdapter.js';
 export * from './lifecycleEventBus.js';
 export * from './memo.js';
 export * from './mounting.js';
+export * from './mountingChildren.js';
 export * from './patching.js';
 export * from './patchingChildren.js';
 export * from './portal.js';
@@ -12,3 +13,4 @@ export * from './ref.js';
 export * from './rerender.js';
 export * from './runtime.js';
 export * from './unmounting.js';
+export * from './unmountingChildren.js';

package/core/mounting.d.ts

@@ -2,7 +2,6 @@ import type { Maybe, Nullable } from '../shared/index.js';
 import { type SimpElement } from './createElement.js';
 import { type MountFrame, type MountFrameMeta } from './processStack.js';
 import { type SimpRenderRuntime } from './runtime.js';
-export declare function mount(element: SimpElement, parentReference: unknown, rightSibling: Nullable<SimpElement>, context: unknown, hostNamespace: Maybe<string>, renderRuntime: SimpRenderRuntime): void;
+export declare function mount(element: SimpElement, parentReference: unknown, subtreeRightBoundary: Nullable<SimpElement>, context: unknown, hostNamespace: Maybe<string>, renderRuntime: SimpRenderRuntime): void;
 export declare function _mount(frame: MountFrame): void;
 export declare function _pushMountEnterFrame(element: SimpElement, meta: MountFrameMeta): void;
-export declare function _pushMountArrayChildrenFrame(element: SimpElement, meta: MountFrameMeta): void;