@storesjs/stores 0.10.0 → 0.12.0

package/dist/vanilla/store/stateUpdate.d.ts

@@ -1,9 +0,0 @@
-import type { SetStateArgs, SetStateOverloads } from '../types';
-/**
- * Calls a `setState` function with captured `setState` arguments.
- */
-export declare function applySetState<S, SetReturn extends Promise<void> | void>(set: SetStateOverloads<S, SetReturn>, args: SetStateArgs<S>): SetReturn;
-/**
- * Applies a `setState` payload to the current state.
- */
-export declare function applyStateUpdate<S>(state: S, ...setArgs: SetStateArgs<S>): S;

package/dist/vanilla/store/types.d.ts

@@ -1,107 +0,0 @@
-import type { StorageValue } from '../storage/storageTypes';
-import type { SetStateOverloads } from '../types/setState';
-import type { SubscribeOverloads } from '../types/subscribe';
-/**
- * Store object contract shared by creators, middleware, and internal store utilities.
- */
-export type StoreApi<S> = {
-    getInitialState: () => S;
-    getState: () => S;
-    setState: SetStateOverloads<S>;
-    subscribe: SubscribeOverloads<S>;
-};
-/**
- * Callback that builds store state from the set/get/store API supplied during construction.
- */
-export type StateCreator<S, Mutators extends StoreMutators = [], StoreMutatorOutput extends StoreMutators = [], U = S> = ((setState: Get<Mutate<StoreApi<S>, Mutators>, 'setState', never>, getState: Get<Mutate<StoreApi<S>, Mutators>, 'getState', never>, store: Mutate<StoreApi<S>, Mutators>) => U) & {
-    $$storeMutators?: StoreMutatorOutput;
-};
-/**
- * Synchronous storage adapter consumed by the persistence wrapper.
- */
-export type SyncPersistStorage<State, PersistedState = Partial<State>> = {
-    getItem: (name: string) => StorageValue<PersistedState> | null;
-    removeItem: (name: string) => void;
-    setItem: (name: string, state: State, version: number | undefined) => void;
-};
-/**
- * Asynchronous storage adapter consumed by the persistence wrapper.
- */
-export type AsyncPersistStorage<State, PersistedState = Partial<State>> = {
-    getItem: (name: string) => Promise<StorageValue<PersistedState> | null>;
-    removeItem: (name: string) => Promise<void>;
-    setItem: (name: string, state: State, version: number | undefined) => Promise<void>;
-};
-/**
- * Accepted storage adapter types for sync or async persistence.
- */
-export type PersistStorage<State, PersistedState = Partial<State>> = AsyncPersistStorage<State, PersistedState> | SyncPersistStorage<State, PersistedState>;
-/**
- * Resolved storage config for persisted stores.
- */
-export type PersistStorageConfig<State, PersistedState extends Partial<State>> = {
-    async: false;
-    persistStorage: SyncPersistStorage<State, PersistedState>;
-    version: number;
-} | {
-    async: true;
-    persistStorage: AsyncPersistStorage<State, PersistedState>;
-    version: number;
-};
-/**
- * Persistence options consumed by the persistence wrapper.
- */
-export type PersistOptions<S, PersistedState = Partial<S>> = {
-    merge?: (persistedState: PersistedState | undefined, currentState: S) => S;
-    migrate?: (persistedState: PersistedState, version: number) => PersistedState | Promise<PersistedState>;
-    name: string;
-    onRehydrateStorage?: (state: S) => ((state?: S, error?: unknown) => void) | void;
-    skipHydration?: boolean;
-    storage: PersistStorage<S, PersistedState>;
-    version: number;
-};
-/**
- * Methods attached by the persistence wrapper before async hydration state is added.
- */
-export type PersistMethods<S, PersistedState> = {
-    clearStorage: () => void;
-    getOptions: () => Partial<PersistOptions<S, PersistedState>>;
-    hasHydrated: () => boolean;
-    onHydrate: (listener: (state: S) => void) => () => void;
-    onFinishHydration: (listener: (state: S) => void) => () => void;
-    rehydrate: () => Promise<void> | void;
-    setOptions: (options: Partial<PersistOptions<S, PersistedState>>) => void;
-};
-/**
- * Store shape after the persistence wrapper adds persistence methods, write-through `setState`,
- * and async hydration state when applicable.
- */
-export type WithPersist<Store, PersistedState, PersistReturn extends void | Promise<void>> = Store extends StoreApi<infer S> ? Write<Store, {
-    persist: PersistMethods<S, PersistedState> & HydrationPromise<PersistReturn>;
-    setState: SetStateOverloads<S, PersistReturn>;
-}> : Store;
-type HydrationPromise<PersistReturn> = PersistReturn extends Promise<void> ? {
-    /** Invoke to get a promise that resolves once hydration completes. */
-    hydrationPromise: () => Promise<void>;
-} : {
-    hydrationPromise?: undefined;
-};
-type Get<T, K, Fallback> = K extends keyof T ? T[K] : Fallback;
-type Write<T, U> = Omit<T, keyof U> & U;
-type PersistMutator<Store, Args> = Args extends [infer PersistedState, infer PersistReturn extends void | Promise<void>] ? WithPersist<Store, PersistedState, PersistReturn> : Store;
-type StoreMutatorIdentifier = keyof StoreMutatorMap<unknown, unknown>;
-/**
- * Mapping from store mutator identifiers to the store API shape they add.
- */
-export interface StoreMutatorMap<Store, Args> {
-    'stores/persist': PersistMutator<Store, Args>;
-}
-/**
- * Ordered list of store mutators applied to a state creator.
- */
-export type StoreMutators = [StoreMutatorIdentifier, unknown][];
-/**
- * Applies a list of store mutators to a store API type.
- */
-export type Mutate<Store, Mutators> = number extends Mutators['length' & keyof Mutators] ? Store : Mutators extends [] ? Store : Mutators extends [[infer Identifier, infer Args], ...infer Rest] ? Identifier extends StoreMutatorIdentifier ? Rest extends StoreMutators ? Mutate<StoreMutatorMap<Store, Args>[Identifier], Rest> : StoreMutatorMap<Store, Args>[Identifier] : Store : Store;
-export {};

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

