@simpreact/simpreact 0.0.2 → 0.0.4

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

@@ -0,0 +1,43 @@
+import * as SimpReactInternal from '../core/internal.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;
+};
+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 Suspense(props: {
+    fallback: SimpReactInternal.SimpNode;
+    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;
+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;
+    };
+    cloneElement: typeof cloneElement;
+    isValidElement: typeof isValidElement;
+    Suspense: typeof Suspense;
+    forwardRef: typeof forwardRef;
+    Fragment: SimpReactInternal.Fragment;
+    createElement: typeof SimpReactInternal.createElement;
+    createPortal: typeof SimpReactInternal.createPortal;
+    memo: typeof SimpReactInternal.memo;
+    flushSync: (value: any) => any;
+    Component: typeof Component;
+};
+export default _default;

package/compat/core.js

@@ -0,0 +1,90 @@
+import * as SimpReactInternal from '../core/internal.js';
+import * as SimpReactHooks from '../hooks/index.js';
+export const Children = {
+    map(children, fn) {
+        return Children.toArray(children).map(fn);
+    },
+    forEach(children, fn) {
+        Children.toArray(children).forEach(fn);
+    },
+    count(children) {
+        return Children.toArray(children).length;
+    },
+    toArray(children) {
+        const result = [];
+        function traverse(node) {
+            if (node == null || typeof node === 'boolean') {
+                return;
+            }
+            if (Array.isArray(node)) {
+                for (const child of node) {
+                    traverse(child);
+                }
+                return;
+            }
+            result.push(node);
+        }
+        traverse(children);
+        return result;
+    },
+    only(children) {
+        const array = Children.toArray(children);
+        if (array.length !== 1 || !isValidElement(array[0])) {
+            throw new Error('Children.only expected a single SimpElement child.');
+        }
+        return array[0];
+    },
+};
+export function cloneElement(element, props, ...children) {
+    if (!isValidElement(element)) {
+        throw new Error(`cloneElement: expected a SimpElement, got ${element}`);
+    }
+    if (element.flag === 'PORTAL') {
+        throw new Error('cloneElement: the argument must be a SimpElement, but you passed a portal instead.');
+    }
+    return SimpReactInternal.createElement(element.flag === 'FRAGMENT' ? SimpReactInternal.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;
+}
+export function Suspense(props) {
+    const [isSuspended, setIsSuspended] = SimpReactHooks.useState(false);
+    SimpReactHooks.useCatch(error => {
+        if (isSuspended) {
+            return;
+        }
+        if (error instanceof Promise) {
+            setIsSuspended(true);
+            error.then(() => setIsSuspended(false));
+        }
+    });
+    return isSuspended ? props.fallback : props.children;
+}
+export function forwardRef(Component) {
+    return function Forwarded(props) {
+        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 flushSync = (value) => value;
+export class Component {
+    constructor() {
+        throw new Error('Not implemented.');
+    }
+}
+export default {
+    Children,
+    cloneElement,
+    isValidElement,
+    Suspense,
+    forwardRef,
+    Fragment,
+    createElement,
+    createPortal,
+    memo,
+    flushSync,
+    Component,
+};

package/compat/dom.d.ts

@@ -0,0 +1,11 @@
+import * as SimpReactDOM from '../dom/index.js';
+import * as SimpReactShared from '../shared/index.js';
+export declare const hydrate: typeof SimpReactShared.noop;
+export declare const render: typeof SimpReactDOM.render;
+export declare const createRoot: typeof SimpReactDOM.createRoot;
+declare const _default: {
+    hydrate: typeof SimpReactShared.noop;
+    render: typeof SimpReactDOM.render;
+    createRoot: typeof SimpReactDOM.createRoot;
+};
+export default _default;

package/compat/dom.js

@@ -0,0 +1,10 @@
+import * as SimpReactDOM from '../dom/index.js';
+import * as SimpReactShared from '../shared/index.js';
+export const hydrate = SimpReactShared.noop;
+export const render = SimpReactDOM.render;
+export const createRoot = SimpReactDOM.createRoot;
+export default {
+    hydrate,
+    render,
+    createRoot,
+};

package/compat/hooks.d.ts

@@ -0,0 +1,24 @@
+import * as SimpReactHooks from '../hooks/index.js';
+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: SimpReactHooks.DependencyList): T;
+export declare function useCallback<T>(cb: T, deps: SimpReactHooks.DependencyList): T;
+export declare const useState: typeof SimpReactHooks.useState;
+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;
+declare const _default: {
+    useSyncExternalStore: typeof useSyncExternalStore;
+    useReducer: typeof useReducer;
+    useId: typeof useId;
+    useMemo: typeof useMemo;
+    useCallback: typeof useCallback;
+    useState: typeof SimpReactHooks.useState;
+    useEffect: typeof SimpReactHooks.useEffect;
+    useLayoutEffect: typeof SimpReactHooks.useEffect;
+    useInsertionEffect: typeof SimpReactHooks.useEffect;
+    useRef: typeof SimpReactHooks.useRef;
+};
+export default _default;

package/compat/hooks.js

@@ -0,0 +1,75 @@
+import * as SimpReactHooks from '../hooks/index.js';
+export function useSyncExternalStore(subscribe, getSnapshot) {
+    const rerender = SimpReactHooks.useRerender();
+    const lastSnapshotRef = SimpReactHooks.useRef(getSnapshot());
+    SimpReactHooks.useEffect(() => {
+        function checkForUpdates() {
+            const nextSnapshot = getSnapshot();
+            if (!Object.is(lastSnapshotRef.current, nextSnapshot)) {
+                lastSnapshotRef.current = nextSnapshot;
+                rerender();
+            }
+        }
+        const unsubscribe = subscribe(checkForUpdates);
+        checkForUpdates();
+        return unsubscribe;
+    }, [subscribe, getSnapshot]);
+    return lastSnapshotRef.current;
+}
+export function useReducer(reducer, initializerArg, initializer) {
+    const rerender = SimpReactHooks.useRerender();
+    const reducerRef = SimpReactHooks.useRef(reducer);
+    reducerRef.current = reducer;
+    const stateRef = SimpReactHooks.useRef([
+        initializer ? initializer(initializerArg) : initializerArg,
+        function dispatch(action) {
+            const newState = reducerRef.current(stateRef.current[0], action);
+            if (Object.is(newState, stateRef.current[0])) {
+                return;
+            }
+            stateRef.current[0] = newState;
+            rerender();
+        },
+    ]);
+    return stateRef.current;
+}
+let globalId = 0;
+export function useId(prefix = 'id') {
+    const idRef = SimpReactHooks.useRef('');
+    if (idRef.current === '') {
+        globalId += 1;
+        idRef.current = `${prefix}-${globalId}`;
+    }
+    return idRef.current;
+}
+export function useMemo(factory, deps) {
+    const ref = SimpReactHooks.useRef({
+        deps: undefined,
+        value: undefined,
+    });
+    if (!SimpReactHooks.areDepsEqual(ref.current.deps, deps)) {
+        ref.current.value = factory();
+        ref.current.deps = deps;
+    }
+    return ref.current.value;
+}
+export function useCallback(cb, deps) {
+    return useMemo(() => cb, deps);
+}
+export const useState = SimpReactHooks.useState;
+export const useEffect = SimpReactHooks.useEffect;
+export const useLayoutEffect = SimpReactHooks.useEffect;
+export const useInsertionEffect = SimpReactHooks.useEffect;
+export const useRef = SimpReactHooks.useRef;
+export default {
+    useSyncExternalStore,
+    useReducer,
+    useId,
+    useMemo,
+    useCallback,
+    useState,
+    useEffect,
+    useLayoutEffect,
+    useInsertionEffect,
+    useRef,
+};

package/compat/index.d.ts

@@ -0,0 +1,43 @@
+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: typeof import("../hooks/index.js").useState;
+    useEffect: typeof import("../hooks/index.js").useEffect;
+    useLayoutEffect: typeof import("../hooks/index.js").useEffect;
+    useInsertionEffect: typeof import("../hooks/index.js").useEffect;
+    useRef: typeof import("../hooks/index.js").useRef;
+    hydrate: typeof import("../shared/utils.js").noop;
+    render: typeof import("../dom/render.js").render;
+    createRoot: typeof import("../dom/render.js").createRoot;
+    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;
+    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: typeof import("../context/index.js").createContext;
+    useContext: typeof import("../context/index.js").useContext;
+};
+export default _default;

package/compat/index.js

@@ -0,0 +1,17 @@
+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,
+    ...jsxRuntimeDefault,
+};

