@storesjs/stores 0.11.0 → 0.12.1

package/dist/utils/equality.d.ts

@@ -1,38 +0,0 @@
-/**
- * **Worklet compatible**
- *
- * Performs a deep equality check between two values.
- *
- * This function recursively compares two values, checking if they are equal. For objects,
- * it validates that both have the same keys and that each corresponding value is deeply equal.
- * For non-objects, it uses strict equality.
- *
- * @param obj1 - The first value to compare.
- * @param obj2 - The second value to compare.
- * @returns `true` if the values are deeply equal; otherwise, `false`.
- */
-export declare function deepEqual<U>(obj1: U, obj2: U): boolean;
-/**
- * **Worklet compatible**
- *
- * Performs a shallow equality check between two values.
- *
- * For non-objects, uses strict equality (===). For objects, checks that both have identical
- * keys and compares their values using `Object.is` without recursing into nested objects.
- *
- * Ideal for preventing re-renders due to top-level object recreation.
- *
- * @param obj1 - The first value to compare.
- * @param obj2 - The second value to compare.
- * @returns `true` if the values are shallowly equal; otherwise, `false`.
- */
-export declare function shallowEqual<U>(obj1: U, obj2: U): boolean;
-/**
- * Performs a deep equality check between two values, supporting objects, arrays, maps, sets, dates, regexps, array buffers, and more.
- * Copied from dequal@2.0.3 and fully typed for TypeScript.
- * @param foo - The first value to compare.
- * @param bar - The second value to compare.
- * @returns `true` if the values are deeply equal; otherwise, `false`.
- */
-export declare function dequal(foo: unknown, bar: unknown): boolean;
-//# sourceMappingURL=equality.d.ts.map

package/dist/utils/hydrationCoordinator.d.ts

@@ -1,13 +0,0 @@
-export type HydrationCoordinator = {
-    readonly complete: () => void;
-    readonly fail: (error: Error) => void;
-    readonly isHydrated: () => boolean;
-    readonly promise: Promise<void>;
-};
-/**
- * Creates a coordinator for tracking async storage hydration lifecycle.
- * Provides a promise that resolves once hydration completes and methods
- * to signal completion or failure.
- */
-export declare function createHydrationCoordinator(): HydrationCoordinator;
-//# sourceMappingURL=hydrationCoordinator.d.ts.map

package/dist/utils/promiseUtils.d.ts

@@ -1,2 +0,0 @@
-export declare function isPromiseLike<T>(value: T | Promise<T> | void): value is Promise<T>;
-//# sourceMappingURL=promiseUtils.d.ts.map

package/dist/utils/serialization.d.ts

@@ -1,14 +0,0 @@
-type SerializedMap = {
-    __type: 'Map';
-    entries: [unknown, unknown][];
-};
-export declare function isSerializedMap(value: unknown): value is SerializedMap;
-type SerializedSet = {
-    __type: 'Set';
-    values: unknown[];
-};
-export declare function isSerializedSet(value: unknown): value is SerializedSet;
-export declare function replacer(_: string, value: unknown): unknown;
-export declare function reviver(_: string, value: unknown): unknown;
-export {};
-//# sourceMappingURL=serialization.d.ts.map

package/dist/utils/stringUtils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns a pluralized (by default: `word` + `'s'`) string based on the count.
- *
- * `word` should be provided in singular form.
- */
-export declare function pluralize(word: string, count: number, pluralSuffix?: string): string;
-//# sourceMappingURL=stringUtils.d.ts.map

package/dist/utils/time.d.ts

