@storesjs/stores 0.11.0 → 0.12.1

package/dist/hooks/useListen.d.ts

@@ -1,98 +0,0 @@
-import { RefObject } from 'react';
-import { BaseStore, EqualityFn, InferStoreState, Selector } from '../types';
-/**
- * Handle returned by `useListen`.
- *
- * The hook cleans itself up, so you normally ignore this handle.
- * Keep it only when you need to pause or resume the listener manually
- * (e.g. suspend heavy work while a long-lived component is off screen).
- */
-export type ListenHandle = {
-    /** `true` while the listener is attached. */
-    isActive: boolean;
-    /** Re-attach the listener. */
-    resubscribe: (options?: ResubscribeOptions) => void;
-    /** Detach the listener. Safe to call more than once. */
-    unsubscribe: () => void;
-};
-/**
- * Options for resubscribing a listener.
- */
-export type ResubscribeOptions = {
-    /**
-     * Whether to fire the callback immediately when resubscribing.
-     * @default false
-     */
-    fireImmediately?: boolean;
-    /**
-     * Whether to force a resubscription even if the listener is already active.
-     * @default false
-     */
-    forceResubscribe?: boolean;
-};
-/**
- * Options for the `useListen` hook.
- */
-export type UseListenOptions<Selected> = {
-    /**
-     * Whether to log debug messages to the console.
-     * @default false
-     */
-    debugMode?: boolean;
-    /**
-     * Whether to enable the listener.
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * Dictates whether `react` should be called on state slice changes.
-     * Compares the previous and current selected values.
-     * @default Object.is
-     */
-    equalityFn?: EqualityFn<Selected>;
-    /**
-     * Whether to fire the callback immediately on mount. Note that if `true`,
-     * the `react` callback will be called on mount regardless of whether the
-     * selected value has changed.
-     * @default false
-     */
-    fireImmediately?: boolean;
-};
-/**
- * ### `useListen`
- *
- * Subscribes to a slice of a store and runs a callback whenever that slice changes,
- * **without triggering re-renders**.
- *
- * Useful for forwarding updates to non-React state (e.g. Reanimated shared values), scoped side
- * effects, or deciding yourself if or when a render should happen.
- *
- * The hook attaches the listener and cleans it up automatically. Use the returned `ListenHandle`
- * only when you need to pause or resume the listener manually.
- *
- * ---
- * 💡 **Note:** With the exception of `enabled`, changes in `options` are **not reactive**.
- * They take effect only if a resubscription occurs.
- *
- * ---
- * @param store - Store to listen to. Should be a stable reference.
- * @param selector - Selects the slice of the store state to listen to.
- * @param react - Triggered when the selected slice changes. Receives `(current, previous, unsubscribe)`.
- * @param optionsOrEqualityFn - Optional `equalityFn`, `fireImmediately` settings, forwarded to `store.subscribe`.
- *
- * ---
- * @example
- * ```ts
- * useListen(
- *   useCandlestickStore,
- *   state => state.getData(),
- *   (candles, previous, unsubscribe) => {
- *     if (candles?.unsupported) return unsubscribe();
- *     updateTokenPrice(token, getPriceUpdate(candles, previous));
- *     runOnUI(() => chartManager.value?.setCandles(candles))();
- *   }
- * );
- * ```
- */
-export declare function useListen<Store extends BaseStore<S>, Selected, S = InferStoreState<Store>>(store: Store, selector: Selector<S, Selected>, react: (current: Selected, previous: Selected, unsubscribe: () => void) => void, optionsOrEqualityFn?: UseListenOptions<Selected> | UseListenOptions<Selected>['equalityFn']): RefObject<Readonly<ListenHandle>>;
-//# sourceMappingURL=useListen.d.ts.map

package/dist/hooks/useStableValue.d.ts

@@ -1,16 +0,0 @@
-/**
- * **Initializes a value once**, guaranteeing stability across renders.
- *
- * @param initializer A function that produces the value. It is invoked **only
- * on the first render** for a given component instance.
- *
- * @returns A stable `T` guaranteed to be the value initially returned by the
- * provided `initializer`.
- *
- * @example
- * ```ts
- * const initialState = useStableValue(() => getInitialState());
- * ```
- */
-export declare function useStableValue<T>(init: () => T): T;
-//# sourceMappingURL=useStableValue.d.ts.map