@@ -1,2 +0,0 @@
-import { SyncStorageInterface } from './types';
-export declare function createStoresStorage(storageKeyPrefix: string): SyncStorageInterface;

package/dist/vanilla/sync/types.d.ts

@@ -1,114 +0,0 @@
-import { UnknownFunction } from '../types/functions';
-/**
- * Metadata for a field's last write.
- */
-export type FieldMetadata = readonly [timestamp: number, sessionId: string];
-export type SyncStateKey<T extends Record<string, unknown>> = Extract<{
-    [K in keyof T]-?: T[K] extends UnknownFunction ? never : K;
-}[keyof T], string>;
-export type SyncValues<T extends Record<string, unknown>> = Partial<T> & {
-    [K in SyncStateKey<T>]?: T[K];
-};
-export type SyncUpdate<T extends Record<string, unknown>> = {
-    replace: boolean;
-    sessionId: string;
-    timestamp: number;
-    values: SyncValues<T>;
-};
-/**
- * Passed to `SyncEngine.register()` to connect a store to the sync system.
- */
-export type SyncRegistration<T extends Record<string, unknown>> = {
-    /** Callback invoked by the engine to apply incoming remote updates to the store. */
-    apply: (update: SyncUpdate<T>) => void;
-    /** The state keys to sync. Non-function properties only. */
-    fields: ReadonlyArray<SyncStateKey<T>>;
-    /** Returns the store's current state. Used by engines that need to read state (e.g., for diffing). */
-    getState: () => T;
-    /** Unique identifier for this store. Must match across clients to sync the same data. */
-    key: string;
-};
-/**
- * Returned by `SyncEngine.register()`. Controls the lifecycle of a synced store.
- */
-export interface SyncHandle<T extends Record<string, unknown>> {
-    /**
-     * Permanently removes this store from the sync engine. After calling, the handle
-     * is invalid and the store will no longer send or receive updates. To temporarily
-     * pause sync, use `onFirstSubscribe`/`onLastUnsubscribe` lifecycle hooks instead.
-     */
-    destroy: () => void;
-    /** Returns `true` once the store has received its initial state from the engine. */
-    hydrated?: () => boolean;
-    /**
-     * Called when the store's subscriber count goes from 0 to 1. The registration
-     * remains active. Use for lazy resource acquisition (e.g., opening a WebSocket).
-     */
-    onFirstSubscribe?: () => void;
-    /** Registers a one-time callback to run when hydration completes. */
-    onHydrated?: (callback: () => void) => void;
-    /**
-     * Called when the store's subscriber count drops to 0. The registration remains
-     * active and `onFirstSubscribe` will fire again on the next subscription.
-     * Use for resource cleanup (e.g., closing idle connections).
-     */
-    onLastUnsubscribe?: () => void;
-    /**
-     * Broadcasts a state update to other clients. Set to `null` for engines where
-     * publishing is implicit (e.g., `chrome.storage` where the write itself triggers sync).
-     */
-    publish: ((update: SyncUpdate<T>) => void) | null;
-}
-/**
- * Interface for multi-client state synchronization. Stores register to send and receive updates.
- */
-export interface SyncEngine {
-    /**
-     * When `true`, embeds sync metadata (`{ origin, timestamp, fields }`) into persisted
-     * storage values. Required for engines that use storage writes as their transport.
-     * Only effective when the store is also persisted.
-     * @default false
-     */
-    readonly injectStorageMetadata?: boolean;
-    /** Registers a store for synchronization. Returns a handle to control the sync lifecycle. */
-    register: {
-        <T extends Record<string, unknown>>(registration: SyncRegistration<T>): SyncHandle<T>;
-        (registration: SyncRegistration<Record<string, unknown>>): SyncHandle<Record<string, unknown>>;
-    };
-    /** Unique identifier for this client session. Used for conflict resolution and filtering self-updates. */
-    readonly sessionId: string;
-}
-export type SyncMergeFn<T, TState = unknown> = (incoming: T, current: T, currentState: TState, incomingValues: Partial<TState>) => T;
-export type SyncConfig<T extends Record<string, unknown>> = {
-    /**
-     * The sync engine implementation to use.
-     *
-     * Defaults to cross-tab sync in browser environments. No-op in other environments unless a
-     * custom engine is provided.
-     */
-    engine?: SyncEngine;
-    /** The state keys to sync. If unspecified, all non-function store properties are synced. */
-    fields?: ReadonlyArray<SyncStateKey<T>>;
-    /**
-     * When true, injects sync metadata (`{ origin, timestamp, fields }`) into the persisted
-     * storage payload. Only takes effect when used with a persisted store.
-     *
-     * Useful for sync engines that use storage events as their transport (e.g., `chrome.storage`).
-     *
-     * Can also be set on the `engine` object. This option takes precedence if both are provided.
-     * @default false
-     */
-    injectStorageMetadata?: boolean;
-    /** The key used to identify the store to the sync engine. Required if `storageKey` is absent. */
-    key?: string;
-    /** Optional merge function to use for each synced state key. Use with caution. */
-    merge?: {
-        [K in SyncStateKey<T>]?: SyncMergeFn<T[K], T>;
-    };
-};
-/**
- * Internal type for `SyncConfig` with `key` always present.
- */
-export type NormalizedSyncConfig<T extends Record<string, unknown>> = SyncConfig<T> & {
-    key: string;
-};

