@faiwer/react 0.8.0

package/dist/hooks/useEffect.js

@@ -0,0 +1,100 @@
+import { getCurrentApp, isFirstFiberRender } from '../core/components';
+import { checkDeps, getNextHookOrCreate, saveDeps } from './helpers';
+import { scheduleEffect } from '../core/reconciliation/effects';
+function useBaseEffect(mode, fn, deps) {
+    const item = getNextHookOrCreate('effect', () => {
+        const item = {
+            type: 'effect',
+            mode,
+            fn,
+            destructor: null,
+            deps: deps ? saveDeps(deps) : null,
+        };
+        scheduleEffect(getCurrentApp(), () => runEffect(item), mode);
+        return item;
+    });
+    item.fn = fn;
+    if (!isFirstFiberRender() && (!deps || !checkDeps(item.deps, deps))) {
+        scheduleEffect(getCurrentApp(), () => runEffect(item), mode);
+        item.deps = deps ? saveDeps(deps) : null;
+    }
+}
+/**
+ * A hook that performs side effects in functional components. This enhanced
+ * version supports async functions and provides an AbortSignal for cleanup.
+ *
+ * Effects run after the render is committed to the screen, making them suitable
+ * for data fetching, subscriptions, or manually changing the DOM.
+ *
+ * @example
+ * // Basic effect with cleanup
+ * useEffect(() => {
+ *   const timer = setInterval(() => console.log('tick'), 1000);
+ *   return () => clearInterval(timer);
+ * }, []);
+ *
+ * // Async effect with abort signal
+ * useEffect(async (signal) => {
+ *   try {
+ *     const response = await fetch('/api/data', { signal });
+ *     const data = await response.json();
+ *     setData(data);
+ *   } catch (error) {
+ *     if (!signal.aborted) {
+ *       console.error('Fetch failed:', error);
+ *     }
+ *   }
+ * }, [userId]);
+ */
+export const useEffect = (
+/** The effect function that receives an AbortSignal. Can be async and can
+ * return a cleanup function. The AbortSignal is automatically aborted when
+ * the effect is cleaned up. */
+fn, 
+/** Optional array of dependencies. If provided, the effect only runs when one
+ * of the dependencies has changed. If omitted, the effect runs after every
+ * render. */
+deps) => {
+    useBaseEffect('normal', fn, deps);
+};
+/**
+ * A hook that performs side effects synchronously after all DOM mutations but
+ * before the browser paints. This enhanced version supports async functions
+ * and provides an AbortSignal for cleanup.
+ *
+ * Use this for DOM measurements, synchronous DOM mutations, or when you need
+ * to read layout properties before the browser paints.
+ *
+ * @example
+ * // Measuring DOM elements before paint
+ * useLayoutEffect(() => {
+ *   const rect = elementRef.current?.getBoundingClientRect();
+ *   if (rect) {
+ *     setDimensions({ width: rect.width, height: rect.height });
+ *   }
+ * }, []);
+ */
+export const useLayoutEffect = (
+/** The effect function that receives an AbortSignal. Can be async and can
+ * return a cleanup function. The AbortSignal is automatically aborted when
+ * the effect is cleaned up. */
+fn, 
+/** Optional array of dependencies. If provided, the effect only runs when one
+ * of the dependencies has changed. If omitted, the effect runs after every
+ * render. */
+deps) => {
+    useBaseEffect('layout', fn, deps);
+};
+const runEffect = (item) => {
+    item.destructor?.();
+    item.destructor = null;
+    const controller = new AbortController();
+    const result = item.fn(controller.signal);
+    item.destructor = function effectDestructor() {
+        controller.abort();
+        if (typeof result === 'function') {
+            result();
+        }
+    };
+};
+//# sourceMappingURL=useEffect.js.map