package/dist/hooks/useSyncExternalStoreWithSelector.d.ts

@@ -1,5 +0,0 @@
-import type { EqualityFn, Selector, SubscribeOverloads } from '../types';
-export declare function useSyncExternalStoreWithSelector<State>(subscribe: SubscribeOverloads<State>, getSnapshot: () => State, getServerSnapshot?: (() => State) | undefined, selector?: undefined, equalityFn?: undefined): State;
-export declare function useSyncExternalStoreWithSelector<State, Selected>(subscribe: SubscribeOverloads<State>, getSnapshot: () => State, getServerSnapshot: (() => State) | undefined, selector: Selector<State, Selected>, equalityFn?: EqualityFn<Selected>): Selected;
-export declare function useSyncExternalStoreWithSelector<State, Selected>(subscribe: SubscribeOverloads<State>, getSnapshot: () => State, getServerSnapshot: (() => State) | undefined, selector: Selector<State, Selected> | undefined, equalityFn?: EqualityFn<Selected>): State | Selected;
-//# sourceMappingURL=useSyncExternalStoreWithSelector.d.ts.map

package/dist/index.shared.d.ts

@@ -1,14 +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';
-//# sourceMappingURL=index.shared.d.ts.map

package/dist/index.vanilla.d.ts

@@ -1,2 +0,0 @@
-export * from './index.shared';
-//# sourceMappingURL=index.vanilla.d.ts.map

package/dist/internal/baseStore.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=baseStore.d.ts.map

package/dist/internal/config.d.ts

@@ -1,64 +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 {};
-//# sourceMappingURL=config.d.ts.map

package/dist/internal/createStoreActions.d.ts

@@ -1,24 +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;
-//# sourceMappingURL=createStoreActions.d.ts.map

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

@@ -1,15 +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;
-//# sourceMappingURL=deriveProxy.d.ts.map

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

@@ -1,26 +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 {};
-//# sourceMappingURL=pathFinder.d.ts.map

package/dist/internal/derivedStore.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=derivedStore.d.ts.map

package/dist/internal/errors.d.ts

@@ -1,10 +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);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/internal/logger.d.ts

@@ -1,10 +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;
-}
-//# sourceMappingURL=logger.d.ts.map

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

@@ -1,20 +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 {};
-//# sourceMappingURL=createHydrationGate.d.ts.map

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

@@ -1,18 +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>;
-//# sourceMappingURL=queryParams.d.ts.map

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

@@ -1,8 +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;
-//# sourceMappingURL=queryStoreDefaults.d.ts.map

package/dist/internal/queryStore.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=queryStore.d.ts.map

package/dist/internal/runtime.d.ts

@@ -1,12 +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';
-//# sourceMappingURL=runtime.d.ts.map

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

@@ -1,12 +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>;
-//# sourceMappingURL=storageCreators.d.ts.map

package/dist/internal/storeUtils.d.ts

