@simpreact/simpreact 0.0.0-alpha.dd6f145

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/createElement.d.ts

@@ -0,0 +1,24 @@
+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;
+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';
+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;
+}
+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;

package/core/createElement.js

@@ -0,0 +1,144 @@
+import { IS_DEVELOPMENT, isArray, isPrimitive } from '../shared';
+import { Fragment } from './fragment';
+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 || (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 === null || props === void 0 ? void 0 : 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 || (newProps = {}))[propName] = props[propName];
+                }
+            }
+        }
+        if (definedChildren !== undefined) {
+            (newProps || (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 (typeof child === 'string' || typeof child === 'number' || typeof child === 'bigint') {
+        result.push(createTextElement(child));
+        return;
+    }
+    if (isArray(child)) {
+        for (const nestedChild of child) {
+            normalizeNode(nestedChild, result);
+        }
+        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);
+    }
+}
+export function normalizeRoot(node) {
+    if (isPrimitive(node)) {
+        return createTextElement(node);
+    }
+    if (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,2 @@
+import { EMPTY_OBJECT } from '../shared';
+export const Fragment = EMPTY_OBJECT;

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,16 @@
+import type { Dict, Maybe, Nullable } from '../shared';
+export type HostReference = never;
+export interface HostAdapter<HostRef = never, HostTextRef = never> {
+    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, child: 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>;
+}

package/core/hostAdapter.js

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

package/core/index.d.ts

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

package/core/index.js

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

package/core/internal.d.ts

@@ -0,0 +1,7 @@
+export * from './index';
+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,7 @@
+export * from './index';
+export * from './createElement';
+export * from './rerender';
+export * from './global';
+export * from './hostAdapter';
+export * from './mounting';
+export * from './patching';

package/core/jsx-runtime.d.ts

@@ -0,0 +1,2 @@
+export { createElement as jsx, createElement as jsxs, createElement as jsxDEV } from './createElement';
+export { Fragment } from './fragment';

package/core/jsx-runtime.js

@@ -0,0 +1,2 @@
+export { createElement as jsx, createElement as jsxs, createElement as jsxDEV } from './createElement';
+export { Fragment } from './fragment';

package/core/mounting.d.ts

@@ -0,0 +1,9 @@
+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;

package/core/mounting.js

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

package/core/patching.d.ts

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

package/core/patching.js

@@ -0,0 +1,271 @@
+import { normalizeRoot } from './createElement';
+import { EMPTY_OBJECT, isArray, isPrimitive } from '../shared';
+import { clearElementHostReference, remove, removeAllChildren, unmount, unmountAllChildren } from './unmounting';
+import { mount, mountArrayChildren } from './mounting';
+import { GLOBAL } from './global';
+export function patch(prevElement, nextElement, parentReference, nextReference) {
+    if (prevElement.type !== nextElement.type || prevElement.key !== nextElement.key) {
+        replaceWithNewElement(prevElement, nextElement, parentReference);
+    }
+    else if (nextElement.flag === 'HOST') {
+        patchElement(prevElement, nextElement);
+    }
+    else if (nextElement.flag === 'FC') {
+        if (prevElement.store != null) {
+            nextElement.store = prevElement.store;
+        }
+        patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference);
+    }
+    else if (nextElement.flag === 'TEXT') {
+        patchText(prevElement, nextElement);
+    }
+    else {
+        patchFragment(prevElement, nextElement, parentReference);
+    }
+}
+function replaceWithNewElement(prevElement, nextElement, parentReference) {
+    unmount(prevElement);
+    if (nextElement.flag === 'HOST' && prevElement.flag === 'HOST') {
+        mount(nextElement, null, null);
+        GLOBAL.hostAdapter.replaceChild(parentReference, nextElement.reference, prevElement.reference);
+    }
+    else {
+        mount(nextElement, parentReference, findHostReferenceFromElement(prevElement, true));
+        clearElementHostReference(prevElement, parentReference);
+    }
+}
+export function findHostReferenceFromElement(element, startEdge) {
+    let flag;
+    let temp = element;
+    while (temp != null) {
+        flag = temp.flag;
+        if (flag === 'HOST' || flag === 'TEXT') {
+            return temp.reference;
+        }
+        temp = findChildElement(temp, startEdge);
+    }
+    return null;
+}
+function findChildElement(element, startEdge) {
+    const children = element.children;
+    if (isArray(children)) {
+        return children[startEdge ? 0 : children.length - 1];
+    }
+    return children;
+}
+function patchElement(prevElement, nextElement) {
+    const hostReference = (nextElement.reference = prevElement.reference);
+    const prevProps = prevElement.props;
+    const nextProps = nextElement.props;
+    for (const propName in nextProps) {
+        const prevValue = prevProps[propName];
+        const nextValue = nextProps[propName];
+        if (prevValue !== nextValue) {
+            GLOBAL.hostAdapter.patchProp(hostReference, propName, prevValue, nextValue);
+        }
+    }
+    for (const propName in prevProps) {
+        if (nextProps[propName] == null && prevProps[propName] != null) {
+            GLOBAL.hostAdapter.patchProp(hostReference, propName, prevProps[propName], null);
+        }
+    }
+    const prevChildren = prevElement.children;
+    const nextChildren = nextElement.children;
+    const nextClassName = nextElement.className;
+    if (prevElement.className !== nextClassName) {
+        GLOBAL.hostAdapter.setClassname(hostReference, nextClassName);
+    }
+    patchChildren(prevChildren, nextChildren, hostReference, null, prevElement);
+}
+function patchChildren(prevChildren, nextChildren, parentReference, nextReference, parentElement) {
+    if (isArray(prevChildren)) {
+        if (isArray(nextChildren)) {
+            const prevChildrenLength = prevChildren.length;
+            const nextChildrenLength = nextChildren.length;
+            if (prevChildrenLength === 0) {
+                if (nextChildrenLength > 0) {
+                    mountArrayChildren(nextChildren, parentReference, nextReference);
+                }
+            }
+            else if (nextChildrenLength === 0) {
+                removeAllChildren(parentReference, parentElement, prevChildren);
+            }
+            else {
+                patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference);
+            }
+        }
+        else if (isPrimitive(nextChildren)) {
+            unmountAllChildren(prevChildren);
+            GLOBAL.hostAdapter.setTextContent(parentReference, (nextChildren || ''));
+        }
+        else {
+            removeAllChildren(parentReference, parentElement, prevChildren);
+            mount(nextChildren, parentReference, nextReference);
+        }
+    }
+    else if (isPrimitive(prevChildren)) {
+        if (isArray(nextChildren)) {
+            GLOBAL.hostAdapter.setTextContent(parentReference, '');
+            mountArrayChildren(nextChildren, parentReference, nextReference);
+        }
+        else if (isPrimitive(nextChildren)) {
+            patchSingleTextChild(prevChildren, nextChildren, parentReference);
+        }
+        else {
+            GLOBAL.hostAdapter.setTextContent(parentReference, '');
+            mount(nextChildren, parentReference, nextReference);
+        }
+    }
+    else {
+        if (isArray(nextChildren)) {
+            replaceOneElementWithMultipleElements(prevChildren, nextChildren, parentReference);
+        }
+        else if (isPrimitive(nextChildren)) {
+            unmount(prevChildren);
+            GLOBAL.hostAdapter.setTextContent(parentReference, nextChildren);
+        }
+        else {
+            patch(prevChildren, nextChildren, parentReference, nextReference);
+        }
+    }
+}
+function replaceOneElementWithMultipleElements(prevChildren, nextChildren, parentReference) {
+    unmount(prevChildren);
+    mountArrayChildren(nextChildren, parentReference, findHostReferenceFromElement(prevChildren, true));
+    clearElementHostReference(prevChildren, parentReference);
+}
+function patchSingleTextChild(prevChildren, nextChildren, parentReference) {
+    if (prevChildren !== nextChildren) {
+        GLOBAL.hostAdapter.setTextContent(parentReference, nextChildren);
+    }
+}
+// export function patchNonKeyedChildren(
+//   prevChildren: SimpElement[],
+//   nextChildren: SimpElement[],
+//   parentReference: HostReference,
+//   prevChildrenLength: number,
+//   nextChildrenLength: number,
+//   nextReference: Nullable<HostReference>
+// ): void {
+//   const commonLength = prevChildrenLength > nextChildrenLength ? nextChildrenLength : prevChildrenLength;
+//   let i = 0;
+//   let prevChild;
+//   let nextChild;
+//
+//   for (; i < commonLength; ++i) {
+//     nextChild = nextChildren[i];
+//     prevChild = prevChildren[i];
+//
+//     patch(prevChild as SimpElement, nextChild as SimpElement, parentReference, nextReference);
+//     prevChildren[i] = nextChild!;
+//   }
+//   if (prevChildrenLength < nextChildrenLength) {
+//     for (i = commonLength; i < nextChildrenLength; ++i) {
+//       nextChild = nextChildren[i];
+//       mount(nextChild as SimpElement, parentReference, nextReference);
+//     }
+//   } else if (prevChildrenLength > nextChildrenLength) {
+//     for (i = commonLength; i < prevChildrenLength; ++i) {
+//       remove(prevChildren[i] as SimpElement, parentReference);
+//     }
+//   }
+// }
+function patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference) {
+    const prevChildren = prevElement.children;
+    const type = nextElement.type;
+    GLOBAL.eventBus.publish({ type: 'beforeRender', element: nextElement });
+    const nextChildren = normalizeRoot(type(nextElement.props || EMPTY_OBJECT));
+    GLOBAL.eventBus.publish({ type: 'afterRender' });
+    patch(prevChildren, nextChildren, parentReference, nextReference);
+    GLOBAL.eventBus.publish({ type: 'mounted', element: nextElement });
+    nextElement.children = nextChildren;
+}
+function patchText(prevElement, nextElement) {
+    const nextText = nextElement.children;
+    const reference = (nextElement.reference = prevElement.reference);
+    if (nextText !== prevElement.children) {
+        GLOBAL.hostAdapter.setTextContent(reference, nextText);
+    }
+}
+function patchFragment(prevElement, nextElement, parentReference) {
+    patchChildren(prevElement.children, nextElement.children, parentReference, null, prevElement);
+}
+export function updateFunctionalComponent(element, parentReference, nextReference) {
+    patch(element, element, parentReference, nextReference);
+}
+export function patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference) {
+    var _a, _b, _c;
+    let prevStart = 0;
+    let nextStart = 0;
+    let prevEnd = prevChildren.length - 1;
+    let nextEnd = nextChildren.length - 1;
+    // Step 1: Sync from start
+    while (prevStart <= prevEnd &&
+        nextStart <= nextEnd &&
+        prevChildren[prevStart].key === nextChildren[nextStart].key) {
+        patch(prevChildren[prevStart], nextChildren[nextStart], parentReference, null);
+        prevStart++;
+        nextStart++;
+    }
+    // Step 2: Sync from end
+    while (prevStart <= prevEnd && nextStart <= nextEnd && prevChildren[prevEnd].key === nextChildren[nextEnd].key) {
+        patch(prevChildren[prevEnd], nextChildren[nextEnd], parentReference, null);
+        prevEnd--;
+        nextEnd--;
+    }
+    // Step 3: Mount new nodes if prev list is exhausted
+    if (prevStart > prevEnd) {
+        const before = ((_a = nextChildren[nextEnd + 1]) === null || _a === void 0 ? void 0 : _a.reference) || nextReference;
+        for (let i = nextStart; i <= nextEnd; i++) {
+            mount(nextChildren[i], parentReference, before);
+        }
+        // Step 4: Remove prev nodes if next list is exhausted
+    }
+    else if (nextStart > nextEnd) {
+        for (let i = prevStart; i <= prevEnd; i++) {
+            remove(prevChildren[i], parentReference);
+        }
+    }
+    // Step 5: Full diff with keyed lookup and movement
+    else {
+        // Create map of keys to indices for prev children
+        const keyToPrevIndexMap = new Map();
+        for (let i = prevStart; i <= prevEnd; i++) {
+            const key = prevChildren[i].key;
+            if (key != null)
+                keyToPrevIndexMap.set(key, i);
+        }
+        // Track reused indices and move plan
+        const toMove = new Array(nextEnd - nextStart + 1);
+        const usedIndices = new Set();
+        // Match and patch/mount
+        for (let i = nextStart; i <= nextEnd; i++) {
+            const nextChild = nextChildren[i];
+            const prevIndex = keyToPrevIndexMap.get(nextChild.key);
+            if (prevIndex != null) {
+                const prevElement = prevChildren[prevIndex];
+                patch(prevElement, nextChild, parentReference, null);
+                toMove[i - nextStart] = prevIndex;
+                usedIndices.add(prevIndex);
+            }
+            else {
+                mount(nextChild, parentReference, ((_b = nextChildren[i + 1]) === null || _b === void 0 ? void 0 : _b.reference) || nextReference);
+                toMove[i - nextStart] = -1;
+            }
+        }
+        // Remove nodes not matched
+        for (let i = prevStart; i <= prevEnd; i++) {
+            if (!usedIndices.has(i)) {
+                remove(prevChildren[i], parentReference);
+            }
+        }
+        // Insert in correct order
+        for (let i = nextEnd; i >= nextStart; i--) {
+            const currentChild = nextChildren[i];
+            const reference = ((_c = nextChildren[i + 1]) === null || _c === void 0 ? void 0 : _c.reference) || nextReference;
+            if (toMove[i - nextStart] !== -1) {
+                GLOBAL.hostAdapter.insertBefore(parentReference, currentChild.reference, reference);
+            }
+        }
+    }
+}