package/dist/vanilla/types/functions.d.ts

@@ -1,23 +0,0 @@
-/**
- * Relaxes function parameter variance to allow subtype
- * assignment otherwise blocked by strict contravariance.
- */
-export type BivariantMethod<T extends Record<string, UnknownFunction>> = T[keyof T];
-/**
- * Extract the keys of `T` whose values are functions.
- */
-export type FunctionKeys<T> = {
-    [K in keyof T]-?: T[K] extends UnknownFunction ? K : never;
-}[keyof T];
-/**
- * A record of string keys to unknown functions.
- */
-export type FunctionRecord = Record<string, UnknownFunction>;
-/**
- * Return `T` if it is **not** a function, otherwise `never`.
- */
-export type NonFunction<T> = T extends (...args: infer _) => unknown ? never : T;
-/**
- * Unknown generic function type.
- */
-export type UnknownFunction = (...args: never[]) => unknown;

package/dist/vanilla/types/objects.d.ts

@@ -1,10 +0,0 @@
-/**
- * Forces TypeScript to expand a type for clearer IDE display.
- */
-export type Prettify<T> = T extends infer U ? {
-    [K in keyof U]: U[K];
-} : never;
-/**
- * Enforce no overlapping keys between two objects.
- */
-export type NoOverlap<A, B> = B & Record<Extract<keyof A, keyof B>, never>;

