@simpreact/simpreact 0.0.0-alpha.1f6ee65

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dmitrii Paskhin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# simpreact

package/core/context.d.ts

@@ -0,0 +1,18 @@
+import type { SimpNode } from './createElement';
+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

@@ -0,0 +1,26 @@
+import type { Many, Maybe, Primitive } from '../shared';
+import type { HostReference } from './hostAdapter';
+import type { SimpContextMap } from './context';
+export type SimpNode = SimpElement | string | number | bigint | Array<SimpNode> | boolean | null | undefined;
+export type Props = any;
+export type Key = string | number | bigint;
+export interface FunctionComponent<P = Props> {
+    (props: P): SimpNode;
+}
+export type FC<P = Props> = FunctionComponent<P>;
+export type SimpElementFlag = 'FC' | 'HOST' | 'TEXT' | 'FRAGMENT' | 'PROVIDER' | 'CONSUMER';
+export interface SimpElement<T = Props> {
+    flag: SimpElementFlag;
+    key?: Maybe<Key>;
+    type?: Maybe<string | FunctionComponent<T>>;
+    props?: Maybe<T>;
+    children?: Maybe<SimpNode>;
+    className?: Maybe<string>;
+    reference?: Maybe<HostReference>;
+    store?: unknown;
+    contextMap?: Maybe<SimpContextMap>;
+}
+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 | undefined;

package/core/createElement.js

@@ -0,0 +1,166 @@
+import { isPrimitive } from '../shared';
+import { Fragment } from './fragment';
+import { isConsumer, isProvider } from './context';
+export function createElement(type, props, ...children) {
+    let newProps;
+    let className;
+    let key;
+    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]);
+        }
+    }
+    if (typeof type === 'string') {
+        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 {
+                    (newProps ||= {})[propName] = props[propName];
+                }
+            }
+        }
+        const element = {
+            flag: 'HOST',
+            type,
+        };
+        if (className) {
+            element.className = className;
+        }
+        if (key) {
+            element.key = key;
+        }
+        if ((definedChildren = normalizeChildren(definedChildren))) {
+            element.children = definedChildren;
+        }
+        if (newProps) {
+            element.props = newProps;
+        }
+        return element;
+    }
+    else if (type === Fragment) {
+        const element = {
+            flag: 'FRAGMENT',
+        };
+        element.children = normalizeChildren(definedChildren || (props != null ? props.children : null));
+        if (props != null && props.key) {
+            element.key = props?.key;
+        }
+        return element;
+    }
+    else if (isProvider(type)) {
+        const element = { flag: 'PROVIDER', type, props: { value: props.value } };
+        element.children = normalizeChildren(definedChildren || props.children);
+        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) },
+        };
+        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];
+                }
+            }
+        }
+        if (definedChildren !== undefined) {
+            (newProps ||= {})['children'] = definedChildren;
+        }
+        const element = {
+            flag: 'FC',
+            type,
+        };
+        if (key) {
+            element.key = key;
+        }
+        if (newProps != null) {
+            element.props = newProps;
+        }
+        return element;
+    }
+}
+export function createTextElement(text) {
+    return {
+        flag: 'TEXT',
+        children: text == null || text === true || text === false ? '' : text,
+    };
+}
+export function normalizeChildren(children) {
+    if (children == null || typeof children === 'boolean') {
+        return;
+    }
+    const result = [];
+    normalizeNode(children, result);
+    if (result.length === 0) {
+        return;
+    }
+    return result.length === 1 ? result[0] : result;
+}
+function normalizeNode(child, result) {
+    if (child == null || typeof child === 'boolean') {
+        return;
+    }
+    if (isPrimitive(child)) {
+        result.push(createTextElement(child));
+        return;
+    }
+    if (Array.isArray(child)) {
+        for (const nestedChild of child) {
+            normalizeNode(nestedChild, result);
+        }
+        return;
+    }
+    if (typeof child === 'object') {
+        if (typeof child.flag !== 'string') {
+            throw new TypeError(`Objects are not valid as a child: ${JSON.stringify(child)}.`);
+        }
+        result.push(child);
+    }
+}
+export function normalizeRoot(node) {
+    if (node == null || typeof node === 'boolean') {
+        return;
+    }
+    if (isPrimitive(node)) {
+        return createTextElement(node);
+    }
+    if (Array.isArray(node)) {
+        return createElement(Fragment, { children: node });
+    }
+    return node;
+}