package/dist/hooks/useEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffect.js","sourceRoot":"","sources":["../../src/hooks/useEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAMtE,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAE1E,SAAS,aAAa,CAAC,IAAgB,EAAE,EAAiB,EAAE,IAAgB,EAAE;IAC5E,MAAM,IAAI,GAAG,mBAAmB,CAAC,QAAQ,EAAE,GAAkB,EAAE,CAAC;QAC9D,MAAM,IAAI,GAAkB;YAC1B,IAAI,EAAE,QAAQ;YACd,IAAI;YACJ,EAAE;YACF,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI;SACnC,CAAC;QACF,cAAc,CAAC,aAAa,EAAE,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;QAC7D,OAAO,IAAI,CAAC;IAAA,CACb,CAAC,CAAC;IAEH,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IAEb,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAK,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC;QACrE,cAAc,CAAC,aAAa,EAAE,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;QAC7D,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3C,CAAC;AAAA,CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;AACvB;;+BAE+B;AAC/B,EAAiB;AACjB;;aAEa;AACb,IAAgB,EAChB,EAAE,CAAC;IACH,aAAa,CAAC,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAAA,CACnC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;AAC7B;;+BAE+B;AAC/B,EAAiB;AACjB;;aAEa;AACb,IAAgB,EAChB,EAAE,CAAC;IACH,aAAa,CAAC,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAAA,CACnC,CAAC;AAEF,MAAM,SAAS,GAAG,CAAC,IAAmB,EAAQ,EAAE,CAAC;IAC/C,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;IACpB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IAEvB,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAE1C,IAAI,CAAC,UAAU,GAAG,SAAS,gBAAgB,GAAG;QAC5C,UAAU,CAAC,KAAK,EAAE,CAAC;QACnB,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,EAAE,CAAC;QACX,CAAC;IAAA,CACF,CAAC;AAAA,CACH,CAAC"}

package/dist/hooks/useId.d.ts

@@ -0,0 +1,2 @@
+export declare function useId(): string;
+//# sourceMappingURL=useId.d.ts.map

package/dist/hooks/useId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useId.d.ts","sourceRoot":"","sources":["../../src/hooks/useId.ts"],"names":[],"mappings":"AAIA,wBAAgB,KAAK,IAAI,MAAM,CAO9B"}

package/dist/hooks/useId.js

@@ -0,0 +1,10 @@
+import { useRef } from './useRef';
+let idx = 0;
+export function useId() {
+    const ref = useRef(null);
+    if (ref.current === undefined) {
+        ref.current = `_r_${++idx}`;
+    }
+    return ref.current;
+}
+//# sourceMappingURL=useId.js.map

package/dist/hooks/useId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useId.js","sourceRoot":"","sources":["../../src/hooks/useId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,IAAI,GAAG,GAAG,CAAC,CAAC;AAEZ,MAAM,UAAU,KAAK,GAAW;IAC9B,MAAM,GAAG,GAAG,MAAM,CAAgB,IAAI,CAAC,CAAC;IACxC,IAAI,GAAG,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAC9B,GAAG,CAAC,OAAO,GAAG,MAAM,EAAE,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED,OAAO,GAAG,CAAC,OAAQ,CAAC;AAAA,CACrB"}

package/dist/hooks/useMemo.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A hook that memoizes the result of a computation and only recalculates it
+ * when one of the dependencies has changed. This is useful for expensive
+ * calculations that you don't want to repeat on every render, or when you want
+ * to preserve the same object across renders to avoid invalidating effects
+ * or other memoization.
+ *
+ * @example
+ * const expensiveValue = useMemo(() => {
+ *   return count * multiplier * 1000; // Simulate expensive computation
+ * }, [count, multiplier]);
+ */
+export declare function useMemo<T>(
+/** A function that computes the value to be memoized. This function should be
+ * pure (no side effects) and will only be called when needed. */
+fn: () => T, 
+/** An array of dependencies that the memoized value depends on. When any of
+ * these values change, the function will be re-executed. */
+deps: unknown[]): T;
+//# sourceMappingURL=useMemo.d.ts.map