package/compat/jsx-runtime.d.ts

@@ -0,0 +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;
+declare const _default: {
+    jsx: typeof SimpReactJSXRuntime.jsx;
+    jsxDEV: typeof SimpReactJSXRuntime.jsx;
+    jsxs: typeof SimpReactJSXRuntime.jsx;
+};
+export default _default;

package/compat/jsx-runtime.js

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

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?: Maybe<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;
@@ -31,7 +30,9 @@ export function createElement(type, props, ...children) {
                         definedChildren = props[propName];
                     }
                 }
-                else if (propName === 'ref') {
+                else if (propName === 'ref' &&
+                    // Handle only a callback ref or an object ref with `current`.
+                    props[propName]) {
                     ref = {
                         value: props[propName],
                     };
@@ -81,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) {
@@ -208,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

@@ -4,9 +4,9 @@ export type ComponentType<P = {}> = FunctionComponent<P>;
 
 export type RefObject<T> = { current: T };
 export type RefCallback<T> = {
-  bivarianceHack(instance: T | null): (() => void | undefined) | void;
+  bivarianceHack(instance: T): (() => void | undefined) | void;
 }['bivarianceHack'];
-export type Ref<T> = RefCallback<T> | RefObject<T> | null;
+export type Ref<T> = RefCallback<T> | RefObject<T | null> | null;
 
 export type Key = string | number | bigint;
 
@@ -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/lifecycleEventBus.d.ts

@@ -6,7 +6,11 @@ export type LifecycleEvent = {
     phase: 'mounting' | 'updating';
 } | {
     type: 'afterRender';
+    element: SimpElement;
     phase: 'mounting' | 'updating';
+} | {
+    type: 'triedToRerender';
+    element: SimpElement;
 } | {
     type: 'mounted';
     element: SimpElement;

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;