@data-client/core 0.14.18 → 0.14.20

package/ts3.4/controller/Controller.d.ts

@@ -1,13 +1,17 @@
 import { ErrorTypes, SnapshotInterface, Schema, Denormalize, Queryable, SchemaArgs } from '@data-client/normalizr';
 import { ExpiryStatus, EndpointInterface, FetchFunction, ResolveType, DenormalizeNullable, MemoCache } from '@data-client/normalizr';
+import AbortOptimistic from './AbortOptimistic.js';
 import { EndpointUpdateFunction } from './types.js';
+import { ReduxMiddlewareAPI } from '../manager/applyManager.js';
+import { GCInterface } from '../state/GCPolicy.js';
 import { ActionTypes, State } from '../types.js';
 export type GenericDispatch = (value: any) => Promise<void>;
 export type DataClientDispatch = (value: ActionTypes) => Promise<void>;
-interface ConstructorProps<D extends GenericDispatch = DataClientDispatch> {
+export interface ControllerConstructorProps<D extends GenericDispatch = DataClientDispatch> {
     dispatch?: D;
     getState?: () => State<unknown>;
     memo?: Pick<MemoCache, 'denormalize' | 'query' | 'buildQueryKey'>;
+    gcPolicy?: GCInterface;
 }
 /**
  * Imperative control of Reactive Data Client store
@@ -19,7 +23,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      *
      * @see https://dataclient.io/docs/api/Controller#dispatch
      */
-    readonly dispatch: D;
+    protected _dispatch: D;
     /**
      * Gets the latest state snapshot that is fully committed.
      *
@@ -27,12 +31,21 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      * This should *not* be used to render; instead useSuspense() or useCache()
      * @see https://dataclient.io/docs/api/Controller#getState
      */
-    readonly getState: () => State<unknown>;
+    getState: () => State<unknown>;
     /**
      * Singleton to maintain referential equality between calls
      */
     readonly memo: Pick<MemoCache, 'denormalize' | 'query' | 'buildQueryKey'>;
-    constructor({ dispatch, getState, memo, }?: ConstructorProps<D>);
+    /**
+     * Handles garbage collection
+     */
+    readonly gcPolicy: GCInterface;
+    constructor({ dispatch, getState, memo, gcPolicy, }?: ControllerConstructorProps<D>);
+    dispatch: D;
+    bindMiddleware({ dispatch, getState, }: {
+        dispatch: D;
+        getState: ReduxMiddlewareAPI['getState'];
+    }): void;
     /*************** Action Dispatchers ***************/
     /**
      * Fetches the endpoint with given args, updating the Reactive Data Client cache with the response or error upon completion.
@@ -154,7 +167,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      * Gets a snapshot (https://dataclient.io/docs/api/Snapshot)
      * @see https://dataclient.io/docs/api/Controller#snapshot
      */
-    snapshot: (state: State<unknown>, fetchedAt?: number) => SnapshotInterface;
+    snapshot: (state: State<unknown>, fetchedAt?: number) => Snapshot<unknown>;
     /**
      * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
      * @see https://dataclient.io/docs/api/Controller#getError
@@ -187,6 +200,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         data: DenormalizeNullable<E['schema']>;
         expiryStatus: ExpiryStatus;
         expiresAt: number;
+        countRef: () => () => void;
     };
     getResponse<E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>>(endpoint: E, ...rest: readonly [
         ...(readonly [
@@ -199,6 +213,36 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         data: DenormalizeNullable<E['schema']>;
         expiryStatus: ExpiryStatus;
         expiresAt: number;
+        countRef: () => () => void;
+    };
+    /**
+     * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+     * @see https://dataclient.io/docs/api/Controller#getResponseMeta
+     */
+    getResponseMeta<E extends EndpointInterface>(endpoint: E, ...rest: readonly [
+        null,
+        State<unknown>
+    ] | readonly [
+        ...Parameters<E>,
+        State<unknown>
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+        countRef: () => () => void;
+    };
+    getResponseMeta<E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>>(endpoint: E, ...rest: readonly [
+        ...(readonly [
+            ...Parameters<E['key']>
+        ] | readonly [
+            null
+        ]),
+        State<unknown>
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+        countRef: () => () => void;
     };
     /**
      * Queries the store for a Querable schema
@@ -208,7 +252,99 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         ...SchemaArgs<S>,
         Pick<State<unknown>, 'entities' | 'entityMeta'>
     ]): DenormalizeNullable<S> | undefined;
+    /**
+     * Queries the store for a Querable schema; providing related metadata
+     * @see https://dataclient.io/docs/api/Controller#getQueryMeta
+     */
+    getQueryMeta<S extends Queryable>(schema: S, ...rest: readonly [
+        ...SchemaArgs<S>,
+        Pick<State<unknown>, 'entities' | 'entityMeta'>
+    ]): {
+        data: DenormalizeNullable<S> | undefined;
+        countRef: () => () => void;
+    };
     private getSchemaResponse;
 }
 export { ErrorTypes };
+declare class Snapshot<T = unknown> implements SnapshotInterface {
+    static readonly abort: AbortOptimistic;
+    private state;
+    private controller;
+    readonly fetchedAt: number;
+    readonly abort: AbortOptimistic;
+    constructor(controller: Controller, state: State<T>, fetchedAt?: number);
+    /*************** Data Access ***************/
+    /** @see https://dataclient.io/docs/api/Snapshot#getResponse */
+    getResponse<E extends EndpointInterface>(endpoint: E, ...args: readonly [
+        null
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    getResponse<E extends EndpointInterface>(endpoint: E, ...args: readonly [
+        ...Parameters<E>
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    getResponse<E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>>(endpoint: E, ...args: readonly [
+        ...Parameters<E['key']>
+    ] | readonly [
+        null
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    /** @see https://dataclient.io/docs/api/Snapshot#getResponseMeta */
+    getResponseMeta<E extends EndpointInterface>(endpoint: E, ...args: readonly [
+        null
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    getResponseMeta<E extends EndpointInterface>(endpoint: E, ...args: readonly [
+        ...Parameters<E>
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    getResponseMeta<E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>>(endpoint: E, ...args: readonly [
+        ...Parameters<E['key']>
+    ] | readonly [
+        null
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    /** @see https://dataclient.io/docs/api/Snapshot#getError */
+    getError<E extends EndpointInterface>(endpoint: E, ...args: readonly [
+        ...Parameters<E>
+    ] | readonly [
+        null
+    ]): ErrorTypes | undefined;
+    getError<E extends Pick<EndpointInterface, 'key'>>(endpoint: E, ...args: readonly [
+        ...Parameters<E['key']>
+    ] | readonly [
+        null
+    ]): ErrorTypes | undefined;
+    /**
+     * Retrieved memoized value for any Querable schema
+     * @see https://dataclient.io/docs/api/Snapshot#get
+     */
+    get<S extends Queryable>(schema: S, ...args: SchemaArgs<S>): DenormalizeNullable<S> | undefined;
+    /**
+     * Queries the store for a Querable schema; providing related metadata
+     * @see https://dataclient.io/docs/api/Snapshot#getQueryMeta
+     */
+    getQueryMeta<S extends Queryable>(schema: S, ...args: SchemaArgs<S>): {
+        data: DenormalizeNullable<S> | undefined;
+        countRef: () => () => void;
+    };
+}
 //# sourceMappingURL=Controller.d.ts.map

package/ts3.4/index.d.ts

@@ -3,8 +3,10 @@ export { __INTERNAL__1 as __INTERNAL__ };
 export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, SchemaClass, ResolveType, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, Queryable, SchemaArgs, NI, } from '@data-client/normalizr';
 export { ExpiryStatus } from '@data-client/normalizr';
 export { default as NetworkManager, ResetError, } from './manager/NetworkManager.js';
+export * from './state/GCPolicy.js';
 export { default as createReducer, initialState, } from './state/reducer/createReducer.js';
 export { default as applyManager } from './manager/applyManager.js';
+export { default as initManager } from './manager/initManager.js';
 export { default as Controller } from './controller/Controller.js';
 export { DataClientDispatch, GenericDispatch, } from './controller/Controller.js';
 import * as actions_1 from './controller/actions/index.js';

package/ts3.4/manager/initManager.d.ts

@@ -0,0 +1,4 @@
+import Controller from '../controller/Controller.js';
+import { Manager, State } from '../types.js';
+export default function initManager(managers: Manager[], controller: Controller, initialState: State<unknown>): () => () => void;
+//# sourceMappingURL=initManager.d.ts.map

package/ts3.4/state/GCPolicy.d.ts

@@ -0,0 +1,55 @@
+import { EntityPath } from '@data-client/normalizr';
+import Controller from '../controller/Controller.js';
+export declare class GCPolicy implements GCInterface {
+    protected endpointCount: Map<string, number>;
+    protected entityCount: Map<string, Map<string, number>>;
+    protected endpointsQ: Set<string>;
+    protected entitiesQ: EntityPath[];
+    protected intervalId: ReturnType<typeof setInterval>;
+    protected controller: Controller;
+    protected options: Required<Pick<GCOptions, Exclude<keyof GCOptions, 'expiresAt'>>>;
+    constructor({ intervalMS, expiryMultiplier, expiresAt, }?: GCOptions);
+    init(controller: Controller): void;
+    cleanup(): void;
+    createCountRef({ key, paths }: {
+        key?: string;
+        paths?: EntityPath[];
+    }): () => () => void;
+    protected expiresAt({ fetchedAt, expiresAt, }: {
+        expiresAt: number;
+        date: number;
+        fetchedAt: number;
+    }): number;
+    protected runSweep(): void;
+    /** Calls the callback when client is not 'busy' with high priority interaction tasks
+     *
+     * Override for platform-specific implementations
+     */
+    protected idleCallback(callback: (...args: any[]) => void, options?: IdleRequestOptions): void;
+}
+export declare class ImmortalGCPolicy implements GCInterface {
+    init(): void;
+    cleanup(): void;
+    createCountRef(): () => () => undefined;
+}
+export interface GCOptions {
+    intervalMS?: number;
+    expiryMultiplier?: number;
+    expiresAt?: (meta: {
+        expiresAt: number;
+        date: number;
+        fetchedAt: number;
+    }) => number;
+}
+export interface CreateCountRef {
+    ({ key, paths }: {
+        key?: string;
+        paths?: EntityPath[];
+    }): () => () => void;
+}
+export interface GCInterface {
+    createCountRef: CreateCountRef;
+    init(controller: Controller): void;
+    cleanup(): void;
+}
+//# sourceMappingURL=GCPolicy.d.ts.map

package/ts3.4/state/reducer/expireReducer.d.ts

@@ -3,6 +3,7 @@ export declare function expireReducer(state: State<unknown>, action: ExpireAllAc
     meta: {
         [x: string]: {
             readonly date: number;
+            readonly fetchedAt: number;
             readonly expiresAt: number;
             readonly prevExpiresAt?: number;
             readonly error?: import("packages/normalizr/lib/index.js").ErrorTypes;

package/ts3.4/state/reducer/invalidateReducer.d.ts

@@ -6,6 +6,7 @@ export declare function invalidateReducer(state: State<unknown>, action: Invalid
     meta: {
         [x: string]: {
             readonly date: number;
+            readonly fetchedAt: number;
             readonly expiresAt: number;
             readonly prevExpiresAt?: number;
             readonly error?: import("packages/normalizr/lib/index.js").ErrorTypes;

package/ts3.4/state/reducer/setReducer.d.ts

@@ -11,6 +11,7 @@ export declare function setReducer(state: State<unknown>, action: SetAction, con
     meta: {
         readonly [key: string]: {
             readonly date: number;
+            readonly fetchedAt: number;
             readonly expiresAt: number;
             readonly prevExpiresAt?: number;
             readonly error?: import("@data-client/normalizr").ErrorTypes;
@@ -21,9 +22,9 @@ export declare function setReducer(state: State<unknown>, action: SetAction, con
     entityMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
         [x: string]: any;
     }>;
-    optimistic: (import("../../actions.js").SetResponseAction | import("../../actions.js").OptimisticAction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
+    optimistic: (import("../../actions.js").OptimisticAction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
         update?: import("../../index.js").EndpointUpdateFunction<import("@data-client/normalizr").EndpointInterface>;
-    }>)[];
+    }> | import("../../actions.js").SetResponseAction)[];
     lastReset: number;
 };
 //# sourceMappingURL=setReducer.d.ts.map

package/ts3.4/state/reducer/setResponseReducer.d.ts

@@ -9,6 +9,7 @@ export declare function setResponseReducer(state: State<unknown>, action: Optimi
     meta: {
         [x: string]: {
             readonly date: number;
+            readonly fetchedAt: number;
             readonly expiresAt: number;
             readonly prevExpiresAt?: number;
             readonly error?: import("@data-client/normalizr").ErrorTypes;
@@ -16,6 +17,7 @@ export declare function setResponseReducer(state: State<unknown>, action: Optimi
             readonly errorPolicy?: "hard" | "soft" | undefined;
         } | {
             date: number;
+            fetchedAt: number;
             expiresAt: number;
             prevExpiresAt: number;
         };
@@ -23,9 +25,9 @@ export declare function setResponseReducer(state: State<unknown>, action: Optimi
     entityMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
         [x: string]: any;
     }>;
-    optimistic: (SetResponseAction | OptimisticAction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
+    optimistic: (OptimisticAction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
         update?: import("../../index.js").EndpointUpdateFunction<import("@data-client/normalizr").EndpointInterface>;
-    }>)[];
+    }> | SetResponseAction)[];
     lastReset: number;
 };
 //# sourceMappingURL=setResponseReducer.d.ts.map

package/ts3.4/types.d.ts

@@ -23,6 +23,7 @@ export interface State<T> {
     readonly meta: {
         readonly [key: string]: {
             readonly date: number;
+            readonly fetchedAt: number;
             readonly expiresAt: number;
             readonly prevExpiresAt?: number;
             readonly error?: ErrorTypes;