package/core/rerender.d.ts

@@ -0,0 +1,2 @@
+import type { SimpElement } from './createElement';
+export declare function rerender(element: SimpElement): void;

package/core/rerender.js

@@ -0,0 +1,5 @@
+import { findHostReferenceFromElement, updateFunctionalComponent } from './patching';
+import { GLOBAL } from './global';
+export function rerender(element) {
+    updateFunctionalComponent(element, GLOBAL.hostAdapter.findParentReference(findHostReferenceFromElement(element, true)), null);
+}

package/core/unmounting.d.ts

@@ -0,0 +1,8 @@
+import type { SimpElement } from './createElement';
+import type { Maybe } from '../shared';
+import type { HostReference } from './hostAdapter';
+export declare function unmount(element: SimpElement): void;
+export declare function unmountAllChildren(children: SimpElement[]): void;
+export declare function clearElementHostReference<HostRef = HostReference>(element: Maybe<SimpElement>, parentHostReference: HostRef): void;
+export declare function removeAllChildren<HostRef = HostReference>(hostReference: HostRef, element: SimpElement, children: SimpElement[]): void;
+export declare function remove<HostRef = HostReference>(element: SimpElement, parentReference: HostRef): void;

package/core/unmounting.js

@@ -0,0 +1,70 @@
+import { isArray } from '../shared';
+import { GLOBAL } from './global';
+export function unmount(element) {
+    if (element.flag === 'HOST') {
+        if (isArray(element.children)) {
+            for (const child of element.children) {
+                unmount(child);
+            }
+        }
+        else if (element.children != null) {
+            unmount(element.children);
+        }
+    }
+    else if (element.flag === 'FC') {
+        unmount(element.children);
+        GLOBAL.eventBus.publish({ type: 'unmounted', element });
+    }
+    else if (element.flag === 'FRAGMENT') {
+        if (isArray(element.children)) {
+            for (const child of element.children) {
+                unmount(child);
+            }
+        }
+        else if (element.children != null) {
+            unmount(element.children);
+        }
+    }
+}
+export function unmountAllChildren(children) {
+    for (const child of children) {
+        unmount(child);
+    }
+}
+export function clearElementHostReference(element, parentHostReference) {
+    while (element != null) {
+        if (element.flag === 'HOST' || element.flag === 'TEXT') {
+            GLOBAL.hostAdapter.removeChild(parentHostReference, element.reference);
+            return;
+        }
+        const children = element.children;
+        if (element.flag === 'FC') {
+            element = children;
+            continue;
+        }
+        if (element.flag === 'FRAGMENT') {
+            if (isArray(children)) {
+                for (let i = 0, len = children.length; i < len; ++i) {
+                    clearElementHostReference(children[i], parentHostReference);
+                }
+                return;
+            }
+            else if (children != null) {
+                element = children;
+            }
+        }
+    }
+}
+export function removeAllChildren(hostReference, element, children) {
+    unmountAllChildren(children);
+    if (element.flag === 'FRAGMENT') {
+        clearElementHostReference(element, hostReference);
+    }
+    else {
+        GLOBAL.hostAdapter.setTextContent(hostReference, '');
+    }
+}
+export function remove(element, parentReference) {
+    unmount(element);
+    clearElementHostReference(element, parentReference);
+}