@@ -1,37 +0,0 @@
-type TimeInMs = number;
-type TimeUtils = {
-    /** Returns the input value unchanged, in milliseconds */
-    ms: (ms: number) => TimeInMs;
-    /** Converts seconds to milliseconds */
-    seconds: (seconds: number) => TimeInMs;
-    /** Converts minutes to milliseconds */
-    minutes: (minutes: number) => TimeInMs;
-    /** Converts hours to milliseconds */
-    hours: (hours: number) => TimeInMs;
-    /** Converts days to milliseconds */
-    days: (days: number) => TimeInMs;
-    /** Converts weeks to milliseconds */
-    weeks: (weeks: number) => TimeInMs;
-    /** Represents infinite time */
-    infinity: typeof Infinity;
-    /** Represents zero time */
-    zero: 0;
-};
-/**
- * Worklet-compatible utility object for defining time values.
- *
- * All methods convert the input unit to milliseconds.
- *
- * @example
- * time.seconds(5) // 5 seconds
- * time.minutes(2) // 2 minutes
- * time.hours(1) // 1 hour
- * time.days(5) // 5 days
- * time.weeks(2) // 2 weeks
- * ––
- * time.infinity // Infinity
- * time.zero // 0
- */
-export declare const time: TimeUtils;
-export {};
-//# sourceMappingURL=time.d.ts.map

package/dist/vanilla/createBaseStore.d.ts

@@ -1,35 +0,0 @@
-import type { BaseStoreOptions, OptionallyPersistedStore, Store, StateCreator } from './types';
-/**
- * Creates a base store without persistence.
- * @param createState - The state creator function for the base store.
- * @returns A store with the specified state.
- */
-export declare function createBaseStore<S>(createState: StateCreator<S>): Store<S>;
-/**
- * Creates a base store with persistence.
- * @param createState - The state creator function for the base store.
- * @param options - The configuration options for persistence and sync.
- * @returns A store with the specified state and persistence.
- */
-export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends void = void>(createState: StateCreator<S>, options: BaseStoreOptions<S, PersistedState, PersistReturn>): Store<S, PersistedState, PersistReturn>;
-/**
- * Creates a base store with async persistence.
- * @param createState - The state creator function for the base store.
- * @param options - The configuration options for persistence and sync.
- * @returns A store with the specified state and persistence.
- */
-export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends Promise<void> = Promise<void>>(createState: StateCreator<S>, options: BaseStoreOptions<S, PersistedState, PersistReturn>): Store<S, PersistedState, PersistReturn>;
-/**
- * Creates a base store with optional persistence.
- * @param createState - The state creator function for the base store.
- * @param options - The configuration options for persistence and sync.
- * @returns A store with the specified state and optional persistence.
- */
-export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends void = void>(createState: StateCreator<S>, options?: BaseStoreOptions<S, PersistedState, PersistReturn>): OptionallyPersistedStore<S, PersistedState, PersistReturn>;
-/**
- * Creates a base store with optional async persistence.
- * @param createState - The state creator function for the base store.
- * @param options - The configuration options for persistence and sync.
- * @returns A store with the specified state and optional persistence.
- */
-export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends Promise<void> = Promise<void>>(createState: StateCreator<S>, options?: BaseStoreOptions<S, PersistedState, PersistReturn>): OptionallyPersistedStore<S, PersistedState, PersistReturn>;

package/dist/vanilla/createDerivedStore.d.ts

