cross-state 0.6.3 → 0.6.4

package/dist/types/lib/diff.d.ts

@@ -1,7 +1,14 @@
-export interface Patch {
-    op: 'replace' | 'remove' | 'add';
-    path: (string | number)[];
-    value?: any;
-    prevValue?: any;
-}
-export declare function diff(a: any, b: any, prefix?: (string | number)[]): Iterable<Patch>;
+import type { KeyType } from './path';
+export type Patch = {
+    op: 'add';
+    path: KeyType[];
+    value: any;
+} | {
+    op: 'remove';
+    path: KeyType[];
+} | {
+    op: 'replace';
+    path: KeyType[];
+    value: any;
+};
+export declare function diff(a: any, b: any): [patches: Patch[], reversePatches: Patch[]];

package/dist/types/lib/{cache.d.ts → instanceCache.d.ts}

@@ -1,4 +1,4 @@
-export declare class Cache<Args extends any[], T extends object> {
+export declare class InstanceCache<Args extends any[], T extends object> {
     private factory;
     private cacheTime?;
     private cache;

package/dist/types/lib/makeSelector.d.ts

@@ -1 +1,2 @@
-export declare function makeSelector<T, S>(selector?: ((value: T) => S) | string): (value: T) => S;
+import type { Path } from './path';
+export declare function makeSelector<T, S>(selector?: ((value: T) => S) | Path<any>): (value: T) => S;

package/dist/types/lib/maybeAsync.d.ts

@@ -0,0 +1,3 @@
+import type { MaybePromise } from './maybePromise';
+export declare function maybeAsync<T, R>(value: MaybePromise<T>, action: (value: T) => MaybePromise<R>): MaybePromise<R>;
+export declare function maybeAsyncArray<T>(values: (() => MaybePromise<T>)[]): MaybePromise<T[]>;

package/dist/types/lib/path.d.ts

@@ -0,0 +1,14 @@
+import type { ArrayToStringPath, Array_, Object_, OptionalPropertyOf, StringToArrayPath, StringToNumber } from './typeHelpers';
+export type KeyType = string | number;
+export type GetKeys<T extends Object_ | Array_> = T extends Array_ ? T extends readonly [] ? never : '0' extends keyof T ? StringToNumber<keyof T> : number : keyof T;
+export type PathAsArray<T, Optional = false> = 0 extends 1 & T ? KeyType[] : T extends never ? never : T extends Object_ | Array_ ? {
+    [K in GetKeys<T>]: (Optional extends true ? (K extends OptionalPropertyOf<T> ? [K] : never) : [K]) | [K, ...PathAsArray<T[K], Optional>];
+}[GetKeys<T>] : T extends Map<infer K extends KeyType, infer V> ? [K] | [K, ...PathAsArray<V, Optional>] : T extends Set<any> ? [number] : never;
+export type PathAsString<T, Optional = false> = ArrayToStringPath<PathAsArray<T, Optional>>;
+export type Path<T, Optional = false> = PathAsString<T, Optional> | PathAsArray<T, Optional>;
+export type Value<T, P> = 0 extends 1 & T ? any : P extends string ? Value<T, StringToArrayPath<P>> : P extends [infer First extends KeyType, ...infer Rest extends KeyType[]] ? T extends Object_ ? Record<any, any> extends T ? Value<T[First], Rest> | undefined : Value<T[First], Rest> : T extends Array_ ? any[] extends T ? Value<T[First & keyof T], Rest> | undefined : Value<T[First & keyof T], Rest> : T extends Map<any, infer V> | Set<infer V> ? Value<V, Rest> | undefined : never : T;
+export type WildcardPathAsArray<T> = [] | (0 extends 1 & T ? KeyType[] : T extends never ? never : T extends Object_ | Array_ ? {
+    [K in GetKeys<T>]: ['*'] | [K] | [K, ...WildcardPathAsArray<T[K]>];
+}[GetKeys<T>] : T extends Map<infer K extends KeyType, infer V> ? ['*'] | [K] | [K, ...WildcardPathAsArray<V>] : T extends Set<any> ? ['*'] | [number] : never);
+export type WildcardPathAsString<T> = ArrayToStringPath<WildcardPathAsArray<T>>;
+export type WildcardPath<T> = WildcardPathAsString<T> | WildcardPathAsArray<T>;

package/dist/types/lib/propAccess.d.ts

@@ -1,13 +1,6 @@
 import type { Update } from '../core/commonTypes';
-type FilterKey<T> = T extends string | number ? T : never;
-type FilterString<T> = T extends string ? T : never;
-export type Obj = Record<string | number, unknown>;
-export type Arr = readonly unknown[];
-type GetKeys<T> = T extends Arr ? T extends readonly [] ? never : '0' extends keyof T ? keyof T & `${number}` : number : keyof T;
-export type Path<T> = 0 extends 1 & T ? string : T extends never ? never : T extends Obj | Arr ? FilterString<keyof {
-    [K in FilterKey<GetKeys<T>> as `${K}` | (T[K] extends Obj | Arr | undefined | null ? `${K}.${Path<NonNullable<T[K]>>}` : never)]: 0;
-}> : never;
-export type Value<T, P extends string> = P extends `${infer K}.${infer Rest}` ? T[K & keyof T] extends Obj | Arr ? Value<T[K & keyof T], Rest> : T[K & keyof T] extends Obj | Arr | undefined | null ? Value<NonNullable<T[K & keyof T]>, Rest> | undefined : never : T[P & keyof T];
-export declare function get<T, P extends Path<T>>(obj: T, path: P): Value<T, P>;
-export declare function set<T, P extends Path<T>>(obj: T, path: P, value: Update<Value<T, P>>, rootPath?: P): T;
-export {};
+import type { Path, Value } from './path';
+export declare function castArrayPath(path: string | KeyType[]): KeyType[];
+export declare function get<T, P extends Path<T>>(object: T, path: P): Value<T, P>;
+export declare function set<T, P extends Path<T>>(object: T, path: P, value: Update<Value<T, P>>, rootPath?: P): T;
+export declare function remove<T, P extends Path<T, true>>(object: T, path: P): T;

package/dist/types/lib/queue.d.ts

@@ -1,9 +1,11 @@
 import type { MaybePromise } from './maybePromise';
 type Action<T> = () => MaybePromise<T>;
 export interface Queue {
-    <T>(action: Action<T>): Promise<T>;
+    <T>(action: Action<T>, ref?: any): Promise<T>;
     clear: () => void;
-    whenDone: Promise<void>;
+    whenDone: () => Promise<void>;
+    size: number;
+    getRefs: () => any[];
 }
 export declare function queue(): Queue;
 export {};

package/dist/types/lib/standardMethods.d.ts

@@ -0,0 +1,25 @@
+import type { Store } from '../core/store';
+type Function_ = (...args: any) => any;
+export declare const arrayMethods: {
+    splice: <T extends any[]>(this: Store<T>, ...args: T["splice"] extends Function_ ? Parameters<T["splice"]> : never) => T["splice"] extends Function_ ? ReturnType<T["splice"]> : never;
+    push: <T_1 extends any[]>(this: Store<T_1>, ...args: T_1["push"] extends Function_ ? Parameters<T_1["push"]> : never) => T_1["push"] extends Function_ ? ReturnType<T_1["push"]> : never;
+    pop: <T_2 extends any[]>(this: Store<T_2>, ...args: T_2["pop"] extends Function_ ? Parameters<T_2["pop"]> : never) => T_2["pop"] extends Function_ ? ReturnType<T_2["pop"]> : never;
+    shift: <T_3 extends any[]>(this: Store<T_3>, ...args: T_3["shift"] extends Function_ ? Parameters<T_3["shift"]> : never) => T_3["shift"] extends Function_ ? ReturnType<T_3["shift"]> : never;
+    unshift: <T_4 extends any[]>(this: Store<T_4>, ...args: T_4["unshift"] extends Function_ ? Parameters<T_4["unshift"]> : never) => T_4["unshift"] extends Function_ ? ReturnType<T_4["unshift"]> : never;
+    reverse: <T_5 extends any[]>(this: Store<T_5>, ...args: T_5["reverse"] extends Function_ ? Parameters<T_5["reverse"]> : never) => T_5["reverse"] extends Function_ ? ReturnType<T_5["reverse"]> : never;
+    sort: <T_6 extends any[]>(this: Store<T_6>, ...args: T_6["sort"] extends Function_ ? Parameters<T_6["sort"]> : never) => T_6["sort"] extends Function_ ? ReturnType<T_6["sort"]> : never;
+};
+export declare const recordMethods: {
+    delete<T extends Record<any, any>, K_1 extends Exclude<{ [K in keyof T]: T extends Record<K, T[K]> ? never : K; }[keyof T], undefined>>(this: Store<T>, key: K_1): void;
+    clear<T_1 extends Record<any, any>>(this: Store<Partial<T_1>>): void;
+};
+export declare const mapMethods: {
+    delete<K, V>(this: Store<Map<K, V>>, key: K): boolean;
+    clear<K_1, V_1>(this: Store<Map<K_1, V_1>>): void;
+};
+export declare const setMethods: {
+    add<T>(this: Store<Set<T>>, value: T): void;
+    delete<T_1>(this: Store<Set<T_1>>, value: T_1): void;
+    clear<T_2>(this: Store<Set<T_2>>): void;
+};
+export {};

package/dist/types/lib/throttle.d.ts

@@ -1 +1,2 @@
-export declare function throttle<Args extends any[]>(fn: (...args: Args) => void, ms: number): (...args: Args) => void;
+import type { Duration } from '../core';
+export declare function throttle<Args extends any[]>(action: (...args: Args) => void, duration: Duration): (...args: Args) => void;

package/dist/types/lib/typeHelpers.d.ts

@@ -0,0 +1,8 @@
+export type Object_ = Record<string | number, unknown>;
+export type Array_ = readonly unknown[];
+export type StringToNumber<T> = T extends `${infer K extends number}` ? K : never;
+export type ArrayToStringPath<T> = T extends [] ? '' : T extends [infer First extends string, ...infer Rest] ? First extends `${string}.${string}` ? never : Rest['length'] extends 0 ? First : `${First}.${ArrayToStringPath<Rest>}` : never;
+export type StringToArrayPath<T> = T extends '' ? [] : T extends `${infer First}.${infer Rest}` ? [First, ...StringToArrayPath<Rest>] : [T];
+export type OptionalPropertyOf<T> = Exclude<{
+    [K in keyof T]: T extends Record<K, T[K]> ? never : K;
+}[keyof T], undefined>;

package/dist/types/persist/index.d.ts

@@ -0,0 +1,3 @@
+export { persist } from './persist';
+export type { Persist, PersistOptions } from './persist';
+export type { PersistStorage, PersistStorageBase, PersistStorageWithKeys, PersistStorageWithLength, } from './persistStorage';

package/dist/types/persist/persist.d.ts

@@ -0,0 +1,33 @@
+import { type PersistStorage, type PersistStorageWithKeys } from './persistStorage';
+import { type Cancel, type Store } from '../core';
+import type { KeyType, WildcardPath } from '../lib/path';
+export interface PersistOptions<T> {
+    id: string;
+    storage: PersistStorage;
+    paths?: WildcardPath<T>[] | {
+        path: WildcardPath<T>;
+        throttleMs?: number;
+    }[];
+    throttleMs?: number;
+}
+export declare class Persist<T> {
+    readonly store: Store<T>;
+    readonly options: PersistOptions<T>;
+    storage: PersistStorageWithKeys;
+    paths: {
+        path: KeyType[];
+        throttleMs?: number;
+    }[];
+    channel: BroadcastChannel;
+    queue: import("../lib/queue").Queue;
+    handles: Set<Cancel>;
+    stopped: boolean;
+    updateInProgress?: [any, any];
+    constructor(store: Store<T>, options: PersistOptions<T>);
+    watchStore(): void;
+    watchStorage(): Promise<void>;
+    load(path: KeyType[]): import("../lib/maybePromise").MaybePromise<void>;
+    save(path: KeyType[]): import("../lib/maybePromise").MaybePromise<unknown[]>;
+    stop(): Promise<void>;
+}
+export declare function persist<T>(store: Store<T>, options: PersistOptions<T>): Persist<T>;

package/dist/types/persist/persistPathHelpers.d.ts

@@ -0,0 +1,6 @@
+import type { KeyType } from '../lib/path';
+export declare const isAncestor: (ancestor: KeyType[], path: KeyType[]) => boolean;
+export declare const split: (value: any, path: KeyType[]) => [value: unknown, subValues: {
+    path: KeyType[];
+    value: unknown;
+}[]];

package/dist/types/persist/persistStorage.d.ts

@@ -0,0 +1,14 @@
+export interface PersistStorageBase {
+    getItem: (key: string) => string | null | Promise<string | null>;
+    setItem: (key: string, value: string) => unknown | Promise<unknown>;
+    removeItem: (key: string) => unknown | Promise<unknown>;
+}
+export interface PersistStorageWithKeys extends PersistStorageBase {
+    keys: () => string[] | Promise<string[]>;
+}
+export interface PersistStorageWithLength extends PersistStorageBase {
+    length: number | (() => number | Promise<number>);
+    key: (keyIndex: number) => string | null | Promise<string | null>;
+}
+export type PersistStorage = PersistStorageBase & (PersistStorageWithKeys | PersistStorageWithLength);
+export declare function normalizeStorage(storage: PersistStorage): PersistStorageWithKeys;

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

@@ -1,6 +1,5 @@
 export { read } from './read';
-export { StoreScopeProvider, useStoreScope } from './storeScope';
-export type { StoreScopeProps } from './storeScope';
+export { type StoreScopeProps, StoreScopeProvider, useStoreScope } from './storeScope';
+export { useCache, type UseCacheArray, type UseCacheValue } from './useCache';
 export { useProp } from './useProp';
-export { useStore } from './useStore';
-export type { UseStoreOptions } from './useStore';
+export { useStore, type UseStoreOptions } from './useStore';

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

@@ -1,4 +1,3 @@
-import type { FetchStore } from '../core/fetchStore';
-import type { SubscribeOptions } from '../core/commonTypes';
-export type UseStoreOptions = Omit<SubscribeOptions, 'runNow'>;
-export declare function read<T>(store: FetchStore<T>, options?: UseStoreOptions): T;
+import type { UseStoreOptions } from './useStore';
+import type { Cache } from '../core';
+export declare function read<T>(cache: Cache<T>, options?: UseStoreOptions): T;

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

@@ -1,6 +1,6 @@
+import type { Context, ReactNode } from '../react';
 import type { Store } from '../core/store';
 import type { StoreScope } from '../core/storeScope';
-import type { Context, ReactNode } from '../react';
 export type StoreScopeProps<T> = {
     scope: StoreScope<T>;
     store?: Store<T>;

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

@@ -0,0 +1,14 @@
+import type { UseStoreOptions } from './useStore';
+import type { CacheState } from '../lib/cacheState';
+import type { Cache } from '../core';
+export type UseCacheArray<T> = [
+    value: T | undefined,
+    error: unknown | undefined,
+    isUpdating: boolean,
+    isStale: boolean
+];
+export type UseCacheValue<T> = UseCacheArray<T> & CacheState<T>;
+export interface UseCacheOptions extends UseStoreOptions {
+    passive?: boolean;
+}
+export declare function useCache<T>(cache: Cache<T>, { passive, ...options }?: UseCacheOptions): UseCacheValue<T>;

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

@@ -1,4 +1,4 @@
-import type { Store } from '../core/store';
-import type { UpdateFn } from '../core/commonTypes';
 import type { UseStoreOptions } from './useStore';
-export declare function useProp<T>(store: Store<T>, options?: UseStoreOptions): [value: T, setValue: UpdateFn<T>];
+import type { Store } from '../core/store';
+import type { UpdateFunction } from '../core/commonTypes';
+export declare function useProp<T>(store: Store<T>, options?: UseStoreOptions): [value: T, setValue: UpdateFunction<T>];

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

@@ -1,4 +1,4 @@
 import type { SubscribeOptions } from '../core/commonTypes';
 import type { Store } from '../core/store';
-export type UseStoreOptions = Omit<SubscribeOptions, 'runNow'>;
+export type UseStoreOptions = Omit<SubscribeOptions, 'runNow' | 'passive'>;
 export declare function useStore<T>(store: Store<T>, options?: UseStoreOptions): T;

package/package.json

@@ -1,12 +1,23 @@
 {
   "name": "cross-state",
-  "type": "module",
-  "repository": "schummar/schummar-state",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "(React) state library",
+  "license": "ISC",
+  "repository": "schummar/schummar-state",
+  "author": {
+    "name": "Marco Schumacher",
+    "email": "marco@schumacher.dev"
+  },
+  "type": "module",
   "sideEffects": false,
+  "files": [
+    "dist",
+    "react.js",
+    "react.d.ts"
+  ],
   "main": "dist/cjs/index.cjs",
   "module": "dist/es/index.mjs",
+  "types": "dist/types/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/es/index.mjs",
@@ -24,7 +35,6 @@
       "default": "./dist/es/immer.mjs"
     }
   },
-  "types": "dist/types/index.d.ts",
   "typesVersions": {
     "*": {
       "*": [
@@ -38,11 +48,6 @@
       ]
     }
   },
-  "author": {
-    "name": "Marco Schumacher",
-    "email": "marco@schumacher.dev"
-  },
-  "license": "ISC",
   "scripts": {
     "start": "tsc --watch",
     "build": "runp -k build:clean :p build:compile:*",
@@ -50,7 +55,7 @@
     "build:compile:js": "vite build",
     "build:compile:types": "tsc && tsc-alias",
     "lint": "runp lint:*",
-    "lint:eslint": "eslint src",
+    "lint:eslint": "lint",
     "lint:tsc": "tsc --noEmit --emitDeclarationOnly false",
     "lint:tsc:tests": "tsc --noEmit --emitDeclarationOnly false -p test/tsconfig.json",
     "prepublishOnly": "runp lint test build",
@@ -58,33 +63,6 @@
     "test:watch": "node --expose-gc node_modules/vitest/vitest.mjs",
     "test:export": "pnpm test:watch run --coverage --reporter=verbose --reporter=junit --outputFile=test/testResults.xml"
   },
-  "devDependencies": {
-    "@schummar/runp": "1.8.2",
-    "@testing-library/react": "13.4.0",
-    "@types/react": "18.0.26",
-    "@types/react-dom": "18.0.10",
-    "@types/use-sync-external-store": "0.0.3",
-    "@typescript-eslint/eslint-plugin": "5.48.1",
-    "@typescript-eslint/parser": "5.48.1",
-    "@vitejs/plugin-react": "3.0.1",
-    "@vitest/coverage-c8": "0.27.1",
-    "eslint": "8.32.0",
-    "eslint-plugin-import": "2.27.4",
-    "fast-equals": "4.0.3",
-    "happy-dom": "8.1.4",
-    "immer": "9.0.18",
-    "prettier": "2.8.3",
-    "react": "18.2.0",
-    "react-dom": "18.2.0",
-    "rimraf": "4.0.7",
-    "semantic-release": "20.0.2",
-    "tsc-alias": "^1.8.2",
-    "typescript": "4.9.4",
-    "use-sync-external-store": "1.2.0",
-    "vite": "4.0.4",
-    "vite-tsconfig-paths": "4.0.3",
-    "vitest": "0.27.1"
-  },
   "peerDependencies": {
     "@types/react": ">=16.8.0",
     "immer": ">=9.0.0",
@@ -101,12 +79,43 @@
       "optional": true
     }
   },
-  "files": [
-    "dist",
-    "react.js",
-    "react.d.ts"
-  ],
+  "devDependencies": {
+    "@schummar/eslint-config": "github:schummar/eslint-config",
+    "@schummar/prettier-config": "github:schummar/prettier-config",
+    "@schummar/runp": "1.9.3",
+    "@testing-library/react": "14.0.0",
+    "@types/react": "18.0.28",
+    "@types/react-dom": "18.0.11",
+    "@types/seedrandom": "3.0.5",
+    "@types/use-sync-external-store": "0.0.3",
+    "@vitejs/plugin-react": "3.1.0",
+    "@vitest/coverage-c8": "0.29.2",
+    "eslint": "8.35.0",
+    "fast-equals": "4.0.3",
+    "happy-dom": "8.9.0",
+    "immer": "9.0.19",
+    "jsdom": "21.1.0",
+    "prettier": "2.8.4",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "rimraf": "4.1.2",
+    "seedrandom": "3.0.5",
+    "semantic-release": "20.1.1",
+    "tsc-alias": "1.8.2",
+    "typescript": "4.9.5",
+    "use-sync-external-store": "1.2.0",
+    "vite": "4.1.4",
+    "vite-tsconfig-paths": "4.0.5",
+    "vitest": "0.29.2"
+  },
   "volta": {
-    "node": "18.9.0"
-  }
+    "node": "18.13.0",
+    "pnpm": "7.28.0"
+  },
+  "eslintConfig": {
+    "extends": [
+      "@schummar/eslint-config"
+    ]
+  },
+  "prettier": "@schummar/prettier-config"
 }