package/core/fragment.d.ts

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

package/core/fragment.js

@@ -0,0 +1 @@
+export const Fragment = Object.freeze(Object.create(null));

package/core/global.d.ts

@@ -0,0 +1,21 @@
+import type { HostAdapter } from './hostAdapter';
+import type { SimpElement } from './createElement';
+import { EventBus } from '../shared';
+export type LifecycleEvent = {
+    type: 'beforeRender';
+    element: SimpElement;
+} | {
+    type: 'afterRender';
+} | {
+    type: 'mounted';
+    element: SimpElement;
+} | {
+    type: 'unmounted';
+    element: SimpElement;
+};
+interface Global {
+    hostAdapter: HostAdapter;
+    eventBus: EventBus<LifecycleEvent>;
+}
+export declare const GLOBAL: Global;
+export {};

package/core/global.js

@@ -0,0 +1,5 @@
+import { EventBus } from '../shared';
+export const GLOBAL = {
+    hostAdapter: null,
+    eventBus: new EventBus(),
+};

package/core/hostAdapter.d.ts

@@ -0,0 +1,17 @@
+import type { Dict, Maybe, Nullable } from '../shared';
+export type HostReference = never;
+export interface HostAdapter<HostRef = any, HostTextRef = any> {
+    createReference(type: string): 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;
+    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>;
+    clearNode(reference: HostRef | HostTextRef): void;
+}

package/core/hostAdapter.js

@@ -0,0 +1 @@
+export {};

package/core/index.d.ts

@@ -0,0 +1,3 @@
+export { type FC, type SimpElement, createElement, type SimpNode, type FunctionComponent } from './createElement';
+export { Fragment } from './fragment';
+export { type SimpContext, createContext } from './context';

package/core/index.js

@@ -0,0 +1,3 @@
+export { createElement } from './createElement';
+export { Fragment } from './fragment';
+export { createContext } from './context';

package/core/internal.d.ts

@@ -0,0 +1,8 @@
+export * from './index';
+export * from './context';
+export * from './createElement';
+export * from './rerender';
+export * from './global';
+export * from './hostAdapter';
+export * from './mounting';
+export * from './patching';

package/core/internal.js

@@ -0,0 +1,8 @@
+export * from './index';
+export * from './context';
+export * from './createElement';
+export * from './rerender';
+export * from './global';
+export * from './hostAdapter';
+export * from './mounting';
+export * from './patching';

package/core/mounting.d.ts