@@ -1,46 +0,0 @@
-import type { QueryStore, QueryStoreState } from '../queryStore/types';
-import type { StoreApi } from '../store/types';
-import type { BaseStore, InferStoreState, PersistedStore } from '../types';
-/**
- * Calls the appropriate reset or destroy method on the store, if available.
- * Handles both `DerivedStore` and `QueryStore`.
- */
-export declare function destroyStore(store: BaseStore<unknown> | StoreApi<unknown> | QueryStore<unknown, Record<string, unknown>, unknown>, options?: {
-    clearQueryCache?: boolean;
-}): void;
-export declare function destroyStores(stores: Partial<Record<string, BaseStore<unknown> | StoreApi<unknown>>> | (BaseStore<unknown> | StoreApi<unknown> | undefined)[], options?: {
-    clearQueryCache?: boolean;
-    skipDestroy?: (store: BaseStore<unknown> | StoreApi<unknown>) => boolean;
-}): void;
-/**
- * Returns the name of the store, either from the `persist` options or the store itself.
- */
-export declare function getStoreName(store: BaseStore<unknown>): string;
-/**
- * Checks if a store is a `DerivedStore` and reveals its internal `getSnapshot` method.
- */
-export declare function hasGetSnapshot<T extends BaseStore<unknown> | StoreApi<unknown>>(store: T): store is T & {
-    getSnapshot: () => InferStoreState<T>;
-};
-/**
- * Checks if a store is a `QueryStore`.
- */
-export declare function isQueryStore<T extends object>(store: T): store is Extract<T, BaseStore<QueryStoreState<unknown, Record<string, unknown>, unknown>>>;
-/**
- * Checks if a store is a `DerivedStore`.
- */
-export declare function isDerivedStore<T extends BaseStore<unknown> | StoreApi<unknown>>(store: T): store is T & {
-    destroy: () => void;
-    flushUpdates: () => void;
-};
-/**
- * Checks if a store is persisted.
- */
-export declare function isPersistedStore<T extends BaseStore<unknown> | PersistedStore<unknown>>(store: T): store is T & {
-    persist: PersistedStore<InferStoreState<T>>['persist'];
-};
-/**
- * Checks if a store is a virtual store.
- */
-export declare function isVirtualStore<T extends BaseStore<unknown> | StoreApi<unknown>>(store: T): store is T & BaseStore<InferStoreState<T>>;
-//# sourceMappingURL=storeUtils.d.ts.map

package/dist/internal/sync/browserSyncEngine.d.ts

@@ -1,3 +0,0 @@
-import { SyncEngine } from '../../sync/types';
-export declare function createBrowserSyncEngine(): SyncEngine;
-//# sourceMappingURL=browserSyncEngine.d.ts.map

package/dist/internal/sync/noopSyncEngine.d.ts

@@ -1,3 +0,0 @@
-import { SyncEngine } from '../../sync/types';
-export declare function createNoopSyncEngine(): SyncEngine;
-//# sourceMappingURL=noopSyncEngine.d.ts.map

package/dist/internal/sync/syncEnhancer.d.ts

@@ -1,26 +0,0 @@
-import { NormalizedSyncConfig } from '../../sync/types';
-import { StateCreator } from '../../types';
-export type SyncContext = {
-    isAsync: boolean;
-    clearFieldTimestamps: (snapshot: Record<string, number> | undefined) => void;
-    getFieldTimestampSnapshot: () => Record<string, number> | undefined;
-    getIsApplyingRemote: () => boolean;
-    getSessionId: () => string | undefined;
-    getTimestamp: () => number | undefined;
-    mergeFieldTimestamps: (fields: Record<string, number>) => void;
-    onHydrationComplete: (() => void) | undefined;
-    onHydrationFlushEnd: (() => void) | undefined;
-    setIsApplyingRemote: (value: boolean) => void;
-    setSessionId: (sessionId: string) => void;
-    setTimestamp: (timestamp: number) => void;
-    setWithoutPersist: (<_T extends (..._: unknown[]) => void | Promise<void>, Args extends unknown[]>(..._: Args) => void | Promise<void>) | undefined;
-};
-export declare function createSyncedStateCreator<T extends Record<string, unknown>>(stateCreator: StateCreator<T>, config: NormalizedSyncConfig<T>, isAsync: boolean): {
-    stateCreator: StateCreator<T>;
-    syncContext: SyncContext;
-};
-/**
- * Readable indices for `FieldMetadata` tuples.
- */
-export declare const TIMESTAMP: 0, SESSION_ID: 1;
-//# sourceMappingURL=syncEnhancer.d.ts.map

package/dist/internal/sync/syncUtils.d.ts

@@ -1,6 +0,0 @@
-import { FieldMetadata } from '../../sync/types';
-/**
- * Helper to create `FieldMetadata` tuples.
- */
-export declare function createFieldMetadata(timestamp: number, sessionId: string): FieldMetadata;
-//# sourceMappingURL=syncUtils.d.ts.map

