frosty 0.0.13 → 0.0.14

package/dist/index.js

@@ -2,16 +2,641 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var state = require('./internals/state-0jEjYdYV.js');
-var sync = require('./internals/sync-CSxmMfGm.js');
-var state$1 = require('./internals/state-DH_D-jro.js');
 var _ = require('lodash');
+var sync = require('./internals/sync-BIbWmXEq.js');
+var utils = require('./internals/utils-Bipfwp1R.js');
+var jsxRuntime = require('./jsx-runtime.js');
 var component = require('./internals/component-DJsXAx2C.js');
-var fragment = require('./internals/fragment-B0rB4qEp.js');
 var runtime = require('./internals/runtime-CHi74WKN.js');
-var utils = require('./internals/utils-Dc66ARNS.js');
 require('myers.js');
 
+//
+//  memo.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+function useRef(initialValue) {
+    return sync._useMemo('useRef', () => ({ current: initialValue }), null);
+}
+/**
+ * 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.
+ */
+const useRefHandle = (ref, init, deps) => sync._useEffect('useRefHandle', () => {
+    try {
+        if (ref) {
+            const _ref = init();
+            if (typeof ref === 'function')
+                ref(_ref);
+            else if (typeof ref === 'object')
+                ref.current = _ref;
+        }
+        return () => void 0;
+    }
+    catch (e) {
+        console.error(e);
+        return () => void 0;
+    }
+}, deps);
+
+//
+//  memo.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+function useState(initialState) {
+    const { value, setValue } = sync._useMemo('useState', ({ node }) => {
+        const state = {
+            value: _.isFunction(initialState) ? initialState() : initialState,
+            setValue: (dispatch) => {
+                state.value = _.isFunction(dispatch) ? dispatch(state.value) : dispatch;
+                node?._setDirty();
+            },
+        };
+        return state;
+    }, null);
+    return [value, setValue];
+}
+
+//
+//  animate.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const interpolate = (value) => ({ inputRange, outputRange }) => {
+    const [inputMin, inputMax] = inputRange;
+    const [outputMin, outputMax] = outputRange;
+    // Safeguard against division by zero
+    if (inputMax === inputMin) {
+        throw new Error('Input range must have distinct values.');
+    }
+    const t = (value - inputMin) / (inputMax - inputMin);
+    const interpolatedValue = outputMin + t * (outputMax - outputMin);
+    return {
+        value: interpolatedValue,
+        interpolate: interpolate(interpolatedValue),
+    };
+};
+/**
+ * A hook to manage animations with support for starting, stopping, and interpolating values.
+ *
+ * @param initialValue - The initial value of the animation.
+ *
+ * @returns An object containing:
+ * - `value`: The current animated value.
+ * - `stop`: A function to stop the animation.
+ * - `start`: A function to start the animation with specified options.
+ * - `interpolate`: A function to interpolate the current value based on input and output ranges.
+ */
+const useAnimate = (initialValue) => {
+    const [value, setValue] = useState(initialValue);
+    const ref = useRef();
+    const _stop = () => {
+        const { interval, callback } = ref.current ?? {};
+        ref.current = undefined;
+        if (interval)
+            clearInterval(interval);
+        return callback;
+    };
+    const stop = sync.useCallback(() => {
+        const callback = _stop();
+        if (_.isFunction(callback))
+            callback({ value, finished: false });
+    });
+    const start = sync.useCallback(({ fromValue = value, toValue, duration, easing = (x) => x, delay = 0, onCompleted, }) => {
+        _stop();
+        const start = Date.now();
+        if (duration > 0) {
+            ref.current = {
+                interval: setInterval(() => {
+                    const t = (Date.now() - start) / duration - delay;
+                    if (t >= 1) {
+                        clearInterval(ref.current?.interval);
+                        ref.current = undefined;
+                        setValue(toValue);
+                        if (_.isFunction(onCompleted))
+                            onCompleted({ value: toValue, finished: true });
+                    }
+                    else if (t >= 0) {
+                        setValue((toValue - fromValue) * easing(_.clamp(t, 0, 1)) + fromValue);
+                    }
+                }, 16),
+                callback: onCompleted,
+            };
+        }
+    });
+    return {
+        value,
+        stop,
+        start,
+        interpolate: interpolate(value),
+    };
+};
+
+//
+//  debounce.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const debounce = (callback, settings) => {
+    const { wait, ...options } = settings;
+    return _.debounce(callback, wait, {
+        ...options,
+        leading: 'leading' in options ? !!options.leading : true,
+        trailing: 'trailing' in options ? !!options.trailing : true,
+    });
+};
+const asyncDebounce = (func, settings) => {
+    let preflight;
+    const debounced = debounce(async (resolve, ...args) => {
+        const result = func(...args);
+        if (_.isFunction(resolve))
+            resolve(result);
+        return result;
+    }, settings);
+    return (...args) => {
+        if (_.isNil(preflight)) {
+            preflight = new Promise(r => debounced(r, ...args));
+            return preflight;
+        }
+        return debounced(undefined, ...args) ?? preflight;
+    };
+};
+/**
+ * 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.
+ */
+const useDebounce = (callback, settings) => {
+    const store = sync._useMemo('useDebounce', () => {
+        const store = {
+            current: callback,
+            stable: debounce(((...args) => store.current(...args)), settings),
+        };
+        return store;
+    }, null);
+    store.current = callback;
+    return store.stable;
+};
+/**
+ * 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.
+ */
+const useAsyncDebounce = (callback, settings) => {
+    const store = sync._useMemo('useAsyncDebounce', () => {
+        const store = {
+            current: callback,
+            stable: asyncDebounce(((...args) => store.current(...args)), settings),
+        };
+        return store;
+    }, null);
+    store.current = callback;
+    return store.stable;
+};
+
+const Context = utils.createContext({
+    errors: [],
+    setErrors: () => { },
+});
+/**
+ * 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.
+ */
+const ResourceErrors = ({ children }) => {
+    const [errors, setErrors] = useState([]);
+    const value = sync.useMemo(() => ({ errors, setErrors }), [errors, setErrors]);
+    return (jsxRuntime.jsx(Context, { value: value, children: children }));
+};
+/**
+ * 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
+ * const errors = useResourceErrors();
+ *
+ * errors.forEach(({ token, error, refresh }) => {
+ *   console.error(`Error [${token}]:`, error);
+ *   // Optionally call refresh() to retry the operation
+ * });
+ * ```
+ *
+ * @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.
+ */
+const useResourceErrors = () => utils.useContext(Context).errors;
+
+//
+//  index.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+/**
+ * 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.
+ */
+const useResource = (config, deps) => {
+    const fetch = _.isFunction(config) ? config : config.fetch;
+    const debounce = _.isFunction(config) ? {} : config.debounce;
+    const [state, setState] = useState({});
+    const _dispatch = (token, next) => setState(state => state.token === token ? ({
+        ...(_.isFunction(next) ? next(state.flag ? state : _.omit(state, 'resource', 'error')) : next),
+        count: state.flag ? state.count : (state.count ?? 0) + 1,
+        flag: true,
+    }) : state);
+    const _fetch = useAsyncDebounce(async (type, abort, reset, param, prevState) => {
+        const token = _.uniqueId();
+        setState(state => ({ ...state, type, token, abort, flag: !reset }));
+        try {
+            const resource = await fetch({
+                param,
+                prevState,
+                abortSignal: abort.signal,
+                dispatch: (next) => {
+                    _dispatch(token, state => ({
+                        ...state,
+                        resource: _.isFunction(next) ? next(state.resource) : next,
+                    }));
+                },
+            });
+            _dispatch(token, state => ({ resource: resource ?? state.resource }));
+        }
+        catch (error) {
+            _dispatch(token, state => ({
+                resource: state.resource,
+                error,
+            }));
+        }
+    }, debounce ?? {});
+    sync.useEffect(() => {
+        const controller = new AbortController();
+        void _fetch('refresh', controller, true);
+        return () => controller.abort();
+    }, deps ?? []);
+    const _cancelRef = sync.useCallback((reason) => { state.abort?.abort(reason); });
+    const _refreshRef = sync.useCallback((param) => _fetch('refresh', new AbortController(), true, param));
+    const _nextRef = sync.useCallback((param) => _fetch('next', new AbortController(), false, param, state.resource));
+    const _setResRef = sync.useCallback((resource) => setState(state => ({
+        ..._.omit(state, 'resource', 'error'),
+        resource: _.isFunction(resource) ? resource(state.resource) : resource,
+    })));
+    const { setErrors } = utils.useContext(Context);
+    sync.useEffect(() => {
+        const { type, abort, token = _.uniqueId(), error } = state;
+        if (!error)
+            return;
+        setErrors(v => [...v, {
+                token,
+                error,
+                refresh: _refreshRef,
+                refreshing: !_.isNil(abort) && type === 'refresh',
+                loading: !_.isNil(abort),
+            }]);
+        return () => setErrors(v => _.filter(v, x => x.token !== token));
+    }, [state]);
+    return {
+        count: state.count ?? 0,
+        refreshing: !_.isNil(state.abort) && state.type === 'refresh',
+        loading: !_.isNil(state.abort),
+        resource: state.resource,
+        error: state.error,
+        cancel: _cancelRef,
+        refresh: _refreshRef,
+        next: _nextRef,
+        setResource: _setResRef,
+    };
+};
+/**
+ * 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.
+ */
+const useIterableResource = (config, deps) => {
+    const fetch = _.isFunction(config) ? config : config.fetch;
+    const debounce = _.isFunction(config) ? {} : config.debounce;
+    const { next, ...result } = useResource({
+        fetch: async ({ dispatch, abortSignal, param }) => {
+            const resource = await fetch({ abortSignal, param });
+            for await (const item of resource) {
+                dispatch(items => items ? [...items, item] : [item]);
+            }
+        },
+        debounce,
+    }, deps);
+    return result;
+};
+
+//
+//  interval.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+/**
+ * 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);
+ */
+const useInterval = (callback, ms) => sync.useEffect(() => {
+    const interval = setInterval(() => {
+        callback();
+    }, ms);
+    return () => clearInterval(interval);
+}, []);
+
+//
+//  store.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+/**
+ * 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}`);
+ * });
+ */
+class Store {
+    #listeners = new Set();
+    #value;
+    /** @internal */
+    constructor(initialValue) {
+        this.#value = initialValue;
+    }
+    /**
+     * Gets the current value of the store.
+     *
+     * @returns The current value of the store.
+     */
+    get value() {
+        return this.#value;
+    }
+    /**
+     * 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) {
+        const oldVal = this.#value;
+        dispatch = _.isFunction(dispatch) ? dispatch(this.#value) : this.#value;
+        this.#listeners.forEach(listener => void listener(oldVal, this.#value));
+    }
+    /**
+     * 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) {
+        this.#listeners.add(callback);
+        return () => { this.#listeners.delete(callback); };
+    }
+}
+/**
+ * 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);
+ */
+const createStore = (initialValue) => new Store(initialValue);
+/**
+ * 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);
+ */
+const useStore = (store, selector = v => v, equal = _.isEqual) => sync.useSyncExternalStore((onStoreChange) => store.subscribe((oldVal, newVal) => {
+    if (equal(selector(oldVal), selector(newVal)))
+        onStoreChange();
+}), () => selector(store.value));
+
 //
 //  stack.ts
 //
@@ -47,7 +672,7 @@ require('myers.js');
  * @throws Will throw an error if the function is called outside of a valid render context.
  */
 const useStack = () => {
-    const state = state$1.reconciler.currentHookState;
+    const state = utils.reconciler.currentHookState;
     if (!state)
         throw Error('useStack must be used within a render function.');
     return _.map(state.stack, x => x._component);
@@ -119,44 +744,60 @@ function useReducer(reducer, initialState) {
 var common = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ComponentNode: component.ComponentNode,
-    ErrorBoundary: state$1.ErrorBoundary,
-    Fragment: fragment.Fragment,
-    PropsProvider: state$1.PropsProvider,
-    createContext: state$1.createContext,
+    ErrorBoundary: utils.ErrorBoundary,
+    Fragment: jsxRuntime.Fragment,
+    PropsProvider: utils.PropsProvider,
+    ResourceErrors: ResourceErrors,
+    createContext: utils.createContext,
     createElement: runtime.createElement,
+    createStore: createStore,
     mergeRefs: utils.mergeRefs,
-    useAsyncDebounce: state.useAsyncDebounce,
+    useAnimate: useAnimate,
+    useAsyncDebounce: useAsyncDebounce,
     useCallback: sync.useCallback,
-    useContext: state$1.useContext,
-    useDebounce: state.useDebounce,
+    useContext: utils.useContext,
+    useDebounce: useDebounce,
     useEffect: sync.useEffect,
+    useInterval: useInterval,
+    useIterableResource: useIterableResource,
     useMemo: sync.useMemo,
     useReducer: useReducer,
-    useRef: state.useRef,
-    useRefHandle: state.useRefHandle,
+    useRef: useRef,
+    useRefHandle: useRefHandle,
+    useResource: useResource,
+    useResourceErrors: useResourceErrors,
     useStack: useStack,
-    useState: state.useState,
+    useState: useState,
+    useStore: useStore,
     useSyncExternalStore: sync.useSyncExternalStore
 });
 
-exports.useAsyncDebounce = state.useAsyncDebounce;
-exports.useDebounce = state.useDebounce;
-exports.useRef = state.useRef;
-exports.useRefHandle = state.useRefHandle;
-exports.useState = state.useState;
 exports.useCallback = sync.useCallback;
 exports.useEffect = sync.useEffect;
 exports.useMemo = sync.useMemo;
 exports.useSyncExternalStore = sync.useSyncExternalStore;
-exports.ErrorBoundary = state$1.ErrorBoundary;
-exports.PropsProvider = state$1.PropsProvider;
-exports.createContext = state$1.createContext;
-exports.useContext = state$1.useContext;
+exports.ErrorBoundary = utils.ErrorBoundary;
+exports.PropsProvider = utils.PropsProvider;
+exports.createContext = utils.createContext;
+exports.mergeRefs = utils.mergeRefs;
+exports.useContext = utils.useContext;
+exports.Fragment = jsxRuntime.Fragment;
 exports.ComponentNode = component.ComponentNode;
-exports.Fragment = fragment.Fragment;
 exports.createElement = runtime.createElement;
-exports.mergeRefs = utils.mergeRefs;
+exports.ResourceErrors = ResourceErrors;
+exports.createStore = createStore;
 exports.default = common;
+exports.useAnimate = useAnimate;
+exports.useAsyncDebounce = useAsyncDebounce;
+exports.useDebounce = useDebounce;
+exports.useInterval = useInterval;
+exports.useIterableResource = useIterableResource;
 exports.useReducer = useReducer;
+exports.useRef = useRef;
+exports.useRefHandle = useRefHandle;
+exports.useResource = useResource;
+exports.useResourceErrors = useResourceErrors;
 exports.useStack = useStack;
+exports.useState = useState;
+exports.useStore = useStore;
 //# sourceMappingURL=index.js.map