@simpreact/simpreact 0.0.4 → 0.0.6

package/core/createElement.d.ts

@@ -1,30 +1,39 @@
-import type { Many, Maybe, Nullable, SimpText } from '../shared/index.js';
-import type { HostReference } from './hostAdapter.js';
+import type { Nullable, SimpText } from '../shared/index.js';
 export type SimpNode = SimpElement | SimpText | Array<SimpNode> | boolean | null | undefined;
 export type Key = string | number | bigint;
 export type FC = (props: any) => SimpNode;
-export type SimpElementFlag = 'FC' | 'HOST' | 'TEXT' | 'FRAGMENT' | 'PORTAL';
+export declare const SIMP_ELEMENT_FLAG_HOST = 1;
+export declare const SIMP_ELEMENT_FLAG_FC: number;
+export declare const SIMP_ELEMENT_FLAG_TEXT: number;
+export declare const SIMP_ELEMENT_FLAG_PORTAL: number;
+export declare const SIMP_ELEMENT_FLAG_FRAGMENT: number;
+export declare const SIMP_ELEMENT_CHILD_FLAG_EMPTY = 1;
+export declare const SIMP_ELEMENT_CHILD_FLAG_UNKNOWN: number;
+export declare const SIMP_ELEMENT_CHILD_FLAG_ELEMENT: number;
+export declare const SIMP_ELEMENT_CHILD_FLAG_LIST: number;
+export declare const SIMP_ELEMENT_CHILD_FLAG_TEXT: number;
 export interface SimpElementStore {
-    latestElement?: Maybe<SimpElement>;
-    hostNamespace?: Maybe<string>;
-    forceRender?: boolean;
-    [key: string]: unknown;
+    latestElement: Nullable<SimpElement>;
+    hostNamespace: Nullable<string>;
+    forceRerender: boolean;
 }
 export interface SimpElement {
-    flag: SimpElementFlag;
+    flag: number;
+    childFlag: number;
     parent: Nullable<SimpElement>;
-    key?: Maybe<Key>;
-    type?: string | FC;
-    props?: any;
-    children?: Maybe<SimpNode>;
-    className?: Maybe<string>;
-    reference?: Maybe<HostReference>;
-    store?: SimpElementStore;
-    context?: any;
-    ref?: any;
-    unmounted?: boolean;
+    key: Nullable<Key>;
+    type: Nullable<string | FC>;
+    props: any;
+    children: SimpNode;
+    className: Nullable<string>;
+    reference: unknown;
+    store: Nullable<SimpElementStore>;
+    context: any;
+    ref: any;
+    unmounted: Nullable<boolean>;
+    index: number;
 }
 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>;
+export declare function normalizeChildren(element: SimpElement, children: SimpNode, skipIgnoredCheck: boolean): SimpElement;
+export declare function normalizeRoot(element: SimpElement, node: SimpNode, skipIgnoredCheck: boolean): SimpElement;

package/core/createElement.js

@@ -1,181 +1,207 @@
 import { isSimpText } from '../shared/index.js';
 import { Fragment } from './fragment.js';
