@simpreact/simpreact 0.0.0-alpha.dd6f145 → 0.0.2

package/core/context.d.ts

@@ -0,0 +1,18 @@
+import type { SimpNode } from './createElement.js';
+type Provider<T = any> = (props: {
+    value: T;
+    children: SimpNode;
+}) => SimpNode;
+type Consumer<T = any> = (props: {
+    children: (value: T) => SimpNode;
+}, contextMap: SimpContextMap) => SimpNode;
+export interface SimpContext<T> {
+    defaultValue: T;
+    Provider: Provider<T>;
+    Consumer: Consumer<T>;
+}
+export type SimpContextMap = Map<SimpContext<any>, any>;
+export declare function createContext<T>(defaultValue: T): SimpContext<T>;
+export declare function isProvider(type: any): boolean;
+export declare function isConsumer(type: any): boolean;
+export {};

package/core/context.js

@@ -0,0 +1,18 @@
+export function createContext(defaultValue) {
+    const context = {
+        defaultValue,
+        Provider: Object.create(null),
+        Consumer(props, contextMap) {
+            return props.children(contextMap.get(context) ?? defaultValue);
+        },
+    };
+    Object.defineProperty(context.Consumer, 'isConsumer', { value: true });
+    Object.defineProperty(context.Provider, 'context', { value: context, enumerable: true });
+    return context;
+}
+export function isProvider(type) {
+    return type != null && type.context != null;
+}
+export function isConsumer(type) {
+    return type != null && type.isConsumer === true;
+}

package/core/createElement.d.ts

