@data-client/core 0.18.0 → 0.18.2

package/src/controller/__tests__/getResponse.ts

@@ -1,4 +1,5 @@
 import { Endpoint, Entity, Scalar, schema } from '@data-client/endpoint';
+import { INVALID } from '@data-client/normalizr';
 
 import { ExpiryStatus } from '../..';
 import { initialState } from '../../state/reducer/createReducer';
@@ -195,6 +196,63 @@ describe('Controller.getResponse()', () => {
   });
 });
 
+describe('Controller.getResponse() with deleted entities', () => {
+  class Tacos extends Entity {
+    type = '';
+    id = '';
+  }
+  const ep = new Endpoint(({ id }: { id: string }) => Promise.resolve(), {
+    key: ({ id }) => `taco ${id}`,
+    schema: Tacos,
+  });
+  const key = ep.key({ id: '1' });
+  const state = {
+    ...initialState,
+    entities: { Tacos: { 1: INVALID } },
+    endpoints: { [key]: '1' },
+  };
+  // error meta keeps the response from counting as expired
+  const erroredState = {
+    ...state,
+    meta: {
+      [key]: {
+        date: 0,
+        fetchedAt: 0,
+        expiresAt: Infinity,
+        error: new Error('failed'),
+      },
+    },
+  };
+
+  it('returns undefined data instead of the INVALID symbol', () => {
+    const controller = new Contoller();
+    const { data, expiryStatus } = controller.getResponse(
+      ep,
+      { id: '1' },
+      state,
+    );
+    expect(data).toBeUndefined();
+    expect(expiryStatus).toBe(ExpiryStatus.Invalid);
+  });
+
+  it('returns undefined data when the last fetch errored', () => {
+    const controller = new Contoller();
+    const { data, expiryStatus } = controller.getResponse(
+      ep,
+      { id: '1' },
+      erroredState,
+    );
+    expect(data).toBeUndefined();
+    expect(expiryStatus).toBe(ExpiryStatus.InvalidIfStale);
+  });
+
+  it('fetchIfStale() resolves errored deleted entities to undefined', () => {
+    const controller = new Contoller();
+    controller.getState = () => erroredState as any;
+    expect(controller.fetchIfStale(ep, { id: '1' })).toBeUndefined();
+  });
+});
+
 describe('Controller.getResponse() with Scalar', () => {
   // Regression: `requiresDenormalize` (formerly `schemaHasEntity`) previously
   // walked `Object.values(scalar)` and recursed into the `lensSelector`
@@ -318,6 +376,53 @@ describe('Controller.getResponse() with Scalar', () => {
   );
 });
 
+describe('Controller.getResponse() with schema-less endpoints', () => {
+  it.each([
+    ['empty string', ''],
+    ['zero', 0],
+    ['false', false],
+    ['null', null],
+  ])('treats cached %s as valid data', (_name, cachedValue) => {
+    const controller = new Contoller();
+    const endpoint = new Endpoint(() => Promise.resolve(), {
+      key: () => 'falsy-endpoint',
+    });
+    const key = endpoint.key();
+    const fetchedAt = Date.now();
+    const state = {
+      ...initialState,
+      endpoints: {
+        [key]: cachedValue,
+      },
+      meta: {
+        [key]: {
+          date: fetchedAt,
+          fetchedAt,
+          expiresAt: fetchedAt + 1000,
+        },
+      },
+    };
+
+    const { data, expiryStatus } = controller.getResponse(endpoint, state);
+    expect(data).toBe(cachedValue);
+    expect(expiryStatus).toBe(ExpiryStatus.Valid);
+  });
+
+  it('treats undefined cache entries as invalid', () => {
+    const controller = new Contoller();
+    const endpoint = new Endpoint(() => Promise.resolve(), {
+      key: () => 'missing-endpoint',
+    });
+
+    const { data, expiryStatus } = controller.getResponse(
+      endpoint,
+      initialState,
+    );
+    expect(data).toBeUndefined();
+    expect(expiryStatus).toBe(ExpiryStatus.Invalid);
+  });
+});
+
 describe('Snapshot.getResponseMeta()', () => {
   it('denormalizes schema with extra members but not set', () => {
     const controller = new Contoller();

package/src/controller/setManyTypes.ts

@@ -0,0 +1,114 @@
+/** Value types for `Controller.set()`, including batch `set([Entity], rows)` */
+import type { Denormalize, EntityInterface } from '@data-client/normalizr';
+
+/** What one row normalizes to: a reference to one stored entity */
+type EntityRef = string | { readonly id: string; readonly schema: string };
+
+/** Schemas that write each row to one stored entity: Entity, Union, or Invalidate (batch delete).
+ * Query, All and Collection don't: they normalize to lists, or Collection keys by args batch set() lacks. */
+type SetEntitySchema = EntityInterface | EntityRefSchema;
+
+/** Union or Invalidate */
+type EntityRefSchema = {
+  _normalizeNullable(): EntityRef | undefined;
+  // excludes Entity and Collection
+  pk?: never;
+};
+
+/** `[Entity]`, `schema.Array(Entity)` or `schema.Values(Entity)` (or of a Union or Invalidate) */
+export type SetManySchema =
+  | readonly SetEntitySchema[]
+  | {
+      readonly schema: SetEntitySchema | Record<string, EntityInterface>;
+      // Array and Values; excludes schema.Object, whose queryKey() returns any
+      schemaKey(): string;
+      queryKey(...args: any): undefined;
+      // excludes Entity, whose `any` returns match the members above
+      pk?: never;
+    };
+
+/** `new Invalidate(Entity)` (or of a Union): not Queryable, since its queryKey() returns undefined */
+export type SetInvalidateSchema = EntityRefSchema & {
+  // excludes Union
+  queryKey(...args: any): undefined;
+  // excludes Lazy
+  query?: never;
+};
+
+type IsUnion<T, U = T> =
+  T extends unknown ?
+    [U] extends [T] ?
+      false
+    : true
+  : never;
+
+type FunctionKeys<U> = {
+  [K in keyof U]: U[K] extends (...args: any) => any ? K : never;
+}[keyof U];
+
+/** Raw input for one field: numbers and strings coerce (literals stay exact);
+ * objects are pre-normalize */
+type SetField<T> =
+  T extends number ?
+    number extends T ?
+      T | string
+    : T
+  : T extends string ?
+    string extends T ?
+      T | number
+    : T
+  : T extends object ? unknown
+  : T;
+
+/** Fields of one row (or a coerced primitive); like EntityFields, but distributive
+ * and without key remapping (TS 4.0). A Union gets one row per member, so a
+ * discriminator like `type` selects the member the other fields are checked against. */
+type SetRow<U> =
+  // EntityMixin and other untyped entities
+  0 extends 1 & U ? { readonly [k: string]: any }
+  : U extends object ?
+    { readonly [K in Exclude<keyof U, FunctionKeys<U>>]?: SetField<U[K]> }
+  : SetField<U>;
+
+/** Keeps S inferred from the schema alone: inferring it from the value too would
+ * walk the value's type against every conditional in SetValue (TS 5.4 has NoInfer) */
+export type SkipInfer<T, S> = [T][S extends unknown ? 0 : never];
+
+export type SetManyValue<S> =
+  S extends readonly (infer E)[] ?
+    true extends IsUnion<E> ?
+      readonly { 'Use a Union schema for several Entity types': never }[]
+    : readonly SetRow<Denormalize<E>>[]
+  : SetValue<S>;
+
+/** Raw input `set()` normalizes for a Queryable */
+export type SetValue<S> =
+  InputSchema<InputSchema<InputSchema<S>>> extends infer N ?
+    N extends EntityInterface ?
+      SetRow<Denormalize<N>>
+    : SetInput<Denormalize<N>>
+  : never;
+
+/** Query normalizes with its inner schema; its process() output is not input
+ *
+ * Applied three times in SetValue to unwrap nested Queries (TS 4.0 has no recursive aliases)
+ */
+type InputSchema<S> =
+  S extends (
+    {
+      readonly schema: infer Sch;
+      process(...args: any): any;
+      // excludes Entity, whose static schema and process() match the members above
+      pk?: never;
+    }
+  ) ?
+    Sch
+  : S;
+
+/** Raw input for a denormalized value, like a Collection's list or a Union's row */
+type SetInput<T> =
+  0 extends 1 & T ? any
+  : // not distributive: SetRow splits a Union into its members itself
+  [T] extends [readonly (infer U)[]] ? readonly SetRow<U>[]
+  : string extends keyof T ? { readonly [k: string]: SetRow<T[keyof T]> }
+  : SetRow<T>;

package/src/manager/DevtoolsManager.ts

@@ -32,7 +32,15 @@ if (process.env.NODE_ENV !== 'production') {
     return serial;
   }
 
-  const HASINTL = typeof Intl !== 'undefined';
+  const dateFormat =
+    typeof Intl !== 'undefined' ?
+      new Intl.DateTimeFormat('en-US', {
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric',
+        fractionalSecondDigits: 3,
+      })
+    : undefined;
   DEFAULT_CONFIG = {
     name: `Data Client: ${globalThis.document?.title}`,
     autoPause: true,
@@ -59,7 +67,7 @@ if (process.env.NODE_ENV !== 'production') {
       options: undefined,
       /* istanbul ignore next */
       replacer:
-        HASINTL ?
+        dateFormat ?
           (key: string | number | symbol, value: unknown) => {
             if (
               typeof value === 'number' &&
@@ -67,12 +75,7 @@ if (process.env.NODE_ENV !== 'production') {
               isFinite(value) &&
               (key === 'date' || key.endsWith('At'))
             ) {
-              return Intl.DateTimeFormat('en-US', {
-                hour: 'numeric',
-                minute: 'numeric',
-                second: 'numeric',
-                fractionalSecondDigits: 3,
-              }).format(value);
+              return dateFormat.format(value);
             }
             return value;
           }

package/src/manager/__tests__/networkManager.ts

@@ -128,7 +128,7 @@ describe('NetworkManager', () => {
     const fetchRejectAction = createFetch(errorUpdateShape, {
       args: [{ id: 5 }, { id: 5, title: 'hi' }],
     });
-    (fetchRejectAction.meta.promise as any).catch((e: unknown) => {});
+    fetchRejectAction.meta.promise.catch(() => {});
 
     let NM: NetworkManager;
     beforeEach(() => {
@@ -138,6 +138,13 @@ describe('NetworkManager', () => {
       NM.cleanup();
     });
 
+    it('meta.promise is a Promise managers can chain with finally()', async () => {
+      const action = createFetch(detailEndpoint, { args: [{ id: 5 }] });
+      const done = action.meta.promise.finally(() => {});
+      action.meta.resolve('result');
+      await expect(done).resolves.toBe('result');
+    });
+
     it('should handle fetch actions and dispatch on success', async () => {
       const next = jest.fn();
       const dispatch = jest.fn();

package/src/mock/MockController.ts

@@ -9,7 +9,10 @@ import { createFixtureMap } from './createFixtureMap.js';
 import type { Fixture, Interceptor } from './fixtureTypes.js';
 import { MockProps } from './mockTypes.js';
 
-export function MockController<TBase extends typeof Controller, T>(
+export function MockController<
+  TBase extends new (...args: any[]) => Controller<any>,
+  T,
+>(
   Base: TBase,
   {
     fixtures = [],
@@ -22,7 +25,7 @@ export function MockController<TBase extends typeof Controller, T>(
   // @ts-ignore
   return class MockedController<
     D extends GenericDispatch = DataClientDispatch,
-  > extends Base<D> {
+  > extends (Base as typeof Controller)<D> {
     // legacy compatibility (re-declaration)
     // TODO: drop when drop support for destructuring (0.14 and below)
     declare protected _dispatch: D;

package/src/mock/__tests__/MockController.ts

@@ -0,0 +1,15 @@
+import Controller from '../../controller/Controller';
+import { MockController } from '../MockController';
+
+describe('MockController', () => {
+  it('accepts a Controller subclass with its own members', () => {
+    class MyController extends Controller {
+      doSomething = () => 'hi';
+    }
+    const Mocked = MockController(MyController, {});
+    const controller = new Mocked();
+
+    expect(controller).toBeInstanceOf(MyController);
+    expect(controller.doSomething()).toBe('hi');
+  });
+});

package/src/mock/fixtureTypes.ts

@@ -9,10 +9,9 @@ export interface SuccessFixtureEndpoint<
   E extends EndpointInterface & { update?: Updater } = EndpointInterface,
 > {
   readonly endpoint: E;
-  readonly args: Parameters<E>;
+  readonly args: Readonly<Parameters<E>>;
   readonly response:
-    | ResolveType<E>
-    | ((...args: Parameters<E>) => ResolveType<E>);
+    ResolveType<E> | ((...args: Parameters<E>) => ResolveType<E>);
   readonly error?: false;
   /** Number of miliseconds to wait before resolving */
   readonly delay?: number;
@@ -85,7 +84,7 @@ export interface ErrorFixtureEndpoint<
   E extends EndpointInterface & { update?: Updater } = EndpointInterface,
 > {
   readonly endpoint: E;
-  readonly args: Parameters<E>;
+  readonly args: Readonly<Parameters<E>>;
   readonly response: any;
   readonly error: true;
   /** Number of miliseconds to wait before resolving */

package/src/mock/mockState.ts

@@ -32,7 +32,7 @@ export default function mockInitialState(
 
 function dispatchFixture(
   fixture: Fixture,
-  args: any[],
+  args: readonly any[],
   controller: Controller,
   fetchedAt?: number,
 ) {

package/ts3.4/actionTypes.d.ts

@@ -1,14 +1,14 @@
-export declare const FETCH: "rdc/fetch";
-export declare const SET: "rdc/set";
-export declare const SET_RESPONSE: "rdc/setresponse";
-export declare const OPTIMISTIC: "rdc/optimistic";
-export declare const RESET: "rdc/reset";
-export declare const SUBSCRIBE: "rdc/subscribe";
-export declare const UNSUBSCRIBE: "rdc/unsubscribe";
-export declare const INVALIDATE: "rdc/invalidate";
-export declare const INVALIDATEALL: "rdc/invalidateall";
-export declare const EXPIREALL: "rdc/expireall";
-export declare const GC: "rdc/gc";
+export declare const FETCH: 'rdc/fetch';
+export declare const SET: 'rdc/set';
+export declare const SET_RESPONSE: 'rdc/setresponse';
+export declare const OPTIMISTIC: 'rdc/optimistic';
+export declare const RESET: 'rdc/reset';
+export declare const SUBSCRIBE: 'rdc/subscribe';
+export declare const UNSUBSCRIBE: 'rdc/unsubscribe';
+export declare const INVALIDATE: 'rdc/invalidate';
+export declare const INVALIDATEALL: 'rdc/invalidateall';
+export declare const EXPIREALL: 'rdc/expireall';
+export declare const GC: 'rdc/gc';
 export declare const FETCH_TYPE: "rdc/fetch";
 export declare const SET_TYPE: "rdc/set";
 export declare const SET_RESPONSE_TYPE: "rdc/setresponse";

package/ts3.4/actions.d.ts

@@ -42,7 +42,7 @@ export interface FetchMeta {
     fetchedAt: number;
     resolve: (value?: any | PromiseLike<any>) => void;
     reject: (reason?: any) => void;
-    promise: PromiseLike<any>;
+    promise: Promise<any>;
 }
 /** Action for Controller.fetch() */
 export interface FetchAction<E extends EndpointAndUpdate<E> = EndpointDefault> {

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

@@ -1,6 +1,7 @@
 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 { SkipInfer, SetInvalidateSchema, SetManySchema, SetManyValue, SetValue } from './setManyTypes.js';
 import { EndpointUpdateFunction } from './types.js';
 import { ReduxMiddlewareAPI } from '../manager/applyManager.js';
 import { GCInterface } from '../state/GCPolicy.js';
@@ -55,7 +56,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         update?: EndpointUpdateFunction<E>;
     }>(endpoint: E, ...args: readonly [
         ...Parameters<E>
-    ]) => E["schema"] extends undefined | null ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
+    ]) => E['schema'] extends undefined | null ? ReturnType<E> : Promise<Denormalize<E['schema']>>;
     /**
      * Fetches only if endpoint is considered 'stale'; otherwise returns undefined
      * @see https://dataclient.io/docs/api/Controller#fetchIfStale
@@ -64,7 +65,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         update?: EndpointUpdateFunction<E>;
     }>(endpoint: E, ...args: readonly [
         ...Parameters<E>
-    ]) => E["schema"] extends undefined | null ? ReturnType<E> | ResolveType<E> : Promise<Denormalize<E["schema"]>> | Denormalize<E["schema"]>;
+    ]) => E['schema'] extends undefined | null ? ReturnType<E> | ResolveType<E> : Promise<Denormalize<E['schema']>> | Denormalize<E['schema']>;
     /**
      * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
      * @see https://dataclient.io/docs/api/Controller#invalidate
@@ -101,12 +102,14 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      */
     set<S extends Queryable>(schema: S, ...rest: readonly [
         ...SchemaArgs<S>,
-        (previousValue: Denormalize<S>) => {}
-    ]): Promise<void>;
-    set<S extends Queryable>(schema: S, ...rest: readonly [
-        ...SchemaArgs<S>,
-        {}
+        SkipInfer<SetValue<S> | ((previousValue: Denormalize<S>) => SetValue<S>), S>
     ]): Promise<void>;
+    /**
+     * Sets every row of an Array or Values of one Entity (or Union) in one normalize,
+     * or invalidates the one Entity an Invalidate schema's value identifies.
+     * @see https://dataclient.io/docs/api/Controller#set
+     */
+    set<S extends SetManySchema | SetInvalidateSchema>(schema: S, value: SkipInfer<SetManyValue<S>, S>): Promise<void>;
     /**
      * Sets response for the Endpoint and args.
      * @see https://dataclient.io/docs/api/Controller#setResponse

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

@@ -0,0 +1,75 @@
+/** Value types for `Controller.set()`, including batch `set([Entity], rows)` */
+import { Denormalize, EntityInterface } from '@data-client/normalizr';
+/** What one row normalizes to: a reference to one stored entity */
+type EntityRef = string | {
+    readonly id: string;
+    readonly schema: string;
+};
+/** Schemas that write each row to one stored entity: Entity, Union, or Invalidate (batch delete).
+ * Query, All and Collection don't: they normalize to lists, or Collection keys by args batch set() lacks. */
+type SetEntitySchema = EntityInterface | EntityRefSchema;
+/** Union or Invalidate */
+type EntityRefSchema = {
+    _normalizeNullable(): EntityRef | undefined;
+    pk?: never;
+};
+/** `[Entity]`, `schema.Array(Entity)` or `schema.Values(Entity)` (or of a Union or Invalidate) */
+export type SetManySchema = readonly SetEntitySchema[] | {
+    readonly schema: SetEntitySchema | Record<string, EntityInterface>;
+    schemaKey(): string;
+    queryKey(...args: any): undefined;
+    pk?: never;
+};
+/** `new Invalidate(Entity)` (or of a Union): not Queryable, since its queryKey() returns undefined */
+export type SetInvalidateSchema = EntityRefSchema & {
+    queryKey(...args: any): undefined;
+    query?: never;
+};
+type IsUnion<T, U = T> = T extends unknown ? [
+    U
+] extends [
+    T
+] ? false : true : never;
+type FunctionKeys<U> = {
+    [K in keyof U]: U[K] extends (...args: any) => any ? K : never;
+}[keyof U];
+/** Raw input for one field: numbers and strings coerce (literals stay exact);
+ * objects are pre-normalize */
+type SetField<T> = T extends number ? number extends T ? T | string : T : T extends string ? string extends T ? T | number : T : T extends object ? unknown : T;
+/** Fields of one row (or a coerced primitive); like EntityFields, but distributive
+ * and without key remapping (TS 4.0). A Union gets one row per member, so a
+ * discriminator like `type` selects the member the other fields are checked against. */
+type SetRow<U> = 0 extends 1 & U ? {
+    readonly [k: string]: any;
+} : U extends object ? {
+    readonly [K in Exclude<keyof U, FunctionKeys<U>>]?: SetField<U[K]>;
+} : SetField<U>;
+/** Keeps S inferred from the schema alone: inferring it from the value too would
+ * walk the value's type against every conditional in SetValue (TS 5.4 has NoInfer) */
+export type SkipInfer<T, S> = [
+    T
+][S extends unknown ? 0 : never];
+export type SetManyValue<S> = S extends readonly (infer E)[] ? true extends IsUnion<E> ? readonly {
+    'Use a Union schema for several Entity types': never;
+}[] : readonly SetRow<Denormalize<E>>[] : SetValue<S>;
+/** Raw input `set()` normalizes for a Queryable */
+export type SetValue<S> = InputSchema<InputSchema<InputSchema<S>>> extends infer N ? N extends EntityInterface ? SetRow<Denormalize<N>> : SetInput<Denormalize<N>> : never;
+/** Query normalizes with its inner schema; its process() output is not input
+ *
+ * Applied three times in SetValue to unwrap nested Queries (TS 4.0 has no recursive aliases)
+ */
+type InputSchema<S> = S extends ({
+    readonly schema: infer Sch;
+    process(...args: any): any;
+    pk?: never;
+}) ? Sch : S;
+/** Raw input for a denormalized value, like a Collection's list or a Union's row */
+type SetInput<T> = 0 extends 1 & T ? any : [
+    T
+] extends [
+    readonly (infer U)[]
+] ? readonly SetRow<U>[] : string extends keyof T ? {
+    readonly [k: string]: SetRow<T[keyof T]>;
+} : SetRow<T>;
+export {};
+//# sourceMappingURL=setManyTypes.d.ts.map

package/ts3.4/mock/MockController.d.ts

@@ -1,4 +1,4 @@
 import { Controller } from '../index.js';
 import { MockProps } from './mockTypes.js';
-export declare function MockController<TBase extends typeof Controller, T>(Base: TBase, { fixtures, getInitialInterceptorData, }: MockProps<T>): TBase;
+export declare function MockController<TBase extends new (...args: any[]) => Controller<any>, T>(Base: TBase, { fixtures, getInitialInterceptorData, }: MockProps<T>): TBase;
 //# sourceMappingURL=MockController.d.ts.map

package/ts3.4/mock/fixtureTypes.d.ts

@@ -4,7 +4,7 @@ export interface SuccessFixtureEndpoint<E extends EndpointInterface & {
     update?: Updater;
 } = EndpointInterface> {
     readonly endpoint: E;
-    readonly args: Parameters<E>;
+    readonly args: Readonly<Parameters<E>>;
     readonly response: ResolveType<E> | ((...args: Parameters<E>) => ResolveType<E>);
     readonly error?: false;
     /** Number of miliseconds to wait before resolving */
@@ -63,7 +63,7 @@ export interface ErrorFixtureEndpoint<E extends EndpointInterface & {
     update?: Updater;
 } = EndpointInterface> {
     readonly endpoint: E;
-    readonly args: Parameters<E>;
+    readonly args: Readonly<Parameters<E>>;
     readonly response: any;
     readonly error: true;
     /** Number of miliseconds to wait before resolving */

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

@@ -1,16 +1,5 @@
 import { State, ExpireAllAction } from '../../types.js';
 export declare function expireReducer(state: State<unknown>, action: ExpireAllAction): {
-    meta: {
-        [key: string]: {
-            readonly date: number;
-            readonly fetchedAt: number;
-            readonly expiresAt: number;
-            readonly prevExpiresAt?: number;
-            readonly error?: import("@data-client/normalizr").ErrorTypes;
-            readonly invalidated?: boolean;
-            readonly errorPolicy?: "hard" | "soft" | undefined;
-        };
-    };
     entities: {
         readonly [entityKey: string]: {
             readonly [pk: string]: unknown;
@@ -31,5 +20,16 @@ export declare function expireReducer(state: State<unknown>, action: ExpireAllAc
     };
     optimistic: (import("../../actions.js").SetResponseAction | import("../../actions.js").OptimisticAction)[];
     lastReset: number;
+    meta: {
+        [key: string]: {
+            readonly date: number;
+            readonly fetchedAt: number;
+            readonly expiresAt: number;
+            readonly prevExpiresAt?: number;
+            readonly error?: import("@data-client/normalizr").ErrorTypes;
+            readonly invalidated?: boolean;
+            readonly errorPolicy?: 'hard' | 'soft' | undefined;
+        };
+    };
 };
 //# sourceMappingURL=expireReducer.d.ts.map

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

@@ -1,19 +1,5 @@
 import { State, InvalidateAllAction, InvalidateAction } from '../../types.js';
 export declare function invalidateReducer(state: State<unknown>, action: InvalidateAction | InvalidateAllAction): {
-    endpoints: {
-        [key: string]: unknown;
-    };
-    meta: {
-        [key: string]: {
-            readonly date: number;
-            readonly fetchedAt: number;
-            readonly expiresAt: number;
-            readonly prevExpiresAt?: number;
-            readonly error?: import("@data-client/normalizr").ErrorTypes;
-            readonly invalidated?: boolean;
-            readonly errorPolicy?: "hard" | "soft" | undefined;
-        };
-    };
     entities: {
         readonly [entityKey: string]: {
             readonly [pk: string]: unknown;
@@ -31,5 +17,19 @@ export declare function invalidateReducer(state: State<unknown>, action: Invalid
     };
     optimistic: (import("../../actions.js").SetResponseAction | import("../../actions.js").OptimisticAction)[];
     lastReset: number;
+    endpoints: {
+        [key: string]: unknown;
+    };
+    meta: {
+        [key: string]: {
+            readonly date: number;
+            readonly fetchedAt: number;
+            readonly expiresAt: number;
+            readonly prevExpiresAt?: number;
+            readonly error?: import("@data-client/normalizr").ErrorTypes;
+            readonly invalidated?: boolean;
+            readonly errorPolicy?: 'hard' | 'soft' | undefined;
+        };
+    };
 };
 //# sourceMappingURL=invalidateReducer.d.ts.map