@@ -1,62 +0,0 @@
-import type { DeriveGetter, DeriveOptions, DerivedStore } from './types';
-/**
- * ### `createDerivedStore`
- *
- * Creates a **read-only** store derived from one or more source stores.
- *
- * ---
- * The `deriveFunction` is called whenever its dependencies change, producing a new derived state.
- * Dependencies are automatically tracked through a special `$` helper, which supports:
- *
- * 1) **Selector-based** usage:
- *    ```ts
- *    $ => {
- *      const user = $(useUserStore, s => s.user, shallowEqual);
- *      const theme = $(useSettingsStore, s => s.appearance.theme);
- *      return { user, theme, isAdmin: user?.roles.includes('admin') };
- *    }
- *    ```
- *
- * 2) **Proxy-based** usage (auto-built selectors for nested properties):
- *    ```ts
- *    $ => {
- *      const { user } = $(useUserStore); // Subscribe to `user`
- *      const theme = $(useSettingsStore).appearance.theme; // Subscribe to `theme`
- *      return { isAdmin: user?.roles.includes('admin'), theme, user };
- *    }
- *    ```
- *
- * ---
- * Derived stores automatically unsubscribe from all dependencies when no consumers remain, and
- * resubscribe when new consumers appear. The returned store exposes:
- *
- * - A **store object** with `getState()`, `subscribe()`, and `destroy()`
- * - In the React build, a **React hook** (`const state = derivedStore(selector, equalityFn?)`)
- *
- * ---
- * You can optionally pass a second parameter (either an equality function or a config object)
- * to enable debouncing, customize the equality function, or set `lockDependencies: true`.
- *
- * (When dependencies are locked, subscriptions created via `$` are established once and are
- * not rebuilt on subsequent re-derives, which can be a performance win for certain workloads.)
- *
- * ---
- * @example
- * ```ts
- * // Create a derived store
- * const searchResultsStore = createDerivedStore($ => {
- *   const query = $(searchStore).query.trim().toLowerCase();
- *   const items = $(itemsStore).items;
- *   return findResults(query, items);
- * }, shallowEqual);
- *
- * const results = searchResultsStore.getState();
- * ```
- *
- * ---
- * @param deriveFunction - Function that reads from other stores via `$` to produce derived state.
- * @param optionsOrEqualityFn - Either an equality function or a config object (see `DeriveOptions`).
- *
- * @returns A read-only derived store. In the React build, it is also callable as a hook.
- */
-export declare function createDerivedStore<Derived>(deriveFunction: ($: DeriveGetter) => Derived, optionsOrEqualityFn?: DeriveOptions<Derived>): DerivedStore<Derived>;

package/dist/vanilla/createQueryStore.d.ts

@@ -1,110 +0,0 @@
-import { defaultRetryDelay } from './internal/runtime';
-import type { QueryStoreConfig, QueryStoreState } from './queryStore/types';
-import type { BaseStoreOptions, OptionallyPersistedStore, PersistedStore, StateCreator, Store } from './types';
-export { defaultRetryDelay };
-export { getQueryKey, parseQueryKey } from './queryStore/queryKey';
-export { queryParam } from './queryStore/queryParam';
-export type { QueryParam, QueryParamConfig, QueryParamKey, ReactiveParam } from './queryStore/queryParam';
-/**
- * Creates a persisted, query-enabled store with data fetching capabilities (sync storage).
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>;
-/**
- * Creates a persisted, query-enabled store with data fetching capabilities (async storage).
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>;
-/**
- * Creates a persisted, query-enabled store with data fetching capabilities (sync storage).
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template CustomState - User-defined custom store state
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>;
-/**
- * Creates a persisted, query-enabled store with data fetching capabilities (async storage).
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template CustomState - User-defined custom store state
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>;
-/**
- * Creates a query-enabled store with data fetching capabilities.
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template CustomState - User-defined custom store state
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options?: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>>): Store<QueryStoreState<TData, TParams, CustomState>>;
-/**
- * Creates a query-enabled store with data fetching capabilities.
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options?: BaseStoreOptions<QueryStoreState<TData, TParams>>): Store<QueryStoreState<TData, TParams>>;
-/**
- * Creates a conditionally persisted, query-enabled store with data-fetching capabilities
- * and custom state (sync storage).
- *
- * `options.persist` may be `undefined` – the returned store exposes `persist?`.
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template CustomState - User-defined custom store state
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options?: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): OptionallyPersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>;
-/**
- * Creates a conditionally persisted, query-enabled store with data-fetching capabilities
- * and custom state (async storage).
- *
- * `options.persist` may be `undefined` – the returned store exposes `persist?`.
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template CustomState - User-defined custom store state
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options?: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): OptionallyPersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>;
-/**
- * Creates a conditionally persisted, query-enabled store with data fetching capabilities (sync storage).
- *
- * `options.persist` may be `undefined` – the returned store exposes `persist?`.
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn> | undefined): OptionallyPersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>;
-/**
- * Creates a conditionally persisted, query-enabled store with data fetching capabilities (async storage).
- *
- * `options.persist` may be `undefined` – the returned store exposes `persist?`.
- *
- * @template TQueryFnData - The raw data type returned by the fetcher
- * @template TParams - Parameters passed to the fetcher function
- * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
- * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
- */
-export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn> | undefined): OptionallyPersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>;