package/dom/domAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { HostAdapter } from '../core/internal';
+export declare const domAdapter: HostAdapter<HTMLElement, Text>;

package/dom/domAdapter.js

@@ -0,0 +1,156 @@
+export const domAdapter = {
+    createReference(type) {
+        return document.createElement(type);
+    },
+    createTextReference(text) {
+        return document.createTextNode(text);
+    },
+    mountProps(reference, props) {
+        mountProps(props, reference);
+    },
+    patchProp(reference, propName, prevValue, nextValue) {
+        patchProp(propName, prevValue, nextValue, reference);
+    },
+    setClassname(reference, className) {
+        if (!className) {
+            reference.removeAttribute('class');
+        }
+        else {
+            reference.className = className;
+        }
+    },
+    setTextContent(reference, text) {
+        reference.textContent = text;
+    },
+    appendChild(parent, child) {
+        parent.appendChild(child);
+    },
+    insertBefore(parent, child, before) {
+        parent.insertBefore(child, before);
+    },
+    insertOrAppend(parent, child, before) {
+        if (before) {
+            domAdapter.insertBefore(parent, child, before);
+        }
+        else {
+            domAdapter.appendChild(parent, child);
+        }
+    },
+    removeChild(parent, child) {
+        parent.removeChild(child);
+    },
+    replaceChild(parent, replacer, child) {
+        parent.replaceChild(child, replacer);
+    },
+    findParentReference(reference) {
+        return reference.parentElement;
+    },
+};
+function mountProps(props, reference) {
+    for (const propsKey in props) {
+        patchProp(propsKey, null, props[propsKey], reference);
+    }
+}
+function patchProp(propName, prevValue, nextValue, dom) {
+    switch (propName) {
+        case 'children':
+        case 'childrenType':
+        case 'className':
+        case 'defaultValue':
+        case 'key':
+        case 'multiple':
+        case 'ref':
+        case 'selectedIndex':
+            break;
+        case 'autoFocus':
+            dom.autofocus = !!nextValue;
+            break;
+        case 'allowfullscreen':
+        case 'autoplay':
+        case 'capture':
+        case 'checked':
+        case 'controls':
+        case 'default':
+        case 'disabled':
+        case 'hidden':
+        case 'indeterminate':
+        case 'loop':
+        case 'muted':
+        case 'novalidate':
+        case 'open':
+        case 'readOnly':
+        case 'required':
+        case 'reversed':
+        case 'scoped':
+        case 'seamless':
+        case 'selected':
+            dom[propName] = !!nextValue;
+            break;
+        case 'defaultChecked':
+        case 'value':
+        case 'volume':
+            patchDomProp(nextValue, dom, propName);
+            break;
+        case 'style':
+            patchStyle(prevValue, nextValue, dom);
+            break;
+        default:
+            if (propName.charCodeAt(0) === 111 && propName.charCodeAt(1) === 110) {
+                patchEvent(propName, prevValue, nextValue, dom);
+            }
+            else if (nextValue == null) {
+                dom.removeAttribute(propName);
+            }
+            else {
+                dom.setAttribute(propName, nextValue);
+            }
+            break;
+    }
+}
+function patchDomProp(nextValue, dom, propKey) {
+    const value = nextValue == null ? '' : nextValue;
+    if (dom[propKey] !== value) {
+        dom[propKey] = value;
+    }
+}
+function patchStyle(lastAttrValue, nextAttrValue, dom) {
+    if (nextAttrValue == null) {
+        dom.removeAttribute('style');
+        return;
+    }
+    const domStyle = dom.style;
+    let style;
+    let value;
+    if (typeof nextAttrValue === 'string') {
+        domStyle.cssText = nextAttrValue;
+        return;
+    }
+    if (lastAttrValue != null && typeof lastAttrValue !== 'string') {
+        for (style in nextAttrValue) {
+            value = nextAttrValue[style];
+            if (value !== lastAttrValue[style]) {
+                domStyle.setProperty(style, value);
+            }
+        }
+        for (style in lastAttrValue) {
+            if (nextAttrValue[style] == null) {
+                domStyle.removeProperty(style);
+            }
+        }
+    }
+    else {
+        for (style in nextAttrValue) {
+            value = nextAttrValue[style];
+            domStyle.setProperty(style, value);
+        }
+    }
+}
+function patchEvent(name, lastValue, nextValue, dom) {
+    name = name.toLowerCase().substring(2);
+    if (typeof lastValue === 'function') {
+        dom.removeEventListener(name, lastValue);
+    }
+    if (typeof nextValue === 'function') {
+        dom.addEventListener(name, nextValue);
+    }
+}