package/dist/vanilla/types/setState.d.ts

@@ -1,21 +0,0 @@
-import type { BivariantMethod } from './functions';
-export type SetPartial<S> = S | Partial<S> | BivariantMethod<{
-    updater(state: S): S | Partial<S>;
-}>;
-export type SetFull<S> = S | BivariantMethod<{
-    updater(state: S): S;
-}>;
-export type SetStateReplaceArgs<S, ExtraArgs extends unknown[] = []> = [update: SetFull<S>, replace: true, ...extraArgs: ExtraArgs];
-export type SetStatePartialArgs<S, ExtraArgs extends unknown[] = []> = [update: SetPartial<S>, replace?: false, ...extraArgs: ExtraArgs];
-export type SetStateArgs<S, ExtraArgs extends unknown[] = []> = SetStatePartialArgs<S, ExtraArgs> | SetStateReplaceArgs<S, ExtraArgs>;
-/**
- * Rest-argument form of `setState`, used when forwarding calls.
- */
-export type SetState<S, ExtraArgs extends unknown[] = [], PersistReturn extends Promise<void> | void = void> = (...args: SetStateArgs<S, ExtraArgs>) => PersistReturn;
-/**
- * Store `setState` method overloads for partial updates and full replacement.
- */
-export type SetStateOverloads<S, PersistReturn extends Promise<void> | void = void> = BivariantMethod<{
-    setState(update: SetPartial<S>, replace?: false): PersistReturn;
-    setState(update: SetFull<S>, replace: true): PersistReturn;
-}>;

package/dist/vanilla/types/subscribe.d.ts

@@ -1,27 +0,0 @@
-export type Listener<S> = (state: S, prevState: S) => void;
-export type Selector<S, Selected> = (state: S) => Selected;
-export type EqualityFn<T = unknown> = (a: T, b: T) => boolean;
-/**
- * Minimum store API required for subscription.
- */
-export type SubscribableStore = {
-    subscribe(selector: Selector<unknown, unknown>, listener: () => void, options?: SubscribeOptions<unknown>): UnsubscribeFn;
-};
-export type SubscribeOptions<Selected> = {
-    equalityFn?: EqualityFn<Selected>;
-    fireImmediately?: boolean;
-    isDerivedStore?: boolean;
-};
-export type ListenerArgs<S> = [listener: Listener<S>];
-export type SelectorArgs<S, Selected> = [
-    selector: Selector<S, Selected>,
-    listener: Listener<Selected>,
-    options?: SubscribeOptions<Selected>
-];
-export type SubscribeArgs<S, Selected = unknown> = ListenerArgs<S> | SelectorArgs<S, Selected>;
-export type UnsubscribeFn<Options extends boolean = false> = Options extends true ? (skipAbortFetch?: boolean) => void : () => void;
-export type SubscribeFn<S, Selected = S> = (...args: SubscribeArgs<S, Selected>) => UnsubscribeFn;
-export type SubscribeOverloads<S, ExtraOptions extends boolean = false> = {
-    (listener: Listener<S>): UnsubscribeFn<ExtraOptions>;
-    <Selected>(selector: Selector<S, Selected>, listener: Listener<Selected>, options?: SubscribeOptions<Selected>): UnsubscribeFn<ExtraOptions>;
-};