package/dist/vanilla/createVirtualStore.d.ts

@@ -1,39 +0,0 @@
-import type { BaseStore, DeriveGetter, InferPersistedState, InferSetStateReturn, InferStoreState, OptionallyPersistedStore } from './types';
-type MethodOverrides<Store extends BaseStore<unknown>> = Partial<Pick<Store, 'getState' | 'setState'>>;
-type VirtualStore<Store extends BaseStore<unknown>> = OptionallyPersistedStore<InferStoreState<Store>, InferPersistedState<Store>, InferSetStateReturn<Store>>;
-type VirtualStoreOptions = {
-    debugMode?: boolean;
-    /**
-     * Whether to lock dependencies (see: {@link DeriveOptions}) for the virtual store.
-     * @default true
-     */
-    lockDependencies?: boolean;
-};
-/**
- * ### `createVirtualStore`
- *
- * Returns a stable store interface backed by different store instances over time.
- * When dependencies change, the derive function runs and creates a new store, then
- * all subscriptions rebind automatically. Only depend on state that should trigger
- * new store creation.
- *
- * ---
- * 💡 **Note:** `lockDependencies` (see: {@link DeriveOptions}) is enabled by default.
- * Ensure that any `$` dependencies in your `createStore` function are called
- * consistently. If they are not, set `lockDependencies` to `false`.
- *
- * ---
- * @param createStore - Derive function that returns a store instance
- * @param overrides - Optional method overrides (e.g., `getState(id?: string)`)
- *
- * @example
- * ```ts
- * const useUserAssetsStore = createVirtualStore($ => {
- *   const address = $(useWalletsStore).accountAddress;
- *   return createUserAssetsStore(address);
- * });
- * ```
- */
-export declare function createVirtualStore<Store extends BaseStore<InferStoreState<Store>>>(createStore: ($: DeriveGetter) => Store, options?: VirtualStoreOptions): VirtualStore<Store>;
-export declare function createVirtualStore<Store extends BaseStore<InferStoreState<Store>>, Overrides extends MethodOverrides<Store>>(createStore: ($: DeriveGetter) => Store, overrides: (getStore: () => Store) => Overrides, options?: VirtualStoreOptions): VirtualStore<Store> & Overrides;
-export {};

package/dist/vanilla/env.web.d.ts

@@ -1,6 +0,0 @@
-export declare const IS_REACT_NATIVE = false;
-export declare const IS_BROWSER: boolean;
-export declare const IS_IOS = false;
-export declare const IS_ANDROID = false;
-export declare const IS_DEV: boolean;
-export declare const IS_TEST: boolean;

package/dist/vanilla/index.d.ts

@@ -1 +0,0 @@
-export * from './index.shared';

package/dist/vanilla/index.shared.d.ts

@@ -1,13 +0,0 @@
-export * from './createBaseStore';
-export * from './createDerivedStore';
-export * from './createQueryStore';
-export * from './createVirtualStore';
-export { configureStores, StoresError } from './internal/runtime';
-export { applyStateUpdate, replacer, reviver } from './internal/runtime';
-export { destroyStore, destroyStores, getStoreName, hasGetSnapshot, isDerivedStore, isPersistedStore, isQueryStore, isVirtualStore, } from './internal/runtime';
-export type * from './sync/types';
-export { QueryStatuses } from './internal/runtime';
-export type * from './queryStore/types';
-export type * from './storage/storageTypes';
-export type * from './types';
-export { createStoreActions, deepEqual, identity, nullObject, shallowEqual, time } from './internal/runtime';