package/dom/index.d.ts

@@ -0,0 +1 @@
+export { createRoot, render } from './render';

package/dom/index.js

@@ -0,0 +1 @@
+export { createRoot, render } from './render';

package/dom/render.d.ts

@@ -0,0 +1,9 @@
+import { type SimpElement } from '../core/internal';
+import type { Nullable } from '../shared';
+export declare function render(element: SimpElement, parentReference: Nullable<HTMLElement>): void;
+interface SimpRoot {
+    render(element: SimpElement): void;
+    unmount(): void;
+}
+export declare function createRoot(container: HTMLElement): SimpRoot;
+export {};

package/dom/render.js

@@ -0,0 +1,27 @@
+import { GLOBAL, mount, patch } from '../core/internal';
+import { domAdapter } from './domAdapter';
+GLOBAL.hostAdapter = domAdapter;
+export function render(element, parentReference) {
+    mount(element, parentReference, null);
+}
+export function createRoot(container) {
+    let currentRoot = null;
+    return {
+        render(element) {
+            if (currentRoot) {
+                patch(currentRoot, element, container, null);
+            }
+            else {
+                mount(element, container, null);
+            }
+            currentRoot = element;
+        },
+        unmount() {
+            // if (currentRoot != null) {
+            //   enqueueRender(currentRoot, null);
+            //   currentRoot = null;
+            // }
+            currentRoot = null;
+        },
+    };
+}