@@ -1,24 +1,33 @@
-import type { Many, Maybe, Primitive } from '../shared';
-import type { HostReference } from './hostAdapter';
-export type SimpNode = SimpElement | string | number | bigint | Array<SimpNode> | boolean | null | undefined;
-export type Props = any;
+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<P = Props> {
-    (props: P): SimpNode;
+export interface FunctionComponent {
+    (props: any): SimpNode;
 }
-export type FC<P = Props> = FunctionComponent<P>;
-export type SimpElementFlag = 'FC' | 'HOST' | 'TEXT' | 'FRAGMENT';
-export interface SimpElement<T = Props> {
+export type FC = FunctionComponent;
+export type SimpElementFlag = 'FC' | 'HOST' | 'TEXT' | 'FRAGMENT' | 'PROVIDER' | 'CONSUMER' | 'PORTAL';
+export interface SimpElementStore {
+    latestElement?: Maybe<SimpElement>;
+    hostNamespace?: Maybe<string>;
+    [key: string]: unknown;
+}
+export interface SimpElement {
     flag: SimpElementFlag;
+    parent: Nullable<SimpElement>;
     key?: Maybe<Key>;
-    type?: Maybe<string | FunctionComponent<T>>;
-    props?: Maybe<T>;
+    type?: Maybe<string | FunctionComponent>;
+    props?: any;
     children?: Maybe<SimpNode>;
     className?: Maybe<string>;
     reference?: Maybe<HostReference>;
-    store?: unknown;
+    store?: SimpElementStore;
+    contextMap?: Maybe<SimpContextMap>;
+    ref?: any;
+    unmounted?: boolean;
 }
-export declare function createElement<P = Props>(type: string | FunctionComponent<Readonly<P>>, props?: Maybe<P>, ...children: SimpNode[]): SimpElement<P>;
-export declare function createTextElement(text: Primitive): SimpElement;
-export declare function normalizeChildren(children: SimpNode): Maybe<Many<SimpElement>>;
-export declare function normalizeRoot(node: SimpNode): SimpElement;
+export declare function createElement(type: string | FunctionComponent, 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,5 +1,6 @@
-import { IS_DEVELOPMENT, isArray, isPrimitive } from '../shared';
-import { Fragment } from './fragment';
+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;
@@ -16,6 +17,7 @@ export function createElement(type, props, ...children) {
         }
     }
     if (typeof type === 'string') {
+        let ref;
         if (props != null) {
             for (const propName in props) {
                 if (propName === 'className') {
@@ -29,14 +31,20 @@ export function createElement(type, props, ...children) {
                         definedChildren = props[propName];
                     }
                 }
+                else if (propName === 'ref') {
+                    ref = {
+                        value: props[propName],
+                    };
+                }
                 else {
-                    (newProps || (newProps = {}))[propName] = props[propName];
+                    (newProps ||= {})[propName] = props[propName];
                 }
             }
         }
         const element = {
             flag: 'HOST',
             type,
+            parent: null,
         };
         if (className) {
             element.className = className;
@@ -44,21 +52,54 @@ export function createElement(type, props, ...children) {
         if (key) {
             element.key = key;
         }
-        if ((definedChildren = normalizeChildren(definedChildren))) {
+        if (isSimpText(definedChildren)) {
+            if (definedChildren !== '') {
+                (newProps ||= {}).children = definedChildren.toString();
+            }
+        }
+        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 (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,
         };
-        element.children = normalizeChildren(definedChildren || (props != null ? props.children : null));
         if (props != null && props.key) {
-            element.key = props === null || props === void 0 ? void 0 : props.key;
+            element.key = props?.key;
         }
         return element;
     }
@@ -74,16 +115,17 @@ export function createElement(type, props, ...children) {
                     }
                 }
                 else {
-                    (newProps || (newProps = {}))[propName] = props[propName];
+                    (newProps ||= {})[propName] = props[propName];
                 }
             }
         }
         if (definedChildren !== undefined) {
-            (newProps || (newProps = {}))['children'] = definedChildren;
+            (newProps ||= {})['children'] = definedChildren;
         }
         const element = {
             flag: 'FC',
             type,
+            parent: null,
         };
         if (key) {
             element.key = key;
@@ -97,48 +139,77 @@ export function createElement(type, props, ...children) {
 export function createTextElement(text) {
     return {
         flag: 'TEXT',
-        children: text == null || text === true || text === false ? '' : text,
+        children: text.toString(),
+        parent: null,
     };
 }
-export function normalizeChildren(children) {
-    if (children == null || typeof children === 'boolean') {
+export function normalizeChildren(children, skipIgnoredCheck) {
+    if (!skipIgnoredCheck && isIgnoredNode(children)) {
         return;
     }
     const result = [];
-    normalizeNode(children, result);
+    normalizeNode(children, result, undefined, true);
     if (result.length === 0) {
         return;
     }
     return result.length === 1 ? result[0] : result;
 }
-function normalizeNode(child, result) {
-    if (child == null || typeof child === 'boolean') {
+function normalizeNode(child, result, currentKey = '', skipIgnoredCheck) {
+    if (!skipIgnoredCheck && isIgnoredNode(child)) {
         return;
     }
-    if (typeof child === 'string' || typeof child === 'number' || typeof child === 'bigint') {
-        result.push(createTextElement(child));
+    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);
         return;
     }
-    if (isArray(child)) {
-        for (const nestedChild of child) {
-            normalizeNode(nestedChild, result);
+    if (Array.isArray(child)) {
+        for (let i = 0; i < child.length; i++) {
+            normalizeNode(child[i], result, currentKey + '.' + i, false);
         }
         return;
     }
-    if (typeof child === 'object') {
-        // noinspection SuspiciousTypeOfGuard
-        if (IS_DEVELOPMENT && typeof child.flag !== 'string') {
-            throw new TypeError(`Objects are not valid as a child: ${JSON.stringify(child)}.`);
-        }
-        result.push(child);
+    if (child.key) {
+        currentKey = currentKey.slice(0, -2) + child.key;
     }
+    child.key =
+        currentKey ||
+            // Hack to treat a single child as a one-item list for more consistent reconciliation.
+            '.0';
+    result.push(child);
 }
-export function normalizeRoot(node) {
-    if (isPrimitive(node)) {
+export function normalizeRoot(node, skipIgnoredCheck) {
+    if (!skipIgnoredCheck && isIgnoredNode(node)) {
+        return;
+    }
+    if (isSimpText(node)) {
         return createTextElement(node);
     }
-    if (isArray(node)) {
+    if (!Array.isArray(node)) {
+        return node;
+    }
+    node = normalizeChildren(node, true);
+    if (Array.isArray(node)) {
         return createElement(Fragment, { children: node });
     }
     return node;
 }
+function isIgnoredNode(node) {
+    if (node == null || typeof node === 'boolean' || node === '') {
+        return true;
+    }
+    if (Array.isArray(node)) {
+        return node.length === 0;
+    }
+    if (isSimpText(node)) {
+        return false;
+    }
+    if (node.flag === 'FRAGMENT' || node.flag === 'PROVIDER' || node.flag === 'PORTAL') {
+        return node.children == null;
+    }
+    return false;
+}

package/core/fragment.d.ts

@@ -1,4 +1,4 @@
-import type { SimpNode } from './createElement';
+import type { SimpNode } from './createElement.js';
 export type Fragment = (props: {
     children?: SimpNode;
 }) => SimpNode;

package/core/fragment.js

@@ -1,2 +1 @@
-import { EMPTY_OBJECT } from '../shared';
-export const Fragment = EMPTY_OBJECT;
+export const Fragment = Object.freeze(Object.create(null));

package/core/hostAdapter.d.ts

@@ -1,16 +1,27 @@
-import type { Dict, Maybe, Nullable } from '../shared';
-export type HostReference = never;
-export interface HostAdapter<HostRef = never, HostTextRef = never> {
-    createReference(type: string): HostRef;
+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> {
+    createReference(type: string, namespace?: Maybe<NS>): HostRef;
     createTextReference(text: string): HostTextRef;
-    mountProps(reference: HostRef, props: Dict): void;
-    patchProp(reference: HostRef, propName: string, prevValue: unknown, nextValue: unknown): void;
-    setClassname(reference: HostRef, className: Maybe<string>): void;
-    setTextContent(reference: HostRef, text: string): void;
+    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;
+    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, 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;
+    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 +1,4 @@
-export {};
+export let hostAdapter;
+export function provideHostAdapter(adapter) {
+    hostAdapter = adapter;
+}

package/core/index.d.ts

@@ -1,2 +1,68 @@
-export { type FC, type SimpElement, createElement, type SimpNode, type FunctionComponent } from './createElement';
-export { Fragment } from './fragment';
+import type { SimpText } from '../shared/index.js';
+
+export type ComponentType<P = {}> = FunctionComponent<P>;
+
+export type RefObject<T> = { current: T };
+export type RefCallback<T> = {
+  bivarianceHack(instance: T | null): (() => void | undefined) | void;
+}['bivarianceHack'];
+export type Ref<T> = RefCallback<T> | RefObject<T> | null;
+
+export type Key = string | number | bigint;
+
+export interface Attributes {
+  key?: Key | null | undefined;
+}
+
+export interface RefAttributes<T> extends Attributes {
+  ref?: Ref<T> | undefined;
+}
+
+export interface SimpElement<P = unknown, T extends string | FunctionComponent<P> = string> {
+  type?: T;
+  props?: P;
+  key?: string | null;
+}
+
+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,
+  ...children: SimpNode[]
+): SimpElement<P>;
+declare function createElement<P extends {}>(
+  type: FunctionComponent<P>,
+  props?: (Attributes & P) | null,
+  ...children: SimpNode[]
+): SimpElement<P>;
+
+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 };

package/core/index.js

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

package/core/internal.d.ts

@@ -1,7 +1,11 @@
-export * from './index';
-export * from './createElement';
-export * from './rerender';
-export * from './global';
-export * from './hostAdapter';
-export * from './mounting';
-export * from './patching';
+export * from './context.js';
+export * from './createElement.js';
+export * from './fragment.js';
+export * from './hostAdapter.js';
+export * from './lifecycleEventBus.js';
+export * from './mounting.js';
+export * from './patching.js';
+export * from './portal.js';
+export * from './ref.js';
+export * from './rerender.js';
+export * from './unmounting.js';

package/core/internal.js

@@ -1,7 +1,11 @@
-export * from './index';
-export * from './createElement';
-export * from './rerender';
-export * from './global';
-export * from './hostAdapter';
-export * from './mounting';
-export * from './patching';
+export * from './context.js';
+export * from './createElement.js';
+export * from './fragment.js';
+export * from './hostAdapter.js';
+export * from './lifecycleEventBus.js';
+export * from './mounting.js';
+export * from './patching.js';
+export * from './portal.js';
+export * from './ref.js';
+export * from './rerender.js';
+export * from './unmounting.js';

package/core/lifecycleEventBus.d.ts

@@ -0,0 +1,26 @@
+import { EventBus } from '../shared/index.js';
+import type { SimpElement } from './createElement.js';
+export type LifecycleEvent = {
+    type: 'beforeRender';
+    element: SimpElement;
+    phase: 'mounting' | 'updating';
+} | {
+    type: 'afterRender';
+    phase: 'mounting' | 'updating';
+} | {
+    type: 'mounted';
+    element: SimpElement;
+} | {
+    type: 'updated';
+    element: SimpElement;
+} | {
+    type: 'unmounted';
+    element: SimpElement;
+} | {
+    type: 'errored';
+    element: SimpElement;
+    error: any;
+    phase: 'mounting' | 'updating';
+};
+export type LifecycleEventBus = EventBus<LifecycleEvent>;
+export declare const lifecycleEventBus: EventBus<LifecycleEvent>;

package/core/lifecycleEventBus.js

@@ -0,0 +1,2 @@
+import { EventBus } from '../shared/index.js';
+export const lifecycleEventBus = new EventBus();

package/core/mounting.d.ts

@@ -1,9 +1,13 @@
-import type { Nullable } from '../shared';
-import type { HostReference } from './hostAdapter';
-import type { SimpElement } from './createElement';
-export declare function mount<HostRef = HostReference>(element: SimpElement, parentReference: Nullable<HostRef>, nextReference: Nullable<HostRef>): void;
-export declare function mountTextElement<HostRef = HostReference>(element: SimpElement, parentReference: Nullable<HostRef>, nextReference: Nullable<HostRef>): void;
-export declare function mountHostElement<HostRef = HostReference>(element: SimpElement, parentReference: Nullable<HostRef>, nextReference: Nullable<HostRef>): void;
-export declare function mountFunctionalElement<HostRef = HostReference>(element: SimpElement, parentReference: Nullable<HostRef>, nextReference: Nullable<HostRef>): void;
-export declare function mountFragment<HostRef = HostReference>(element: SimpElement, parentReference: Nullable<HostRef>, nextReference: Nullable<HostRef>): void;
-export declare function mountArrayChildren<HostRef = HostReference>(children: SimpElement[], reference: Nullable<HostRef>, nextReference: Nullable<HostRef>): void;
+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 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;