package/dist/internal/types/internalSubscribeTypes.d.ts

@@ -1,16 +0,0 @@
-import type { Listener, ListenerArgs, Selector, SubscribeOptions } from '../../types/subscribe';
-export type InternalSubscribeOptions<Selected> = SubscribeOptions<Selected> & {
-    isCascadeParticipant?: boolean;
-};
-export type InternalSelectorArgs<S, Selected> = [
-    selector: Selector<S, Selected>,
-    listener: Listener<Selected>,
-    options?: InternalSubscribeOptions<Selected>
-];
-export type InternalSubscribeArgs<S, Selected = unknown> = ListenerArgs<S> | InternalSelectorArgs<S, Selected>;
-export type InternalUnsubscribeFn = (skipAbortFetch?: boolean) => void;
-export type InternalSubscribeOverloads<S> = {
-    (...args: ListenerArgs<S>): InternalUnsubscribeFn;
-    <Selected>(...args: InternalSelectorArgs<S, Selected>): InternalUnsubscribeFn;
-};
-//# sourceMappingURL=internalSubscribeTypes.d.ts.map

package/dist/internal/utils/persistUtils.d.ts

@@ -1,9 +0,0 @@
-import type { StorageValue } from '../../storage/storageTypes';
-/**
- * Default partialize function if none is provided. It omits top-level store
- * methods and keeps all other state.
- */
-export declare function omitStoreMethods<S, PersistedState extends Partial<S> = Partial<S>>(state: S): PersistedState;
-export declare function defaultSerializeState<PersistedState>(storageValue: StorageValue<PersistedState>, shouldUseReplacer: boolean): string;
-export declare function defaultDeserializeState<PersistedState>(serializedState: string, shouldUseReviver: boolean): StorageValue<PersistedState>;
-//# sourceMappingURL=persistUtils.d.ts.map

package/dist/internal/virtualStore.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=virtualStore.d.ts.map

package/dist/plugins/chrome/chromeExtensionSyncEngine.d.ts

@@ -1,30 +0,0 @@
-import { SyncEngine, SyncHandle, SyncRegistration } from '../../sync/types';
-import { ChromeStorageAdapter, ChromeStorageAdapterOptions } from './chromeStorageAdapter';
-export type ChromeExtensionSyncEngineOptions = ChromeStorageAdapterOptions | {
-    storage: ChromeStorageAdapter;
-};
-export declare class ChromeExtensionSyncEngine implements SyncEngine {
-    readonly injectStorageMetadata = true;
-    readonly sessionId: string;
-    private readonly area;
-    private readonly storageKeyPrefix;
-    private readonly registrations;
-    private isListening;
-    constructor(options?: ChromeExtensionSyncEngineOptions);
-    destroy(): void;
-    register<T extends Record<string, unknown>>(registration: SyncRegistration<T>): SyncHandle<T>;
-    private generateSessionId;
-    private attachListener;
-    private detachListener;
-    private onStorageChanged;
-    /**
-     * Extracts which fields changed in this update.
-     * Prefers field-level metadata when available, falls back to full state diff.
-     * Does NOT perform conflict resolution - that's handled by syncEnhancer.processUpdate.
-     */
-    private extractChangedFields;
-    private setRegistration;
-    private toStorageKey;
-    private parsePersistValue;
-}
-//# sourceMappingURL=chromeExtensionSyncEngine.d.ts.map

package/dist/plugins/chrome/chromeStorageAdapter.d.ts