package/hooks/index.d.ts

@@ -0,0 +1,10 @@
+import type { VoidFunction } from '../shared';
+type Cleanup = VoidFunction;
+type Effect = () => void | Cleanup;
+type DependencyList = readonly unknown[];
+export declare function useRef<T>(initialValue: T): {
+    current: T;
+};
+export declare function useRerender(): VoidFunction;
+export declare function useEffect(effect: Effect, deps?: DependencyList): void;
+export {};

package/hooks/index.js

@@ -0,0 +1,68 @@
+import { GLOBAL, rerender } from '../core/internal';
+let currentIndex = 0;
+let currentElement = null;
+GLOBAL.eventBus.subscribe(event => {
+    if (event.type === 'beforeRender') {
+        currentElement = event.element;
+        currentElement.store || (currentElement.store = { hookStates: [], mountEffects: [] });
+        currentElement.store.mountEffects = [];
+    }
+    if (event.type === 'afterRender') {
+        currentElement = null;
+        currentIndex = 0;
+    }
+    if (event.type === 'mounted') {
+        for (const state of event.element.store.mountEffects) {
+            if (typeof state.cleanup === 'function') {
+                state.cleanup();
+            }
+            state.cleanup = state.effect() || undefined;
+        }
+    }
+    if (event.type === 'unmounted') {
+        for (const state of event.element.store.hookStates) {
+            if (state && 'cleanup' in state && typeof state.cleanup === 'function') {
+                state.cleanup();
+            }
+        }
+    }
+});
+export function useRef(initialValue) {
+    var _a, _b;
+    return ((_a = currentElement.store.hookStates)[_b = currentIndex++] || (_a[_b] = { current: initialValue }));
+}
+export function useRerender() {
+    var _a, _b;
+    const state = ((_a = currentElement.store.hookStates)[_b = currentIndex++] || (_a[_b] = {
+        element: null,
+        fn() {
+            rerender(state.element);
+        },
+    }));
+    state.element = currentElement;
+    return state.fn;
+}
+export function useEffect(effect, deps) {
+    var _a, _b;
+    const state = ((_a = currentElement.store.hookStates)[_b = currentIndex++] || (_a[_b] = {
+        effect,
+        deps: undefined,
+        cleanup: undefined,
+    }));
+    if (!areDepsEqual(deps, state.deps)) {
+        state.effect = effect;
+        state.deps = deps;
+        currentElement.store.mountEffects.push(state);
+    }
+}
+function areDepsEqual(nextDeps, prevDeps) {
+    if (nextDeps == null || prevDeps == null || nextDeps.length !== prevDeps.length) {
+        return false;
+    }
+    for (let i = 0; i < prevDeps.length; i++) {
+        if (!Object.is(nextDeps[i], prevDeps[i])) {
+            return false;
+        }
+    }
+    return true;
+}