package/dist/vanilla/internal/baseStore.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/vanilla/internal/config.d.ts

@@ -1,63 +0,0 @@
-import { QueryStoreConfig } from '../queryStore/types';
-import { SyncEngine } from '../sync/types';
-import { AsyncStorageInterface, SyncStorageInterface } from '../types';
-import { NonFunction } from '../types/functions';
-import { Prettify } from '../types/objects';
-import { Logger } from './logger';
-/**
- * Global configuration for all stores.
- */
-export type StoresConfig = {
-    /**
-     * Custom logger for debug output. Defaults to a no-op logger in production.
-     */
-    logger: Logger;
-    /**
-     * Default options used by all query stores.
-     */
-    queryStoreDefaults: QueryStoreDefaults;
-    /**
-     * Storage backend for persisted stores. Defaults to `localStorage` in browsers,
-     * MMKV in React Native.
-     */
-    storage: AsyncStorageInterface | SyncStorageInterface;
-    /**
-     * Prefix for storage keys built by the default storage adapter.
-     * Should include a delimiter, e.g., `'myapp:'`.
-     * @default 'stores:'
-     */
-    storageKeyPrefix: string;
-    /**
-     * Sync engine for cross-client state synchronization. Defaults to cross-tab sync
-     * in browsers, no-op in other environments.
-     */
-    syncEngine: SyncEngine;
-};
-export type QueryStoreDefaults = Prettify<ConfigDefaults<QueryStoreConfig<unknown, Record<string, unknown>>, 'disableCache' | 'enabled' | 'params', 'retryDelay'>> & {
-    /**
-     * Minimum stale time for auto-refetching query stores under which to log warnings in development.
-     * `false` disables warnings.
-     * @default false
-     */
-    minStaleTime?: number | false;
-};
-type ConfigDefaults<C, Excluded extends keyof C = never, AllowedFunctions extends keyof C = never> = Omit<{
-    [K in keyof C as K extends AllowedFunctions ? K : NonFunction<C[K]> extends undefined ? never : K]?: K extends AllowedFunctions ? C[K] : NonFunction<C[K]>;
-}, Excluded>;
-/**
- * Configures global defaults for all stores.
- *
- * If used, must be called before creating any stores.
- *
- * @see {@link StoresConfig}
- *
- * @example
- * ```ts
- * configureStores({
- *   logger: { debug: console.debug, error: console.error },
- *   storageKeyPrefix: 'myapp:',
- * });
- * ```
- */
-export declare function configureStores(config: Partial<StoresConfig>): void;
-export {};

package/dist/vanilla/internal/createStoreActions.d.ts

@@ -1,23 +0,0 @@
-import type { StoreApi } from '../store/types';
-import type { InferStoreState, StoreActions } from '../types';
-import type { FunctionRecord } from '../types/functions';
-import type { NoOverlap } from '../types/objects';
-/**
- * Given a store instance, produces a new object containing only its actions.
- *
- * Intended for export alongside the associated store.
- *
- * @param store - The store to create actions for.
- * @param bundledMethods - Optional extra methods to bundle into the actions object.
- *
- * @example
- * export const useCounterStore = createRainbowStore(set => ({
- *   count: 0,
- *   increment: () => set(state => ({ count: state.count + 1 })),
- * }));
- *
- * export const exampleActions = createStoreActions(useExampleStore);
- * exampleActions.increment();
- */
-export declare function createStoreActions<Store extends StoreApi<unknown>>(store: Store): StoreActions<Store>;
-export declare function createStoreActions<Store extends StoreApi<unknown>, Bundled extends FunctionRecord>(store: Store, bundledMethods: NoOverlap<InferStoreState<Store>, Bundled>): StoreActions<Store> & Bundled;

package/dist/vanilla/internal/derivedStore/deriveProxy.d.ts