package/dist/vanilla/types/useStoreCallSignatures.d.ts

@@ -1 +0,0 @@
-export type UseStoreCallSignatures<_> = Record<never, never>;

package/dist/vanilla/types/useStoreCallSignatures.vanilla.d.ts

@@ -1 +0,0 @@
-export type UseStoreCallSignatures<_> = Record<never, never>;

package/dist/vanilla/types/utils.d.ts

@@ -1,12 +0,0 @@
-/**
- * Typed `hasOwnProperty` alias.
- */
-export declare function hasOwn<T extends Record<string, unknown>, K extends string>(value: T, key: K): value is T & Record<K, unknown>;
-/**
- * Checks prototype is `Object.prototype` or `null`. Excludes arrays, class instances, etc.
- */
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-/**
- * Checks for non-null, non-array objects.
- */
-export declare function isRecordLike(value: unknown): value is Record<string, unknown>;

package/dist/vanilla/types.d.ts

@@ -1,285 +0,0 @@
-import type { StorageValue } from './storage/storageTypes';
-import type { PersistOptions, StateCreator as StoreStateCreator, StoreApi, StoreMutators, WithPersist } from './store/types';
-import type { SyncConfig } from './sync/types';
-import type { FunctionKeys } from './types/functions';
-import type { SetFull, SetPartial, SetStateArgs } from './types/setState';
-import type { EqualityFn, Selector, SubscribeOverloads } from './types/subscribe';
-import type { UseStoreCallSignatures } from './types/useStoreCallSignatures';
-export type { StoreMutators } from './store/types';
-export type * from './types/setState';
-export type * from './types/subscribe';
-export type * from './types/useStoreCallSignatures';
-export type StoreMutatorsWithSelector<Mutators extends StoreMutators = StoreMutators> = Mutators;
-export type StateCreator<S, U = S> = StoreStateCreator<S, [], [], U>;
-export type UseBoundStoreWithEqualityFn<Store extends {
-    getState: () => unknown;
-}, State = InferStoreState<Store>> = UseStoreCallSignatures<State> & Store;
-export type BaseStore<S, ExtraSubscribeOptions extends boolean = false> = UseBoundStoreWithEqualityFn<StoreApi<S>> & {
-    subscribe: SubscribeOverloads<S, ExtraSubscribeOptions>;
-};
-export type PersistedStore<S, PersistedState = Partial<S>, PersistReturn extends void | Promise<void> = void | Promise<void>, ExtraSubscribeOptions extends boolean = false> = UseStoreCallSignatures<S> & WithPersist<BaseStore<S, ExtraSubscribeOptions>, PersistedState, PersistReturn>;
-export type Store<S, PersistedState extends Partial<S> = never, PersistReturn extends void | Promise<void> = void | Promise<void>, ExtraSubscribeOptions extends boolean = false> = [PersistedState] extends [never] ? BaseStore<S, ExtraSubscribeOptions> : PersistedStore<S, PersistedState, PersistReturn, ExtraSubscribeOptions>;
-/**
- * Store returned by creators that accept optional persistence options.
- * `persist` exists only when persistence is configured.
- */
-export type OptionallyPersistedStore<S, PersistedState, PersistReturn extends void | Promise<void> = void> = UseStoreCallSignatures<S> & Omit<BaseStore<S>, 'setState'> & {
-    persist?: PersistedStore<S, PersistedState, PersistReturn, false>['persist'];
-    setState(update: SetPartial<S>, replace?: false): PersistReturn;
-    setState(update: SetFull<S>, replace: true): PersistReturn;
-};
-export type NoInfer<T> = [T][T extends unknown ? 0 : never];
-export type Timeout = ReturnType<typeof setTimeout>;
-export type InferStoreState<Store> = Store extends {
-    getState: () => infer T;
-} ? T : never;
-/**
- * Action methods returned by `createStoreActions(store)`.
- */
-export type StoreActions<Store extends StoreApi<unknown>> = Pick<InferStoreState<Store>, FunctionKeys<InferStoreState<Store>>>;
-/**
- * Extracts a store's `setState` return type.
- *  - `void` for non-persisted or synchronous persisted stores.
- *  - `Promise<void>` for async persisted stores.
- */
-export type InferSetStateReturn<Store> = Store extends {
-    setState(...args: SetStateArgs<infer S>): infer R;
-} ? R : void;
-/**
- * Extracts a store's `PersistedState` type.
- * Returns `never` if the store doesn't use persistence.
- */
-export type InferPersistedState<PersistedStore> = PersistedStore extends Store<infer _, infer PersistedState> ? PersistedState : never;
-/**
- * Reads store state and records the dependencies of a derived computation.
- *  - `$(store, selector, equalityFn?)` depends on the selected state
- *  - `$(store)` depends on accessed state paths
- */
-export type DeriveGetter = {
-    <S extends Store<InferStoreState<S>>>(store: S): InferStoreState<S>;
-    <S extends Store<InferStoreState<S>>, Selected>(store: S, selector: Selector<InferStoreState<S>, Selected>, equalityFn?: EqualityFn<Selected>): Selected;
-};
-export type DerivedStore<S> = WithFlushUpdates<ReadOnlyDerivedStore<BaseStore<S>>>;
-export type WithFlushUpdates<Store extends StoreApi<unknown>> = Store & {
-    /**
-     * Destroy the derived store and its subscriptions.
-     *
-     * Derived stores automatically clean up internal resources and subscriptions
-     * when no subscribers exist. So calling `destroy()` is usually unnecessary,
-     * unless `keepAlive: true` is specified and explict teardown is desired.
-     */
-    destroy: () => void;
-    /**
-     * Flush all pending updates — only applicable to **debounced** derived stores.
-     */
-    flushUpdates: () => void;
-};
-export type WithGetSnapshot<Store extends StoreApi<unknown>> = Store & {
-    /**
-     * Reads the current snapshot while activating lazy derived stores before subscription.
-     */
-    getSnapshot: () => InferStoreState<Store>;
-};
-type ReadOnlyDerivedStore<Store extends BaseStore<unknown>> = Omit<Store, 'getInitialState' | 'setState'> & UseStoreCallSignatures<InferStoreState<Store>> & {
-    /**
-     * @deprecated **Not applicable to derived stores.** Will throw an error.
-     */
-    getInitialState: Store['getInitialState'];
-    /**
-     * @deprecated **Not applicable to derived stores.** Will throw an error.
-     */
-    setState: Store['setState'];
-};
-/**
- * Configuration for creating derived stores. You can pass either:
- *  - A **function** (used as `equalityFn`), or
- *  - An **object** with the fields below
- */
-export type DeriveOptions<DerivedState = unknown> = EqualityFn<DerivedState> | {
-    /**
-     * Delay before triggering a re-derive when dependencies change.
-     * Accepts a number (ms) or debounce options:
-     *
-     * `{ delay: number, leading?: boolean, trailing?: boolean, maxWait?: number }`
-     * @default 0
-     */
-    debounce?: number | DebounceOptions;
-    /**
-     * If `true`, the store will log debug messages to the console.
-     *
-     * If `'verbose'`, the store will log the subscriptions it creates each time the derive
-     * function is run, rather than only the first time.
-     * @default false
-     */
-    debugMode?: boolean | 'verbose';
-    /**
-     * A custom comparison function for detecting state changes.
-     * @default `Object.is`
-     */
-    equalityFn?: EqualityFn<DerivedState>;
-    /**
-     * If `true`, the derived store will never destroy itself. Useful in cases where your
-     * derived store serves as a permanent cache subscribed to intermittently or not at all.
-     * Manual calls to `destroy` *will* destroy the store even when `keepAlive` is `true`.
-     *
-     * *Use this option carefully.*
-     * @default false
-     */
-    keepAlive?: boolean;
-    /**
-     * Locks the dependency graph after the first derivation. Subscriptions to
-     * underlying stores are established once and reused on subsequent runs, rather
-     * than being torn down and rebuilt (the default behavior).
-     *
-     * This avoids the overhead of regenerating selectors and prevents unnecessary
-     * subscription churn. However, it means only the *initially tracked* dependencies
-     * will trigger updates — even if your derive function conditionally reads different
-     * stores in later runs.
-     *
-     * **Requirement**: All `$` calls in your derive function must be consistent and
-     * top level. Conditional dependency tracking will not work correctly.
-     *
-     * Safe to enable for most derived stores where dependencies are static.
-     *
-     * @default false
-     */
-    lockDependencies?: boolean;
-};
-export type Deserializer<SerializedState, PersistedState> = (serializedState: SerializedState) => StorageValue<PersistedState>;
-export type Serializer<SerializedState> = <PersistedState>(storageValue: StorageValue<PersistedState>) => SerializedState;
-/**
- * Synchronous storage interface.
- * Used for localStorage and MMKV implementations.
- */
-export type SyncStorageInterface<SerializedState = unknown> = {
-    readonly async?: false;
-    /**
-     * Adapter-level deserializer used when a store does not supply its own.
-     * Acts as the default before falling back to the framework implementation.
-     */
-    deserializer?<PersistedState>(serializedState: SerializedState): StorageValue<PersistedState>;
-    /**
-     * Adapter-level serializer used when a store does not supply its own.
-     * Acts as the default before falling back to the framework implementation.
-     */
-    serializer?<PersistedState>(storageValue: StorageValue<PersistedState>): SerializedState;
-    clearAll(): void;
-    contains(key: string): boolean;
-    delete(key: string): void;
-    get(key: string): SerializedState | undefined;
-    getAllKeys(): string[];
-    set(key: string, value: SerializedState): void;
-};
-/**
- * Asynchronous storage interface.
- * Used for Chrome storage and other async storage implementations.
- */
-export type AsyncStorageInterface<SerializedState = unknown> = {
-    readonly async: true;
-    /**
-     * Adapter-level deserializer used when a store does not supply its own.
-     * Acts as the default before falling back to the framework implementation.
-     */
-    deserializer?<PersistedState>(serializedState: SerializedState): StorageValue<PersistedState>;
-    /**
-     * Adapter-level serializer used when a store does not supply its own.
-     * Acts as the default before falling back to the framework implementation.
-     */
-    serializer?<PersistedState>(storageValue: StorageValue<PersistedState>): SerializedState;
-    clearAll(): Promise<void>;
-    contains(key: string): Promise<boolean>;
-    delete(key: string): Promise<void>;
-    get(key: string): Promise<SerializedState | undefined>;
-    getAllKeys(): Promise<string[]>;
-    set(key: string, value: SerializedState): Promise<void>;
-};
-/**
- * Configuration options for creating a persistable store.
- */
-export type PersistConfig<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn = void> = {
-    /**
-     * A function to convert the serialized value back into the state object.
-     * If not provided, the storage adapter's `deserializer` is used before falling back to the default implementation.
-     */
-    deserializer?: (serializedState: unknown) => StorageValue<PersistedState>;
-    /**
-     * A function to merge persisted state with current state during hydration.
-     * By default, persisted state is shallow-merged into the current state.
-     */
-    merge?: PersistOptions<S, PersistedState>['merge'];
-    /**
-     * A function to perform persisted state migration.
-     * This function will be called when persisted state versions mismatch with the one specified here.
-     */
-    migrate?: PersistOptions<S, PersistedState>['migrate'];
-    /**
-     * A function returning another (optional) function.
-     * The main function will be called before the state rehydration.
-     * The returned function will be called after the state rehydration or when an error occurred.
-     */
-    onRehydrateStorage?: PersistOptions<S, PersistedState>['onRehydrateStorage'];
-    /**
-     * A function that determines which parts of the state should be persisted.
-     * By default, the entire state is persisted.
-     */
-    partialize?: (state: Readonly<S>) => PersistedState;
-    /**
-     * The throttle rate for the persist operation in milliseconds.
-     * @default iOS: time.seconds(3) | Android: time.seconds(5)
-     */
-    persistThrottleMs?: PersistReturn extends Promise<unknown> ? undefined : number;
-    /**
-     * A function to serialize the state and version for storage.
-     * If not provided, the storage adapter's `serializer` is used before falling back to the default implementation.
-     */
-    serializer?: (storageValue: StorageValue<PersistedState>) => string;
-    /**
-     * Custom storage implementation. If async, `setState` will return a Promise that resolves
-     * when the state is persisted. If sync, `setState` will return void.
-     */
-    storage?: PersistReturn extends Promise<unknown> ? AsyncStorageInterface : SyncStorageInterface;
-    /**
-     * The unique key for the persisted store.
-     */
-    storageKey: string;
-    /**
-     * The version of the store's schema.
-     * Useful for handling schema changes across app versions.
-     * @default 0
-     */
-    version?: number;
-};
-export type EnforceStorageKey<Options> = {
-    storageKey: string;
-} extends Options ? Options : never;
-export type BaseStoreOptions<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn = void> = (PersistConfig<S, PersistedState, PersistReturn> & {
-    sync?: S extends Record<string, unknown> ? SyncOption<S> : undefined;
-}) | ({
-    sync: S extends Record<string, unknown> ? SyncWithoutStorageOption<NoInfer<S>> : undefined;
-} & UndefinedPersistKeys<S, PersistedState, PersistReturn>);
-/**
- * The `sync` option can be:
- * - `SyncConfig` object
- * - `string` (shorthand for `{ key: string }`)
- * - `true` (inherits key from `storageKey` — only valid with persistence)
- */
-export type SyncOption<S extends Record<string, unknown>> = SyncConfig<S> | string | true;
-type SyncWithoutStorageOption<S extends Record<string, unknown>> = string | (Omit<SyncConfig<S>, 'injectStorageMetadata' | 'key'> & {
-    injectStorageMetadata?: never;
-    key: SyncWithoutStorageKey<SyncConfig<S>>;
-});
-type SyncWithoutStorageKey<Config> = Config extends {
-    key?: infer Key;
-} ? Extract<Key, string> extends never ? string : Extract<Key, string> : string;
-type UndefinedPersistKeys<S, PersistedState extends Partial<S>, PersistReturn> = {
-    [K in keyof PersistConfig<S, PersistedState, PersistReturn>]?: undefined;
-};
-/**
- * Expanded options for custom debounce behavior.
- */
-export type DebounceOptions = {
-    delay: number;
-    leading?: boolean;
-    maxWait?: number;
-    trailing?: boolean;
-};

package/dist/vanilla/utils/core.d.ts

@@ -1,25 +0,0 @@
-/**
- * Returns the argument provided.
- */
-export declare function identity<T>(value: T): T;
-export declare function identity<T, _>(value: T): T;
-/**
- * Creates a null-prototype object using the runtime-optimal path:
- *  - React Native: direct literal `{ __proto__: null }`
- *  - Web/Node: `Object.create` with a shared, frozen null prototype
- */
-export declare function nullObject<T extends Record<string, unknown> | object = Record<string, unknown>>(): T;
-/**
- * Builds null-prototype objects. Provided arguments are
- * shallow-merged into a newly created null-prototype object:
- *
- * ```ts
- * Object.assign(nullObject(), a, b?)
- * ```
- */
-export declare function buildNullObject<A extends Record<string, unknown>>(a: A): A;
-export declare function buildNullObject<A extends object, B>(a: object, b?: object): [undefined] extends B ? A : A & B;
-/**
- * Does nothing.
- */
-export declare function noop(): void;