package/jsx-runtime/index.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionComponent, SimpElement } from '../core';
+import { Fragment } from '../core';
+import type { Maybe } from '../shared';
+import type { Key, Props } from '../core/createElement';
+export declare function jsx(type: string | FunctionComponent<any>, props?: Maybe<Props>, key?: Maybe<Key>): SimpElement;
+export { jsx as jsxs, jsx as jsxDEV };
+export { Fragment };

package/jsx-runtime/index.js

@@ -0,0 +1,16 @@
+import { createElement, Fragment } from '../core';
+export function jsx(type, props, key) {
+    let _key;
+    if (key != null) {
+        _key = key;
+    }
+    if (props && props.key != null) {
+        _key = props.key;
+    }
+    if (_key != null) {
+        (props || (props = {})).key = _key;
+    }
+    return createElement(type, props);
+}
+export { jsx as jsxs, jsx as jsxDEV };
+export { Fragment };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@simpreact/simpreact",
+  "version": "0.0.0-alpha.dd6f145",
+  "description": "",
+  "homepage": "https://github.com/dPaskhin/simpreact#readme",
+  "main": "./core/index.js",
+  "module": "./core/index.js",
+  "types": "./core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./core/index.d.ts",
+      "import": "./core/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./jsx-runtime/index.d.ts",
+      "import": "./jsx-runtime/index.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./jsx-runtime/index.d.ts",
+      "import": "./jsx-runtime/index.js"
+    },
+    "./hooks": {
+      "types": "./hooks/index.d.ts",
+      "import": "./hooks/index.js"
+    },
+    "./dom": {
+      "types": "./dom/index.d.ts",
+      "import": "./dom/index.js"
+    },
+    "./shared": {
+      "types": "./shared/index.d.ts",
+      "import": "./shared/index.js"
+    }
+  },
+  "bugs": {
+    "url": "https://github.com/dPaskhin/simpreact/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dPaskhin/simpreact.git"
+  },
+  "type": "module",
+  "license": "MIT",
+  "author": "Dmitrii Paskhin <d.pasxin@gmail.com>"
+}