package/dist/types/core/derivedStore.d.ts

@@ -1,38 +0,0 @@
-import { CalculationHelper } from '../lib/calculationHelper';
-import type { Cancel, Selector, Update, Use } from './commonTypes';
-import type { StoreOptions } from './store';
-import { Store } from './store';
-export declare class DerivedStore<T> extends Store<T> {
-    protected calculate: (this: {
-        use: Use;
-    }, fns: {
-        use: Use;
-    }) => T;
-    protected readonly options: StoreOptions;
-    protected derivedFrom?: {
-        store: Store<any>;
-        selectors: (Selector<any, any> | string)[];
-    } | undefined;
-    calculationHelper: CalculationHelper<T>;
-    protected valid: boolean;
-    protected check?: () => void;
-    protected cancel?: Cancel;
-    constructor(calculate: (this: {
-        use: Use;
-    }, fns: {
-        use: Use;
-    }) => T, options?: StoreOptions, derivedFrom?: {
-        store: Store<any>;
-        selectors: (Selector<any, any> | string)[];
-    } | undefined);
-    get(): T;
-    update(update: Update<T>): void;
-    protected invalidate(): void;
-}
-declare function _derivedStore<T>(calculate: (this: {
-    use: Use;
-}, fns: {
-    use: Use;
-}) => T, options?: StoreOptions): DerivedStore<T>;
-export declare const derivedStore: typeof _derivedStore;
-export {};