-export function createElement(type, props, ...children) {
-    let newProps;
-    let className;
-    let key;
+export const SIMP_ELEMENT_FLAG_HOST = 1;
+export const SIMP_ELEMENT_FLAG_FC = 1 << 1;
+export const SIMP_ELEMENT_FLAG_TEXT = 1 << 2;
+export const SIMP_ELEMENT_FLAG_PORTAL = 1 << 3;
+export const SIMP_ELEMENT_FLAG_FRAGMENT = 1 << 4;
+export const SIMP_ELEMENT_CHILD_FLAG_EMPTY = 1;
+export const SIMP_ELEMENT_CHILD_FLAG_UNKNOWN = 1 << 1;
+export const SIMP_ELEMENT_CHILD_FLAG_ELEMENT = 1 << 2;
+export const SIMP_ELEMENT_CHILD_FLAG_LIST = 1 << 3;
+export const SIMP_ELEMENT_CHILD_FLAG_TEXT = 1 << 4;
+export function createElement(type, props) {
     let definedChildren;
-    const childLength = children.length;
-    if (childLength === 1) {
-        definedChildren = children[0];
-    }
-    else if (childLength > 1) {
-        definedChildren = [];
-        for (let i = 0; i < childLength; i++) {
-            definedChildren.push(children[i]);
+    const argLength = arguments.length;
+    if (argLength > 2) {
+        if (argLength === 3) {
+            definedChildren = arguments[2];
         }
-    }
-    if (typeof type === 'string') {
-        let ref;
-        if (props != null) {
-            for (const propName in props) {
-                if (propName === 'className') {
-                    className = props[propName];
-                }
-                else if (propName === 'key') {
-                    key = props[propName];
-                }
-                else if (propName === 'children') {
-                    if (definedChildren === undefined) {
-                        definedChildren = props[propName];
-                    }
-                }
-                else if (propName === 'ref' &&
-                    // Handle only a callback ref or an object ref with `current`.
-                    props[propName]) {
-                    ref = {
-                        value: props[propName],
-                    };
-                }
-                else {
-                    (newProps ||= {})[propName] = props[propName];
-                }
+        else {
+            const arr = [];
+            for (let i = 2; i < argLength; i++) {
+                arr.push(arguments[i]);
             }
+            definedChildren = arr;
         }
-        const element = {
-            flag: 'HOST',
-            type,
-            parent: null,
-        };
-        if (className) {
-            element.className = className;
-        }
-        if (key) {
-            element.key = key;
-        }
-        if (isSimpText(definedChildren)) {
+    }
+    definedChildren = definedChildren === undefined ? props?.children : definedChildren;
+    const key = props?.key == null ? null : props.key.toString();
+    switch (typeof type) {
+        case 'string': {
+            if (!isSimpText(definedChildren)) {
+                return normalizeChildren({
+                    flag: SIMP_ELEMENT_FLAG_HOST,
+                    childFlag: SIMP_ELEMENT_CHILD_FLAG_UNKNOWN,
+                    parent: null,
+                    key,
+                    type,
+                    props: props || null,
+                    children: null,
+                    className: props?.className || null,
+                    reference: null,
+                    store: null,
+                    context: null,
+                    ref: props?.ref ? { value: props.ref } : null,
+                    unmounted: null,
+                    index: 0,
+                }, definedChildren, false);
+            }
+            let childFlag = SIMP_ELEMENT_CHILD_FLAG_EMPTY;
+            definedChildren = definedChildren.toString();
             if (definedChildren !== '') {
-                (newProps ||= {}).children = definedChildren.toString();
+                (props ||= {}).children = definedChildren;
+                childFlag = SIMP_ELEMENT_CHILD_FLAG_TEXT;
             }
+            return {
+                flag: SIMP_ELEMENT_FLAG_HOST,
+                childFlag,
+                parent: null,
+                key,
+                type,
+                props: props || null,
+                children: null,
+                className: props?.className || null,
+                reference: null,
+                store: null,
+                context: null,
+                ref: props?.ref ? { value: props.ref } : null,
+                unmounted: null,
+                index: 0,
+            };
         }
-        else if ((definedChildren = normalizeChildren(definedChildren, false))) {
-            element.children = definedChildren;
-        }
-        if (newProps) {
-            element.props = newProps;
-        }
-        if (ref) {
-            element.ref = ref;
-        }
-        return element;
-    }
-    else if (type === Fragment) {
-        const element = {
-            flag: 'FRAGMENT',
-            parent: null,
-        };
-        if ((definedChildren = normalizeChildren(definedChildren || (props != null ? props.children : null), false))) {
-            element.children = definedChildren;
-        }
-        if (props != null && props.key) {
-            element.key = props?.key;
-        }
-        return element;
-    }
-    else {
-        if (props != null) {
-            for (const propName in props) {
-                if (propName === 'key') {
-                    key = props[propName];
-                }
-                else if (propName === 'children') {
-                    if (definedChildren === undefined) {
-                        definedChildren = props[propName];
-                    }
-                }
-                else {
-                    (newProps ||= {})[propName] = props[propName];
-                }
+        case 'function': {
+            if (definedChildren !== undefined) {
+                (props ||= {}).children = definedChildren;
             }
+            return {
+                flag: SIMP_ELEMENT_FLAG_FC,
+                childFlag: SIMP_ELEMENT_CHILD_FLAG_UNKNOWN,
+                parent: null,
+                key,
+                type,
+                props: props || null,
+                children: null,
+                className: null,
+                reference: null,
+                store: null,
+                context: null,
+                ref: null,
+                unmounted: null,
+                index: 0,
+            };
         }
-        if (definedChildren !== undefined) {
-            (newProps ||= {})['children'] = definedChildren;
-        }
-        const element = {
-            flag: 'FC',
-            type,
-            parent: null,
-        };
-        if (key) {
-            element.key = key;
+        default: {
+            return normalizeChildren({
+                flag: SIMP_ELEMENT_FLAG_FRAGMENT,
+                childFlag: SIMP_ELEMENT_CHILD_FLAG_UNKNOWN,
+                parent: null,
+                key,
+                type: null,
+                props: null,
+                children: null,
+                className: null,
+                reference: null,
+                store: null,
+                context: null,
+                ref: null,
+                unmounted: null,
+                index: 0,
+            }, definedChildren, false);
         }
-        if (newProps != null) {
-            element.props = newProps;
-        }
-        return element;
     }
 }
 export function createTextElement(text) {
     return {
-        flag: 'TEXT',
-        children: text.toString(),
+        flag: SIMP_ELEMENT_FLAG_TEXT,
+        childFlag: SIMP_ELEMENT_CHILD_FLAG_TEXT,
         parent: null,
+        key: null,
+        type: null,
+        props: null,
+        children: text.toString(),
+        className: null,
+        reference: null,
+        store: null,
+        context: null,
+        ref: null,
+        unmounted: null,
+        index: 0,
     };
 }
-export function normalizeChildren(children, skipIgnoredCheck) {
+export function normalizeChildren(element, children, skipIgnoredCheck) {
     if (!skipIgnoredCheck && isIgnoredNode(children)) {
-        return;
+        element.childFlag = SIMP_ELEMENT_CHILD_FLAG_EMPTY;
+        element.children = null;
+        return element;
     }
     const result = [];
     normalizeNode(children, result, undefined, true);
     if (result.length === 0) {
-        return;
+        element.childFlag = SIMP_ELEMENT_CHILD_FLAG_EMPTY;
+        element.children = null;
+        return element;
+    }
+    if (result.length === 1) {
+        element.childFlag = SIMP_ELEMENT_CHILD_FLAG_ELEMENT;
+        element.children = result[0];
+        return element;
     }
-    return result.length === 1 ? result[0] : result;
+    element.childFlag = SIMP_ELEMENT_CHILD_FLAG_LIST;
+    element.children = result;
+    return element;
 }
-function normalizeNode(child, result, currentKey = '', skipIgnoredCheck) {
+function normalizeNode(child, result, currentKey = null, skipIgnoredCheck) {
     if (!skipIgnoredCheck && isIgnoredNode(child)) {
         return;
     }
     if (isSimpText(child)) {
-        child = createTextElement(child);
-        child.key =
-            currentKey ||
-                // Hack to treat a single child as a one-item list for more consistent reconciliation.
-                '.0';
-        result.push(child);
+        const element = createTextElement(child);
+        element.key = currentKey;
+        element.index = result.length;
+        result.push(element);
         return;
     }
     if (Array.isArray(child)) {
         for (let i = 0; i < child.length; i++) {
-            normalizeNode(child[i], result, currentKey + '.' + i, false);
+            normalizeNode(child[i], result, `${currentKey ?? ''}.${i}`, false);
         }
         return;
     }
-    if (child.key) {
-        currentKey = currentKey.slice(0, -2) + child.key;
+    const element = child;
+    if (element.key != null) {
+        currentKey = `${(currentKey ?? '').slice(0, -2)}${element.key}`;
     }
-    child.key =
-        currentKey ||
-            // Hack to treat a single child as a one-item list for more consistent reconciliation.
-            '.0';
-    result.push(child);
+    element.key = currentKey;
+    element.index = result.length;
+    result.push(element);
 }
-export function normalizeRoot(node, skipIgnoredCheck) {
+export function normalizeRoot(element, node, skipIgnoredCheck) {
     if (!skipIgnoredCheck && isIgnoredNode(node)) {
-        return;
+        element.childFlag = SIMP_ELEMENT_CHILD_FLAG_EMPTY;
+        element.children = null;
+        return element;
     }
     if (isSimpText(node)) {
-        return createTextElement(node);
+        element.childFlag = SIMP_ELEMENT_CHILD_FLAG_ELEMENT;
+        element.children = createTextElement(node);
+        return element;
     }
     if (!Array.isArray(node)) {
-        return node;
+        element.childFlag = SIMP_ELEMENT_CHILD_FLAG_ELEMENT;
+        element.children = node;
+        return element;
     }
-    node = normalizeChildren(node, true);
-    if (Array.isArray(node)) {
-        return createElement(Fragment, { children: node });
+    normalizeChildren(element, node, true);
+    if (element.childFlag === SIMP_ELEMENT_CHILD_FLAG_ELEMENT) {
+        return element;
+    }
+    if (element.childFlag === SIMP_ELEMENT_CHILD_FLAG_EMPTY) {
+        return element;
     }
-    return node;
+    element.childFlag = SIMP_ELEMENT_CHILD_FLAG_ELEMENT;
+    element.children = createElement(Fragment, { children: element.children });
+    return element;
 }
 function isIgnoredNode(node) {
     if (node == null || typeof node === 'boolean' || node === '') {
@@ -187,7 +213,7 @@ function isIgnoredNode(node) {
     if (isSimpText(node)) {
         return false;
     }
-    if (node.flag === 'FRAGMENT' || node.flag === 'PORTAL') {
+    if ((node.flag & SIMP_ELEMENT_FLAG_FRAGMENT) !== 0 || (node.flag & SIMP_ELEMENT_FLAG_PORTAL) !== 0) {
         return node.children == null;
     }
     return false;

package/core/hostAdapter.d.ts

@@ -1,27 +1,23 @@
 import type { Maybe, Nullable } from '../shared/index.js';
 import type { SimpElement } from './createElement.js';
-export type HostReference = any;
-export interface HostAdapter<HostRef = any, HostTextRef = any, NS = string> {
+import type { SimpRenderRuntime } from './runtime.js';
+export interface HostAdapter<HostRef = unknown, HostTextRef = unknown, NS = string> {
     createReference(type: string, namespace?: Maybe<NS>): HostRef;
     createTextReference(text: string): HostTextRef;
-    mountProps(reference: HostRef, element: SimpElement, namespace?: Maybe<NS>): void;
-    patchProps(reference: HostRef, prevElement: SimpElement, nextElement: SimpElement, namespace?: Maybe<NS>): void;
-    unmountProps(reference: HostRef, element: SimpElement): void;
+    mountProps(reference: HostRef, element: SimpElement, renderRuntime: SimpRenderRuntime, namespace?: Maybe<NS>): void;
+    patchProps(reference: HostRef, prevElement: SimpElement, nextElement: SimpElement, renderRuntime: SimpRenderRuntime, namespace?: Maybe<NS>): void;
+    unmountProps(reference: HostRef, element: SimpElement, renderRuntime: SimpRenderRuntime): void;
     setClassname(reference: HostRef, className: Maybe<string>, namespace?: Maybe<NS>): void;
     setTextContent(reference: HostRef, text: string, referenceHasOnlyTextElement?: boolean): void;
-    appendChild(parent: HostRef, child: HostRef | HostTextRef): void;
     removeChild(parent: HostRef, child: HostRef | HostTextRef): void;
     replaceChild(parent: HostRef, replacer: HostRef | HostTextRef, toBeReplaced: HostRef | HostTextRef): void;
-    insertBefore(parent: HostRef, child: HostRef | HostTextRef, before: Nullable<HostRef | HostTextRef>): void;
     insertOrAppend(parent: HostRef, child: HostRef | HostTextRef, before: Nullable<HostRef | HostTextRef>): void;
-    findParentReference(reference: HostRef | HostTextRef): Nullable<HostRef>;
-    findNextSiblingReference(reference: HostRef | HostTextRef): Nullable<HostRef>;
     clearNode(reference: HostRef | HostTextRef): void;
-    attachElementToReference(element: SimpElement, reference: HostRef | HostTextRef): void;
+    attachElementToReference(element: SimpElement, reference: HostRef | HostTextRef, renderRuntime: SimpRenderRuntime): void;
+    detachElementFromReference(reference: HostRef | HostTextRef, renderRuntime: SimpRenderRuntime): void;
+    getElementFromReference(reference: HostRef | HostTextRef, renderRuntime: SimpRenderRuntime): Nullable<SimpElement>;
     getHostNamespaces(element: SimpElement, currentNamespace: Maybe<NS>): Nullable<{
         self: Nullable<NS>;
         children: Nullable<NS>;
     }>;
 }
-export declare let hostAdapter: HostAdapter;
-export declare function provideHostAdapter(adapter: HostAdapter): void;

package/core/hostAdapter.js

@@ -1,4 +1 @@
-export let hostAdapter;
-export function provideHostAdapter(adapter) {
-    hostAdapter = adapter;
-}
+export {};

package/core/hostOperations.d.ts

@@ -0,0 +1,5 @@
+import type { SimpElement } from './createElement.js';
+import { type PlaceElementFrameMeta, type ReplaceElementFrameMeta } from './processStack.js';
+import type { SimpRenderRuntime } from './runtime.js';
+export declare function _pushHostOperationPlaceElement(element: SimpElement, meta: PlaceElementFrameMeta): void;
+export declare function _pushHostOperationReplaceElement(element: SimpElement, renderRuntime: SimpRenderRuntime, meta: ReplaceElementFrameMeta): void;

package/core/hostOperations.js

@@ -0,0 +1,15 @@
+import { HOST_OPS_PLACE_ELEMENT_BEFORE_ANCHOR, HOST_OPS_REPLACE_CHILD, } from './processStack.js';
+export function _pushHostOperationPlaceElement(element, meta) {
+    meta.renderRuntime.renderStack.push({
+        node: element,
+        kind: HOST_OPS_PLACE_ELEMENT_BEFORE_ANCHOR,
+        meta,
+    });
+}
+export function _pushHostOperationReplaceElement(element, renderRuntime, meta) {
+    renderRuntime.renderStack.push({
+        node: element,
+        kind: HOST_OPS_REPLACE_CHILD,
+        meta,
+    });
+}

package/core/index.d.ts

@@ -1,6 +1,7 @@
-import type { SimpText } from '../shared/index.js';
+import type { HostReference, TraversalStack } from './internal.js';
+import type { Maybe, Nullable, SimpText } from '../shared/index.js';
 
-export type ComponentType<P = {}> = FunctionComponent<P>;
+export type ComponentType<P = {}> = FunctionalComponent<P>;
 
 export type RefObject<T> = { current: T };
 export type RefCallback<T> = {
@@ -18,7 +19,7 @@ export interface RefAttributes<T> extends Attributes {
   ref?: Ref<T> | undefined;
 }
 
-export interface SimpElement<P = unknown, T extends string | FunctionComponent<P> = string> {
+export interface SimpElement<P = unknown, T extends string | FunctionalComponent<P> = string> {
   type?: T;
   props?: P;
   key?: string | null;
@@ -32,7 +33,7 @@ declare function createElement<P extends {}, T>(
   ...children: SimpNode[]
 ): SimpElement<P>;
 declare function createElement<P extends {}>(
-  type: FunctionComponent<P>,
+  type: FunctionalComponent<P>,
   props?: (Attributes & P) | null,
   ...children: SimpNode[]
 ): SimpElement<P>;
@@ -41,9 +42,31 @@ declare function createPortal<HostRef = {}>(children: SimpNode, container: HostR
 
 declare function Fragment(props: PropsWithChildren): SimpElement;
 
-export type FunctionComponent<P = {}> = (props: P) => SimpNode;
-export type FC<P = {}> = FunctionComponent<P>;
+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 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>;
+  elementToHostMap: Map<unknown, SimpElement>;
+}

package/core/internal.d.ts

@@ -5,7 +5,10 @@ export * from './lifecycleEventBus.js';
 export * from './memo.js';
 export * from './mounting.js';
 export * from './patching.js';
+export * from './patchingChildren.js';
 export * from './portal.js';
+export * from './processStack.js';
 export * from './ref.js';
 export * from './rerender.js';
+export * from './runtime.js';
 export * from './unmounting.js';

package/core/internal.js

@@ -5,7 +5,10 @@ export * from './lifecycleEventBus.js';
 export * from './memo.js';
 export * from './mounting.js';
 export * from './patching.js';
+export * from './patchingChildren.js';
 export * from './portal.js';
+export * from './processStack.js';
 export * from './ref.js';
 export * from './rerender.js';
+export * from './runtime.js';
 export * from './unmounting.js';

package/core/lifecycleEventBus.d.ts

@@ -1,30 +1,39 @@
-import { EventBus } from '../shared/index.js';
 import type { SimpElement } from './createElement.js';
+import type { SimpRenderRuntime } from './runtime.js';
 export type LifecycleEvent = {
     type: 'beforeRender';
     element: SimpElement;
-    phase: 'mounting' | 'updating';
+    renderRuntime: SimpRenderRuntime;
 } | {
     type: 'afterRender';
     element: SimpElement;
-    phase: 'mounting' | 'updating';
+    renderRuntime: SimpRenderRuntime;
 } | {
     type: 'triedToRerender';
     element: SimpElement;
+    renderRuntime: SimpRenderRuntime;
 } | {
     type: 'mounted';
     element: SimpElement;
+    renderRuntime: SimpRenderRuntime;
 } | {
     type: 'updated';
     element: SimpElement;
+    renderRuntime: SimpRenderRuntime;
 } | {
     type: 'unmounted';
     element: SimpElement;
+    renderRuntime: SimpRenderRuntime;
 } | {
     type: 'errored';
     element: SimpElement;
     error: any;
-    phase: 'mounting' | 'updating';
+    handled: boolean;
+    renderRuntime: SimpRenderRuntime;
 };
-export type LifecycleEventBus = EventBus<LifecycleEvent>;
-export declare const lifecycleEventBus: EventBus<LifecycleEvent>;
+type Subscriber = (event: LifecycleEvent) => boolean | void;
+export declare const lifecycleEventBus: {
+    publish(event: LifecycleEvent): void;
+    subscribe(subscriber: Subscriber): () => void;
+};
+export {};

package/core/lifecycleEventBus.js

@@ -1,2 +1,16 @@
-import { EventBus } from '../shared/index.js';
-export const lifecycleEventBus = new EventBus();
+const subscribers = [];
+export const lifecycleEventBus = {
+    publish(event) {
+        for (const subscriber of subscribers) {
+            subscriber(event);
+        }
+    },
+    subscribe(subscriber) {
+        if (subscribers.indexOf(subscriber) === -1) {
+            subscribers.push(subscriber);
+        }
+        return () => {
+            subscribers.splice(subscribers.indexOf(subscriber), 1);
+        };
+    },
+};

package/core/memo.d.ts

@@ -2,8 +2,6 @@ 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;

package/core/memo.js

@@ -1,11 +1,9 @@
 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;
+    return !!type._compare;
 }