frosty 0.0.112 → 0.0.114

package/dist/_native.d.mts

@@ -0,0 +1,19 @@
+import { N as NativeElementType, c as PropsType, C as ComponentNode } from './internals/common-CpEB3ieX.mjs';
+export { V as VNode, _ as _Renderer } from './internals/renderer-BelBgEvy.mjs';
+export { u as uniqueId } from './internals/utils-CWsh4Zpu.mjs';
+import '@o2ter/utils-js';
+import 'lodash';
+import 'csstype';
+
+declare class EventEmitter {
+    private _listeners;
+    register(event: string, callback: (event: string, ...args: any[]) => void): {
+        remove: () => void;
+    };
+    emit(event: string, ...args: any[]): void;
+}
+
+declare function _createNativeElement(type: typeof NativeElementType, props: PropsType, key?: string | number): ComponentNode;
+
+export { EventEmitter, NativeElementType, _createNativeElement };
+//# sourceMappingURL=_native.d.mts.map

package/dist/_native.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_native.d.mts","sources":["../src/core/reconciler/events.ts","../src/renderer/native.ts"],"sourcesContent":["//\n//  events.ts\n//\n//  The MIT License\n//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.\n//\n//  Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to deal\n//  in the Software without restriction, including without limitation the rights\n//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n//  copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n//  The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n//  THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n//\n\nimport _ from 'lodash';\n\nexport class EventEmitter {\n\n  private _listeners: Record<string, ((...args: any[]) => void)[]> = {};\n\n  register(event: string, callback: (event: string, ...args: any[]) => void) {\n    if (_.isNil(this._listeners[event])) this._listeners[event] = [];\n    const _callback = (...args: any[]) => callback(event, ...args);\n    this._listeners[event].push(_callback);\n    return {\n      remove: () => {\n        this._listeners[event] = _.filter(this._listeners[event], x => x !== _callback);\n      },\n    };\n  }\n\n  emit(event: string, ...args: any[]) {\n    this._listeners[event]?.forEach(async callback => {\n      try {\n        await callback(...args)\n      } catch (e) {\n        console.error(e);\n      }\n    });\n  }\n}\n","//\n//  native.ts\n//\n//  The MIT License\n//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.\n//\n//  Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to deal\n//  in the Software without restriction, including without limitation the rights\n//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n//  copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n//  The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n//  THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n//\n\nimport { _createElement, PropsType } from '../core/types/runtime';\nimport { ComponentNode, NativeElementType } from '../core/types/component';\n\nexport { _Renderer } from '../core/renderer';\nexport { uniqueId } from '../core/utils';\nexport { EventEmitter } from '../core/reconciler/events';\nexport { VNode } from '../core/reconciler/vnode';\nexport { NativeElementType } from '../core/types/component';\n\nexport function _createNativeElement(\n  type: typeof NativeElementType,\n  props: PropsType,\n  key?: string | number\n): ComponentNode {\n  return _createElement(type, { ...props, key });\n}\n"],"names":[],"mappings":";;;;;;;AAAO,cAAA,YAAA;AACP;AACA;AACA;AACA;AACA;AACA;;ACCO,iBAAA,oBAAA,cAAA,iBAAA,SAAA,SAAA,0BAAA,aAAA;;;;"}

package/dist/dom.d.mts

@@ -0,0 +1,15 @@
+import { _ as _DOMRenderer } from './internals/renderer-BQawOCgo.mjs';
+import './internals/common-CpEB3ieX.mjs';
+import '@o2ter/utils-js';
+import 'lodash';
+import 'csstype';
+import './internals/renderer-BelBgEvy.mjs';
+import 'jsdom';
+
+declare class DOMRenderer extends _DOMRenderer {
+    static default: DOMRenderer;
+    static createRoot(root: Element): ReturnType<typeof DOMRenderer.default.createRoot>;
+}
+
+export { DOMRenderer };
+//# sourceMappingURL=dom.d.mts.map