package/dist/hooks/useMemo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemo.d.ts","sourceRoot":"","sources":["../../src/hooks/useMemo.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC;AACvB;iEACiE;AACjE,EAAE,EAAE,MAAM,CAAC;AACX;4DAC4D;AAC5D,IAAI,EAAE,OAAO,EAAE,GACd,CAAC,CAgBH"}

package/dist/hooks/useMemo.js

@@ -0,0 +1,33 @@
+import { isFirstFiberRender } from '../core/components';
+import { checkDeps, getNextHookOrCreate, saveDeps } from './helpers';
+/**
+ * A hook that memoizes the result of a computation and only recalculates it
+ * when one of the dependencies has changed. This is useful for expensive
+ * calculations that you don't want to repeat on every render, or when you want
+ * to preserve the same object across renders to avoid invalidating effects
+ * or other memoization.
+ *
+ * @example
+ * const expensiveValue = useMemo(() => {
+ *   return count * multiplier * 1000; // Simulate expensive computation
+ * }, [count, multiplier]);
+ */
+export function useMemo(
+/** A function that computes the value to be memoized. This function should be
+ * pure (no side effects) and will only be called when needed. */
+fn, 
+/** An array of dependencies that the memoized value depends on. When any of
+ * these values change, the function will be re-executed. */
+deps) {
+    const item = getNextHookOrCreate('memo', () => ({
+        type: 'memo',
+        value: fn(),
+        deps: saveDeps(deps),
+    }));
+    if (!isFirstFiberRender() && !checkDeps(item.deps, deps)) {
+        item.value = fn();
+        item.deps = saveDeps(deps);
+    }
+    return item.value;
+}
+//# sourceMappingURL=useMemo.js.map

package/dist/hooks/useMemo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemo.js","sourceRoot":"","sources":["../../src/hooks/useMemo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,OAAO;AACrB;iEACiE;AACjE,EAAW;AACX;4DAC4D;AAC5D,IAAe,EACZ;IACH,MAAM,IAAI,GAAG,mBAAmB,CAC9B,MAAM,EACN,GAAgB,EAAE,CAAC,CAAC;QAClB,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,EAAE,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;KACrB,CAAC,CACH,CAAC;IAEF,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;QACzD,IAAI,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC;QAClB,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO,IAAI,CAAC,KAAU,CAAC;AAAA,CACxB"}

package/dist/hooks/useRef.d.ts

@@ -0,0 +1,4 @@
+import { type Ref } from '../types';
+export declare function useRef<T>(): Ref<T | undefined>;
+export declare function useRef<T>(initialValue: T): Ref<T>;
+//# sourceMappingURL=useRef.d.ts.map

package/dist/hooks/useRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRef.d.ts","sourceRoot":"","sources":["../../src/hooks/useRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGrD,wBAAgB,MAAM,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAChD,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC"}

package/dist/hooks/useRef.js

@@ -0,0 +1,9 @@
+import { getNextHookOrCreate } from './helpers';
+export function useRef(initialValue) {
+    const item = getNextHookOrCreate('ref', () => ({
+        type: 'ref',
+        value: { current: initialValue ?? undefined },
+    }));
+    return item.value;
+}
+//# sourceMappingURL=useRef.js.map

package/dist/hooks/useRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRef.js","sourceRoot":"","sources":["../../src/hooks/useRef.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAIhD,MAAM,UAAU,MAAM,CAAI,YAAgB,EAAU;IAClD,MAAM,IAAI,GAAG,mBAAmB,CAC9B,KAAK,EACL,GAAe,EAAE,CAAC,CAAC;QACjB,IAAI,EAAE,KAAK;QACX,KAAK,EAAE,EAAE,OAAO,EAAE,YAAY,IAAI,SAAS,EAAE;KAC9C,CAAC,CACH,CAAC;IAEF,OAAO,IAAI,CAAC,KAAe,CAAC;AAAA,CAC7B"}

