@simpreact/simpreact 0.0.1 → 0.0.3

package/compat/core.d.ts

@@ -0,0 +1,46 @@
+import * as SimpReactInternal from '../core/internal.js';
+import { identity } from './utils.js';
+export declare const Children: {
+    map(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
+    forEach(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => void): void;
+    count(children: SimpReactInternal.SimpNode): number;
+    toArray(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
+    only(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpElement;
+};
+export declare function cloneElement(element: SimpReactInternal.SimpElement, props?: any, ...children: SimpReactInternal.SimpNode[]): SimpReactInternal.SimpElement;
+export declare function isValidElement(element: unknown): element is SimpReactInternal.SimpElement;
+export declare function Suspense(props: {
+    fallback: SimpReactInternal.SimpNode;
+    children: SimpReactInternal.SimpNode;
+}): SimpReactInternal.SimpNode;
+export declare function forwardRef<P, T>(Component: (props: P, ref: SimpReactInternal.Ref<T>) => any): (props: P) => any;
+export declare const Fragment: SimpReactInternal.Fragment;
+export declare const createElement: typeof SimpReactInternal.createElement;
+export declare const createContext: typeof SimpReactInternal.createContext;
+export declare const createPortal: typeof SimpReactInternal.createPortal;
+export declare const memo: typeof identity;
+export declare const flushSync: typeof identity;
+export declare class Component {
+    constructor();
+}
+declare const _default: {
+    Children: {
+        map(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
+        forEach(children: SimpReactInternal.SimpNode, fn: (child: SimpReactInternal.SimpNode, index: number) => void): void;
+        count(children: SimpReactInternal.SimpNode): number;
+        toArray(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpNode[];
+        only(children: SimpReactInternal.SimpNode): SimpReactInternal.SimpElement;
+    };
+    cloneElement: typeof cloneElement;
+    isValidElement: typeof isValidElement;
+    Suspense: typeof Suspense;
+    forwardRef: typeof forwardRef;
+    Fragment: SimpReactInternal.Fragment;
+    createElement: typeof SimpReactInternal.createElement;
+    createContext: typeof SimpReactInternal.createContext;
+    createPortal: typeof SimpReactInternal.createPortal;
+    memo: typeof identity;
+    flushSync: typeof identity;
+    Component: typeof Component;
+};
+export default _default;

package/compat/core.js

@@ -0,0 +1,93 @@
+import * as SimpReactInternal from '../core/internal.js';
+import * as SimpReactHooks from '../hooks/index.js';
+import { identity } from './utils.js';
+export const Children = {
+    map(children, fn) {
+        return Children.toArray(children).map(fn);
+    },
+    forEach(children, fn) {
+        Children.toArray(children).forEach(fn);
+    },
+    count(children) {
+        return Children.toArray(children).length;
+    },
+    toArray(children) {
+        const result = [];
+        function traverse(node) {
+            if (node == null || typeof node === 'boolean') {
+                return;
+            }
+            if (Array.isArray(node)) {
+                for (const child of node) {
+                    traverse(child);
+                }
+                return;
+            }
+            result.push(node);
+        }
+        traverse(children);
+        return result;
+    },
+    only(children) {
+        const array = Children.toArray(children);
+        if (array.length !== 1 || !isValidElement(array[0])) {
+            throw new Error('Children.only expected a single SimpElement child.');
+        }
+        return array[0];
+    },
+};
+export function cloneElement(element, props, ...children) {
+    if (!isValidElement(element)) {
+        throw new Error(`cloneElement: expected a SimpElement, got ${element}`);
+    }
+    if (element.flag === 'PORTAL') {
+        throw new Error('cloneElement: the argument must be a SimpElement, but you passed a portal instead.');
+    }
+    return SimpReactInternal.createElement(element.flag === 'FRAGMENT' ? SimpReactInternal.Fragment : element.type, Object.assign({}, element.props, props), arguments.length > 2 ? children : props.children || element.children);
+}
+export function isValidElement(element) {
+    return typeof element === 'object' && element !== null && 'flag' in element;
+}
+export function Suspense(props) {
+    const [isSuspended, setIsSuspended] = SimpReactHooks.useState(false);
+    SimpReactHooks.useCatch(error => {
+        if (isSuspended) {
+            return;
+        }
+        if (error instanceof Promise) {
+            setIsSuspended(true);
+            error.then(() => setIsSuspended(false));
+        }
+    });
+    return isSuspended ? props.fallback : props.children;
+}
+export function forwardRef(Component) {
+    return function Forwarded(props) {
+        return Component(props, props?.ref || null);
+    };
+}
+export const Fragment = SimpReactInternal.Fragment;
+export const createElement = SimpReactInternal.createElement;
+export const createContext = SimpReactInternal.createContext;
+export const createPortal = SimpReactInternal.createPortal;
+export const memo = identity;
+export const flushSync = identity;
+export class Component {
+    constructor() {
+        throw new Error('Not implemented.');
+    }
+}
+export default {
+    Children,
+    cloneElement,
+    isValidElement,
+    Suspense,
+    forwardRef,
+    Fragment,
+    createElement,
+    createContext,
+    createPortal,
+    memo,
+    flushSync,
+    Component,
+};

package/compat/dom.d.ts

@@ -0,0 +1,11 @@
+import * as SimpReactDOM from '../dom/index.js';
+import * as SimpReactShared from '../shared/index.js';
+export declare const hydrate: typeof SimpReactShared.noop;
+export declare const render: typeof SimpReactDOM.render;
+export declare const createRoot: typeof SimpReactDOM.createRoot;
+declare const _default: {
+    hydrate: typeof SimpReactShared.noop;
+    render: typeof SimpReactDOM.render;
+    createRoot: typeof SimpReactDOM.createRoot;
+};
+export default _default;

package/compat/dom.js

@@ -0,0 +1,10 @@
+import * as SimpReactDOM from '../dom/index.js';
+import * as SimpReactShared from '../shared/index.js';
+export const hydrate = SimpReactShared.noop;
+export const render = SimpReactDOM.render;
+export const createRoot = SimpReactDOM.createRoot;
+export default {
+    hydrate,
+    render,
+    createRoot,
+};

package/compat/hooks.d.ts

@@ -0,0 +1,26 @@
+import * as SimpReactHooks from '../hooks/index.js';
+export declare function useSyncExternalStore<T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T): T;
+export declare function useReducer<R extends (state: any, action: any) => any, I>(reducer: R, initializerArg: I, initializer?: (arg: I) => ReturnType<R>): [ReturnType<R>, (action: Parameters<R>[1]) => void];
+export declare function useId(prefix?: string): string;
+export declare function useMemo<T>(factory: () => T, deps: SimpReactHooks.DependencyList): T;
+export declare function useCallback<T>(cb: T, deps: SimpReactHooks.DependencyList): T;
+export declare const useState: typeof SimpReactHooks.useState;
+export declare const useEffect: typeof SimpReactHooks.useEffect;
+export declare const useLayoutEffect: typeof SimpReactHooks.useEffect;
+export declare const useInsertionEffect: typeof SimpReactHooks.useEffect;
+export declare const useRef: typeof SimpReactHooks.useRef;
+export declare const useContext: typeof SimpReactHooks.useContext;
+declare const _default: {
+    useSyncExternalStore: typeof useSyncExternalStore;
+    useReducer: typeof useReducer;
+    useId: typeof useId;
+    useMemo: typeof useMemo;
+    useCallback: typeof useCallback;
+    useState: typeof SimpReactHooks.useState;
+    useEffect: typeof SimpReactHooks.useEffect;
+    useLayoutEffect: typeof SimpReactHooks.useEffect;
+    useInsertionEffect: typeof SimpReactHooks.useEffect;
+    useRef: typeof SimpReactHooks.useRef;
+    useContext: typeof SimpReactHooks.useContext;
+};
+export default _default;

package/compat/hooks.js

@@ -0,0 +1,77 @@
+import * as SimpReactHooks from '../hooks/index.js';
+export function useSyncExternalStore(subscribe, getSnapshot) {
+    const rerender = SimpReactHooks.useRerender();
+    const lastSnapshotRef = SimpReactHooks.useRef(getSnapshot());
+    SimpReactHooks.useEffect(() => {
+        function checkForUpdates() {
+            const nextSnapshot = getSnapshot();
+            if (!Object.is(lastSnapshotRef.current, nextSnapshot)) {
+                lastSnapshotRef.current = nextSnapshot;
+                rerender();
+            }
+        }
+        const unsubscribe = subscribe(checkForUpdates);
+        checkForUpdates();
+        return unsubscribe;
+    }, [subscribe, getSnapshot]);
+    return lastSnapshotRef.current;
+}
+export function useReducer(reducer, initializerArg, initializer) {
+    const rerender = SimpReactHooks.useRerender();
+    const reducerRef = SimpReactHooks.useRef(reducer);
+    reducerRef.current = reducer;
+    const stateRef = SimpReactHooks.useRef([
+        initializer ? initializer(initializerArg) : initializerArg,
+        function dispatch(action) {
+            const newState = reducerRef.current(stateRef.current[0], action);
+            if (Object.is(newState, stateRef.current[0])) {
+                return;
+            }
+            stateRef.current[0] = newState;
+            rerender();
+        },
+    ]);
+    return stateRef.current;
+}
+let globalId = 0;
+export function useId(prefix = 'id') {
+    const idRef = SimpReactHooks.useRef('');
+    if (idRef.current === '') {
+        globalId += 1;
+        idRef.current = `${prefix}-${globalId}`;
+    }
+    return idRef.current;
+}
+export function useMemo(factory, deps) {
+    const ref = SimpReactHooks.useRef({
+        deps: undefined,
+        value: undefined,
+    });
+    if (!SimpReactHooks.areDepsEqual(ref.current.deps, deps)) {
+        ref.current.value = factory();
+        ref.current.deps = deps;
+    }
+    return ref.current.value;
+}
+export function useCallback(cb, deps) {
+    return useMemo(() => cb, deps);
+}
+export const useState = SimpReactHooks.useState;
+export const useEffect = SimpReactHooks.useEffect;
+export const useLayoutEffect = SimpReactHooks.useEffect;
+export const useInsertionEffect = SimpReactHooks.useEffect;
+export const useRef = SimpReactHooks.useRef;
+export const useContext = SimpReactHooks.useContext;
+export default {
+    useSyncExternalStore,
+    useReducer,
+    useId,
+    useMemo,
+    useCallback,
+    useState,
+    useEffect,
+    useLayoutEffect,
+    useInsertionEffect,
+    useRef,
+    useContext,
+};

package/compat/index.d.ts

@@ -0,0 +1,42 @@
+export * from './core.js';
+export * from './dom.js';
+export * from './hooks.js';
+export * from './jsx-runtime.js';
+declare const _default: {
+    jsx: typeof import("../jsx-runtime/index.js").jsx;
+    jsxDEV: typeof import("../jsx-runtime/index.js").jsx;
+    jsxs: typeof import("../jsx-runtime/index.js").jsx;
+    useSyncExternalStore: typeof import("./hooks.js").useSyncExternalStore;
+    useReducer: typeof import("./hooks.js").useReducer;
+    useId: typeof import("./hooks.js").useId;
+    useMemo: typeof import("./hooks.js").useMemo;
+    useCallback: typeof import("./hooks.js").useCallback;
+    useState: typeof import("../hooks/index.js").useState;
+    useEffect: typeof import("../hooks/index.js").useEffect;
+    useLayoutEffect: typeof import("../hooks/index.js").useEffect;
+    useInsertionEffect: typeof import("../hooks/index.js").useEffect;
+    useRef: typeof import("../hooks/index.js").useRef;
+    useContext: typeof import("../hooks/index.js").useContext;
+    hydrate: typeof import("../shared/utils.js").noop;
+    render: typeof import("../dom/render.js").render;
+    createRoot: typeof import("../dom/render.js").createRoot;
+    Children: {
+        map(children: import("../core/createElement.js").SimpNode, fn: (child: import("../core/createElement.js").SimpNode, index: number) => import("../core/createElement.js").SimpNode): import("../core/createElement.js").SimpNode[];
+        forEach(children: import("../core/createElement.js").SimpNode, fn: (child: import("../core/createElement.js").SimpNode, index: number) => void): void;
+        count(children: import("../core/createElement.js").SimpNode): number;
+        toArray(children: import("../core/createElement.js").SimpNode): import("../core/createElement.js").SimpNode[];
+        only(children: import("../core/createElement.js").SimpNode): import("../core/createElement.js").SimpElement;
+    };
+    cloneElement: typeof import("./core.js").cloneElement;
+    isValidElement: typeof import("./core.js").isValidElement;
+    Suspense: typeof import("./core.js").Suspense;
+    forwardRef: typeof import("./core.js").forwardRef;
+    Fragment: import("../core/fragment.js").Fragment;
+    createElement: typeof import("../core/createElement.js").createElement;
+    createContext: typeof import("../core/context.js").createContext;
+    createPortal: typeof import("../core/portal.js").createPortal;
+    memo: typeof import("./utils.js").identity;
+    flushSync: typeof import("./utils.js").identity;
+    Component: typeof import("./core.js").Component;
+};
+export default _default;

package/compat/index.js

@@ -0,0 +1,14 @@
+import coreDefault from './core.js';
+import domDefault from './dom.js';
+import hooksDefault from './hooks.js';
+import jsxRuntimeDefault from './jsx-runtime.js';
+export * from './core.js';
+export * from './dom.js';
+export * from './hooks.js';
+export * from './jsx-runtime.js';
+export default {
+    ...coreDefault,
+    ...domDefault,
+    ...hooksDefault,
+    ...jsxRuntimeDefault,
+};

package/compat/jsx-runtime.d.ts

@@ -0,0 +1,10 @@
+import * as SimpReactJSXRuntime from '../jsx-runtime/index.js';
+export declare const jsx: typeof SimpReactJSXRuntime.jsx;
+export declare const jsxDEV: typeof SimpReactJSXRuntime.jsx;
+export declare const jsxs: typeof SimpReactJSXRuntime.jsx;
+declare const _default: {
+    jsx: typeof SimpReactJSXRuntime.jsx;
+    jsxDEV: typeof SimpReactJSXRuntime.jsx;
+    jsxs: typeof SimpReactJSXRuntime.jsx;
+};
+export default _default;

package/compat/jsx-runtime.js

@@ -0,0 +1,9 @@
+import * as SimpReactJSXRuntime from '../jsx-runtime/index.js';
+export const jsx = SimpReactJSXRuntime.jsx;
+export const jsxDEV = SimpReactJSXRuntime.jsxDEV;
+export const jsxs = SimpReactJSXRuntime.jsxs;
+export default {
+    jsx,
+    jsxDEV,
+    jsxs,
+};

package/compat/utils.d.ts

@@ -0,0 +1 @@
+export declare function identity(value: any): any;

package/compat/utils.js

@@ -0,0 +1,3 @@
+export function identity(value) {
+    return value;
+}

package/core/context.d.ts

@@ -1,4 +1,4 @@
-import type { SimpNode } from './createElement';
+import type { SimpNode } from './createElement.js';
 type Provider<T = any> = (props: {
     value: T;
     children: SimpNode;

package/core/createElement.d.ts

@@ -1,6 +1,6 @@
-import type { Many, Maybe, Nullable, SimpText } from '../shared';
-import type { HostReference } from './hostAdapter';
-import type { SimpContextMap } from './context';
+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 {
@@ -17,7 +17,7 @@ export interface SimpElement {
     flag: SimpElementFlag;
     parent: Nullable<SimpElement>;
     key?: Maybe<Key>;
-    type?: Maybe<string | FunctionComponent>;
+    type?: string | FunctionComponent;
     props?: any;
     children?: Maybe<SimpNode>;
     className?: Maybe<string>;

package/core/createElement.js

@@ -1,6 +1,6 @@
-import { isSimpText } from '../shared';
-import { Fragment } from './fragment';
-import { isConsumer, isProvider } from './context';
+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;
@@ -31,7 +31,9 @@ export function createElement(type, props, ...children) {
                         definedChildren = props[propName];
                     }
                 }
-                else if (propName === 'ref') {
+                else if (propName === 'ref' &&
+                    // Handle only a callback ref or an object ref with `current`.
+                    props[propName]) {
                     ref = {
                         value: props[propName],
                     };
@@ -52,7 +54,12 @@ export function createElement(type, props, ...children) {
         if (key) {
             element.key = key;
         }
-        if ((definedChildren = normalizeChildren(definedChildren, false))) {
+        if (isSimpText(definedChildren)) {
+            if (definedChildren !== '') {
+                (newProps ||= {}).children = definedChildren.toString();
+            }
+        }
+        else if ((definedChildren = normalizeChildren(definedChildren, false))) {
             element.children = definedChildren;
         }
         if (newProps) {
@@ -134,7 +141,7 @@ export function createElement(type, props, ...children) {
 export function createTextElement(text) {
     return {
         flag: 'TEXT',
-        children: text,
+        children: text.toString(),
         parent: null,
     };
 }

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

@@ -1,5 +1,5 @@
-import type { Maybe, Nullable } from '../shared';
-import type { SimpElement } from './createElement';
+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;
@@ -8,7 +8,7 @@ export interface HostAdapter<HostRef = any, HostTextRef = any, NS = string> {
     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): void;
+    setTextContent(reference: HostRef, text: string, referenceHasOnlyTextElement?: boolean): void;
     appendChild(parent: HostRef, child: HostRef | HostTextRef): void;
     removeChild(parent: HostRef, child: HostRef | HostTextRef): void;
     replaceChild(parent: HostRef, replacer: HostRef | HostTextRef, toBeReplaced: HostRef | HostTextRef): void;

package/core/index.d.ts

@@ -1,12 +1,12 @@
-import type { SimpText } from '../shared';
+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(instance: T): (() => void | undefined) | void;
 }['bivarianceHack'];
-export type Ref<T> = RefCallback<T> | RefObject<T> | null;
+export type Ref<T> = RefCallback<T> | RefObject<T | null> | null;
 
 export type Key = string | number | bigint;
 

package/core/index.js

@@ -1,6 +1,6 @@
-import { createElement } from './createElement';
-import { Fragment } from './fragment';
-import { createContext } from './context';
-import { createPortal } from './portal';
+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,11 +1,11 @@
-export * from './context';
-export * from './createElement';
-export * from './fragment';
-export * from './hostAdapter';
-export * from './lifecycleEventBus';
-export * from './mounting';
-export * from './patching';
-export * from './portal';
-export * from './ref';
-export * from './rerender';
-export * from './unmounting';
+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,11 +1,11 @@
-export * from './context';
-export * from './createElement';
-export * from './fragment';
-export * from './hostAdapter';
-export * from './lifecycleEventBus';
-export * from './mounting';
-export * from './patching';
-export * from './portal';
-export * from './ref';
-export * from './rerender';
-export * from './unmounting';
+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

@@ -1,12 +1,16 @@
-import { EventBus } from '../shared';
-import type { SimpElement } from './createElement';
+import { EventBus } from '../shared/index.js';
+import type { SimpElement } from './createElement.js';
 export type LifecycleEvent = {
     type: 'beforeRender';
     element: SimpElement;
     phase: 'mounting' | 'updating';
 } | {
     type: 'afterRender';
+    element: SimpElement;
     phase: 'mounting' | 'updating';
+} | {
+    type: 'triedToRerender';
+    element: SimpElement;
 } | {
     type: 'mounted';
     element: SimpElement;

package/core/lifecycleEventBus.js

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

package/core/mounting.d.ts

@@ -1,7 +1,7 @@
-import type { Maybe, Nullable } from '../shared';
-import type { HostReference } from './hostAdapter';
-import type { SimpElement } from './createElement';
-import type { SimpContextMap } from './context';
+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;