@@ -1,14 +0,0 @@
-import type { StoreApi } from '../../store/types';
-import { TrackPathFn } from './pathFinder';
-/**
- * Gets or creates a lightweight tracking proxy that records path access and store
- * method invocations via proxy traps. Used to auto-generate selectors that point
- * to either the accessed path or the value returned by an invoked store method.
- */
-export declare function getOrCreateProxy<S>(store: StoreApi<S>, rootProxyCache: WeakMap<object, unknown>, trackPath: TrackPathFn): S;
-/**
- * Strips tracking proxies from published values to ensure
- * proxies remain confined to internal tracking contexts.
- */
-export declare function stripProxies<T>(value: T): T;
-export declare function stripProxies(value: unknown, seen?: WeakSet<object>): unknown;

package/dist/vanilla/internal/derivedStore/pathFinder.d.ts

@@ -1,25 +0,0 @@
-import { Selector, SubscribableStore } from '../../types';
-type TrackedInvocation = {
-    args: unknown[] | undefined;
-};
-type PathEntry = {
-    path: string[];
-    store: SubscribableStore;
-    invocation?: TrackedInvocation;
-    isLeaf: boolean;
-};
-type SubscriptionBuilder = (store: SubscribableStore, selector: Selector<unknown, unknown>, path: string[]) => void;
-export type PathFinder = {
-    buildProxySubscriptions(createSubscription: SubscriptionBuilder, shouldLog: boolean, minConsolidationDepth?: number, shouldBuild?: (paths: Set<PathEntry>) => boolean): void;
-    reset(): void;
-    trackPath: TrackPathFn;
-};
-export type TrackPathFn = (store: SubscribableStore, path: string[], isLeaf: boolean, invocation?: TrackedInvocation) => void;
-/**
- * A factory that returns a proxy path-tracking object with three methods:
- *  - `buildProxySubscriptions()`: builds subscriptions to the final paths
- *  - `reset()`: clears all tracked paths
- *  - `trackPath()`: records usage of a store path
- */
-export declare function createPathFinder(): PathFinder;
-export {};

package/dist/vanilla/internal/derivedStore.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/vanilla/internal/errors.d.ts

@@ -1,9 +0,0 @@
-/**
- * Error reported or thrown by the stores package itself.
- *
- * If an underlying thrown value caused the failure, it is available as `cause`.
- */
-export declare class StoresError extends Error {
-    cause?: unknown;
-    constructor(message: string, cause?: unknown);
-}

package/dist/vanilla/internal/logger.d.ts

@@ -1,9 +0,0 @@
-export interface Logger {
-    debug: (message: string, context?: Record<string, unknown>) => void;
-    error: {
-        <T extends Error>(error: T, context?: Record<string, unknown>): void;
-        <T extends string>(error: T, context?: Record<string, unknown>): void;
-    };
-    info: (message: string, context?: Record<string, unknown>) => void;
-    warn: (message: string, context?: Record<string, unknown>) => void;
-}

package/dist/vanilla/internal/middleware/createHydrationGate.d.ts

@@ -1,19 +0,0 @@
-import { StateCreator } from '../../types';
-import { SyncContext } from '../sync/syncEnhancer';
-type WrappedOnRehydrateStorage<S> = (userCallback: ((state: S) => ((finalState?: S, error?: unknown) => void) | void) | undefined, syncContext: SyncContext | undefined) => (state: S) => (finalState?: S, error?: unknown) => void;
-/**
- * Creates hydration-gating middleware that queues state updates until rehydration completes.
- *
- * **Before hydration**: Queues all `set()` calls and flushes them sequentially after rehydration.
- *
- * **After hydration**: Passes `set()` calls through synchronously without batching.
- *
- * This ensures persistence sees a fully rehydrated base state before applying queued updates,
- * while keeping in-memory state changes synchronous post-hydration.
- */
-export declare function createHydrationGate<S>(stateCreator: StateCreator<S>): {
-    hydrationPromise: () => Promise<void>;
-    stateCreator: StateCreator<S>;
-    wrapOnRehydrateStorage: WrappedOnRehydrateStorage<S>;
-};
-export {};