package/dist/hooks/useStableCallback.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A hook that returns a stable callback function that never changes reference
+ * but always calls the latest version of the provided function. This is
+ * superior to React's `useEffectEvent` which returns a new function on each
+ * render.
+ *
+ * Unlike React's `useEffectEvent`, this hook:
+ * - Returns the SAME function reference on every render (truly stable)
+ * - Can be safely included in dependency arrays (though not needed)
+ * - Is designed for async actions and event handlers, not just effects
+ * - Eliminates the need to exclude it from dependency arrays
+ *
+ * ⚠️ **Important**: The returned function should never be called during the
+ * rendering phase because at that time its internal function is not updated,
+ * so calling it would work incorrectly. Only call it in event handlers,
+ * effects, or other non-rendering contexts.
+ *
+ * @example
+ * const MyComponent = ({ onSubmit, userId }) => {
+ *   // This callback never changes reference, unlike useCallback
+ *   const handleSubmit = useStableCallback((data: FormData) => {
+ *     // Always uses the latest onSubmit and userId values
+ *     onSubmit({ ...data, userId });
+ *   });
+ *
+ *   useEffect(() => {
+ *     // Safe to include in deps (though not necessary)
+ *     document.addEventListener('keydown', handleSubmit);
+ *     return () => document.removeEventListener('keydown', handleSubmit);
+ *   }, [handleSubmit]); // No lint warnings, handleSubmit never changes
+ *
+ *   // Perfect for async event handlers
+ *   const handleClick = useStableCallback(async () => {
+ *     const result = await api.updateUser(userId); // Always latest userId
+ *     onSubmit(result); // Always latest onSubmit
+ *   });
+ *
+ *   return <User onClick={handleClick}>Update User</User>;
+ * };
+ */
+export declare function useStableCallback<TArgs extends unknown[], TRes>(
+/** The function to wrap. The wrapper will always call the latest version of
+ * this function, but the wrapper itself never changes reference. */
+fn: (...TArgs: TArgs) => TRes): (...TArgs: TArgs) => TRes;
+//# sourceMappingURL=useStableCallback.d.ts.map

package/dist/hooks/useStableCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStableCallback.d.ts","sourceRoot":"","sources":["../../src/hooks/useStableCallback.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,IAAI;AAC7D;oEACoE;AACpE,EAAE,EAAE,CAAC,GAAG,KAAK,EAAE,KAAK,KAAK,IAAI,GAC5B,CAAC,GAAG,KAAK,EAAE,KAAK,KAAK,IAAI,CAyB3B"}

package/dist/hooks/useStableCallback.js

