@storesjs/stores 0.11.0 → 0.12.0

package/dist/sync/types.d.ts

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

package/dist/types/functions.d.ts

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

package/dist/types/objects.d.ts

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

package/dist/types/setState.d.ts

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

package/dist/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;
-};
-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 = () => void;
-export type SubscribeFn<S, Selected = S> = (...args: SubscribeArgs<S, Selected>) => UnsubscribeFn;
-export type SubscribeOverloads<S> = {
-    (listener: Listener<S>): UnsubscribeFn;
-    <Selected>(selector: Selector<S, Selected>, listener: Listener<Selected>, options?: SubscribeOptions<Selected>): UnsubscribeFn;
-};
-//# sourceMappingURL=subscribe.d.ts.map

package/dist/types/useStoreCallSignatures.d.ts

@@ -1,2 +0,0 @@
-export type { UseStoreCallSignatures } from './useStoreCallSignatures.react';
-//# sourceMappingURL=useStoreCallSignatures.d.ts.map

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

@@ -1,6 +0,0 @@
-import type { EqualityFn, Selector } from './subscribe';
-export type UseStoreCallSignatures<State> = {
-    (): State;
-    <Selected>(selector: Selector<State, Selected>, equalityFn?: EqualityFn<Selected>): Selected;
-};
-//# sourceMappingURL=useStoreCallSignatures.react.d.ts.map

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

@@ -1,2 +0,0 @@
-export type UseStoreCallSignatures<_> = Record<never, never>;
-//# sourceMappingURL=useStoreCallSignatures.vanilla.d.ts.map

package/dist/types/utils.d.ts

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

package/dist/types.d.ts

@@ -1,288 +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> = UseBoundStoreWithEqualityFn<StoreApi<S>> & {
-    subscribe: SubscribeOverloads<S>;
-};
-export type PersistedStore<S, PersistedState = Partial<S>, PersistReturn extends void | Promise<void> = void | Promise<void>> = UseStoreCallSignatures<S> & WithPersist<BaseStore<S>, PersistedState, PersistReturn>;
-export type Store<S, PersistedState extends Partial<S> = never, PersistReturn extends void | Promise<void> = void | Promise<void>> = [
-    PersistedState
-] extends [never] ? BaseStore<S> : PersistedStore<S, PersistedState, PersistReturn>;
-/**
- * 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>['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 dependencies for tracked computations.
- *  - `$(store, selector, equalityFn?)` depends on the selected state
- *  - `$(store)` depends on accessed state paths
- */
-export type DeriveGetter = {
-    <Store extends StoreApi<InferStoreState<Store>>>(store: Store): InferStoreState<Store>;
-    <Store extends StoreApi<InferStoreState<Store>>, Selected>(store: Store, selector: Selector<InferStoreState<Store>, 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;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/utils/core.d.ts

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

package/dist/utils/createAsyncMicrotaskScheduler.d.ts

@@ -1,35 +0,0 @@
-/**
- * Creates an async microtask-batched scheduler for a given async function.
- *
- * When the returned scheduler is called multiple times synchronously, only a single
- * microtask execution occurs. All callers receive the same Promise that resolves
- * after the batched execution completes. The function will be invoked with the
- * arguments from the most recent call.
- *
- * This is useful for batching rapid successive async operations (e.g., async storage
- * writes, network requests) to reduce unnecessary work while ensuring:
- * - The latest values are used
- * - All callers can await the completion of the batched operation
- *
- * @template Args - The argument types of the async function to schedule
- * @param fn - The async function to schedule for microtask execution
- * @returns A scheduler function that returns a Promise resolving after execution
- *
- * @example
- * ```ts
- * const batchedSave = createAsyncMicrotaskScheduler(async (data: string) => {
- *   await storage.write(data);
- *   console.log('Saved:', data);
- * });
- *
- * await Promise.all([
- *   batchedSave('first'),
- *   batchedSave('second'),
- *   batchedSave('third'),
- * ]);
- * // Writes "third" to storage once, all three Promises resolve together
- * // Logs "Saved: third"
- * ```
- */
-export declare function createAsyncMicrotaskScheduler<Args extends unknown[]>(fn: (...args: Args) => Promise<void>): (...args: Args) => Promise<void>;
-//# sourceMappingURL=createAsyncMicrotaskScheduler.d.ts.map

package/dist/utils/createMicrotaskScheduler.d.ts

@@ -1,29 +0,0 @@
-/**
- * Creates a microtask-batched scheduler for a given function.
- *
- * When the returned scheduler is called multiple times synchronously, only a single
- * microtask execution occurs. The function will be invoked with the arguments from
- * the most recent call.
- *
- * This is useful for batching rapid successive calls (e.g., state updates, change
- * handlers) to reduce unnecessary work while ensuring the latest values are used.
- *
- * @template TArgs - The argument types of the function to schedule
- * @param fn - The function to schedule for microtask execution
- * @param enqueue - The queue that should run the scheduled task
- * @returns A scheduler function with the same signature as the input function
- *
- * @example
- * ```ts
- * const batchedUpdate = createMicrotaskScheduler((value: number) => {
- *   console.log('Updated:', value);
- * });
- *
- * batchedUpdate(1);
- * batchedUpdate(2);
- * batchedUpdate(3);
- * // Logs "Updated: 3" once in the next microtask
- * ```
- */
-export declare function createMicrotaskScheduler<Args extends unknown[]>(fn: (...args: Args) => void, enqueue?: (task: () => void) => void): (...args: Args) => void;
-//# sourceMappingURL=createMicrotaskScheduler.d.ts.map

package/dist/utils/debounce.d.ts

@@ -1,22 +0,0 @@
-export type DebounceOptions = {
-    leading?: boolean;
-    maxWait?: number;
-    trailing?: boolean;
-};
-export type DebouncedFunction<F extends (...args: Parameters<F>) => ReturnType<F>> = {
-    (...args: Parameters<F>): ReturnType<F> | undefined;
-    cancel: () => void;
-    flush: () => ReturnType<F> | undefined;
-};
-/**
- * Creates a debounced function that delays invoking `func` until after `wait` milliseconds
- * have elapsed since the last time the debounced function was invoked.
- * Copied and adapted from lodash@4.17.21.
- *
- * @param func The function to debounce.
- * @param wait The number of milliseconds to delay.
- * @param options The options object.
- * @returns Returns the new debounced function.
- */
-export declare function debounce<F extends (...args: Parameters<F>) => ReturnType<F>>(func: F, wait?: number, options?: DebounceOptions): DebouncedFunction<F>;
-//# sourceMappingURL=debounce.d.ts.map