package/dist/types/core/fetchStore.d.ts

@@ -1,76 +0,0 @@
-import { CalculationHelper } from '../lib/calculationHelper';
-import type { Path, Value } from '../lib/propAccess';
-import type { Cancel, Duration, Listener, Selector, SubscribeOptions, Update, Use, UseFetch } from './commonTypes';
-import type { ResourceGroup } from './resourceGroup';
-import { Store } from './store';
-type Common<T> = {
-    isUpdating: false;
-    update?: undefined;
-    ref: unknown;
-} | {
-    isUpdating: true;
-    update: Promise<T>;
-    ref: unknown;
-};
-type WithValue<T> = {
-    status: 'value';
-    value: T;
-    error?: undefined;
-    isStale: boolean;
-} & Common<T>;
-type WithError<T> = {
-    status: 'error';
-    value?: undefined;
-    error: unknown;
-    isStale: boolean;
-} & Common<T>;
-type Pending<T> = {
-    status: 'pending';
-    value?: undefined;
-    error?: undefined;
-    isStale: true;
-} & Common<T>;
-export type FetchStoreState<T> = WithValue<T> | WithError<T> | Pending<T>;
-export interface FetchOptions {
-    cache?: 'updateWhenStale' | 'backgroundUpdate' | 'forceUpdate';
-}
-export interface FetchFn<T, Args extends any[] = []> {
-    (this: {
-        use: Use;
-        useFetch: UseFetch;
-    }, ...args: Args): Promise<T>;
-}
-export interface FetchStoreOptions<T> {
-    invalidateAfter?: Duration | ((state: FetchStoreState<T>) => Duration);
-    clearAfter?: Duration | ((state: FetchStoreState<T>) => Duration);
-    resourceGroup?: ResourceGroup | ResourceGroup[];
-    retain?: number;
-    clearUnusedAfter?: Duration;
-}
-export declare class FetchStore<T> extends Store<FetchStoreState<T>> {
-    protected fetchFn: FetchFn<T>;
-    protected options: FetchStoreOptions<T>;
-    calculationHelper: CalculationHelper<T>;
-    constructor(fetchFn: FetchFn<T>, options?: FetchStoreOptions<T>);
-    update(value: Update<FetchStoreState<T>>): void;
-    fetch(options?: FetchOptions): Promise<T>;
-    setValue(value: T | Promise<T>): void;
-    protected setPromise(promise: Promise<T>): void;
-    setError(error: unknown): void;
-    invalidate(): void;
-    clear(): void;
-    sub(listener: Listener<FetchStoreState<T>>, options?: SubscribeOptions): Cancel;
-    mapValue<S>(selector: Selector<T, S>): FetchStore<S>;
-    mapValue<P extends Path<T>>(selector: P): FetchStore<Value<T, P>>;
-}
-declare function create<T>(fetch: FetchFn<T>, options?: FetchStoreOptions<T>): FetchStore<T>;
-declare function withArgs<T, Args extends any[]>(fetch: FetchFn<T, Args>, options?: FetchStoreOptions<T>): {
-    (...args: Args): FetchStore<T>;
-    invalidate: () => void;
-    clear: () => void;
-};
-export declare const fetchStore: typeof create & {
-    withArgs: typeof withArgs;
-    defaultOptions: FetchStoreOptions<unknown>;
-};
-export {};