package/dist/vanilla/internal/queryStore/queryParams.d.ts

@@ -1,17 +0,0 @@
-import type { QueryParam, ReactiveParam } from '../../queryStore/queryParam';
-import type { StoreApi } from '../../store/types';
-import type { InternalUnsubscribeFn } from '../types/internalSubscribeTypes';
-export type TrackedValue<T> = {
-    readonly initialValue: T;
-    subscribe(listener: (value: T) => void): InternalUnsubscribeFn;
-};
-export type QueryParams<TParams extends Record<string, unknown>> = {
-    buildKey(params?: TParams): string;
-    complete(params: Partial<TParams> | undefined): TParams;
-    get(): TParams;
-    subscribe(onChange: (key: keyof TParams, oldValue: unknown, newValue: unknown) => void): InternalUnsubscribeFn;
-};
-export declare function createQueryParams<TParams extends Record<string, unknown>, State>(params: {
-    [K in keyof TParams]: QueryParam<TParams[K], State>;
-} | undefined, store: StoreApi<State>, requiredKeys: (keyof TParams)[]): QueryParams<TParams>;
-export declare function trackQueryValue<T, State>(getValue: ReactiveParam<T, State>, ownerStore: StoreApi<State>): TrackedValue<T>;

package/dist/vanilla/internal/queryStore/queryStoreDefaults.d.ts

@@ -1,7 +0,0 @@
-import { Prettify } from '../../types/objects';
-import { QueryStoreDefaults } from '../config';
-export declare function getQueryStoreDefaults(): Prettify<Required<QueryStoreDefaults>>;
-/**
- * Exponential backoff: starts at `baseDelay` (5s), doubles each retry, capped at `maxDelay` (5m).
- */
-export declare function defaultRetryDelay(retryCount: number): number;

package/dist/vanilla/internal/queryStore.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/vanilla/internal/runtime.d.ts

@@ -1,11 +0,0 @@
-export { configureStores } from './config';
-export { StoresError } from './errors';
-export { QueryStatuses } from '../queryStore/types';
-export { defaultRetryDelay } from './queryStore/queryStoreDefaults';
-export { applyStateUpdate } from '../store/stateUpdate';
-export { replacer, reviver } from '../utils/serialization';
-export { destroyStore, destroyStores, getStoreName, hasGetSnapshot, isDerivedStore, isPersistedStore, isQueryStore, isVirtualStore, } from './storeUtils';
-export { identity, nullObject } from '../utils/core';
-export { createStoreActions } from './createStoreActions';
-export { deepEqual, shallowEqual } from '../utils/equality';
-export { time } from '../utils/time';

package/dist/vanilla/internal/storage/storageCreators.d.ts

@@ -1,11 +0,0 @@
-import type { AsyncPersistStorage, PersistStorageConfig } from '../../store/types';
-import type { AsyncStorageInterface, BaseStoreOptions, EnforceStorageKey, SyncStorageInterface } from '../../types';
-import type { SyncContext } from '../sync/syncEnhancer';
-/**
- * Creates a persist storage object for the base store.
- */
-export declare function createPersistStorage<S, PersistedState extends Partial<S>, PersistReturn>(options: EnforceStorageKey<BaseStoreOptions<S, PersistedState, PersistReturn>>, storage: AsyncStorageInterface | SyncStorageInterface | undefined, syncContext: SyncContext | undefined): PersistStorageConfig<S, PersistedState>;
-/**
- * Creates an asynchronous persist storage adapter.
- */
-export declare function createAsyncPersistStorage<S, PersistedState extends Partial<S>, PersistReturn>(storage: AsyncStorageInterface, options: EnforceStorageKey<BaseStoreOptions<S, PersistedState, PersistReturn>>, persistThrottleMs: number | undefined, syncContext?: SyncContext): AsyncPersistStorage<S, PersistedState>;