@@ -0,0 +1,66 @@
+import { getNextHookOrCreate } from './helpers';
+import { useLayoutEffect } from './useEffect';
+/**
+ * A hook that returns a stable callback function that never changes reference
+ * but always calls the latest version of the provided function. This is
+ * superior to React's `useEffectEvent` which returns a new function on each
+ * render.
+ *
+ * Unlike React's `useEffectEvent`, this hook:
+ * - Returns the SAME function reference on every render (truly stable)
+ * - Can be safely included in dependency arrays (though not needed)
+ * - Is designed for async actions and event handlers, not just effects
+ * - Eliminates the need to exclude it from dependency arrays
+ *
+ * ⚠️ **Important**: The returned function should never be called during the
+ * rendering phase because at that time its internal function is not updated,
+ * so calling it would work incorrectly. Only call it in event handlers,
+ * effects, or other non-rendering contexts.
+ *
+ * @example
+ * const MyComponent = ({ onSubmit, userId }) => {
+ *   // This callback never changes reference, unlike useCallback
+ *   const handleSubmit = useStableCallback((data: FormData) => {
+ *     // Always uses the latest onSubmit and userId values
+ *     onSubmit({ ...data, userId });
+ *   });
+ *
+ *   useEffect(() => {
+ *     // Safe to include in deps (though not necessary)
+ *     document.addEventListener('keydown', handleSubmit);
+ *     return () => document.removeEventListener('keydown', handleSubmit);
+ *   }, [handleSubmit]); // No lint warnings, handleSubmit never changes
+ *
+ *   // Perfect for async event handlers
+ *   const handleClick = useStableCallback(async () => {
+ *     const result = await api.updateUser(userId); // Always latest userId
+ *     onSubmit(result); // Always latest onSubmit
+ *   });
+ *
+ *   return <User onClick={handleClick}>Update User</User>;
+ * };
+ */
+export function useStableCallback(
+/** The function to wrap. The wrapper will always call the latest version of
+ * this function, but the wrapper itself never changes reference. */
+fn) {
+    const item = getNextHookOrCreate('ref', () => {
+        let item;
+        const state = {
+            fn,
+            wrapper: function effectEventHandler(...args) {
+                return item.value.current.fn(...args);
+            },
+        };
+        item = {
+            type: 'ref',
+            value: { current: state },
+        };
+        return item;
+    });
+    useLayoutEffect(() => {
+        item.value.current.fn = fn;
+    }, [fn]);
+    return item.value.current.wrapper;
+}
+//# sourceMappingURL=useStableCallback.js.map

package/dist/hooks/useStableCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStableCallback.js","sourceRoot":"","sources":["../../src/hooks/useStableCallback.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,UAAU,iBAAiB;AAC/B;oEACoE;AACpE,EAA6B,EACF;IAC3B,MAAM,IAAI,GAAG,mBAAmB,CAC9B,KAAK,EACL,GAAmC,EAAE,CAAC;QACpC,IAAI,IAAoC,CAAC;QACzC,MAAM,KAAK,GAAuB;YAChC,EAAE;YACF,OAAO,EAAE,SAAS,kBAAkB,CAAC,GAAG,IAAW,EAAQ;gBACzD,OAAO,IAAK,CAAC,KAAK,CAAC,OAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;YAAA,CACzC;SACF,CAAC;QAEF,IAAI,GAAG;YACL,IAAI,EAAE,KAAK;YACX,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;SAC1B,CAAC;QACF,OAAO,IAAI,CAAC;IAAA,CACb,CACF,CAAC;IAEF,eAAe,CAAC,GAAG,EAAE,CAAC;QACpB,IAAI,CAAC,KAAK,CAAC,OAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IAAA,CAC7B,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAET,OAAO,IAAI,CAAC,KAAK,CAAC,OAAQ,CAAC,OAAoC,CAAC;AAAA,CACjE"}

package/dist/hooks/useState.d.ts

@@ -0,0 +1,15 @@
+import { type StateSetter } from '../types';
+/**
+ * A hook that allows you to add state to functional components. Returns a
+ * stateful value and a function to update it.
+ *
+ * @example
+ * const [count, setCount] = useState(0);
+ * setCount(1); // Set to specific value
+ * setCount(prev => prev + 1); // Update based on previous value
+ *
+ * // With lazy initialization
+ * const [data, setData] = useState(() => expensiveComputation());
+ */
+export declare const useState: <T>(initValue: (() => T) | (T extends Function ? () => T : T)) => [T, StateSetter<T>];
+//# sourceMappingURL=useState.d.ts.map

package/dist/hooks/useState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useState.d.ts","sourceRoot":"","sources":["../../src/hooks/useState.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,UAAU,CAAC;AAG/D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,mFA2BzB,CAAC"}

package/dist/hooks/useState.js

