@data-client/core 0.14.2 → 0.14.5

package/src/middlewareTypes.ts

@@ -1,14 +1,15 @@
 import type Controller from './controller/Controller.js';
-import { ActionTypes, State } from './types.js';
+import type { ActionTypes, State } from './types.js';
 
-type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
+export type Dispatch<Actions = ActionTypes> = (value: Actions) => Promise<void>;
+
+export interface MiddlewareAPI extends Controller<Dispatch<ActionTypes>> {}
 
-export interface MiddlewareAPI<R extends DataClientReducer = DataClientReducer>
-  extends Controller<RHDispatch<ActionTypes>> {}
 export interface MiddlewareController<Actions = ActionTypes>
-  extends Controller<RHDispatch<Actions>> {}
+  extends Controller<Dispatch<Actions>> {}
 
-export type Middleware<Actions = any> = <
+/** @see https://dataclient.io/docs/api/Manager#middleware */
+export type Middleware<Actions = ActionTypes> = <
   C extends MiddlewareController<Actions>,
 >(
   controller: C,
@@ -18,14 +19,3 @@ export type DataClientReducer = (
   prevState: State<unknown>,
   action: ActionTypes,
 ) => State<unknown>;
-
-/* The next are types from React; but we don't want dependencies on it */
-export type Dispatch<R extends Reducer<any, any>> = (
-  action: ReducerAction<R>,
-) => Promise<void>;
-
-export type Reducer<S, A> = (prevState: S, action: A) => S;
-export type ReducerState<R extends Reducer<any, any>> =
-  R extends Reducer<infer S, any> ? S : never;
-export type ReducerAction<R extends Reducer<any, any>> =
-  R extends Reducer<any, infer A> ? A : never;

package/src/state/reducer/createReducer.ts

@@ -66,8 +66,8 @@ export default function createReducer(controller: Controller): ReducerType {
 
 export const initialState: State<unknown> = {
   entities: {},
-  indexes: {},
   endpoints: {},
+  indexes: {},
   meta: {},
   entityMeta: {},
   optimistic: [],

package/src/state/reducer/setReducer.ts

@@ -26,10 +26,10 @@ export function setReducer(
     );
     return {
       entities,
-      indexes,
       endpoints: state.endpoints,
-      entityMeta,
+      indexes,
       meta: state.meta,
+      entityMeta,
       optimistic: state.optimistic,
       lastReset: state.lastReset,
     };

package/src/state/reducer/setResponseReducer.ts

@@ -69,9 +69,8 @@ export function setResponseReducer(
     }
     return {
       entities,
-      indexes,
       endpoints,
-      entityMeta,
+      indexes,
       meta: {
         ...state.meta,
         [action.key]: {
@@ -80,6 +79,7 @@ export function setResponseReducer(
           prevExpiresAt: state.meta[action.key]?.expiresAt,
         },
       },
+      entityMeta,
       optimistic: filterOptimistic(state, action),
       lastReset: state.lastReset,
     };

package/src/types.ts

@@ -18,14 +18,18 @@ export type { AbstractInstanceType, UpdateFunction };
 
 export type PK = string;
 
+/** Normalized state for Reactive Data Client
+ *
+ * @see https://dataclient.io/docs/concepts/normalization
+ */
 export interface State<T> {
   readonly entities: {
     readonly [entityKey: string]: { readonly [pk: string]: T } | undefined;
   };
-  readonly indexes: NormalizedIndex;
   readonly endpoints: {
     readonly [key: string]: unknown | PK[] | PK | undefined;
   };
+  readonly indexes: NormalizedIndex;
   readonly meta: {
     readonly [key: string]: {
       readonly date: number;
@@ -49,9 +53,20 @@ export interface State<T> {
   readonly lastReset: number;
 }
 
+/** Singletons that handle global side-effects
+ *
+ * Kind of like useEffect() for the central data store
+ *
+ * @see https://dataclient.io/docs/api/Manager
+ */
 export interface Manager<Actions = ActionTypes> {
-  getMiddleware(): Middleware<Actions>;
+  /** @see https://dataclient.io/docs/api/Manager#getmiddleware */
+  getMiddleware?(): Middleware<Actions>;
+  /** @see https://dataclient.io/docs/api/Manager#middleware */
+  middleware?: Middleware<Actions>;
+  /** @see https://dataclient.io/docs/api/Manager#cleanup */
   cleanup(): void;
+  /** @see https://dataclient.io/docs/api/Manager#init */
   init?: (state: State<any>) => void;
 }
 

package/ts3.4/index.d.ts

@@ -1,6 +1,6 @@
 import * as __INTERNAL__1 from './internal.js';
 export { __INTERNAL__1 as __INTERNAL__ };
-export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, ResolveType, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, Queryable, SchemaArgs, NI, } from '@data-client/normalizr';
+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 { default as createReducer, initialState, } from './state/reducer/createReducer.js';

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

@@ -1,6 +1,6 @@
 import { DevToolsConfig } from './devtoolsTypes.js';
-import { Middleware } from './LogoutManager.js';
 import { Controller } from '../index.js';
+import { Middleware } from '../middlewareTypes.js';
 import { Manager, State, ActionTypes } from '../types.js';
 export { DevToolsConfig };
 /** Integrates with https://github.com/reduxjs/redux-devtools
@@ -10,7 +10,7 @@ export { DevToolsConfig };
  * @see https://dataclient.io/docs/api/DevToolsManager
  */
 export default class DevToolsManager implements Manager {
-    protected middleware: Middleware;
+    middleware: Middleware;
     protected devTools: undefined | any;
     protected started: boolean;
     protected actions: [
@@ -18,6 +18,7 @@ export default class DevToolsManager implements Manager {
         State<unknown>
     ][];
     protected controller: Controller;
+    skipLogging?: (action: ActionTypes) => boolean;
     maxBufferLength: number;
     constructor(config?: DevToolsConfig, skipLogging?: (action: ActionTypes) => boolean);
     handleAction(action: any, state: any): void;
@@ -25,9 +26,5 @@ export default class DevToolsManager implements Manager {
     init(state: State<any>): void;
     /** Ensures all subscriptions are cleaned up. */
     cleanup(): void;
-    /** Attaches Manager to store
-     *
-     */
-    getMiddleware(): Middleware;
 }
 //# sourceMappingURL=DevtoolsManager.d.ts.map

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

@@ -1,21 +1,18 @@
 import Controller from '../controller/Controller.js';
 import { UnknownError } from '../index.js';
-import { ActionTypes, Manager } from '../types.js';
+import { Manager, Middleware } from '../types.js';
 /** Handling network unauthorized indicators like HTTP 401
  *
  * @see https://dataclient.io/docs/api/LogoutManager
  */
 export default class LogoutManager implements Manager {
-    protected middleware: Middleware;
     constructor({ handleLogout, shouldLogout }?: Props);
+    middleware: Middleware;
     cleanup(): void;
-    getMiddleware(): Middleware;
     protected shouldLogout(error: UnknownError): boolean;
-    handleLogout(controller: Controller<Dispatch>): void;
+    handleLogout(controller: Controller): void;
 }
-type Dispatch = (value: ActionTypes) => Promise<void>;
-export type Middleware = <C extends Controller<Dispatch>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
-type HandleLogout = (controller: Controller<Dispatch>) => void;
+type HandleLogout = (controller: Controller) => void;
 interface Props {
     handleLogout?: HandleLogout;
     shouldLogout?: (error: UnknownError) => boolean;

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

@@ -28,16 +28,19 @@ export default class NetworkManager implements Manager {
     };
     readonly dataExpiryLength: number;
     readonly errorExpiryLength: number;
-    protected middleware: Middleware;
     protected controller: Controller;
     cleanupDate?: number;
-    constructor(dataExpiryLength?: number, errorExpiryLength?: number);
-    /** Used by DevtoolsManager to determine whether to log an action */
-    skipLogging(action: ActionTypes): boolean;
+    constructor({ dataExpiryLength, errorExpiryLength }?: {
+        dataExpiryLength?: number | undefined;
+        errorExpiryLength?: number | undefined;
+    });
+    middleware: Middleware;
     /** On mount */
     init(): void;
     /** Ensures all promises are completed by rejecting remaining. */
     cleanup(): void;
+    /** Used by DevtoolsManager to determine whether to log an action */
+    skipLogging(action: ActionTypes): boolean;
     allSettled(): Promise<PromiseSettledResult<any>[]> | undefined;
     /** Clear all promise state */
     protected clearAll(): void;
@@ -58,14 +61,6 @@ export default class NetworkManager implements Manager {
      * Will resolve the promise associated with set key.
      */
     protected handleSet(action: SetResponseAction): void;
-    /** Attaches NetworkManager to store
-     *
-     * Intercepts 'rdc/fetch' actions to start requests.
-     *
-     * Resolve/rejects a request when matching 'rdc/set' event
-     * is seen.
-     */
-    getMiddleware(): Middleware;
     /** Ensures only one request for a given key is in flight at any time
      *
      * Uses key to either retrieve in-flight promise, or if not

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

@@ -18,14 +18,14 @@ export interface SubscriptionConstructable {
  *
  * @see https://dataclient.io/docs/api/SubscriptionManager
  */
-export default class SubscriptionManager<S extends SubscriptionConstructable> implements Manager<Actions> {
+export default class SubscriptionManager<S extends SubscriptionConstructable = SubscriptionConstructable> implements Manager<Actions> {
     protected subscriptions: {
         [key: string]: InstanceType<S>;
     };
     protected readonly Subscription: S;
-    protected middleware: Middleware;
     protected controller: Controller;
     constructor(Subscription: S);
+    middleware: Middleware;
     /** Ensures all subscriptions are cleaned up. */
     cleanup(): void;
     /** Called when middleware intercepts 'rdc/subscribe' action.
@@ -36,15 +36,6 @@ export default class SubscriptionManager<S extends SubscriptionConstructable> im
      *
      */
     protected handleUnsubscribe(action: UnsubscribeAction): void;
-    /** Attaches Manager to store
-     *
-     * Intercepts 'rdc/subscribe'/'rest-hordc/ribe' to register resources that
-     * need to be kept up to date.
-     *
-     * Will possibly dispatch 'rdc/fetch' or 'rest-hordc/' to keep resources fresh
-     *
-     */
-    getMiddleware(): Middleware;
 }
 export {};
 //# sourceMappingURL=SubscriptionManager.d.ts.map

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

@@ -1,10 +1,13 @@
 import Controller from '../controller/Controller.js';
-import { Reducer, Dispatch, ReducerState } from '../middlewareTypes.js';
 import { Manager } from '../types.js';
-export default function applyManager(managers: Manager[], controller: Controller): Middleware[];
-export interface MiddlewareAPI<R extends Reducer<any, any> = Reducer<any, any>> {
+export default function applyManager(managers: Manager[], controller: Controller): ReduxMiddleware[];
+export interface ReduxMiddlewareAPI<R extends Reducer<any, any> = Reducer<any, any>> {
     getState: () => ReducerState<R>;
-    dispatch: Dispatch<R>;
+    dispatch: ReactDispatch<R>;
 }
-export type Middleware = <R extends Reducer<any, any>>({ dispatch, }: MiddlewareAPI<R>) => (next: Dispatch<R>) => Dispatch<R>;
+export type ReduxMiddleware = <R extends Reducer<any, any>>({ dispatch, }: ReduxMiddlewareAPI<R>) => (next: ReactDispatch<R>) => ReactDispatch<R>;
+export type ReactDispatch<R extends Reducer<any, any>> = (action: ReducerAction<R>) => Promise<void>;
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any> ? S : never;
+export type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<any, infer A> ? A : never;
 //# sourceMappingURL=applyManager.d.ts.map

package/ts3.4/middlewareTypes.d.ts

@@ -1,15 +1,11 @@
 import Controller from './controller/Controller.js';
 import { ActionTypes, State } from './types.js';
-type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
-export interface MiddlewareAPI<R extends DataClientReducer = DataClientReducer> extends Controller<RHDispatch<ActionTypes>> {
+export type Dispatch<Actions = ActionTypes> = (value: Actions) => Promise<void>;
+export interface MiddlewareAPI extends Controller<Dispatch<ActionTypes>> {
 }
-export interface MiddlewareController<Actions = ActionTypes> extends Controller<RHDispatch<Actions>> {
+export interface MiddlewareController<Actions = ActionTypes> extends Controller<Dispatch<Actions>> {
 }
-export type Middleware<Actions = any> = <C extends MiddlewareController<Actions>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
+/** @see https://dataclient.io/docs/api/Manager#middleware */
+export type Middleware<Actions = ActionTypes> = <C extends MiddlewareController<Actions>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
 export type DataClientReducer = (prevState: State<unknown>, action: ActionTypes) => State<unknown>;
-export type Dispatch<R extends Reducer<any, any>> = (action: ReducerAction<R>) => Promise<void>;
-export type Reducer<S, A> = (prevState: S, action: A) => S;
-export type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any> ? S : never;
-export type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<any, infer A> ? A : never;
-export {};
 //# sourceMappingURL=middlewareTypes.d.ts.map

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

@@ -15,10 +15,10 @@ export declare function expireReducer(state: State<unknown>, action: ExpireAllAc
             readonly [pk: string]: unknown;
         } | undefined;
     };
-    indexes: import("packages/normalizr/lib/interface.js").NormalizedIndex;
     endpoints: {
         readonly [key: string]: unknown | import("../../types.js").PK[] | import("../../types.js").PK | undefined;
     };
+    indexes: import("packages/normalizr/lib/interface.js").NormalizedIndex;
     entityMeta: {
         readonly [entityKey: string]: {
             readonly [pk: string]: {

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

@@ -4,13 +4,10 @@ export declare function setReducer(state: State<unknown>, action: SetAction, con
     entities: {
         [x: string]: any;
     };
-    indexes: import("@data-client/normalizr").NormalizedIndex;
     endpoints: {
         readonly [key: string]: unknown;
     };
-    entityMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
-        [x: string]: any;
-    }>;
+    indexes: import("@data-client/normalizr").NormalizedIndex;
     meta: {
         readonly [key: string]: {
             readonly date: number;
@@ -21,6 +18,9 @@ export declare function setReducer(state: State<unknown>, action: SetAction, con
             readonly errorPolicy?: "hard" | "soft" | undefined;
         };
     };
+    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> & {
         update?: import("../../index.js").EndpointUpdateFunction<import("@data-client/normalizr").EndpointInterface>;
     }>)[];

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

@@ -4,11 +4,8 @@ export declare function setResponseReducer(state: State<unknown>, action: Optimi
     entities: {
         [x: string]: any;
     };
-    indexes: import("@data-client/normalizr").NormalizedIndex;
     endpoints: Record<string, unknown>;
-    entityMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
-        [x: string]: any;
-    }>;
+    indexes: import("@data-client/normalizr").NormalizedIndex;
     meta: {
         [x: string]: {
             readonly date: number;
@@ -23,6 +20,9 @@ export declare function setResponseReducer(state: State<unknown>, action: Optimi
             prevExpiresAt: number;
         };
     };
+    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> & {
         update?: import("../../index.js").EndpointUpdateFunction<import("@data-client/normalizr").EndpointInterface>;
     }>)[];

package/ts3.4/types.d.ts

@@ -6,16 +6,20 @@ import { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
 export * from './actions.js';
 export { AbstractInstanceType, UpdateFunction };
 export type PK = string;
+/** Normalized state for Reactive Data Client
+ *
+ * @see https://dataclient.io/docs/concepts/normalization
+ */
 export interface State<T> {
     readonly entities: {
         readonly [entityKey: string]: {
             readonly [pk: string]: T;
         } | undefined;
     };
-    readonly indexes: NormalizedIndex;
     readonly endpoints: {
         readonly [key: string]: unknown | PK[] | PK | undefined;
     };
+    readonly indexes: NormalizedIndex;
     readonly meta: {
         readonly [key: string]: {
             readonly date: number;
@@ -38,9 +42,20 @@ export interface State<T> {
     readonly optimistic: (SetResponseAction | OptimisticAction)[];
     readonly lastReset: number;
 }
+/** Singletons that handle global side-effects
+ *
+ * Kind of like useEffect() for the central data store
+ *
+ * @see https://dataclient.io/docs/api/Manager
+ */
 export interface Manager<Actions = ActionTypes> {
-    getMiddleware(): Middleware<Actions>;
+    /** @see https://dataclient.io/docs/api/Manager#getmiddleware */
+    getMiddleware?(): Middleware<Actions>;
+    /** @see https://dataclient.io/docs/api/Manager#middleware */
+    middleware?: Middleware<Actions>;
+    /** @see https://dataclient.io/docs/api/Manager#cleanup */
     cleanup(): void;
+    /** @see https://dataclient.io/docs/api/Manager#init */
     init?: (state: State<any>) => void;
 }
 export { Dispatch, Middleware, MiddlewareAPI };