@@ -1,31 +0,0 @@
-import { StorageValue } from '../../storage/storageTypes';
-import { AsyncStorageInterface } from '../../types';
-export type AreaName = keyof Pick<typeof chrome.storage, 'local' | 'managed' | 'session' | 'sync'>;
-export type ChromeStorageAdapterOptions = {
-    area?: AreaName;
-    storageKeyPrefix?: string;
-};
-export type ChromeStorageValue<PersistedState = unknown> = StorageValue<PersistedState>;
-export declare class ChromeStorageAdapter implements AsyncStorageInterface {
-    readonly area: AreaName;
-    readonly storageKeyPrefix: string;
-    readonly async = true;
-    readonly deserializer: typeof deserializeChromeStorageValue;
-    readonly serializer: typeof serializeChromeStorageValue;
-    constructor(options?: ChromeStorageAdapterOptions);
-    clearAll(): Promise<void>;
-    contains(key: string): Promise<boolean>;
-    delete(key: string): Promise<void>;
-    getAllKeys(): Promise<string[]>;
-    get(key: string): Promise<unknown>;
-    set(key: string, value: unknown): Promise<void>;
-    private ensureStorage;
-    private toStorageKey;
-    private listPrefixedKeys;
-    private getFromStorage;
-    private execute;
-    private invokeWithCallbackSupport;
-}
-export declare function serializeChromeStorageValue<PersistedState>(storageValue: StorageValue<PersistedState>): unknown;
-export declare function deserializeChromeStorageValue<PersistedState>(serializedState: unknown): StorageValue<PersistedState>;
-//# sourceMappingURL=chromeStorageAdapter.d.ts.map

package/dist/plugins/chrome/createSyncedChromeStorage.d.ts

@@ -1,14 +0,0 @@
-import { ChromeExtensionSyncEngine } from './chromeExtensionSyncEngine';
-import { ChromeStorageAdapter, ChromeStorageAdapterOptions } from './chromeStorageAdapter';
-/**
- * Creates a synced Chrome storage engine for extension environments.
- * @returns
- * ```ts
- * { engine: ChromeExtensionSyncEngine; storage: ChromeStorageAdapter }
- * ```
- */
-export declare function createSyncedChromeStorage(options?: ChromeStorageAdapterOptions): {
-    storage: ChromeStorageAdapter;
-    syncEngine: ChromeExtensionSyncEngine;
-};
-//# sourceMappingURL=createSyncedChromeStorage.d.ts.map

package/dist/queryStore/classes/SubscriptionManager.d.ts

@@ -1,39 +0,0 @@
-/**
- * Lazy initialization config for subscription handlers.
- */
-interface SubscriptionHandlerConfig {
-    /**
-     * Callback executed when a subscription is added.
-     * @param isFirstSubscription - Whether this is the first subscription
-     * @param shouldThrottle - Whether to throttle the fetch
-     */
-    onSubscribe: (isFirstSubscription: boolean, shouldThrottle: boolean) => void;
-    /** Callback executed when the last remaining subscription is removed. */
-    onLastUnsubscribe: (willResubscribe?: boolean) => void;
-}
-/**
- * Manages subscription state and lifecycle events for a `createQueryStore` instance.
- */
-export declare class SubscriptionManager {
-    private count;
-    private lastSubscriptionTime;
-    private readonly fetchThrottleMs;
-    private onSubscribe;
-    private onLastUnsubscribe;
-    /**
-     * Creates a new SubscriptionManager instance.
-     */
-    constructor(disableAutoRefetching: boolean);
-    /**
-     * Initializes subscription event handlers.
-     */
-    init({ onSubscribe, onLastUnsubscribe }: SubscriptionHandlerConfig): void;
-    hasSubscribers(): boolean;
-    /**
-     * Adds a new subscription and triggers relevant lifecycle callbacks.
-     * @returns A cleanup function that removes the subscription when called
-     */
-    subscribe(): (skipAbortFetch?: boolean) => void;
-}
-export {};
-//# sourceMappingURL=SubscriptionManager.d.ts.map

package/dist/queryStore/queryKey.d.ts

@@ -1,10 +0,0 @@
-/**
- * Generates a deterministic query store `queryKey` from the given
- * key payload, consistent with internally generated keys.
- */
-export declare function getQueryKey<TKeyPayload extends Record<string, unknown>>(keyPayload: TKeyPayload): string;
-/**
- * Parses a query store `queryKey` into the key payload it encodes.
- */
-export declare function parseQueryKey<TKeyPayload extends Record<string, unknown> = Record<string, unknown>>(queryKey: string): TKeyPayload;
-//# sourceMappingURL=queryKey.d.ts.map