@simpreact/simpreact 0.0.3 → 0.0.5

package/compat/context.d.ts

@@ -0,0 +1,8 @@
+import * as SimpReactContext from '../context/index.js';
+export declare const createContext: typeof SimpReactContext.createContext;
+export declare const useContext: typeof SimpReactContext.useContext;
+declare const _default: {
+    createContext: typeof SimpReactContext.createContext;
+    useContext: typeof SimpReactContext.useContext;
+};
+export default _default;

package/compat/context.js

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

package/compat/core.d.ts

@@ -1,5 +1,4 @@
 import * as SimpReactInternal from '../core/internal.js';
-import { identity } from './utils.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;
@@ -16,10 +15,9 @@ export declare function Suspense(props: {
 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 createContext: typeof SimpReactInternal.createContext;
 export declare const createPortal: typeof SimpReactInternal.createPortal;
-export declare const memo: typeof identity;
-export declare const flushSync: typeof identity;
+export declare const memo: typeof SimpReactInternal.memo;
+export declare const flushSync: (value: any) => any;
 export declare class Component {
     constructor();
 }
@@ -37,10 +35,9 @@ declare const _default: {
     forwardRef: typeof forwardRef;
     Fragment: SimpReactInternal.Fragment;
     createElement: typeof SimpReactInternal.createElement;
-    createContext: typeof SimpReactInternal.createContext;
     createPortal: typeof SimpReactInternal.createPortal;
-    memo: typeof identity;
-    flushSync: typeof identity;
+    memo: typeof SimpReactInternal.memo;
+    flushSync: (value: any) => any;
     Component: typeof Component;
 };
 export default _default;

package/compat/core.js

@@ -1,6 +1,5 @@
 import * as SimpReactInternal from '../core/internal.js';
 import * as SimpReactHooks from '../hooks/index.js';
-import { identity } from './utils.js';
 export const Children = {
     map(children, fn) {
         return Children.toArray(children).map(fn);
@@ -51,13 +50,14 @@ export function isValidElement(element) {
 export function Suspense(props) {
     const [isSuspended, setIsSuspended] = SimpReactHooks.useState(false);
     SimpReactHooks.useCatch(error => {
+        if (!(error instanceof Promise)) {
+            throw error;
+        }
         if (isSuspended) {
             return;
         }
-        if (error instanceof Promise) {
-            setIsSuspended(true);
-            error.then(() => setIsSuspended(false));
-        }
+        setIsSuspended(true);
+        error.then(() => setIsSuspended(false));
     });
     return isSuspended ? props.fallback : props.children;
 }
@@ -68,10 +68,9 @@ export function forwardRef(Component) {
 }
 export const Fragment = SimpReactInternal.Fragment;
 export const createElement = SimpReactInternal.createElement;
-export const createContext = SimpReactInternal.createContext;
 export const createPortal = SimpReactInternal.createPortal;
-export const memo = identity;
-export const flushSync = identity;
+export const memo = SimpReactInternal.memo;
+export const flushSync = (value) => value;
 export class Component {
     constructor() {
         throw new Error('Not implemented.');
@@ -85,7 +84,6 @@ export default {
     forwardRef,
     Fragment,
     createElement,
-    createContext,
     createPortal,
     memo,
     flushSync,

package/compat/hooks.d.ts

@@ -9,7 +9,6 @@ export declare const useEffect: typeof SimpReactHooks.useEffect;
 export declare const useLayoutEffect: typeof SimpReactHooks.useEffect;
 export declare const useInsertionEffect: typeof SimpReactHooks.useEffect;
 export declare const useRef: typeof SimpReactHooks.useRef;
-export declare const useContext: typeof SimpReactHooks.useContext;
 declare const _default: {
     useSyncExternalStore: typeof useSyncExternalStore;
     useReducer: typeof useReducer;
@@ -21,6 +20,5 @@ declare const _default: {
     useLayoutEffect: typeof SimpReactHooks.useEffect;
     useInsertionEffect: typeof SimpReactHooks.useEffect;
     useRef: typeof SimpReactHooks.useRef;
-    useContext: typeof SimpReactHooks.useContext;
 };
 export default _default;

package/compat/hooks.js

@@ -61,7 +61,6 @@ export const useEffect = SimpReactHooks.useEffect;
 export const useLayoutEffect = SimpReactHooks.useEffect;
 export const useInsertionEffect = SimpReactHooks.useEffect;
 export const useRef = SimpReactHooks.useRef;
-export const useContext = SimpReactHooks.useContext;
 export default {
     useSyncExternalStore,
     useReducer,
@@ -73,5 +72,4 @@ export default {
     useLayoutEffect,
     useInsertionEffect,
     useRef,
-    useContext,
 };

package/compat/index.d.ts

@@ -1,3 +1,4 @@
+export * from './context.js';
 export * from './core.js';
 export * from './dom.js';
 export * from './hooks.js';
@@ -16,7 +17,6 @@ declare const _default: {
     useLayoutEffect: typeof import("../hooks/index.js").useEffect;
     useInsertionEffect: typeof import("../hooks/index.js").useEffect;
     useRef: typeof import("../hooks/index.js").useRef;
-    useContext: typeof import("../hooks/index.js").useContext;
     hydrate: typeof import("../shared/utils.js").noop;
     render: typeof import("../dom/render.js").render;
     createRoot: typeof import("../dom/render.js").createRoot;
@@ -33,10 +33,11 @@ declare const _default: {
     forwardRef: typeof import("./core.js").forwardRef;
     Fragment: import("../core/fragment.js").Fragment;
     createElement: typeof import("../core/createElement.js").createElement;
-    createContext: typeof import("../core/context.js").createContext;
     createPortal: typeof import("../core/portal.js").createPortal;
-    memo: typeof import("./utils.js").identity;
-    flushSync: typeof import("./utils.js").identity;
+    memo: typeof import("../core/memo.js").memo;
+    flushSync: (value: any) => any;
     Component: typeof import("./core.js").Component;
+    createContext: typeof import("../context/index.js").createContext;
+    useContext: typeof import("../context/index.js").useContext;
 };
 export default _default;

package/compat/index.js

@@ -1,12 +1,15 @@
+import contextDefault from './context.js';
 import coreDefault from './core.js';
 import domDefault from './dom.js';
 import hooksDefault from './hooks.js';
 import jsxRuntimeDefault from './jsx-runtime.js';
+export * from './context.js';
 export * from './core.js';
 export * from './dom.js';
 export * from './hooks.js';
 export * from './jsx-runtime.js';
 export default {
+    ...contextDefault,
     ...coreDefault,
     ...domDefault,
     ...hooksDefault,

package/context/index.d.ts

@@ -0,0 +1,24 @@
+import type { FunctionComponent, SimpNode } from '../core/index.js';
+
+export interface ProviderProps<T> {
+  value: T;
+  children?: SimpNode;
+}
+
+export interface ConsumerProps<T> {
+  children: (value: T) => SimpNode;
+}
+
+export type SimpContext<T> = {
+  Provider: Provider<T>;
+  Consumer: Consumer<T>;
+};
+
+export type ContextType<C extends SimpContext<any>> = C extends SimpContext<infer T> ? T : never;
+
+export type Provider<T> = FunctionComponent<ProviderProps<T>>;
+export type Consumer<T> = FunctionComponent<ConsumerProps<T>>;
+
+declare function createContext<T>(defaultValue: T): SimpContext<T>;
+
+declare function useContext<T>(context: SimpContext<T>): T;

package/context/index.js

@@ -0,0 +1,64 @@
+import { lifecycleEventBus, rerender } from '../core/internal.js';
+// In runtime these variables are nullable.
+let currentElement;
+let phase;
+lifecycleEventBus.subscribe(event => {
+    if (event.type === 'beforeRender') {
+        currentElement = event.element;
+        phase = event.phase;
+    }
+    if (event.type === 'afterRender') {
+        currentElement = null;
+        phase = null;
+    }
+    if (event.type === 'unmounted') {
+        event.element.context?.forEach(value => value.subs.delete(event.element.store));
+    }
+});
+export function createContext(defaultValue) {
+    const context = {
+        defaultValue,
+        Provider(props) {
+            if (!currentElement.context) {
+                currentElement.context = new Map();
+            }
+            else if (phase === 'mounting') {
+                currentElement.context = new Map(currentElement.context);
+            }
+            if (phase === 'mounting') {
+                currentElement.context.set(context, { value: props.value, subs: new Set() });
+                return props.children;
+            }
+            let contextEntry = currentElement.context.get(context);
+            if (!contextEntry) {
+                contextEntry = { value: props.value, subs: new Set() };
+                currentElement.context.set(context, contextEntry);
+                return props.children;
+            }
+            if (Object.is(contextEntry.value, props.value)) {
+                return props.children;
+            }
+            contextEntry.value = props.value;
+            for (let sub of contextEntry.subs) {
+                sub.forceRender = true;
+                rerender(sub.latestElement);
+            }
+            return props.children;
+        },
+        Consumer(props) {
+            return props.children(currentElement.context?.get(context)?.value ?? defaultValue);
+        },
+    };
+    return context;
+}
+export function useContext(context) {
+    const contextEntry = currentElement.context?.get(context);
+    if (!contextEntry) {
+        // No provider above: just return the default value, don't subscribe
+        return context.defaultValue;
+    }
+    if (!contextEntry.subs.has(currentElement.store)) {
+        contextEntry.subs.add(currentElement.store);
+    }
+    return contextEntry.value;
+}

package/core/createElement.d.ts

@@ -1,33 +1,30 @@
 import type { Many, Maybe, Nullable, SimpText } from '../shared/index.js';
 import type { HostReference } from './hostAdapter.js';
-import type { SimpContextMap } from './context.js';
 export type SimpNode = SimpElement | SimpText | Array<SimpNode> | boolean | null | undefined;
 export type Key = string | number | bigint;
-export interface FunctionComponent {
-    (props: any): SimpNode;
-}
-export type FC = FunctionComponent;
-export type SimpElementFlag = 'FC' | 'HOST' | 'TEXT' | 'FRAGMENT' | 'PROVIDER' | 'CONSUMER' | 'PORTAL';
+export type FC = (props: any) => SimpNode;
+export type SimpElementFlag = 'FC' | 'HOST' | 'TEXT' | 'FRAGMENT' | 'PORTAL';
 export interface SimpElementStore {
     latestElement?: Maybe<SimpElement>;
     hostNamespace?: Maybe<string>;
+    forceRender?: boolean;
     [key: string]: unknown;
 }
 export interface SimpElement {
     flag: SimpElementFlag;
     parent: Nullable<SimpElement>;
     key?: Maybe<Key>;
-    type?: string | FunctionComponent;
+    type?: string | FC;
     props?: any;
     children?: Maybe<SimpNode>;
     className?: Maybe<string>;
     reference?: Maybe<HostReference>;
     store?: SimpElementStore;
-    contextMap?: Maybe<SimpContextMap>;
+    context?: any;
     ref?: any;
     unmounted?: boolean;
 }
-export declare function createElement(type: string | FunctionComponent, props?: any, ...children: SimpNode[]): SimpElement;
+export declare function createElement(type: string | FC, props?: any, ...children: SimpNode[]): SimpElement;
 export declare function createTextElement(text: SimpText): SimpElement;
 export declare function normalizeChildren(children: SimpNode, skipIgnoredCheck: boolean): Maybe<Many<SimpElement>>;
 export declare function normalizeRoot(node: SimpNode, skipIgnoredCheck: boolean): Maybe<SimpElement>;

package/core/createElement.js

@@ -1,6 +1,5 @@
 import { isSimpText } from '../shared/index.js';
 import { Fragment } from './fragment.js';
-import { isConsumer, isProvider } from './context.js';
 export function createElement(type, props, ...children) {
     let newProps;
     let className;
@@ -83,28 +82,6 @@ export function createElement(type, props, ...children) {
         }
         return element;
     }
-    else if (isProvider(type)) {
-        const element = { flag: 'PROVIDER', type, props: { value: props.value }, parent: null };
-        if ((definedChildren = normalizeChildren(definedChildren || props.children, false))) {
-            element.children = definedChildren;
-        }
-        if (props != null && props.key) {
-            element.key = props?.key;
-        }
-        return element;
-    }
-    else if (isConsumer(type)) {
-        const element = {
-            flag: 'CONSUMER',
-            type,
-            props: { children: definedChildren || (props != null ? props.children : null) },
-            parent: null,
-        };
-        if (props != null && props.key) {
-            element.key = props?.key;
-        }
-        return element;
-    }
     else {
         if (props != null) {
             for (const propName in props) {
@@ -210,7 +187,7 @@ function isIgnoredNode(node) {
     if (isSimpText(node)) {
         return false;
     }
-    if (node.flag === 'FRAGMENT' || node.flag === 'PROVIDER' || node.flag === 'PORTAL') {
+    if (node.flag === 'FRAGMENT' || node.flag === 'PORTAL') {
         return node.children == null;
     }
     return false;

package/core/index.d.ts

@@ -26,25 +26,6 @@ export interface SimpElement<P = unknown, T extends string | FunctionComponent<P
 
 export type SimpNode = SimpElement | SimpText | Array<SimpNode> | boolean | null | undefined;
 
-export interface ProviderProps<T> {
-  value: T;
-  children?: SimpNode | undefined;
-}
-
-export interface ConsumerProps<T> {
-  children: (value: T) => SimpNode;
-}
-
-export type SimpContext<T> = {
-  Provider: Provider<T>;
-  Consumer: Consumer<T>;
-};
-
-export type ContextType<C extends SimpContext<any>> = C extends SimpContext<infer T> ? T : never;
-
-export type Provider<T> = FunctionComponent<ProviderProps<T>>;
-export type Consumer<T> = FunctionComponent<ConsumerProps<T>>;
-
 declare function createElement<P extends {}, T>(
   type: string,
   props?: (RefAttributes<T> & P) | null,
@@ -58,11 +39,11 @@ declare function createElement<P extends {}>(
 
 declare function createPortal<HostRef = {}>(children: SimpNode, container: HostRef): SimpElement;
 
-declare function createContext<T>(defaultValue: T): SimpContext<T>;
-
 declare function Fragment(props: PropsWithChildren): SimpElement;
 
 export type FunctionComponent<P = {}> = (props: P) => SimpNode;
 export type FC<P = {}> = FunctionComponent<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>;

package/core/index.js

@@ -1,6 +1,6 @@
 import { createElement } from './createElement.js';
 import { Fragment } from './fragment.js';
-import { createContext } from './context.js';
+import { memo } from './memo.js';
 import { createPortal } from './portal.js';
-export { createElement, Fragment, createContext, createPortal };
-export default { createElement, Fragment, createContext, createPortal };
+export { createElement, Fragment, memo, createPortal };
+export default { createElement, Fragment, memo, createPortal };

package/core/internal.d.ts

@@ -1,8 +1,8 @@
-export * from './context.js';
 export * from './createElement.js';
 export * from './fragment.js';
 export * from './hostAdapter.js';
 export * from './lifecycleEventBus.js';
+export * from './memo.js';
 export * from './mounting.js';
 export * from './patching.js';
 export * from './portal.js';

package/core/internal.js

@@ -1,8 +1,8 @@
-export * from './context.js';
 export * from './createElement.js';
 export * from './fragment.js';
 export * from './hostAdapter.js';
 export * from './lifecycleEventBus.js';
+export * from './memo.js';
 export * from './mounting.js';
 export * from './patching.js';
 export * from './portal.js';

package/core/memo.d.ts

@@ -0,0 +1,10 @@
+import { shallowEqual } from '../shared/index.js';
+import type { FC, SimpNode } from './createElement.js';
+export interface MemoizedComponent {
+    (props: any): SimpNode;
+    _isMemo: true;
+    _render: FC;
+    _compare: (prevProps: any, nextProps: any) => boolean;
+}
+export declare function memo(Component: FC, compare?: typeof shallowEqual): MemoizedComponent;
+export declare function isMemo(type: any): type is MemoizedComponent;

package/core/memo.js

@@ -0,0 +1,11 @@
+import { shallowEqual } from '../shared/index.js';
+export function memo(Component, compare = shallowEqual) {
+    const Memoized = (props => Component(props));
+    Memoized._isMemo = true;
+    Memoized._render = Component;
+    Memoized._compare = compare;
+    return Memoized;
+}
+export function isMemo(type) {
+    return type._isMemo;
+}

package/core/mounting.d.ts

@@ -1,13 +1,10 @@
 import type { Maybe, Nullable } from '../shared/index.js';
 import type { HostReference } from './hostAdapter.js';
 import type { SimpElement } from './createElement.js';
-import type { SimpContextMap } from './context.js';
-export declare function mount(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
+export declare function mount(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, context: unknown, hostNamespace: Maybe<string>): void;
 export declare function mountTextElement(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>): void;
-export declare function mountHostElement(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
-export declare function mountFunctionalElement(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
-export declare function mountFragment(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
-export declare function mountArrayChildren(children: SimpElement[], reference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, parentElement: SimpElement, hostNamespace: Maybe<string>): void;
-export declare function mountProvider(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
-export declare function mountConsumer(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
-export declare function mountPortal(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;
+export declare function mountHostElement(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, context: unknown, hostNamespace: Maybe<string>): void;
+export declare function mountFunctionalElement(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, context: unknown, hostNamespace: Maybe<string>): void;
+export declare function mountFragment(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, context: unknown, hostNamespace: Maybe<string>): void;
+export declare function mountArrayChildren(children: SimpElement[], reference: Nullable<HostReference>, nextReference: Nullable<HostReference>, context: unknown, parentElement: SimpElement, hostNamespace: Maybe<string>): void;
+export declare function mountPortal(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, context: unknown): void;

package/core/mounting.js

@@ -1,30 +1,23 @@
-import { emptyMap, emptyObject } from '../shared/index.js';
+import { 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) {
+export function mount(element, parentReference, nextReference, context, hostNamespace) {
     if (element.flag === 'TEXT') {
         mountTextElement(element, parentReference, nextReference);
     }
     else if (element.flag === 'HOST') {
-        mountHostElement(element, parentReference, nextReference, contextMap, hostNamespace);
+        mountHostElement(element, parentReference, nextReference, context, hostNamespace);
     }
     else if (element.flag === 'FC') {
-        mountFunctionalElement(element, parentReference, nextReference, contextMap, hostNamespace);
+        mountFunctionalElement(element, parentReference, nextReference, context, hostNamespace);
     }
     else if (element.flag === 'FRAGMENT') {
-        mountFragment(element, parentReference, nextReference, contextMap, hostNamespace);
-    }
-    else if (element.flag === 'PROVIDER') {
-        mountProvider(element, parentReference, nextReference, contextMap, hostNamespace);
-    }
-    else if (element.flag === 'PORTAL') {
-        mountPortal(element, parentReference, nextReference, contextMap);
+        mountFragment(element, parentReference, nextReference, context, hostNamespace);
     }
     else {
-        mountConsumer(element, parentReference, nextReference, contextMap, hostNamespace);
+        mountPortal(element, parentReference, nextReference, context);
     }
 }
 export function mountTextElement(element, parentReference, nextReference) {
@@ -33,7 +26,7 @@ export function mountTextElement(element, parentReference, nextReference) {
         hostAdapter.insertOrAppend(parentReference, reference, nextReference);
     }
 }
-export function mountHostElement(element, parentReference, nextReference, contextMap, hostNamespace) {
+export function mountHostElement(element, parentReference, nextReference, context, hostNamespace) {
     const hostNamespaces = hostAdapter.getHostNamespaces(element, hostNamespace);
     hostNamespace = hostNamespaces?.self;
     const hostReference = (element.reference = hostAdapter.createReference(element.type, hostNamespace));
@@ -41,11 +34,11 @@ export function mountHostElement(element, parentReference, nextReference, contex
     // HOST element always has Maybe<Many<SimpElement>> children due to normalization process.
     const children = element.children;
     if (Array.isArray(children)) {
-        mountArrayChildren(children, hostReference, null, contextMap, element, hostNamespaces?.children);
+        mountArrayChildren(children, hostReference, null, context, element, hostNamespaces?.children);
     }
     else if (children) {
         children.parent = element;
-        mount(children, hostReference, null, contextMap, hostNamespaces?.children);
+        mount(children, hostReference, null, context, hostNamespaces?.children);
     }
     if (element.props) {
         hostAdapter.mountProps(hostReference, element, hostNamespace);
@@ -62,9 +55,9 @@ export function mountHostElement(element, parentReference, nextReference, contex
     }
     applyRef(element);
 }
-export function mountFunctionalElement(element, parentReference, nextReference, contextMap, hostNamespace) {
-    if (contextMap) {
-        element.contextMap = contextMap;
+export function mountFunctionalElement(element, parentReference, nextReference, context, hostNamespace) {
+    if (context) {
+        element.context = context;
     }
     if (element.unmounted) {
         element.unmounted = false;
@@ -87,18 +80,10 @@ export function mountFunctionalElement(element, parentReference, nextReference,
         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;
+                throw new Error('Too many re-renders.');
             }
             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);
@@ -112,50 +97,30 @@ export function mountFunctionalElement(element, parentReference, nextReference,
     }
     if (children) {
         children.parent = element;
-        mount((element.children = children), parentReference, nextReference, contextMap, hostNamespace);
+        mount((element.children = children), parentReference, nextReference, element.context, hostNamespace);
     }
     lifecycleEventBus.publish({ type: 'mounted', element });
 }
-export function mountFragment(element, parentReference, nextReference, contextMap, hostNamespace) {
+export function mountFragment(element, parentReference, nextReference, context, hostNamespace) {
     // FRAGMENT element always has Maybe<Many<SimpElement>> children due to normalization process.
     if (Array.isArray(element.children)) {
-        mountArrayChildren(element.children, parentReference, nextReference, contextMap, element, hostNamespace);
+        mountArrayChildren(element.children, parentReference, nextReference, context, element, hostNamespace);
     }
     else if (element.children) {
         element.children.parent = element;
-        mount(element.children, parentReference, nextReference, contextMap, hostNamespace);
+        mount(element.children, parentReference, nextReference, context, hostNamespace);
     }
 }
-export function mountArrayChildren(children, reference, nextReference, contextMap, parentElement, hostNamespace) {
+export function mountArrayChildren(children, reference, nextReference, context, parentElement, hostNamespace) {
     for (const child of children) {
         child.parent = parentElement;
-        mount(child, reference, nextReference, contextMap, hostNamespace);
-    }
-}
-export function mountProvider(element, parentReference, nextReference, contextMap, hostNamespace) {
-    contextMap = new Map(contextMap);
-    contextMap.set(element.type.context, element.props.value);
-    // PROVIDER element always has Maybe<Many<SimpElement>> children due to normalization process.
-    if (Array.isArray(element.children)) {
-        mountArrayChildren(element.children, parentReference, nextReference, contextMap, element, hostNamespace);
-    }
-    else if (element.children) {
-        element.children.parent = element;
-        mount(element.children, parentReference, nextReference, contextMap, hostNamespace);
-    }
-}
-export function mountConsumer(element, parentReference, nextReference, contextMap, hostNamespace) {
-    const children = normalizeRoot(element.type(element.props || emptyObject, contextMap || emptyMap), false);
-    if (!children) {
-        return;
+        mount(child, reference, nextReference, context, hostNamespace);
     }
-    children.parent = element;
-    mount((element.children = children), parentReference, nextReference, contextMap, hostNamespace);
 }
-export function mountPortal(element, parentReference, nextReference, contextMap) {
+export function mountPortal(element, parentReference, nextReference, context) {
     if (element.children) {
         element.children.parent = element;
-        mount(element.children, element.ref, null, contextMap, hostAdapter.getHostNamespaces(element.children, undefined)?.self);
+        mount(element.children, element.ref, null, context, hostAdapter.getHostNamespaces(element.children, undefined)?.self);
     }
     const placeHolderElement = createTextElement('');
     mountTextElement(placeHolderElement, parentReference, nextReference);

package/core/patching.d.ts

@@ -1,10 +1,9 @@
 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;
-export declare function patchKeyedChildren(prevChildren: SimpElement[], nextChildren: SimpElement[], parentReference: HostReference, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>, hostNamespace: Maybe<string>): void;
+export declare function patch(prevElement: SimpElement, nextElement: SimpElement, parentReference: HostReference, nextReference: Nullable<HostReference>, context: unknown, hostNamespace: Maybe<string>): void;
+export declare function patchPortal(prevElement: SimpElement, nextElement: SimpElement, context: unknown): void;
+export declare function updateFunctionalComponent(element: SimpElement, parentReference: HostReference, nextReference: Nullable<HostReference>, context: unknown, hostNamespace: Maybe<string>): void;
+export declare function patchKeyedChildren(prevChildren: SimpElement[], nextChildren: SimpElement[], parentReference: HostReference, nextReference: Nullable<HostReference>, context: unknown, hostNamespace: Maybe<string>): void;
 export declare function findParentReferenceFromElement(element: SimpElement): Nullable<HostReference>;
 export declare function findHostReferenceFromElement(element: SimpElement): Nullable<HostReference>;