@@ -0,0 +1,39 @@
+import { invalidateFiber } from '../core/reconciliation/invalidateFiber';
+import { getNextHookOrCreate } from './helpers';
+/**
+ * A hook that allows you to add state to functional components. Returns a
+ * stateful value and a function to update it.
+ *
+ * @example
+ * const [count, setCount] = useState(0);
+ * setCount(1); // Set to specific value
+ * setCount(prev => prev + 1); // Update based on previous value
+ *
+ * // With lazy initialization
+ * const [data, setData] = useState(() => expensiveComputation());
+ */
+export const useState = (
+/** The initial state value or a function that returns the initial state. If a
+ * function is provided, it will only be called once during initialization. */
+initValue) => {
+    const item = getNextHookOrCreate('state', (fiber) => {
+        const item = {
+            type: 'state',
+            state: (typeof initValue === 'function'
+                ? initValue()
+                : initValue),
+            setter: function setState(valueOrFn) {
+                const v = (typeof valueOrFn === 'function'
+                    ? valueOrFn(item.state)
+                    : valueOrFn);
+                if (item.state === v)
+                    return;
+                item.state = v;
+                invalidateFiber(fiber);
+            },
+        };
+        return item;
+    });
+    return [item.state, item.setter];
+};
+//# sourceMappingURL=useState.js.map

package/dist/hooks/useState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useState.js","sourceRoot":"","sources":["../../src/hooks/useState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kDAAkD,CAAC;AAEnF,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;AACtB;8EAC8E;AAC9E,SAAyD,EACpC,EAAE,CAAC;IACxB,MAAM,IAAI,GAAG,mBAAmB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAgB,EAAE,CAAC;QACjE,MAAM,IAAI,GAAoB;YAC5B,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,CAAC,OAAO,SAAS,KAAK,UAAU;gBACrC,CAAC,CAAE,SAAqB,EAAE;gBAC1B,CAAC,CAAC,SAAS,CAAM;YACnB,MAAM,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE;gBACnC,MAAM,CAAC,GAAG,CACR,OAAO,SAAS,KAAK,UAAU;oBAC7B,CAAC,CAAE,SAA4B,CAAC,IAAI,CAAC,KAAK,CAAC;oBAC3C,CAAC,CAAC,SAAS,CACT,CAAC;gBAEP,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC;oBAAE,OAAO;gBAC7B,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;gBACf,eAAe,CAAC,KAAK,CAAC,CAAC;YAAA,CACxB;SACF,CAAC;QACF,OAAO,IAAoB,CAAC;IAAA,CAC7B,CAAC,CAAC;IAEH,OAAO,CAAC,IAAI,CAAC,KAAU,EAAE,IAAI,CAAC,MAAwB,CAAC,CAAC;AAAA,CACzD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './hooks/index';
+export * from './core/createRoot';
+export * from './core/createElement';
+export declare function memo<T>(Comp: T, isEq: unknown): T;
+/** <Fragment/> */
+export { FRAGMENT_TAG as Fragment } from './core/reconciliation/fibers';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AAErC,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CAMjD;AAED,kBAAkB;AAClB,OAAO,EAAE,YAAY,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from './types';
+export * from './hooks/index';
+export * from './core/createRoot';
+export * from './core/createElement';
+export function memo(Comp, isEq) {
+    if (isEq) {
+        throw new Error(`Custom "isEqual" for memo is not supported`);
+    }
+    return Comp; // Components are already memoized by default.
+}
+/** <Fragment/> */
+export { FRAGMENT_TAG as Fragment } from './core/reconciliation/fibers';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AAErC,MAAM,UAAU,IAAI,CAAI,IAAO,EAAE,IAAa,EAAK;IACjD,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IAED,OAAO,IAAI,CAAC,CAAC,8CAA8C;AAA/C,CACb;AAED,kBAAkB;AAClB,OAAO,EAAE,YAAY,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1,6 @@
+import { createElement } from './index';
+export declare const jsx: typeof createElement;
+export declare const jsxDEV: typeof createElement;
+export declare const jsxs: typeof createElement;
+export declare const Fragment = "x-fragment";
+//# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/dist/jsx-dev-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-dev-runtime.d.ts","sourceRoot":"","sources":["../src/jsx-dev-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,eAAO,MAAM,GAAG,sBAAgB,CAAC;AACjC,eAAO,MAAM,MAAM,sBAAgB,CAAC;AACpC,eAAO,MAAM,IAAI,sBAAgB,CAAC;AAClC,eAAO,MAAM,QAAQ,eAAe,CAAC"}

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,7 @@
+import { createElement } from './index';
+import { FRAGMENT_TAG } from './core/reconciliation/fibers';
+export const jsx = createElement;
+export const jsxDEV = createElement;
+export const jsxs = createElement;
+export const Fragment = FRAGMENT_TAG;
+//# sourceMappingURL=jsx-dev-runtime.js.map

