@simpreact/simpreact 0.0.0-alpha.1f6ee65

package/core/patching.js

@@ -0,0 +1,279 @@
+import { normalizeRoot } from './createElement';
+import { EMPTY_MAP, EMPTY_OBJECT, 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, contextMap) {
+    if (prevElement.type !== nextElement.type || prevElement.key !== nextElement.key) {
+        replaceWithNewElement(prevElement, nextElement, parentReference, contextMap);
+    }
+    else if (nextElement.flag === 'HOST') {
+        patchElement(prevElement, nextElement, contextMap);
+    }
+    else if (nextElement.flag === 'FC') {
+        if (prevElement.store != null) {
+            nextElement.store = prevElement.store;
+        }
+        patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference, contextMap);
+    }
+    else if (nextElement.flag === 'TEXT') {
+        patchText(prevElement, nextElement);
+    }
+    else if (nextElement.flag === 'FRAGMENT') {
+        patchFragment(prevElement, nextElement, parentReference, nextReference, contextMap);
+    }
+    else if (nextElement.flag === 'PROVIDER') {
+        patchProvider(prevElement, nextElement, parentReference, nextReference, contextMap);
+    }
+    else {
+        patchConsumer(prevElement, nextElement, parentReference, nextReference, contextMap);
+    }
+}
+function replaceWithNewElement(prevElement, nextElement, parentReference, contextMap) {
+    unmount(prevElement);
+    if (nextElement.flag === 'HOST' && prevElement.flag === 'HOST') {
+        mount(nextElement, null, null, contextMap);
+        GLOBAL.hostAdapter.replaceChild(parentReference, nextElement.reference, prevElement.reference);
+    }
+    else {
+        mount(nextElement, parentReference, findHostReferenceFromElement(prevElement), contextMap);
+        clearElementHostReference(prevElement, parentReference);
+    }
+}
+export function findHostReferenceFromElement(element) {
+    let flag;
+    let temp = element;
+    while (temp != null) {
+        flag = temp.flag;
+        if (flag === 'HOST' || flag === 'TEXT') {
+            return temp.reference;
+        }
+        temp = (Array.isArray(temp.children) ? temp.children[0] : temp.children);
+    }
+    return null;
+}
+function patchElement(prevElement, nextElement, contextMap) {
+    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);
+        }
+    }
+    if (prevElement.className !== nextElement.className) {
+        GLOBAL.hostAdapter.setClassname(hostReference, nextElement.className);
+    }
+    patchChildren(prevElement.children, nextElement.children, hostReference, null, prevElement, contextMap);
+}
+function patchChildren(prevChildren, nextChildren, parentReference, nextReference, parentElement, contextMap) {
+    if (Array.isArray(prevChildren)) {
+        if (Array.isArray(nextChildren)) {
+            const prevChildrenLength = prevChildren.length;
+            const nextChildrenLength = nextChildren.length;
+            if (prevChildrenLength === 0) {
+                if (nextChildrenLength > 0) {
+                    mountArrayChildren(nextChildren, parentReference, nextReference, contextMap);
+                }
+            }
+            else if (nextChildrenLength === 0) {
+                removeAllChildren(parentReference, parentElement, prevChildren);
+            }
+            else {
+                patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference, contextMap);
+            }
+        }
+        else if (isPrimitive(nextChildren)) {
+            unmountAllChildren(prevChildren);
+            GLOBAL.hostAdapter.setTextContent(parentReference, (nextChildren || ''));
+        }
+        else {
+            removeAllChildren(parentReference, parentElement, prevChildren);
+            mount(nextChildren, parentReference, nextReference, contextMap);
+        }
+    }
+    else if (isPrimitive(prevChildren)) {
+        if (Array.isArray(nextChildren)) {
+            GLOBAL.hostAdapter.clearNode(parentReference);
+            mountArrayChildren(nextChildren, parentReference, nextReference, contextMap);
+        }
+        else if (isPrimitive(nextChildren)) {
+            patchSingleTextChild(prevChildren, nextChildren, parentReference);
+        }
+        else {
+            GLOBAL.hostAdapter.clearNode(parentReference);
+            mount(nextChildren, parentReference, nextReference, contextMap);
+        }
+    }
+    else {
+        if (Array.isArray(nextChildren)) {
+            replaceOneElementWithMultipleElements(prevChildren, nextChildren, parentReference, contextMap);
+        }
+        else if (isPrimitive(nextChildren)) {
+            unmount(prevChildren);
+            GLOBAL.hostAdapter.setTextContent(parentReference, nextChildren);
+        }
+        else {
+            patch(prevChildren, nextChildren, parentReference, nextReference, contextMap);
+        }
+    }
+}
+function replaceOneElementWithMultipleElements(prevChildren, nextChildren, parentReference, contextMap) {
+    unmount(prevChildren);
+    mountArrayChildren(nextChildren, parentReference, findHostReferenceFromElement(prevChildren), contextMap);
+    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, contextMap) {
+    nextElement.contextMap = contextMap;
+    GLOBAL.eventBus.publish({ type: 'beforeRender', element: nextElement });
+    const nextChildren = normalizeRoot(nextElement.type(nextElement.props || EMPTY_OBJECT));
+    GLOBAL.eventBus.publish({ type: 'afterRender' });
+    if (nextChildren != null) {
+        nextElement.children = nextChildren;
+    }
+    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, prevElement, contextMap);
+    GLOBAL.eventBus.publish({ type: 'mounted', element: nextElement });
+}
+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, nextReference, contextMap) {
+    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, prevElement, contextMap);
+}
+function patchProvider(prevElement, nextElement, parentReference, nextReference, contextMap) {
+    contextMap = new Map(contextMap);
+    contextMap.set(nextElement.type.context, nextElement.props.value);
+    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, prevElement, contextMap);
+}
+function patchConsumer(prevElement, nextElement, parentReference, nextReference, contextMap) {
+    const children = normalizeRoot(nextElement.type(nextElement.props || EMPTY_OBJECT, contextMap || EMPTY_MAP));
+    if (children != null) {
+        nextElement.children = children;
+    }
+    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, prevElement, contextMap);
+}
+export function updateFunctionalComponent(element, parentReference, nextReference, contextMap) {
+    patch(element, element, parentReference, nextReference, contextMap);
+}
+export function patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference, contextMap) {
+    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, contextMap);
+        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, contextMap);
+        prevEnd--;
+        nextEnd--;
+    }
+    // Step 3: Mount new nodes if prev list is exhausted
+    if (prevStart > prevEnd) {
+        const before = nextChildren[nextEnd + 1]?.reference || nextReference;
+        for (let i = nextStart; i <= nextEnd; i++) {
+            mount(nextChildren[i], parentReference, before, contextMap);
+        }
+        // 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, contextMap);
+                toMove[i - nextStart] = prevIndex;
+                usedIndices.add(prevIndex);
+            }
+            else {
+                mount(nextChild, parentReference, nextChildren[i + 1]?.reference || nextReference, contextMap);
+                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 = nextChildren[i + 1]?.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)), null, element.contextMap || 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(element: Maybe<SimpElement>, parentHostReference: HostReference): void;
+export declare function removeAllChildren(hostReference: HostReference, element: SimpElement, children: SimpElement[]): void;
+export declare function remove(element: SimpElement, parentReference: HostReference): void;

