@data-client/core 0.4.2 → 0.8.0

package/src/manager/__tests__/networkManager.ts

@@ -71,12 +71,9 @@ describe('NetworkManager', () => {
         return updates;
       },
     });
-    const fetchReceiveWithUpdatersAction = createFetch(
-      detailWithUpdaterEndpoint,
-      {
-        args: [{ id: 5 }],
-      },
-    );
+    const fetchSetWithUpdatersAction = createFetch(detailWithUpdaterEndpoint, {
+      args: [{ id: 5 }],
+    });
 
     const updateShape = new Endpoint(
       (params: any, body: any) => Promise.resolve(body),
@@ -158,7 +155,7 @@ describe('NetworkManager', () => {
 
       const data = await fetchResolveAction.payload();
 
-      // mutations resolve before dispatch, so we must wait for next tick to see receive
+      // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
@@ -176,7 +173,7 @@ describe('NetworkManager', () => {
       expect(dispatch).toHaveBeenCalledWith(action);
       expect(next).not.toHaveBeenCalledWith(action);
     });
-    it('should handle fetch receive action and dispatch on success with updaters', async () => {
+    it('should handle fetch set action and dispatch on success with updaters', async () => {
       const next = jest.fn();
       const dispatch = jest.fn();
       const controller = new Controller({ dispatch, getState });
@@ -187,20 +184,20 @@ describe('NetworkManager', () => {
         },
       );
 
-      middleware(API)(next)(fetchReceiveWithUpdatersAction);
+      middleware(API)(next)(fetchSetWithUpdatersAction);
 
-      const data = await fetchReceiveWithUpdatersAction.payload();
+      const data = await fetchSetWithUpdatersAction.payload();
 
-      // mutations resolve before dispatch, so we must wait for next tick to see receive
+      // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
         type: SET_TYPE,
-        endpoint: fetchReceiveWithUpdatersAction.endpoint,
+        endpoint: fetchSetWithUpdatersAction.endpoint,
         payload: data,
         meta: {
-          args: fetchReceiveWithUpdatersAction.meta.args,
-          key: fetchReceiveWithUpdatersAction.meta.key,
+          args: fetchSetWithUpdatersAction.meta.args,
+          key: fetchSetWithUpdatersAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
           fetchedAt: expect.any(Number),
@@ -224,7 +221,7 @@ describe('NetworkManager', () => {
 
       const data = await fetchRpcWithUpdatersAction.payload();
 
-      // mutations resolve before dispatch, so we must wait for next tick to see receive
+      // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
@@ -258,7 +255,7 @@ describe('NetworkManager', () => {
       const data = await fetchRpcWithUpdatersAndOptimisticAction.payload();
 
       expect(next).toHaveBeenCalled();
-      // mutations resolve before dispatch, so we must wait for next tick to see receive
+      // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
       expect(dispatch).toHaveBeenCalledWith({
         type: SET_TYPE,

package/src/manager/applyManager.ts

@@ -8,16 +8,11 @@ export default function applyManager(
 ): Middleware[] {
   return managers.map(manager => {
     const middleware = manager.getMiddleware();
-    // TODO(breaking): remove this once controller prop is no longer supported
     return ({ dispatch, getState }) => {
       (controller as any).dispatch = dispatch;
       (controller as any).getState = getState;
-      // this is needed for backwards compatibility as we added 'controller' prop previously
-      const API = Object.create(controller, {
-        controller: { value: controller },
-      });
       // controller is a superset of the middleware API
-      return middleware(API);
+      return middleware(controller as Controller<any>);
     };
   });
 }

package/src/middlewareTypes.ts

@@ -3,15 +3,10 @@ import { ActionTypes, State } from './types.js';
 
 type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
 
-export interface MiddlewareAPI<R extends RestHooksReducer = RestHooksReducer>
-  extends Controller<RHDispatch<ActionTypes>> {
-  /** @deprecated use members directly instead */
-  controller: Controller<RHDispatch<ActionTypes>>;
-}
+export interface MiddlewareAPI<R extends DataClientReducer = DataClientReducer>
+  extends Controller<RHDispatch<ActionTypes>> {}
 export interface MiddlewareController<Actions = ActionTypes>
-  extends Controller<RHDispatch<Actions>> {
-  controller: Controller<RHDispatch<Actions>>;
-}
+  extends Controller<RHDispatch<Actions>> {}
 
 export type Middleware<Actions = any> = <
   C extends MiddlewareController<Actions>,
@@ -19,7 +14,7 @@ export type Middleware<Actions = any> = <
   controller: C,
 ) => (next: C['dispatch']) => C['dispatch'];
 
-export type RestHooksReducer = (
+export type DataClientReducer = (
   prevState: State<unknown>,
   action: ActionTypes,
 ) => State<unknown>;

package/src/next/index.ts

@@ -1,2 +0,0 @@
-export { default as Controller } from '../controller/Controller.js';
-export * from '../controller/Controller.js';

package/src/state/__tests__/__snapshots__/reducer.ts.snap

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`reducer should set error in meta for "receive" 1`] = `
+exports[`reducer should set error in meta for "set" 1`] = `
 {
   "entities": {},
   "entityMeta": {},

package/src/state/__tests__/reducer.ts

@@ -143,20 +143,38 @@ describe('reducer', () => {
       expect(nextMeta.date).toBe(action.meta.date);
     });
 
-    it('should use entity.expiresAt()', () => {
+    it('should use entity.mergeMetaWithStore()', () => {
       class ExpiresSoon extends Article {
         static get key() {
           return Article.key;
         }
 
-        static expiresAt(
-          { expiresAt, date }: { expiresAt: number; date: number },
-          input: any,
-        ): number {
-          return input.content ? expiresAt : 0;
+        static mergeMetaWithStore(
+          existingMeta: {
+            expiresAt: number;
+            date: number;
+            fetchedAt: number;
+          },
+          incomingMeta: { expiresAt: number; date: number; fetchedAt: number },
+          existing: any,
+          incoming: any,
+        ) {
+          return this.shouldReorder(
+            existingMeta,
+            incomingMeta,
+            existing,
+            incoming,
+          )
+            ? existingMeta
+            : {
+                ...incomingMeta,
+                expiresAt: incoming.content
+                  ? incomingMeta.expiresAt
+                  : existingMeta.expiresAt,
+              };
         }
       }
-      const spy = jest.spyOn(ExpiresSoon, 'expiresAt');
+      const spy = jest.spyOn(ExpiresSoon, 'mergeMetaWithStore');
       const localAction = {
         ...partialResultAction,
         endpoint: (partialResultAction.endpoint as any).extend({
@@ -401,7 +419,7 @@ describe('reducer', () => {
     expectedMeta['20'] = { expiresAt: 0, invalidated: true };
     expect(newState.meta).toEqual(expectedMeta);
   });
-  it('should set error in meta for "receive"', () => {
+  it('should set error in meta for "set"', () => {
     const id = 20;
     const error = new Error('hi');
     const action: SetAction = {
@@ -472,7 +490,7 @@ describe('reducer', () => {
     const newState = reducer(iniState, action);
     expect(newState.entities).toBe(iniState.entities);
   });
-  it('rest-hooks/fetch should console.warn()', () => {
+  it('rdc/fetch should console.warn()', () => {
     const warnspy = jest
       .spyOn(global.console, 'warn')
       .mockImplementation(() => {});

package/src/state/reducer/fetchReducer.ts

@@ -1,16 +1,16 @@
 import createOptimistic from '../../controller/createOptimistic.js';
 import type {
   State,
-  ReceiveAction,
+  SetAction,
   OptimisticAction,
   FetchAction,
 } from '../../types.js';
 
 export function fetchReducer(state: State<unknown>, action: FetchAction) {
-  let receiveAction: ReceiveAction | OptimisticAction;
+  let setAction: SetAction | OptimisticAction;
 
   if (action.endpoint.getOptimisticResponse && action.endpoint.sideEffect) {
-    receiveAction = createOptimistic(action.endpoint, {
+    setAction = createOptimistic(action.endpoint, {
       args: action.meta.args,
       fetchedAt: action.meta.createdAt,
     });
@@ -22,7 +22,7 @@ export function fetchReducer(state: State<unknown>, action: FetchAction) {
         'Fetch appears unhandled - you are likely missing the NetworkManager middleware',
       );
       console.warn(
-        'See https://resthooks.io/docs/guides/redux#indextsx for hooking up redux',
+        'See https://dataclient.io/docs/guides/redux#indextsx for hooking up redux',
       );
     }
 
@@ -30,6 +30,6 @@ export function fetchReducer(state: State<unknown>, action: FetchAction) {
   }
   return {
     ...state,
-    optimistic: [...state.optimistic, receiveAction],
+    optimistic: [...state.optimistic, setAction],
   };
 }

package/src/state/reducer/setReducer.ts

@@ -2,11 +2,11 @@ import { normalize } from '@data-client/normalizr';
 
 import { OPTIMISTIC_TYPE } from '../../actionTypes.js';
 import type Controller from '../../controller/Controller.js';
-import type { State, ReceiveAction, OptimisticAction } from '../../types.js';
+import type { State, SetAction, OptimisticAction } from '../../types.js';
 
 export function setReducer(
   state: State<unknown>,
-  action: OptimisticAction | ReceiveAction,
+  action: OptimisticAction | SetAction,
   controller: Controller,
 ) {
   if (action.error) {
@@ -14,7 +14,7 @@ export function setReducer(
   }
   try {
     let payload: any;
-    // for true receives payload is contained in action
+    // for true set's payload is contained in action
     if (action.type === OPTIMISTIC_TYPE) {
       // this should never happen
       if (!action.endpoint.getOptimisticResponse) return state;
@@ -104,7 +104,7 @@ export function setReducer(
 
 function reduceError(
   state: State<unknown>,
-  action: ReceiveAction | OptimisticAction,
+  action: SetAction | OptimisticAction,
   error: any,
 ): State<unknown> {
   if (error.name === 'AbortError') {
@@ -133,7 +133,7 @@ function reduceError(
 /** Filter all requests with same serialization that did not start after the resolving request */
 function filterOptimistic(
   state: State<unknown>,
-  resolvingAction: ReceiveAction | OptimisticAction,
+  resolvingAction: SetAction | OptimisticAction,
 ) {
   return state.optimistic.filter(
     optimisticAction =>

package/src/types.ts

@@ -5,13 +5,13 @@ import type {
 } from '@data-client/normalizr';
 import type { ErrorTypes } from '@data-client/normalizr';
 
+import type { ActionTypes, SetAction, OptimisticAction } from './actions.js';
 import { SET_TYPE } from './actionTypes.js';
 import type { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
-import type { ActionTypes, SetAction, OptimisticAction } from './newActions.js';
 
 export type { AbstractInstanceType, UpdateFunction };
 
-export type ReceiveTypes = typeof SET_TYPE;
+export type SetTypes = typeof SET_TYPE;
 
 export type PK = string;
 
@@ -44,8 +44,7 @@ export interface State<T> {
   readonly lastReset: number;
 }
 
-export * as newActions from './newActions.js';
-export * from './newActions.js';
+export * from './actions.js';
 
 export interface Manager<Actions = ActionTypes> {
   getMiddleware(): Middleware<Actions>;

package/ts3.4/actionTypes.d.ts

@@ -1,13 +1,11 @@
-export declare const FETCH_TYPE: "rest-hooks/fetch";
-/** @deprecated use SET_TYPE instead */
-export declare const RECEIVE_TYPE: "rest-hooks/receive";
-export declare const SET_TYPE: "rest-hooks/receive";
-export declare const OPTIMISTIC_TYPE: "rest-hooks/optimistic";
-export declare const RESET_TYPE: "rest-hooks/reset";
-export declare const SUBSCRIBE_TYPE: "rest-hooks/subscribe";
-export declare const UNSUBSCRIBE_TYPE: "rest-hook/unsubscribe";
-export declare const INVALIDATE_TYPE: "rest-hooks/invalidate";
-export declare const INVALIDATEALL_TYPE: "rest-hooks/invalidateall";
-export declare const EXPIREALL_TYPE: "rest-hooks/expireall";
-export declare const GC_TYPE: "rest-hooks/gc";
+export declare const FETCH_TYPE: "rdc/fetch";
+export declare const SET_TYPE: "rdc/set";
+export declare const OPTIMISTIC_TYPE: "rdc/optimistic";
+export declare const RESET_TYPE: "rdc/reset";
+export declare const SUBSCRIBE_TYPE: "rdc/subscribe";
+export declare const UNSUBSCRIBE_TYPE: "rdc/unsubscribe";
+export declare const INVALIDATE_TYPE: "rdc/invalidate";
+export declare const INVALIDATEALL_TYPE: "rdc/invalidateall";
+export declare const EXPIREALL_TYPE: "rdc/expireall";
+export declare const GC_TYPE: "rdc/gc";
 //# sourceMappingURL=actionTypes.d.ts.map

package/ts3.4/{newActions.d.ts → actions.d.ts}

@@ -29,8 +29,6 @@ export interface SetActionError<E extends EndpointAndUpdate<E> = EndpointDefault
     error: true;
 }
 export type SetAction<E extends EndpointAndUpdate<E> = EndpointDefault> = SetActionSuccess<E> | SetActionError<E>;
-/** @deprecated use SetAction instead */
-export type ReceiveAction<E extends EndpointAndUpdate<E> = EndpointDefault> = SetAction<E>;
 export interface FetchMeta {
     args: readonly any[];
     key: string;
@@ -97,4 +95,4 @@ export interface GCAction {
 }
 export type ActionTypes = FetchAction | OptimisticAction | SetAction | SubscribeAction | UnsubscribeAction | InvalidateAction | InvalidateAllAction | ExpireAllAction | ResetAction | GCAction;
 export {};
-//# sourceMappingURL=newActions.d.ts.map
+//# sourceMappingURL=actions.d.ts.map

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

@@ -10,14 +10,14 @@ interface ConstructorProps<D extends GenericDispatch = DataClientDispatch> {
     globalCache?: DenormalizeCache;
 }
 /**
- * Imperative control of Rest Hooks store
- * @see https://resthooks.io/docs/api/Controller
+ * Imperative control of Reactive Data Client store
+ * @see https://dataclient.io/docs/api/Controller
  */
 export default class Controller<D extends GenericDispatch = DataClientDispatch> {
     /**
-     * Dispatches an action to Rest Hooks reducer.
+     * Dispatches an action to Reactive Data Client reducer.
      *
-     * @see https://resthooks.io/docs/api/Controller#dispatch
+     * @see https://dataclient.io/docs/api/Controller#dispatch
      */
     readonly dispatch: D;
     /**
@@ -25,15 +25,15 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      *
      * This can be useful for imperative use-cases like event handlers.
      * This should *not* be used to render; instead useSuspense() or useCache()
-     * @see https://resthooks.io/docs/api/Controller#getState
+     * @see https://dataclient.io/docs/api/Controller#getState
      */
     readonly getState: () => State<unknown>;
     readonly globalCache: DenormalizeCache;
     constructor({ dispatch, getState, globalCache, }?: ConstructorProps<D>);
     /*************** Action Dispatchers ***************/
     /**
-     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
-     * @see https://resthooks.io/docs/api/Controller#fetch
+     * Fetches the endpoint with given args, updating the Reactive Data Client cache with the response or error upon completion.
+     * @see https://dataclient.io/docs/api/Controller#fetch
      */
     fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
@@ -47,7 +47,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> | ResolveType<E> : Denormalize<E["schema"]> | Promise<Denormalize<E["schema"]>>;
     /**
      * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
-     * @see https://resthooks.io/docs/api/Controller#invalidate
+     * @see https://dataclient.io/docs/api/Controller#invalidate
      */
     invalidate: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>>(endpoint: E, ...args: readonly [
         ...Parameters<E>
@@ -56,7 +56,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     ]) => Promise<void>;
     /**
      * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
-     * @see https://resthooks.io/docs/api/Controller#invalidateAll
+     * @see https://dataclient.io/docs/api/Controller#invalidateAll
      * @returns Promise that resolves when invalidation is commited.
      */
     invalidateAll: (options: {
@@ -71,13 +71,13 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         testKey: (key: string) => boolean;
     }) => Promise<void>;
     /**
-     * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
-     * @see https://resthooks.io/docs/api/Controller#resetEntireStore
+     * Resets the entire Reactive Data Client cache. All inflight requests will not resolve.
+     * @see https://dataclient.io/docs/api/Controller#resetEntireStore
      */
     resetEntireStore: () => Promise<void>;
     /**
      * Stores response in cache for given Endpoint and args.
-     * @see https://resthooks.io/docs/api/Controller#set
+     * @see https://dataclient.io/docs/api/Controller#set
      */
     setResponse: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
@@ -85,18 +85,9 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         ...Parameters<E>,
         any
     ]) => Promise<void>;
-    /**
-     * @deprecated use https://resthooks.io/docs/api/Controller#setResponse instead
-     */
-    receive: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
-        update?: EndpointUpdateFunction<E> | undefined;
-    }>(endpoint: E, ...rest: readonly [
-        ...Parameters<E>,
-        any
-    ]) => Promise<void>;
     /**
      * Stores the result of Endpoint and args as the error provided.
-     * @see https://resthooks.io/docs/api/Controller#setError
+     * @see https://dataclient.io/docs/api/Controller#setError
      */
     setError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
@@ -104,19 +95,9 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
         ...Parameters<E>,
         Error
     ]) => Promise<void>;
-    /**
-     * Another name for setError
-     * @deprecated use https://resthooks.io/docs/api/Controller#setError instead
-     */
-    receiveError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
-        update?: EndpointUpdateFunction<E> | undefined;
-    }>(endpoint: E, ...rest: readonly [
-        ...Parameters<E>,
-        Error
-    ]) => Promise<void>;
     /**
      * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
-     * @see https://resthooks.io/docs/api/Controller#resolve
+     * @see https://dataclient.io/docs/api/Controller#resolve
      */
     resolve: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
@@ -137,7 +118,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     }) => Promise<void>;
     /**
      * Marks a new subscription to a given Endpoint.
-     * @see https://resthooks.io/docs/api/Controller#subscribe
+     * @see https://dataclient.io/docs/api/Controller#subscribe
      */
     subscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
         null
@@ -146,7 +127,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     ]) => Promise<void>;
     /**
      * Marks completion of subscription to a given Endpoint.
-     * @see https://resthooks.io/docs/api/Controller#unsubscribe
+     * @see https://dataclient.io/docs/api/Controller#unsubscribe
      */
     unsubscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
         null
@@ -155,13 +136,13 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     ]) => Promise<void>;
     /*************** More ***************/
     /**
-     * Gets a snapshot (https://resthooks.io/docs/api/Snapshot)
-     * @see https://resthooks.io/docs/api/Controller#snapshot
+     * Gets a snapshot (https://dataclient.io/docs/api/Snapshot)
+     * @see https://dataclient.io/docs/api/Controller#snapshot
      */
     snapshot: (state: State<unknown>, fetchedAt?: number) => SnapshotInterface;
     /**
      * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
-     * @see https://resthooks.io/docs/api/Controller#getError
+     * @see https://dataclient.io/docs/api/Controller#getError
      */
     getError: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "key">, Args extends readonly [
         null
@@ -173,7 +154,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     ]) => ErrorTypes | undefined;
     /**
      * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
-     * @see https://resthooks.io/docs/api/Controller#getResponse
+     * @see https://dataclient.io/docs/api/Controller#getResponse
      */
     getResponse: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "schema" | "key" | "invalidIfStale">, Args extends readonly [
         null

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

@@ -0,0 +1,3 @@
+export declare const ensurePojo: (body: any) => any;
+export default ensurePojo;
+//# sourceMappingURL=ensurePojo.d.ts.map

package/ts3.4/index.d.ts

@@ -8,7 +8,7 @@ export { default as applyManager } from './manager/applyManager.js';
 export { default as Controller } from './controller/Controller.js';
 export { DataClientDispatch, GenericDispatch, } from './controller/Controller.js';
 export { default as createFetch } from './controller/createFetch.js';
-export { default as createReceive } from './controller/createSet.js';
+export { default as createSet } from './controller/createSet.js';
 export * from './controller/types.js';
 import * as actionTypes_1 from './actionTypes.js';
 export { actionTypes_1 as actionTypes };

package/ts3.4/internal.d.ts

@@ -1,4 +1,4 @@
-export { inferResults, DELETED, INVALID } from '@data-client/normalizr';
+export { inferResults, INVALID } from '@data-client/normalizr';
 export { default as RIC } from './state/RIC.js';
 export { initialState } from './state/reducer/createReducer.js';
 //# sourceMappingURL=internal.d.ts.map

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

@@ -44,7 +44,7 @@ export default class NetworkManager implements Manager {
     /** Clear promise state for a given key */
     protected clear(key: string): void;
     protected getLastReset(): number;
-    /** Called when middleware intercepts 'rest-hooks/fetch' action.
+    /** Called when middleware intercepts 'rdc/fetch' action.
      *
      * Will then start a promise for a key and potentially start the network
      * fetch.
@@ -53,16 +53,16 @@ export default class NetworkManager implements Manager {
      * for ensures mutation requests always go through.
      */
     protected handleFetch(action: FetchAction): Promise<any>;
-    /** Called when middleware intercepts a receive action.
+    /** Called when middleware intercepts a set action.
      *
-     * Will resolve the promise associated with receive key.
+     * Will resolve the promise associated with set key.
      */
-    protected handleReceive(action: SetAction): void;
+    protected handleSet(action: SetAction): void;
     /** Attaches NetworkManager to store
      *
-     * Intercepts 'rest-hooks/fetch' actions to start requests.
+     * Intercepts 'rdc/fetch' actions to start requests.
      *
-     * Resolve/rejects a request when matching 'rest-hooks/receive' event
+     * Resolve/rejects a request when matching 'rdc/set' event
      * is seen.
      */
     getMiddleware(): Middleware;

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

@@ -11,7 +11,7 @@ export interface Subscription {
 export interface SubscriptionConstructable {
     new (action: Pick<SubscribeAction, Exclude<keyof SubscribeAction, 'type'>>, controller: Controller): Subscription;
 }
-/** Handles subscription actions -> fetch or receive actions
+/** Handles subscription actions -> fetch or set actions
  *
  * Constructor takes a SubscriptionConstructable class to control how
  * subscriptions are handled. (e.g., polling, websockets)
@@ -28,20 +28,20 @@ export default class SubscriptionManager<S extends SubscriptionConstructable> im
     constructor(Subscription: S);
     /** Ensures all subscriptions are cleaned up. */
     cleanup(): void;
-    /** Called when middleware intercepts 'rest-hooks/subscribe' action.
+    /** Called when middleware intercepts 'rdc/subscribe' action.
      *
      */
     protected handleSubscribe(action: SubscribeAction): void;
-    /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.
+    /** Called when middleware intercepts 'rdc/unsubscribe' action.
      *
      */
     protected handleUnsubscribe(action: UnsubscribeAction): void;
     /** Attaches Manager to store
      *
-     * Intercepts 'rest-hooks/subscribe'/'rest-hooks/unsubscribe' to register resources that
+     * Intercepts 'rdc/subscribe'/'rest-hordc/ribe' to register resources that
      * need to be kept up to date.
      *
-     * Will possibly dispatch 'rest-hooks/fetch' or 'rest-hooks/receive' to keep resources fresh
+     * Will possibly dispatch 'rdc/fetch' or 'rest-hordc/' to keep resources fresh
      *
      */
     getMiddleware(): Middleware;

package/ts3.4/middlewareTypes.d.ts

@@ -1,15 +1,12 @@
 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 RestHooksReducer = RestHooksReducer> extends Controller<RHDispatch<ActionTypes>> {
-    /** @deprecated use members directly instead */
-    controller: Controller<RHDispatch<ActionTypes>>;
+export interface MiddlewareAPI<R extends DataClientReducer = DataClientReducer> extends Controller<RHDispatch<ActionTypes>> {
 }
 export interface MiddlewareController<Actions = ActionTypes> extends Controller<RHDispatch<Actions>> {
-    controller: Controller<RHDispatch<Actions>>;
 }
 export type Middleware<Actions = any> = <C extends MiddlewareController<Actions>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
-export type RestHooksReducer = (prevState: State<unknown>, action: ActionTypes) => State<unknown>;
+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;

package/ts3.4/next/index.d.ts

@@ -1,3 +1 @@
-export { default as Controller } from '../controller/Controller.js';
-export * from '../controller/Controller.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -28,7 +28,7 @@ export declare function expireReducer(state: State<unknown>, action: ExpireAllAc
             };
         };
     };
-    optimistic: (import("../../newActions.js").SetAction | import("../../newActions.js").OptimisticAction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined> & {
+    optimistic: (import("../../actions.js").SetAction | import("../../actions.js").OptimisticAction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined> & {
         update?: import("../../index.js").EndpointUpdateFunction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined>> | undefined;
     }>)[];
     lastReset: number;

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

@@ -28,7 +28,7 @@ export declare function invalidateReducer(state: State<unknown>, action: Invalid
             };
         };
     };
-    optimistic: (import("../../newActions.js").SetAction | import("../../newActions.js").OptimisticAction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined> & {
+    optimistic: (import("../../actions.js").SetAction | import("../../actions.js").OptimisticAction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined> & {
         update?: import("../../index.js").EndpointUpdateFunction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined>> | undefined;
     }>)[];
     lastReset: number;