package/dist/jsx-dev-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-dev-runtime.js","sourceRoot":"","sources":["../src/jsx-dev-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,MAAM,CAAC,MAAM,GAAG,GAAG,aAAa,CAAC;AACjC,MAAM,CAAC,MAAM,MAAM,GAAG,aAAa,CAAC;AACpC,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAC;AAClC,MAAM,CAAC,MAAM,QAAQ,GAAG,YAAY,CAAC"}

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,31 @@
+import { createElement } from './index';
+/**
+ * This file is used to get `jsx`, `jsxs` & `Fragment` to be used by the JSX | TSX
+ * compiler to convert <tag/> or <Component/> into vNodes (ElementNode in this
+ * library).
+ */
+/**
+ * @example
+ * <span/> ===
+ *    jsx("span", {})
+ * <span>A</span> ===
+ *    jsx("span", { children: "A" })
+ */
+export declare const jsx: typeof createElement;
+/**
+ * `createElement` with 2+ children
+ * @example
+ * <div><span>A</span><span>B</span></div> ===
+ *   jsxs("div", { children: [
+ *     jsx("span", { children: "A" }),
+ *     jsx("span", { children: "B" })
+ *   ]});
+ */
+export declare const jsxs: typeof createElement;
+/**
+ * <>[1,2]</>
+ *   === jsxs(FRAGMENT_TAG, { children: [1,2] })
+ *   === jsxs('x-fragment', { children: [1,2] })
+ */
+export declare const Fragment = "x-fragment";
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/dist/jsx-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.d.ts","sourceRoot":"","sources":["../src/jsx-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC;;;;GAIG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,sBAAgB,CAAC;AAEjC;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,sBAAgB,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,QAAQ,eAAe,CAAC"}

package/dist/jsx-runtime.js

@@ -0,0 +1,32 @@
+import { createElement } from './index';
+import { FRAGMENT_TAG } from './core/reconciliation/fibers';
+/**
+ * This file is used to get `jsx`, `jsxs` & `Fragment` to be used by the JSX | TSX
+ * compiler to convert <tag/> or <Component/> into vNodes (ElementNode in this
+ * library).
+ */
+/**
+ * @example
+ * <span/> ===
+ *    jsx("span", {})
+ * <span>A</span> ===
+ *    jsx("span", { children: "A" })
+ */
+export const jsx = createElement;
+/**
+ * `createElement` with 2+ children
+ * @example
+ * <div><span>A</span><span>B</span></div> ===
+ *   jsxs("div", { children: [
+ *     jsx("span", { children: "A" }),
+ *     jsx("span", { children: "B" })
+ *   ]});
+ */
+export const jsxs = createElement;
+/**
+ * <>[1,2]</>
+ *   === jsxs(FRAGMENT_TAG, { children: [1,2] })
+ *   === jsxs('x-fragment', { children: [1,2] })
+ */
+export const Fragment = FRAGMENT_TAG;
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/jsx-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.js","sourceRoot":"","sources":["../src/jsx-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D;;;;GAIG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,aAAa,CAAC;AAEjC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAC;AAElC;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,YAAY,CAAC"}

