cross-state 0.6.4 → 0.6.7

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

@@ -13,24 +13,30 @@ export interface CacheFunction<T, Args extends any[] = []> {
     }, ...args: Args): Promise<T>;
 }
 export interface CacheOptions<T> {
-    invalidateAfter?: Duration | ((state: ValueState<T> | ErrorState) => Duration | undefined);
-    clearAfter?: Duration | ((state: ValueState<T> | ErrorState) => Duration | undefined);
+    invalidateAfter?: Duration | ((state: ValueState<T> | ErrorState) => Duration | null) | null;
+    invalidateOnWindowFocus?: boolean;
+    invalidateOnActivation?: boolean;
+    clearOnInvalidate?: boolean;
+    clearUnusedAfter?: Duration | null;
     resourceGroup?: ResourceGroup | ResourceGroup[];
     retain?: number;
-    clearUnusedAfter?: Duration;
 }
 export declare class Cache<T> extends Store<Promise<T>> {
     readonly options: CacheOptions<T>;
+    readonly derivedFromCache?: {
+        cache: Cache<any>;
+        selectors: (Selector<any, any> | Path<any>)[];
+    } | undefined;
     readonly state: Store<CacheState<T>> & Omit<ThisType<Store<CacheState<T>>>, keyof Store<T_1>> & {
         delete<T_2 extends Record<any, any>, K_1 extends Exclude<{ [K in keyof T_2]: T_2 extends Record<K, T_2[K]> ? never : K; }[keyof T_2], undefined>>(this: Store<T_2>, key: K_1): void;
         clear<T_3 extends Record<any, any>>(this: Store<Partial<T_3>>): void;
     };
     protected stalePromise?: Promise<T>;
-    protected timers: Set<number>;
-    constructor(getter: CacheFunction<T>, options?: CacheOptions<T>, derivedFrom?: {
-        store: Store<any>;
+    protected invalidationTimer?: ReturnType<typeof setTimeout>;
+    constructor(getter: CacheFunction<T>, options?: CacheOptions<T>, derivedFromCache?: {
+        cache: Cache<any>;
         selectors: (Selector<any, any> | Path<any>)[];
-    });
+    } | undefined, _call?: (...args: any[]) => any);
     get({ update, backgroundUpdate }?: CacheGetOptions): Promise<T>;
     invalidate({ invalidateDependencies }?: {
         invalidateDependencies?: boolean;
@@ -42,15 +48,15 @@ export declare class Cache<T> extends Store<Promise<T>> {
     mapValue<P extends Path<T>>(selector: P): Cache<Value<T, P>>;
     protected watchPromise(): void;
     protected setTimers(): void;
+    protected watchFocus(): void;
 }
-declare function create<T>(cacheFunction: CacheFunction<T>, options?: CacheOptions<T>): Cache<T>;
-declare function withArgs<T, Args extends any[]>(cacheFunction: CacheFunction<T, Args>, options?: CacheOptions<T>): {
+type CreateReturnType<T, Args extends any[]> = {
     (...args: Args): Cache<T>;
-    invalidate: () => void;
-    clear: () => void;
-};
+    invalidateAll: () => void;
+    clearAll: () => void;
+} & ([] extends Args ? Cache<T> : {});
+declare function create<T, Args extends any[]>(cacheFunction: CacheFunction<T, Args>, options?: CacheOptions<T>): CreateReturnType<T, Args>;
 export declare const createCache: typeof create & {
-    withArgs: typeof withArgs;
     defaultOptions: CacheOptions<unknown>;
 };
 export {};

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

@@ -1,5 +1,6 @@
 import type { Cancel, Duration, Effect, Listener, Selector, SubscribeOptions, Update, Use, UseOptions } from './commonTypes';
 import { CalculationHelper } from '../lib/calculationHelper';
+import { Callable } from '../lib/callable';
 import type { Path, Value } from '../lib/path';
 import { arrayMethods, mapMethods, recordMethods, setMethods } from '../lib/standardMethods';
 export type StoreMethods = Record<string, (...args: any[]) => any>;
@@ -17,13 +18,14 @@ export type Calculate<T> = (this: {
 }) => T;
 type StandardMethods<T> = T extends Map<any, any> ? typeof mapMethods : T extends Set<any> ? typeof setMethods : T extends Array<any> ? typeof arrayMethods : T extends Record<any, any> ? typeof recordMethods : Record<string, never>;
 type StoreWithMethods<T, Methods extends StoreMethods> = Store<T> & Omit<BoundStoreMethods<T, Methods>, keyof Store<T>> & StandardMethods<T>;
-export declare class Store<T> {
+export declare class Store<T> extends Callable<any, any> {
     readonly getter: T | Calculate<T>;
     readonly options: StoreOptions;
-    protected derivedFrom?: {
+    readonly derivedFrom?: {
         store: Store<any>;
         selectors: (Selector<any, any> | Path<any>)[];
     } | undefined;
+    protected readonly _call: (...args: any[]) => any;
     protected _value?: {
         v: T;
     };
@@ -38,7 +40,7 @@ export declare class Store<T> {
     constructor(getter: T | Calculate<T>, options?: StoreOptions, derivedFrom?: {
         store: Store<any>;
         selectors: (Selector<any, any> | Path<any>)[];
-    } | undefined);
+    } | undefined, _call?: (...args: any[]) => any);
     get(): T;
     set(update: Update<T>): void;
     set<P extends Path<T>>(path: P, update: Update<Value<T, P>>): void;
@@ -60,7 +62,7 @@ export declare class Store<T> {
      */
     addEffect(effect: Effect, retain?: Duration): () => void;
     /** Return whether the store is currently active, which means whether it has at least one subscriber. */
-    get isActive(): boolean;
+    isActive(): boolean;
     protected onSubscribe(): void;
     protected onUnsubscribe(): void;
     protected notify(): void;

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

@@ -0,0 +1,4 @@
+export declare class Callable<Args extends any[], T> extends Function {
+    protected _call: (...args: Args) => T;
+    constructor(_call: (...args: Args) => T);
+}

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

@@ -1,6 +1,6 @@
 export declare class InstanceCache<Args extends any[], T extends object> {
-    private factory;
-    private cacheTime?;
+    readonly factory: (...args: Args) => T;
+    readonly cacheTime?: number | undefined;
     private cache;
     private interval;
     constructor(factory: (...args: Args) => T, cacheTime?: number | undefined);

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

@@ -1,6 +1,6 @@
 import type { UseStoreOptions } from './useStore';
-import type { CacheState } from '../lib/cacheState';
 import type { Cache } from '../core';
+import type { CacheState } from '../lib/cacheState';
 export type UseCacheArray<T> = [
     value: T | undefined,
     error: unknown | undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cross-state",
-  "version": "0.6.4",
+  "version": "0.6.7",
   "description": "(React) state library",
   "license": "ISC",
   "repository": "schummar/schummar-state",
@@ -16,23 +16,23 @@
     "react.d.ts"
   ],
   "main": "dist/cjs/index.cjs",
-  "module": "dist/es/index.mjs",
+  "module": "dist/es/index.js",
   "types": "dist/types/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/es/index.mjs",
+      "import": "./dist/es/index.js",
       "require": "./dist/cjs/index.cjs",
-      "default": "./dist/es/index.mjs"
+      "default": "./dist/es/index.js"
     },
     "./react": {
-      "import": "./dist/es/react.mjs",
+      "import": "./dist/es/react.js",
       "require": "./dist/cjs/react.cjs",
-      "default": "./dist/es/react.mjs"
+      "default": "./dist/es/react.js"
     },
     "./immer": {
-      "import": "./dist/es/immer.mjs",
+      "import": "./dist/es/immer.js",
       "require": "./dist/cjs/immer.cjs",
-      "default": "./dist/es/immer.mjs"
+      "default": "./dist/es/immer.js"
     }
   },
   "typesVersions": {