package/dist/types/core/once.d.ts

@@ -1,13 +0,0 @@
-import type { Cancel, Listener } from './commonTypes';
-interface Subscribe<T> {
-    (listener: Listener<T>, options?: {
-        runNow?: boolean;
-    }): Cancel;
-}
-export declare function once<T, S extends T>(subscribe: Subscribe<T>, condition: (value: T) => value is S): Promise<S>;
-export declare function once<T>(subscribe: Subscribe<T>, condition?: (value: T) => boolean): Promise<T>;
-export declare function onceValue<T>(subscribe: Subscribe<{
-    value?: T;
-    error?: unknown;
-}>): Promise<T>;
-export {};

package/dist/types/lib/storeActions.d.ts

@@ -1,28 +0,0 @@
-import type { Update, UpdateFrom } from '../core/commonTypes';
-import type { Store } from '../core/store';
-type Fn = (...args: any) => any;
-export declare const arrayActions: {
-    splice: <T extends any[]>(this: Store<T>, ...args: T["splice"] extends Fn ? Parameters<T["splice"]> : never) => T["splice"] extends Fn ? ReturnType<T["splice"]> : never;
-    push: <T_1 extends any[]>(this: Store<T_1>, ...args: T_1["push"] extends Fn ? Parameters<T_1["push"]> : never) => T_1["push"] extends Fn ? ReturnType<T_1["push"]> : never;
-    pop: <T_2 extends any[]>(this: Store<T_2>, ...args: T_2["pop"] extends Fn ? Parameters<T_2["pop"]> : never) => T_2["pop"] extends Fn ? ReturnType<T_2["pop"]> : never;
-    shift: <T_3 extends any[]>(this: Store<T_3>, ...args: T_3["shift"] extends Fn ? Parameters<T_3["shift"]> : never) => T_3["shift"] extends Fn ? ReturnType<T_3["shift"]> : never;
-    unshift: <T_4 extends any[]>(this: Store<T_4>, ...args: T_4["unshift"] extends Fn ? Parameters<T_4["unshift"]> : never) => T_4["unshift"] extends Fn ? ReturnType<T_4["unshift"]> : never;
-    reverse: <T_5 extends any[]>(this: Store<T_5>, ...args: T_5["reverse"] extends Fn ? Parameters<T_5["reverse"]> : never) => T_5["reverse"] extends Fn ? ReturnType<T_5["reverse"]> : never;
-    sort: <T_6 extends any[]>(this: Store<T_6>, ...args: T_6["sort"] extends Fn ? Parameters<T_6["sort"]> : never) => T_6["sort"] extends Fn ? ReturnType<T_6["sort"]> : never;
-};
-export declare const recordActions: {
-    set<T extends Record<any, any>, K extends keyof T>(this: Store<T>, key: K, value: Update<T[K]>): Store<T>;
-    delete<T_1 extends Record<any, any>, K_2 extends Exclude<{ [K_1 in keyof T_1]: T_1 extends Record<K_1, T_1[K_1]> ? never : K_1; }[keyof T_1], undefined>>(this: Store<T_1>, key: K_2): void;
-    clear<T_2 extends Record<any, any>>(this: Store<Partial<T_2>>): void;
-};
-export declare const mapActions: {
-    set<K, V>(this: Store<Map<K, V>>, key: K, value: UpdateFrom<V, [V | undefined]>): Store<Map<K, V>>;
-    delete<K_1, V_1>(this: Store<Map<K_1, V_1>>, key: K_1): boolean;
-    clear<K_2, V_2>(this: Store<Map<K_2, V_2>>): void;
-};
-export declare const setActions: {
-    add<T>(this: Store<Set<T>>, value: T): void;
-    delete<T_1>(this: Store<Set<T_1>>, value: T_1): void;
-    clear<T_2>(this: Store<Set<T_2>>): void;
-};
-export {};

package/react.d.ts

@@ -1 +0,0 @@
-export * from './dist/types/react';

package/react.js

@@ -1 +0,0 @@
-module.exports = require('./dist/cjs/react.cjs');