@@ -0,0 +1,12 @@
+import type { Nullable } from '../shared';
+import type { HostReference } from './hostAdapter';
+import type { SimpElement } from './createElement';
+import type { SimpContextMap } from './context';
+export declare function mount(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): 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>): void;
+export declare function mountFunctionalElement(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;
+export declare function mountFragment(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;
+export declare function mountArrayChildren(children: SimpElement[], reference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;
+export declare function mountProvider(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;
+export declare function mountConsumer(element: SimpElement, parentReference: Nullable<HostReference>, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;

package/core/mounting.js

@@ -0,0 +1,95 @@
+import { EMPTY_MAP, EMPTY_OBJECT } from '../shared';
+import { GLOBAL } from './global';
+import { normalizeRoot } from './createElement';
+export function mount(element, parentReference, nextReference, contextMap) {
+    if (element.flag === 'TEXT') {
+        mountTextElement(element, parentReference, nextReference);
+    }
+    else if (element.flag === 'HOST') {
+        mountHostElement(element, parentReference, nextReference, contextMap);
+    }
+    else if (element.flag === 'FC') {
+        mountFunctionalElement(element, parentReference, nextReference, contextMap);
+    }
+    else if (element.flag === 'FRAGMENT') {
+        mountFragment(element, parentReference, nextReference, contextMap);
+    }
+    else if (element.flag === 'PROVIDER') {
+        mountProvider(element, parentReference, nextReference, contextMap);
+    }
+    else {
+        mountConsumer(element, parentReference, nextReference, contextMap);
+    }
+}
+export function mountTextElement(element, parentReference, nextReference) {
+    const reference = (element.reference ||= GLOBAL.hostAdapter.createTextReference(element.children));
+    if (parentReference != null) {
+        GLOBAL.hostAdapter.insertOrAppend(parentReference, reference, nextReference);
+    }
+}
+export function mountHostElement(element, parentReference, nextReference, contextMap) {
+    const props = element.props;
+    const className = element.className;
+    const hostReference = (element.reference = GLOBAL.hostAdapter.createReference(element.type));
+    // HOST element always has Maybe<Many<SimpElement>> children due to normalization process.
+    const children = element.children;
+    if (className != null && className !== '') {
+        GLOBAL.hostAdapter.setClassname(hostReference, className);
+    }
+    if (Array.isArray(children)) {
+        mountArrayChildren(children, hostReference, null, contextMap);
+    }
+    else if (children != null) {
+        mount(children, hostReference, null, contextMap);
+    }
+    if (parentReference != null) {
+        GLOBAL.hostAdapter.insertOrAppend(parentReference, hostReference, nextReference);
+    }
+    if (props != null) {
+        GLOBAL.hostAdapter.mountProps(hostReference, props);
+    }
+}
+export function mountFunctionalElement(element, parentReference, nextReference, contextMap) {
+    const type = element.type;
+    let children;
+    element.contextMap = contextMap;
+    GLOBAL.eventBus.publish({ type: 'beforeRender', element });
+    children = normalizeRoot(type(element.props || EMPTY_OBJECT));
+    GLOBAL.eventBus.publish({ type: 'afterRender' });
+    if (children != null) {
+        mount((element.children = children), parentReference, nextReference, contextMap);
+    }
+    GLOBAL.eventBus.publish({ type: 'mounted', element });
+}
+export function mountFragment(element, parentReference, nextReference, contextMap) {
+    // FRAGMENT element always has Maybe<Many<SimpElement>> children due to normalization process.
+    if (Array.isArray(element.children)) {
+        mountArrayChildren(element.children, parentReference, nextReference, contextMap);
+    }
+    else if (element.children != null) {
+        mount(element.children, parentReference, nextReference, contextMap);
+    }
+}
+export function mountArrayChildren(children, reference, nextReference, contextMap) {
+    for (const child of children) {
+        mount(child, reference, nextReference, contextMap);
+    }
+}
+export function mountProvider(element, parentReference, nextReference, contextMap) {
+    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);
+    }
+    else if (element.children != null) {
+        mount(element.children, parentReference, nextReference, contextMap);
+    }
+}
+export function mountConsumer(element, parentReference, nextReference, contextMap) {
+    const children = normalizeRoot(element.type(element.props || EMPTY_OBJECT, contextMap || EMPTY_MAP));
+    if (children == null) {
+        return;
+    }
+    mount((element.children = children), parentReference, nextReference, contextMap);
+}

package/core/patching.d.ts

@@ -0,0 +1,8 @@
+import type { SimpElement } from './createElement';
+import type { Nullable } from '../shared';
+import type { HostReference } from './hostAdapter';
+import type { SimpContextMap } from './context';
+export declare function patch(prevElement: SimpElement, nextElement: SimpElement, parentReference: HostReference, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;
+export declare function findHostReferenceFromElement(element: SimpElement): Nullable<HostReference>;
+export declare function updateFunctionalComponent(element: SimpElement, parentReference: HostReference, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;
+export declare function patchKeyedChildren(prevChildren: SimpElement[], nextChildren: SimpElement[], parentReference: HostReference, nextReference: Nullable<HostReference>, contextMap: Nullable<SimpContextMap>): void;