package/dist/testing.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Put your "setState" calls in tests within the `fn` callback. When the promise
+ * resolves, the component will be re-rendered and its HTML will be up to date.
+ * Layout effects will have finished running, but normal effects may still be
+ * pending.
+ */
+export declare const act: (fn: () => void | Promise<void>) => Promise<void>;
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,GAAG,mDAEf,CAAC"}

package/dist/testing.js

@@ -0,0 +1,10 @@
+/**
+ * Put your "setState" calls in tests within the `fn` callback. When the promise
+ * resolves, the component will be re-rendered and its HTML will be up to date.
+ * Layout effects will have finished running, but normal effects may still be
+ * pending.
+ */
+export const act = async (fn) => {
+    await fn();
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,KAAK,EAAE,EAA8B,EAAE,EAAE,CAAC;IAC3D,MAAM,EAAE,EAAE,CAAC;AAAA,CACZ,CAAC"}

package/dist/types/actions.d.ts

@@ -0,0 +1,53 @@
+import type { CommentMode, UnknownProps } from './core';
+import type { TagAttrValue } from './dom';
+import type { FiberMap, FiberNode } from './fiber';
+import type { Ref, RefSetter } from './refs';
+type CommonAction = {
+    fiber: FiberNode;
+};
+type CreateTagAction = CommonAction & {
+    type: 'CreateTag';
+};
+type CreateTextAction = CommonAction & {
+    type: 'CreateText';
+};
+export type CreateCommentAction = CommonAction & {
+    type: 'CreateComment';
+    mode: CommentMode;
+};
+type CreateAction = CreateTagAction | CreateTextAction | CreateCommentAction;
+export type SetTextAction = CommonAction & {
+    type: 'SetText';
+    text: string;
+};
+export type SetAttrAction = CommonAction & {
+    type: 'SetAttr';
+    name: string;
+    value: TagAttrValue;
+};
+export type SetRefAction = CommonAction & {
+    type: 'SetRef';
+    ref: Ref<unknown> | RefSetter<unknown> | null;
+    dontUnsetRef?: boolean;
+};
+export type SetPropsAction = CommonAction & {
+    type: 'SetProps';
+    props: UnknownProps;
+};
+type UpdateAction = SetTextAction | SetAttrAction | SetPropsAction | SetRefAction;
+export type RemoveAction = CommonAction & {
+    type: 'Remove';
+};
+export type RelayoutAction = CommonAction & {
+    type: 'Relayout';
+    before: FiberMap;
+    after: FiberMap;
+};
+export type ReplaceAction = CommonAction & {
+    type: 'Replace';
+    newFiber: FiberNode;
+};
+type LayoutAction = RemoveAction | RelayoutAction | ReplaceAction;
+export type Action = CreateAction | UpdateAction | LayoutAction;
+export {};
+//# sourceMappingURL=actions.d.ts.map

package/dist/types/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/types/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAE7C,KAAK,YAAY,GAAG;IAClB,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC;AAGF,KAAK,eAAe,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC;AAC5D,KAAK,gBAAgB,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG;IAC/C,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,WAAW,CAAC;CACnB,CAAC;AACF,KAAK,YAAY,GAAG,eAAe,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;AAG7E,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAC7E,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IACzC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG;IACxC,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAE9C,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG;IAC1C,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AACF,KAAK,YAAY,GACb,aAAa,GACb,aAAa,GACb,cAAc,GACd,YAAY,CAAC;AAGjB,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAC7D,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG;IAC1C,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IACzC,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AACF,KAAK,YAAY,GAAG,YAAY,GAAG,cAAc,GAAG,aAAa,CAAC;AAElE,MAAM,MAAM,MAAM,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC"}

package/dist/types/actions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=actions.js.map

package/dist/types/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.js","sourceRoot":"","sources":["../../src/types/actions.ts"],"names":[],"mappings":""}