package/shared/EventBus.d.ts

@@ -0,0 +1,18 @@
+type Subscriber<Event> = (event: Event) => boolean | void;
+export declare class EventBus<Event = void> {
+    private _subscribers;
+    /**
+     * Synchronously invokes subscribers and passes the event.
+     *
+     * @param event The event to publish.
+     */
+    publish(event: Event): void;
+    /**
+     * Adds a subscriber to the event bus. Subscriber would receive all events published via {@link EventBus.publish}.
+     *
+     * @param subscriber The subscriber callback.
+     * @returns The callback that unsubscribes the subscriber from the event bus.
+     */
+    subscribe(subscriber: Subscriber<Event>): () => void;
+}
+export {};

package/shared/EventBus.js

@@ -0,0 +1,30 @@
+export class EventBus {
+    constructor() {
+        this._subscribers = [];
+    }
+    /**
+     * Synchronously invokes subscribers and passes the event.
+     *
+     * @param event The event to publish.
+     */
+    publish(event) {
+        for (const subscriber of this._subscribers) {
+            subscriber(event);
+        }
+    }
+    /**
+     * Adds a subscriber to the event bus. Subscriber would receive all events published via {@link EventBus.publish}.
+     *
+     * @param subscriber The subscriber callback.
+     * @returns The callback that unsubscribes the subscriber from the event bus.
+     */
+    subscribe(subscriber) {
+        const subscribers = this._subscribers;
+        if (subscribers.indexOf(subscriber) === -1) {
+            subscribers.push(subscriber);
+        }
+        return () => {
+            subscribers.splice(subscribers.indexOf(subscriber), 1);
+        };
+    }
+}