package/dist/dom.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.mts","sources":["../src/renderer/dom.ts"],"sourcesContent":["//\n//  dom.ts\n//\n//  The MIT License\n//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.\n//\n//  Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to deal\n//  in the Software without restriction, including without limitation the rights\n//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n//  copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n//  The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n//  THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n//\n\nimport _ from 'lodash';\nimport { _DOMRenderer } from './common';\n\nexport class DOMRenderer extends _DOMRenderer {\n\n  static default = new DOMRenderer(window);\n\n  static createRoot(root: Element): ReturnType<typeof DOMRenderer.default.createRoot> {\n    return this.default.createRoot(root);\n  }\n\n  /** @internal */\n  get _server(): boolean {\n    return false;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;AACO,cAAA,WAAA,SAAA,YAAA;AACP,oBAAA,WAAA;AACA,4BAAA,OAAA,GAAA,UAAA,QAAA,WAAA,CAAA,OAAA,CAAA,UAAA;AACA;;;;"}

package/dist/index.d.mts

@@ -0,0 +1,551 @@
+import { _ as _ElementType, N as NativeElementType, P as PropsWithChildren, C as ComponentNode, S as SetStateAction, a as ComponentType, E as ElementNode, R as RefObject, b as Ref, c as PropsType } from './internals/common-CpEB3ieX.mjs';
+export { h as CSSProperties, e as ClassName, j as ComponentProps, k as ComponentPropsWithoutRef, m as ComponentRef, g as ExtendedCSSProperties, i as RefAttribute, l as RefCallback, f as StyleProp, d as createElement } from './internals/common-CpEB3ieX.mjs';
+export { F as Fragment } from './internals/fragment-BlS4iF_x.mjs';
+import _ from 'lodash';
+import { Awaitable } from '@o2ter/utils-js';
+export { m as mergeRefs } from './internals/utils-CWsh4Zpu.mjs';
+import 'csstype';
+
+/**
+ * Create a pair of Parent and Child components.
+ *
+ * @param allowTextChildren - Whether to allow text children in the Parent component.
+ * @param allowedChildTypes - An array of additional allowed child component types.
+ * @returns An object containing the Parent and Child components.
+ */
+declare const createPairs: ({ allowTextChildren, allowedChildTypes }?: {
+    allowTextChildren?: boolean;
+    allowedChildTypes?: (_ElementType | typeof NativeElementType)[];
+}) => {
+    Parent: ({ children }: PropsWithChildren<{}>) => ComponentNode;
+    Child: ({ children }: PropsWithChildren<{}>) => ComponentNode;
+};
+
+/**
+ * Represents a function to fetch asynchronous resources.
+ *
+ * @template T - The type of the resource being fetched.
+ * @template P - The type of the parameters passed to the fetch function.
+ *
+ * @param x - An object containing:
+ *   - `abortSignal`: An `AbortSignal` to handle cancellation of the fetch operation.
+ *   - `param`: Optional parameters for the fetch operation, passed by the `refresh` or `next` function.
+ *   - `prevState`: The previous state of the resource, if applicable. This is only populated when the `next` function is called.
+ *   - `dispatch`: A function to update the resource state during the fetch process.
+ *
+ * @returns A promise that resolves to the fetched resource or `void`.
+ */
+type Fetch<T, P> = (x: {
+    abortSignal: AbortSignal;
+    param?: P;
+    prevState?: T;
+    dispatch: (value: SetStateAction<T, T | undefined>) => void;
+}) => PromiseLike<void | T>;
+/**
+ * Represents a function to fetch asynchronous iterable resources, such as streams or paginated data.
+ *
+ * @template T - The type of the resource items being fetched.
+ * @template P - The type of the parameters passed to the fetch function.
+ *
+ * @param x - An object containing:
+ *   - `abortSignal`: An `AbortSignal` to handle cancellation of the fetch operation.
+ *   - `param`: Optional parameters for the fetch operation, passed by the `refresh` or `next` function.
+ *
+ * @returns An `AsyncIterable` that yields the fetched resource items.
+ */
+type FetchWithIterable<T, P> = (x: {
+    abortSignal: AbortSignal;
+    param?: P;
+}) => Awaitable<AsyncIterable<T>>;
+/**
+ * Configuration object for asynchronous resource fetching.
+ *
+ * @template F - The type of the fetch function.
+ *
+ * @property fetch - The fetch function to retrieve the resource.
+ * @property debounce - Optional debounce settings to control the frequency of fetch calls.
+ *   - `wait`: The number of milliseconds to delay.
+ *   - Other settings as defined in `_.DebounceSettings`.
+ */
+type Config<F> = {
+    fetch: F;
+    debounce?: _.DebounceSettings & {
+        wait?: number;
+    };
+};
+
+type Errors = {
+    token: string;
+    error: any;
+    refresh: () => Awaitable<void>;
+    refreshing: boolean;
+    loading: boolean;
+}[];
+/**
+ * A context provider component for managing asynchronous resource errors.
+ *
+ * This component provides a shared context for tracking errors encountered during
+ * asynchronous operations. It allows child components to access and manage these errors
+ * using the `useResourceErrors` hook.
+ *
+ * ### Usage:
+ * Wrap your application or specific parts of it with this component to enable error tracking:
+ *
+ * ```tsx
+ * <ResourceErrors>
+ *   <YourComponent />
+ * </ResourceErrors>
+ * ```
+ *
+ * @param children - The child components that will have access to the error context.
+ *
+ * @returns A context provider that wraps the provided children.
+ */
+declare const ResourceErrors: ComponentType<PropsWithChildren<{}>>;
+/**
+ * A hook to access the list of asynchronous resource errors.
+ *
+ * This hook allows components to retrieve the current list of errors being tracked
+ * in the `ResourceErrors` context. It must be used within a component that is
+ * a descendant of the `ResourceErrors` provider.
+ *
+ * ### Usage:
+ * ```tsx
+ * import { useEffect, useResourceErrors } from 'frosty';
+ *
+ * const errors = useResourceErrors();
+ *
+ * useEffect(() => {
+ *   errors.forEach(({ token, error, refresh }) => {
+ *     console.error(`Error [${token}]:`, error);
+ *     // Optionally call refresh() to retry the operation
+ *   });
+ * }, [errors]);
+ * ```
+ *
+ * @returns The list of errors currently being tracked in the context. Each error includes:
+ * - `token`: A unique identifier for the error.
+ * - `error`: The error object or message.
+ * - `refresh`: A function to retry the operation that caused the error.
+ */
+declare const useResourceErrors: () => Errors;
+
+/**
+ * A hook to manage asynchronous resources with support for debouncing, error handling, and state management.
+ *
+ * @template T - The type of the resource being fetched.
+ * @template P - The type of the parameters passed to the fetch function.
+ *
+ * @param config - The fetch function or a configuration object containing the fetch function and optional debounce settings.
+ * @param deps - An optional dependency array to control when the resource is refreshed.
+ *
+ * @returns An object containing:
+ * - `count`: The number of times the resource has been fetched.
+ * - `refreshing`: A boolean indicating if the resource is currently being refreshed.
+ * - `loading`: A boolean indicating if the resource is currently being loaded.
+ * - `resource`: The fetched resource.
+ * - `error`: Any error encountered during the fetch.
+ * - `cancel`: A function to cancel the current fetch operation.
+ * - `refresh`: A function to refresh the resource.
+ * - `next`: A function to fetch the next set of data (for paginated resources).
+ * - `setResource`: A function to manually update the resource state.
+ */
+declare const useResource: <T, P = any>(config: Fetch<T, P> | Config<Fetch<T, P>>, deps?: any) => {
+    count: number;
+    refreshing: boolean;
+    loading: boolean;
+    resource: T | undefined;
+    error: any;
+    cancel: (reason?: any) => void;
+    refresh: (param?: P) => Promise<void>;
+    next: (param?: P) => Promise<void>;
+    setResource: (resource: T | ((prevState?: T) => T)) => void;
+};
+/**
+ * A hook to manage asynchronous iterable resources, such as streams or paginated data.
+ *
+ * @template T - The type of the resource items being fetched.
+ * @template P - The type of the parameters passed to the fetch function.
+ *
+ * @param config - The fetch function or a configuration object containing the fetch function and optional debounce settings.
+ * @param deps - An optional dependency array to control when the resource is refreshed.
+ *
+ * @returns An object containing the same properties as `useResource`, but optimized for iterable resources.
+ */
+declare const useIterableResource: <T, P = any>(config: FetchWithIterable<T, P> | Config<FetchWithIterable<T, P>>, deps?: any) => {
+    count: number;
+    refreshing: boolean;
+    loading: boolean;
+    resource: T[] | undefined;
+    error: any;
+    cancel: (reason?: any) => void;
+    refresh: (param?: any) => Promise<void>;
+    setResource: (resource: T[] | ((prevState?: T[] | undefined) => T[])) => void;
+};
+
+/**
+ * A hook that repeatedly calls the provided callback function at the specified interval.
+ *
+ * @param callback - The function to be executed at each interval.
+ * @param ms - The delay in milliseconds between each call to the callback. If not provided, the interval will not be set.
+ * @returns void
+ *
+ * @example
+ * useInterval(() => {
+ *   // Code to run every 1000ms
+ * }, 1000);
+ */
+declare const useInterval: (callback: () => void, ms?: number) => void;
+
+/**
+ * A class representing a store that holds a value and allows for subscription
+ * to changes in that value.
+ *
+ * @template T - The type of the value stored in the store.
+ *
+ * @example
+ * const store = createStore(0);
+ * store.setValue(1);
+ * store.subscribe((oldVal, newVal) => {
+ *   console.log(`Value changed from ${oldVal} to ${newVal}`);
+ * });
+ */
+declare class Store<T> {
+    #private;
+    /**
+     * Gets the current value of the store.
+     *
+     * @returns The current value of the store.
+     */
+    get value(): T;
+    /**
+     * Sets the value of the store and notifies all subscribers.
+     *
+     * @param dispatch - The new value or a function that returns the new value.
+     */
+    setValue(dispatch: SetStateAction<T>): void;
+    /**
+     * Subscribes to changes in the store's value.
+     *
+     * @param callback - The function to call when the value changes.
+     * @returns A function to unsubscribe from the store.
+     */
+    subscribe(callback: (oldVal: T, newVal: T) => void): () => void;
+}
+/**
+ * Creates a new store with the given initial value.
+ *
+ * @param initialValue - The initial value to be stored.
+ * @returns {Store<T>} A new store instance.
+ *
+ * @example
+ * const counterStore = createStore(0);
+ */
+declare const createStore: <T extends unknown = any>(initialValue: T) => Store<T>;
+/**
+ * A hook to subscribe to a store and select a slice of its state.
+ * The component will re-render when the selected state changes.
+ *
+ * @param store - The store instance to subscribe to.
+ * @param selector - A function to select a part of the store's state. Defaults to the entire state.
+ * @param equal - A function to compare selected values for equality. Defaults to deep equality.
+ * @returns The selected slice of the store's state.
+ *
+ * @example
+ * const count = useStore(counterStore);
+ *
+ * @example
+ * // Using a selector
+ * const userName = useStore(userStore, user => user.name);
+ */
+declare const useStore: <T extends unknown = any, S = T>(store: Store<T>, selector?: (state: T) => S, equal?: (value: S, other: S) => boolean) => S;
+
+/**
+ * Eagerly resolves a promise returned by the factory function and caches its result or error.
+ *
+ * This hook ensures the promise settles before rendering completes. If the promise is still pending,
+ * it returns `undefined` and schedules an immediate rerender of the current component. Once resolved, it returns the value.
+ * If rejected, it throws the error.
+ *
+ * #### Usage
+ * ```typescript
+ * const data = useAwaited(() => fetchData(id), [id]);
+ * ```
+ *
+ * #### Parameters
+ * - `factory`: `() => PromiseLike<T>`
+ *   A function that returns a promise to resolve.
+ * - `deps` (optional): `any`
+ *   Dependency array for memoization. The promise is recreated when dependencies change.
+ *
+ * #### Returns
+ * - `T | undefined`
+ *   The resolved value, once available. Returns `undefined` while the promise is pending.
+ * - Throws the rejection error if the promise fails.
+ *
+ * #### Throws
+ * - Error if used outside a render function.
+ * - The rejection error if the promise fails.
+ *
+ * @template T Type of the resolved value.
+ */
+declare const useAwaited: <T>(factory: () => PromiseLike<T>, deps?: any) => T | undefined;
+
+/**
+ * A hook that creates a debounced version of a function.
+ * The debounced function delays invoking the callback until after
+ * the specified wait time has elapsed since the last time it was called.
+ *
+ * This is useful for optimizing performance in scenarios where frequent
+ * function calls (e.g., during user input or window resizing) can be expensive.
+ *
+ * @template T The type of the callback function.
+ * @param callback The function to debounce.
+ * @param settings Configuration options for debouncing, including:
+ *   - `wait` (number): The number of milliseconds to delay.
+ *   - Other lodash debounce options such as `leading` and `trailing`.
+ * @returns A debounced version of the callback function.
+ */
+declare const useDebounce: <T extends (...args: any) => any>(callback: T, settings: _.DebounceSettings & {
+    wait?: number;
+}) => _.DebouncedFunc<T>;
+/**
+ * A hook that creates a debounced version of an asynchronous function.
+ * The debounced function delays invoking the callback until after
+ * the specified wait time has elapsed since the last time it was called.
+ *
+ * This is particularly useful for scenarios where frequent API calls
+ * or other asynchronous operations need to be throttled to improve performance.
+ *
+ * @template T The type of the asynchronous callback function.
+ * @param callback The asynchronous function to debounce.
+ * @param settings Configuration options for debouncing, including:
+ *   - `wait` (number): The number of milliseconds to delay.
+ *   - Other lodash debounce options such as `leading` and `trailing`.
+ * @returns A debounced version of the asynchronous callback function.
+ */
+declare const useAsyncDebounce: <T extends (...args: any) => PromiseLike<any>>(callback: T, settings: _.DebounceSettings & {
+    wait?: number;
+}) => (this: any, ...args: Parameters<T>) => Promise<T extends (...args: any) => PromiseLike<infer R> ? R : never>;
+
+/**
+ * A hook that manages side effects with support for an `AbortSignal`.
+ * It ensures proper cleanup logic and handles asynchronous operations effectively.
+ *
+ * @param effect -
+ *   A function that receives an `AbortSignal` and performs side effects.
+ *   It can optionally return a cleanup function or a promise that resolves to a cleanup function.
+ *
+ * @param deps -
+ *   An optional dependencies that determines when the effect should be re-executed.
+ *
+ * @example
+ * useEffect((signal) => {
+  *   fetch('/api/data', { signal })
+ *     .then(response => response.json())
+ *     .then(data => console.log(data))
+ *     .catch(err => {
+ *       if (err.name === 'AbortError') {
+ *         console.log('Fetch aborted');
+ *       } else {
+ *         console.error(err);
+ *       }
+ *     });
+ *
+ *   return () => {
+ *     console.log('Cleanup logic here');
+ *   };
+ * }, []);
+ */
+declare const useEffect: (effect: (signal: AbortSignal) => Awaitable<void | (() => Awaitable<void>)>, deps?: any) => void;
+
+type Context<Value> = ReturnType<typeof _createContext<Value>>;
+type ContextType<C extends Context<any>> = C extends Context<infer T> ? T : never;
+declare const _createContext: <Value extends unknown>(defaultValue: Value) => ComponentType<{
+    value: Value;
+    children?: ElementNode | ((value: Value) => ElementNode);
+}> & {
+    Consumer: ComponentType<{
+        children: (value: Value) => ElementNode;
+    }>;
+};
+/**
+ * Creates a new context object with an optional default value.
+ *
+ * A context object allows you to share a value across a component tree
+ * without explicitly passing it as a prop to every level.
+ *
+ * @template Value - The type of the value to be stored in the context.
+ * @param - The default value for the context.
+ * @returns A context object that can be used to provide and consume the value.
+ */
+declare function createContext<Value>(defaultValue: Value): Context<Value>;
+declare function createContext<Value = undefined>(): Context<Value | undefined>;
+/**
+ * A hook that retrieves the current value of a context and optionally applies
+ * a selector function to transform the context value. This hook ensures that the component
+ * subscribes to the context and re-renders when the context value changes.
+ *
+ * @template T - The type of the context value.
+ * @template R - The type of the transformed value returned by the selector.
+ * @param context - The context object to retrieve the value from.
+ * @param selector - An optional selector function to transform the context value.
+ *                   Defaults to an identity function.
+ * @returns - The current value of the context, optionally transformed by the selector.
+ *
+ * @throws - Throws an error if the provided context is invalid or if the hook
+ *           is used outside of a render function.
+ *
+ * @example
+ * const MyContext = createContext({ user: null });
+ *
+ * function MyComponent() {
+ *   const user = useContext(MyContext, context => context.user);
+ *   return <div>{user ? `Hello, ${user.name}` : 'Hello, Guest'}</div>;
+ * }
+ */
+declare const useContext: <T, R = T>(context: Context<T>, selector?: (state: T) => R) => R;
+
+/**
+ * A utility function that memoizes the result of a factory function.
+ *
+ * @template T The type of the value returned by the factory function.
+ * @param factory A function that produces a value to be memoized.
+ * @param deps An optional dependency array. The memoized value is recalculated
+ *             only when the dependencies change.
+ * @returns The memoized value produced by the factory function.
+ */
+declare const useMemo: <T>(factory: () => T, deps?: any) => T;
+
+/**
+ * Creates a mutable reference object that persists across function calls.
+ *
+ * @template T The type of the value stored in the reference.
+ * @param initialValue The initial value to store in the reference.
+ * @returns An object with a `current` property that holds the value.
+ */
+declare function useRef<T>(initialValue: T): RefObject<T>;
+declare function useRef<T = undefined>(): RefObject<T | undefined>;
+/**
+ * Associates a reference with a value created by an initializer function.
+ *
+ * @template T The type of the reference.
+ * @template R The type of the value created by the initializer function.
+ * @param ref A reference object or a callback function to receive the value.
+ * @param init A function that initializes and returns the value to associate with the reference.
+ * @param deps An optional dependency array. The initializer function is re-executed when the dependencies change.
+ */
+declare const useRefHandle: <T, R extends T>(ref: Ref<T> | undefined, init: () => R, deps?: any) => void;
+
+/**
+ * A hook that memoizes a callback function, ensuring that it only changes
+ * if its dependencies change. This is useful for optimizing performance by preventing
+ * unnecessary re-creations of functions.
+ *
+ * @template T - The type of the callback function.
+ * @param callback - The callback function to be memoized.
+ * @param deps - An optional dependencies. If provided, the callback
+ *               will only be updated when one of these dependencies changes.
+ *               If not provided, the callback will remain stable.
+ * @returns - A stable version of the callback function that will not change unless
+ *            its dependencies change.
+ *
+ * @example
+ * const memoizedCallback = useCallback(() => {
+ *   console.log('This function is memoized!');
+ * }, [dependency]);
+ */
+declare function useCallback<T extends (...args: any) => any>(callback: T, deps?: any): T;
+declare function useCallback<T extends ((...args: any) => any) | _.Falsey>(callback: T, deps?: any): T;
+
+/**
+ * A hook function for managing state within a custom framework or library.
+ *
+ * @template T - The type of the state value.
+ * @param - The initial state value or a function that returns the initial state.
+ * @returns - A tuple containing the current state value and a function to update the state.
+ *
+ * The `useState` function provides a way to manage stateful values. It returns the current state
+ * and a setter function that can update the state. The setter function accepts either a new value
+ * or a function that receives the current state and returns the updated state.
+ *
+ * Example:
+ * ```typescript
+ * const [count, setCount] = useState(0);
+ * setCount(5); // Updates the state to 5
+ * setCount(prev => prev + 1); // Updates the state to the previous value + 1
+ * ```
+ */
+declare function useState<T>(initialState: T | (() => T)): [T, (dispatch: SetStateAction<T>) => void];
+declare function useState<T = undefined>(): [T | undefined, (dispatch: SetStateAction<T | undefined>) => void];
+
+/**
+ * Retrieves the stack of parent components from the current hook state.
+ *
+ * This function accesses the current hook state and extracts the stack of
+ * parent components. It throws an error if called outside of a valid render
+ * context.
+ *
+ * @returns An array of parent components from the current hook state.
+ * @throws Will throw an error if the function is called outside of a valid render context.
+ */
+declare const useStack: () => ComponentNode[];
+
+/**
+ * A utility function that manages state using a reducer pattern.
+ *
+ * @template T The type of the state.
+ * @template A The type of the action object (optional).
+ * @param reducer A function that takes the current state and an action, and returns the new state.
+ * @param initialState The initial state value or a function that returns the initial state.
+ * @returns A tuple containing the current state and a dispatch function to update the state.
+ */
+declare function useReducer<T>(reducer: (prevState: T) => T, initialState: T | (() => T)): [T, (dispatch: () => void) => void];
+declare function useReducer<T, A = any>(reducer: (prevState: T, action: A) => T, initialState: T | (() => T)): [T, (dispatch: (action: A) => void) => void];
+declare function useReducer<T = undefined>(reducer: (prevState: T | undefined) => T | undefined): [T | undefined, (dispatch: () => void) => void];
+declare function useReducer<T = undefined, A = any>(reducer: (prevState: T | undefined, action: A) => T | undefined): [T | undefined, (dispatch: (action: A) => void) => void];
+
+/**
+ * A hook utility for synchronizing with an external store.
+ *
+ * @template Snapshot - The type of the snapshot returned by the store.
+ * @param subscribe - A function that sets up a subscription to the external store.
+ *   - `onStoreChange`: A callback to invoke when the store changes.
+ *   - `signal`: An `AbortSignal` to handle cleanup when the subscription is no longer needed.
+ *   - Returns an optional cleanup function or a promise resolving to one.
+ * @param getSnapshot - A function that retrieves the current snapshot of the store.
+ * @param getServerSnapshot - (Optional) A function that retrieves the snapshot of the store
+ *   in a server environment.
+ * @returns The current snapshot of the store.
+ *
+ * @throws Will throw an error if used outside of a valid render context.
+ */
+declare const useSyncExternalStore: <Snapshot>(subscribe: (onStoreChange: () => void, signal: AbortSignal) => Awaitable<void | (() => Awaitable<void>)>, getSnapshot: () => Snapshot, getServerSnapshot?: () => Snapshot) => Snapshot;
+
+/**
+ * Returns a persistent storage Map associated with the current renderer instance.
+ * This hook allows components to store and retrieve values that persist across renders,
+ * scoped to the renderer. Must be called within a render function.
+ *
+ * @throws Error if called outside of a render function.
+ * @returns {Map<any, any>} The storage map for the current renderer.
+ */
+declare const useRendererStorage: () => Map<any, any>;
+
+type ErrorBoundaryProps = PropsWithChildren<{
+    silent?: boolean;
+    onError?: (error: any, component: ComponentNode, stack: ComponentNode[]) => void;
+}>;
+declare const ErrorBoundary: ComponentType<ErrorBoundaryProps>;
+
+type PropsProviderProps = PropsWithChildren<{
+    callback: (v: {
+        type: _ElementType | typeof NativeElementType;
+        props: PropsType;
+    }) => PropsType | undefined | null;
+}>;
+declare const PropsProvider: ComponentType<PropsProviderProps>;
+
+export { ComponentNode, ComponentType, ElementNode, _ElementType as ElementType, ErrorBoundary, PropsProvider, PropsWithChildren, Ref, RefObject, ResourceErrors, SetStateAction, createContext, createPairs, createStore, useAsyncDebounce, useAwaited, useCallback, useContext, useDebounce, useEffect, useInterval, useIterableResource, useMemo, useReducer, useRef, useRefHandle, useRendererStorage, useResource, useResourceErrors, useStack, useState, useStore, useSyncExternalStore };
+export type { Context, ContextType };
+//# sourceMappingURL=index.d.mts.map