package/core/unmounting.js

@@ -0,0 +1,65 @@
+import { GLOBAL } from './global';
+export function unmount(element) {
+    if (element.flag === 'FC') {
+        // FC element always has only one root element due to normalization.
+        unmount(element.children);
+        GLOBAL.eventBus.publish({ type: 'unmounted', element });
+        return;
+    }
+    if (element.flag === 'TEXT') {
+        return;
+    }
+    // Only FRAGMENT, PROVIDER, CONSUMER, and HOST elements remain,
+    // with Maybe<Many<SimpElement>> children due to normalization.
+    if (Array.isArray(element.children)) {
+        unmountAllChildren(element.children);
+    }
+    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.flag === 'CONSUMER') {
+            element = children;
+            continue;
+        }
+        if (element.flag === 'FRAGMENT' || element.flag === 'PROVIDER') {
+            if (Array.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' ||
+        element.flag === 'FC' ||
+        element.flag === 'PROVIDER' ||
+        element.flag === 'CONSUMER') {
+        clearElementHostReference(element, hostReference);
+    }
+    else {
+        GLOBAL.hostAdapter.clearNode(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,159 @@
+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, toBeReplaced) {
+        parent.replaceChild(replacer, toBeReplaced);
+    },
+    findParentReference(reference) {
+        return reference.parentElement;
+    },
+    clearNode(reference) {
+        reference.textContent = '';
+    },
+};
+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: Element | DocumentFragment): SimpRoot;
+export {};

package/dom/render.js

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

package/hooks/index.d.ts

@@ -0,0 +1,12 @@
+import type { SimpContext } from '../core';
+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 declare function useContext<T>(context: SimpContext<T>): T;
+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 ||= { 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) {
+    return (currentElement.store.hookStates[currentIndex++] ||= { current: initialValue });
+}
+export function useRerender() {
+    const state = (currentElement.store.hookStates[currentIndex++] ||= {
+        element: null,
+        fn() {
+            rerender(state.element);
+        },
+    });
+    state.element = currentElement;
+    return state.fn;
+}
+export function useEffect(effect, deps) {
+    const state = (currentElement.store.hookStates[currentIndex++] ||= {
+        effect,
+        deps: undefined,
+        cleanup: undefined,
+    });
+    if (!areDepsEqual(deps, state.deps)) {
+        state.effect = effect;
+        state.deps = deps;
+        currentElement.store.mountEffects.push(state);
+    }
+}
+export function useContext(context) {
+    return currentElement.contextMap?.get(context) ?? context.defaultValue;
+}
+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 ||= {}).key = _key;
+    }
+    return createElement(type, props);
+}
+export { jsx as jsxs, jsx as jsxDEV };
+export { Fragment };