package/shared/index.d.ts

@@ -0,0 +1,4 @@
+export * from './EventBus';
+export * from './lang';
+export * from './types';
+export * from './utils';

package/shared/index.js

@@ -0,0 +1,4 @@
+export * from './EventBus';
+export * from './lang';
+export * from './types';
+export * from './utils';

package/shared/lang.d.ts

@@ -0,0 +1,4 @@
+export declare const EMPTY_OBJECT: Readonly<{}>;
+export declare const EMPTY_ARRAY: readonly never[];
+export declare const EMPTY_MAP: Map<any, any>;
+export declare const isArray: (arg: any) => arg is any[];

package/shared/lang.js

@@ -0,0 +1,4 @@
+export const EMPTY_OBJECT = Object.freeze({});
+export const EMPTY_ARRAY = Object.freeze([]);
+export const EMPTY_MAP = new Map();
+export const isArray = Array.isArray;

package/shared/types.d.ts

@@ -0,0 +1,8 @@
+export type Nullable<T> = T | null;
+export type Maybe<T> = Nullable<T> | undefined;
+export type Many<T> = T[] | T;
+export type Dict<T = any> = Record<string, T>;
+export type Primitive = string | number | boolean | bigint | undefined | null;
+export interface VoidFunction {
+    (): void;
+}

package/shared/types.js

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

package/shared/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Primitive } from './types';
+export declare const IS_DEVELOPMENT: boolean;
+export declare function isPrimitive(value: unknown): value is Primitive;

package/shared/utils.js

@@ -0,0 +1,8 @@
+export const IS_DEVELOPMENT = process.env.NODE_ENV !== 'production';
+export function isPrimitive(value) {
+    return (value == null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'bigint' ||
+        typeof value === 'boolean');
+}