@data-client/core 0.1.0 → 0.2.0

package/src/types.ts

@@ -1,30 +1,17 @@
-import {
-  EndpointInterface,
-  NormalizedIndex,
-  Schema,
-} from '@data-client/normalizr';
+import { NormalizedIndex } from '@data-client/normalizr';
 import type {
   UpdateFunction,
   AbstractInstanceType,
 } from '@data-client/normalizr';
 import type { ErrorTypes } from '@data-client/normalizr';
 
-import { RECEIVE_TYPE } from './actionTypes.js';
-import {
-  CompatibleFetchAction,
-  CompatibleReceiveAction,
-  CompatibleSubscribeAction,
-  CompatibleUnsubscribeAction,
-} from './compatibleActions.js';
-import { EndpointUpdateFunction } from './controller/types.js';
-import * as legacyActions from './legacyActions.js';
-import { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
-import * as newActions from './newActions.js';
-import * as previousActions from './previousActions.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 RECEIVE_TYPE;
+export type ReceiveTypes = typeof SET_TYPE;
 
 export type PK = string;
 
@@ -53,70 +40,14 @@ export interface State<T> {
       };
     };
   };
-  readonly optimistic: (
-    | previousActions.ReceiveAction
-    | previousActions.OptimisticAction
-  )[];
-  readonly lastReset: Date | number;
+  readonly optimistic: (SetAction | OptimisticAction)[];
+  readonly lastReset: number;
 }
 
-export * as legacyActions from './legacyActions.js';
 export * as newActions from './newActions.js';
-export type { SetAction } from './newActions.js';
-
-/* maintain backwards compatibility */
-/* TODO: switch to only include newActions in future */
-export type OptimisticAction<
-  E extends EndpointInterface & {
-    update?: EndpointUpdateFunction<E>;
-  } = EndpointInterface & {
-    update?: EndpointUpdateFunction<EndpointInterface>;
-  },
-> = newActions.OptimisticAction<E>;
-export type InvalidateAction = newActions.InvalidateAction;
-export type ResetAction = newActions.ResetAction | legacyActions.ResetAction;
-export type GCAction = newActions.GCAction;
-export type FetchAction<
-  Payload extends object | string | number | null =
-    | object
-    | string
-    | number
-    | null,
-  S extends Schema | undefined = any,
-> = CompatibleFetchAction | legacyActions.FetchAction<Payload, S>;
-export type ReceiveAction<
-  Payload extends object | string | number | null =
-    | object
-    | string
-    | number
-    | null,
-  S extends Schema | undefined = any,
-> = CompatibleReceiveAction | legacyActions.ReceiveAction<Payload, S>;
-export type SubscribeAction =
-  | CompatibleSubscribeAction
-  | legacyActions.SubscribeAction;
-export type UnsubscribeAction =
-  | CompatibleUnsubscribeAction
-  | legacyActions.UnsubscribeAction;
-
-export type ResponseActions = ReceiveAction;
-
-// put other actions here in union
-export type OldActionTypes = previousActions.ActionTypes;
-
-export type CombinedActionTypes =
-  | OptimisticAction
-  | InvalidateAction
-  | ResetAction
-  | GCAction
-  | FetchAction
-  | ReceiveAction
-  | SubscribeAction
-  | UnsubscribeAction;
-
-export type ActionTypes = CombinedActionTypes;
+export * from './newActions.js';
 
-export interface Manager<Actions = CombinedActionTypes> {
+export interface Manager<Actions = ActionTypes> {
   getMiddleware(): Middleware<Actions>;
   cleanup(): void;
   init?: (state: State<any>) => void;

package/ts3.4/actionTypes.d.ts

@@ -1,4 +1,5 @@
 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";

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

@@ -1,14 +1,176 @@
-import { EndpointInterface } from '@data-client/normalizr';
-import BaseController, { CompatibleDispatch, GenericDispatch } from './BaseController.js';
+import { ErrorTypes, SnapshotInterface, DenormalizeCache, Schema, Denormalize } from '@data-client/normalizr';
+import { ExpiryStatus, EndpointInterface, FetchFunction, DenormalizeNullable } from '@data-client/normalizr';
 import { EndpointUpdateFunction } from './types.js';
-export default class Controller<D extends GenericDispatch = CompatibleDispatch> extends BaseController<D> {
+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> {
+    dispatch?: D;
+    getState?: () => State<unknown>;
+    globalCache?: DenormalizeCache;
+}
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/Controller
+ */
+export default class Controller<D extends GenericDispatch = DataClientDispatch> {
+    /**
+     * Dispatches an action to Rest Hooks reducer.
+     *
+     * @see https://resthooks.io/docs/api/Controller#dispatch
+     */
+    readonly dispatch: D;
+    /**
+     * Gets the latest state snapshot that is fully committed.
+     *
+     * 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
+     */
+    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
      */
-    fetch: <E extends EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
+    fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
+    /**
+     * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+     * @see https://resthooks.io/docs/api/Controller#invalidate
+     */
+    invalidate: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>>(endpoint: E, ...args: readonly [
+        ...Parameters<E>
+    ] | readonly [
+        null
+    ]) => Promise<void>;
+    /**
+     * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
+     * @see https://resthooks.io/docs/api/Controller#invalidateAll
+     */
+    invalidateAll: (options: {
+        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
+     */
+    resetEntireStore: () => Promise<void>;
+    /**
+     * Stores response in cache for given Endpoint and args.
+     * @see https://resthooks.io/docs/api/Controller#set
+     */
+    setResponse: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [
+        ...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
+     */
+    setError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [
+        ...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, ...args_0: Parameters<E>) => ReturnType<E>;
+    }>(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
+     */
+    resolve: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, meta: {
+        args: readonly [
+            ...Parameters<E>
+        ];
+        response: Error;
+        fetchedAt: number;
+        error: true;
+    } | {
+        args: readonly [
+            ...Parameters<E>
+        ];
+        response: any;
+        fetchedAt: number;
+        error?: false | undefined;
+    }) => Promise<void>;
+    /**
+     * Marks a new subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#subscribe
+     */
+    subscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
+        null
+    ] | readonly [
+        ...Parameters<E>
+    ]) => Promise<void>;
+    /**
+     * Marks completion of subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#unsubscribe
+     */
+    unsubscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
+        null
+    ] | readonly [
+        ...Parameters<E>
+    ]) => Promise<void>;
+    /*************** More ***************/
+    /**
+     * Gets a snapshot (https://resthooks.io/docs/api/Snapshot)
+     * @see https://resthooks.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
+     */
+    getError: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "key">, Args extends readonly [
+        null
+    ] | readonly [
+        ...Parameters<E["key"]>
+    ]>(endpoint: E, ...rest: [
+        ...Args,
+        State<unknown>
+    ]) => 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
+     */
+    getResponse: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "schema" | "key" | "invalidIfStale">, Args extends readonly [
+        null
+    ] | readonly [
+        ...Parameters<E["key"]>
+    ]>(endpoint: E, ...rest: [
+        ...Args,
+        State<unknown>
+    ]) => {
+        data: DenormalizeNullable<E["schema"]>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
 }
-export * from './BaseController.js';
+export { ErrorTypes };
 //# sourceMappingURL=Controller.d.ts.map

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

@@ -1,6 +1,6 @@
 import { EndpointInterface } from '@data-client/normalizr';
 import { EndpointUpdateFunction } from './types.js';
-import { CompatibleFetchAction } from '../compatibleActions.js';
+import { FetchAction } from '../types.js';
 /**
  * Requesting a fetch to begin
  */
@@ -10,5 +10,5 @@ export default function createFetch<E extends EndpointInterface & {
     args: readonly [
         ...Parameters<E>
     ];
-}): CompatibleFetchAction<E>;
+}): FetchAction<E>;
 //# sourceMappingURL=createFetch.d.ts.map

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

@@ -1,5 +1,5 @@
 import { EndpointInterface } from '@data-client/normalizr';
-import { InvalidateAction } from '../newActions.js';
+import { InvalidateAction } from '../types.js';
 export default function createInvalidate<E extends EndpointInterface>(endpoint: E, { args }: {
     args: readonly [
         ...Parameters<E>

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

@@ -1,3 +1,3 @@
-import { InvalidateAllAction } from '../newActions.js';
+import { InvalidateAllAction } from '../types.js';
 export default function createInvalidateAll(testKey: (key: string) => boolean): InvalidateAllAction;
 //# sourceMappingURL=createInvalidateAll.d.ts.map

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

@@ -1,6 +1,6 @@
 import { EndpointInterface } from '@data-client/normalizr';
 import { EndpointUpdateFunction } from './types.js';
-import { OptimisticAction } from '../newActions.js';
+import { OptimisticAction } from '../types.js';
 export default function createOptimistic<E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
 }>(endpoint: E, { args, fetchedAt, }: {

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

@@ -1,3 +1,3 @@
-import { ResetAction } from '../newActions.js';
+import { ResetAction } from '../types.js';
 export default function createReset(): ResetAction;
 //# sourceMappingURL=createReset.d.ts.map

package/ts3.4/controller/{createReceive.d.ts → createSet.d.ts}

@@ -1,7 +1,7 @@
 import { EndpointInterface, ResolveType } from '@data-client/normalizr';
 import { EndpointUpdateFunction } from './types.js';
-import { CompatibleReceiveAction } from '../compatibleActions.js';
-export default function createReceive<E extends EndpointInterface & {
+import { SetAction } from '../types.js';
+export default function createSet<E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
 }>(endpoint: E, options: {
     args: readonly [
@@ -10,8 +10,8 @@ export default function createReceive<E extends EndpointInterface & {
     response: Error;
     fetchedAt?: number;
     error: true;
-}): CompatibleReceiveAction<E>;
-export default function createReceive<E extends EndpointInterface & {
+}): SetAction<E>;
+export default function createSet<E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
 }>(endpoint: E, options: {
     args: readonly [
@@ -20,5 +20,5 @@ export default function createReceive<E extends EndpointInterface & {
     response: ResolveType<E>;
     fetchedAt?: number;
     error?: false;
-}): CompatibleReceiveAction<E>;
-//# sourceMappingURL=createReceive.d.ts.map
+}): SetAction<E>;
+//# sourceMappingURL=createSet.d.ts.map

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

@@ -1,13 +1,13 @@
 import { EndpointInterface } from '@data-client/normalizr';
-import { CompatibleSubscribeAction, CompatibleUnsubscribeAction } from '../compatibleActions.js';
+import { SubscribeAction, UnsubscribeAction } from '../types.js';
 export declare function createSubscription<E extends EndpointInterface>(endpoint: E, { args }: {
     args: readonly [
         ...Parameters<E>
     ];
-}): CompatibleSubscribeAction<E>;
+}): SubscribeAction<E>;
 export declare function createUnsubscription<E extends EndpointInterface>(endpoint: E, { args }: {
     args: readonly [
         ...Parameters<E>
     ];
-}): CompatibleUnsubscribeAction<E>;
+}): UnsubscribeAction<E>;
 //# sourceMappingURL=createSubscription.d.ts.map

package/ts3.4/index.d.ts

@@ -4,19 +4,14 @@ export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, Enti
 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';
-export { default as reducer } from './state/reducerInstance.js';
 export { default as applyManager } from './manager/applyManager.js';
 export { default as Controller } from './controller/Controller.js';
-export { CompatibleDispatch, GenericDispatch, } 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/createReceive.js';
+export { default as createReceive } from './controller/createSet.js';
 export * from './controller/types.js';
-import * as legacyActions_1 from './state/legacy-actions/index.js';
-export { legacyActions_1 as legacyActions };
 import * as actionTypes_1 from './actionTypes.js';
 export { actionTypes_1 as actionTypes };
 export * from './types.js';
-export { FetchShape, ReadShape, MutateShape, DeleteShape, } from './endpoint/shapes.js';
-export { SetShapeParams, ParamsFromShape, BodyFromShape, ReturnFromShape, } from './endpoint/types.js';
 export * from './manager/index.js';
 //# sourceMappingURL=index.d.ts.map

package/ts3.4/internal.d.ts

@@ -1,4 +1,4 @@
-export { inferResults, DELETED } from '@data-client/normalizr';
+export { inferResults, DELETED, 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/DevtoolsManager.d.ts

@@ -6,7 +6,7 @@ export { DevToolsConfig };
  *
  * Options: https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md
  *
- * @see https://resthooks.io/docs/api/DevToolsManager
+ * @see https://dataclient.io/docs/api/DevToolsManager
  */
 export default class DevToolsManager implements Manager {
     protected middleware: Middleware;

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

@@ -1,12 +1,11 @@
 import Controller from '../controller/Controller.js';
 import { UnknownError } from '../index.js';
-import { CombinedActionTypes } from '../types.js';
-import { Manager } from '../types.js';
+import { ActionTypes, Manager } from '../types.js';
 /** Handling network unauthorized indicators like HTTP 401
  *
- * @see https://resthooks.io/docs/api/LogoutManager
+ * @see https://dataclient.io/docs/api/LogoutManager
  */
-export default class LogoutManager implements Manager<CombinedActionTypes> {
+export default class LogoutManager implements Manager {
     protected middleware: Middleware;
     constructor({ handleLogout, shouldLogout }?: Props);
     cleanup(): void;
@@ -14,7 +13,7 @@ export default class LogoutManager implements Manager<CombinedActionTypes> {
     protected shouldLogout(error: UnknownError): boolean;
     handleLogout(controller: Controller<Dispatch>): void;
 }
-type Dispatch = (value: CombinedActionTypes) => Promise<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;
 interface Props {

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

@@ -1,5 +1,5 @@
 import Controller from '../controller/Controller.js';
-import { FetchAction, ReceiveAction, Manager, ActionTypes, Middleware, State } from '../types.js';
+import { FetchAction, Manager, ActionTypes, Middleware, SetAction } from '../types.js';
 export declare class ResetError extends Error {
     name: string;
     constructor();
@@ -11,7 +11,7 @@ export declare class ResetError extends Error {
  *
  * Interfaces with store via a redux-compatible middleware.
  *
- * @see https://resthooks.io/docs/api/NetworkManager
+ * @see https://dataclient.io/docs/api/NetworkManager
  */
 export default class NetworkManager implements Manager {
     protected fetched: {
@@ -29,7 +29,6 @@ export default class NetworkManager implements Manager {
     readonly dataExpiryLength: number;
     readonly errorExpiryLength: number;
     protected middleware: Middleware;
-    protected getState: () => State<unknown>;
     protected controller: Controller;
     cleanupDate?: number;
     constructor(dataExpiryLength?: number, errorExpiryLength?: number);
@@ -53,12 +52,12 @@ export default class NetworkManager implements Manager {
      * Uses throttle only when instructed by action meta. This is valuable
      * for ensures mutation requests always go through.
      */
-    protected handleFetch(action: FetchAction, dispatch: (action: any) => Promise<void>, controller: Controller): Promise<any>;
+    protected handleFetch(action: FetchAction): Promise<any>;
     /** Called when middleware intercepts a receive action.
      *
      * Will resolve the promise associated with receive key.
      */
-    protected handleReceive(action: ReceiveAction): void;
+    protected handleReceive(action: SetAction): void;
     /** Attaches NetworkManager to store
      *
      * Intercepts 'rest-hooks/fetch' actions to start requests.

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

@@ -1,27 +1,27 @@
-import { Schema } from '@data-client/normalizr';
+import { EndpointInterface } from '@data-client/normalizr';
 import ConnectionListener from './ConnectionListener.js';
-import { Subscription, SubscriptionInit } from './SubscriptionManager.js';
-import { State, Dispatch } from '../types.js';
+import { Subscription } from './SubscriptionManager.js';
+import Controller from '../controller/Controller.js';
+import { SubscribeAction } from '../types.js';
 /**
  * PollingSubscription keeps a given resource updated by
  * dispatching a fetch at a rate equal to the minimum update
  * interval requested.
  *
- * @see https://resthooks.io/docs/api/PollingSubscription
+ * @see https://dataclient.io/docs/api/PollingSubscription
  */
 export default class PollingSubscription implements Subscription {
-    protected readonly schema: Schema | undefined;
-    protected readonly fetch: () => Promise<any>;
+    protected readonly endpoint: EndpointInterface;
+    protected readonly args: readonly any[];
     protected readonly key: string;
     protected frequency: number;
     protected frequencyHistogram: Map<number, number>;
-    protected dispatch: Dispatch<any>;
-    protected getState: () => State<unknown>;
+    protected controller: Controller;
     protected intervalId?: ReturnType<typeof setInterval>;
     protected lastIntervalId?: ReturnType<typeof setInterval>;
     protected startId?: ReturnType<typeof setTimeout>;
     private connectionListener;
-    constructor({ key, schema, fetch, frequency, getState }: SubscriptionInit, dispatch: Dispatch<any>, connectionListener?: ConnectionListener);
+    constructor(action: Pick<SubscribeAction, Exclude<keyof SubscribeAction, 'type'>>, controller: Controller, connectionListener?: ConnectionListener);
     /** Subscribe to a frequency */
     add(frequency?: number): void;
     /** Unsubscribe from a frequency */

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

@@ -1,13 +1,6 @@
-import { Schema } from '@data-client/normalizr';
-import { Manager, State, Middleware, Dispatch, UnsubscribeAction, SubscribeAction } from '../types.js';
-/** Properties sent to Subscription constructor */
-export interface SubscriptionInit {
-    schema?: Schema | undefined;
-    fetch: () => Promise<any>;
-    key: string;
-    getState: () => State<unknown>;
-    frequency?: number | undefined;
-}
+import Controller from '../controller/Controller.js';
+import { Manager, Middleware, UnsubscribeAction, SubscribeAction } from '../types.js';
+type Actions = UnsubscribeAction | SubscribeAction;
 /** Interface handling a single resource subscription */
 export interface Subscription {
     add(frequency?: number): void;
@@ -16,32 +9,33 @@ export interface Subscription {
 }
 /** The static class that constructs Subscription */
 export interface SubscriptionConstructable {
-    new (init: SubscriptionInit, dispatch: Dispatch<any>): Subscription;
+    new (action: Pick<SubscribeAction, Exclude<keyof SubscribeAction, 'type'>>, controller: Controller): Subscription;
 }
 /** Handles subscription actions -> fetch or receive actions
  *
  * Constructor takes a SubscriptionConstructable class to control how
  * subscriptions are handled. (e.g., polling, websockets)
  *
- * @see https://resthooks.io/docs/api/SubscriptionManager
+ * @see https://dataclient.io/docs/api/SubscriptionManager
  */
-export default class SubscriptionManager<S extends SubscriptionConstructable> implements Manager {
+export default class SubscriptionManager<S extends SubscriptionConstructable> implements Manager<Actions> {
     protected subscriptions: {
         [key: string]: InstanceType<S>;
     };
     protected readonly Subscription: S;
     protected middleware: Middleware;
+    protected controller: Controller;
     constructor(Subscription: S);
     /** Ensures all subscriptions are cleaned up. */
     cleanup(): void;
     /** Called when middleware intercepts 'rest-hooks/subscribe' action.
      *
      */
-    protected handleSubscribe(action: SubscribeAction, dispatch: (action: any) => Promise<void>, getState: () => State<unknown>): void;
+    protected handleSubscribe(action: SubscribeAction): void;
     /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.
      *
      */
-    protected handleUnsubscribe(action: UnsubscribeAction, dispatch: (action: any) => Promise<void>): void;
+    protected handleUnsubscribe(action: UnsubscribeAction): void;
     /** Attaches Manager to store
      *
      * Intercepts 'rest-hooks/subscribe'/'rest-hooks/unsubscribe' to register resources that
@@ -52,4 +46,5 @@ export default class SubscriptionManager<S extends SubscriptionConstructable> im
      */
     getMiddleware(): Middleware;
 }
+export {};
 //# sourceMappingURL=SubscriptionManager.d.ts.map

package/ts3.4/middlewareTypes.d.ts

@@ -1,11 +1,11 @@
 import Controller from './controller/Controller.js';
-import { ActionTypes } from './newActions.js';
-import { ActionTypes as LegacyActionTypes, CombinedActionTypes, State } from './types.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<CombinedActionTypes>> {
-    controller: Controller<RHDispatch<CombinedActionTypes>>;
+export interface MiddlewareAPI<R extends RestHooksReducer = RestHooksReducer> extends Controller<RHDispatch<ActionTypes>> {
+    /** @deprecated use members directly instead */
+    controller: Controller<RHDispatch<ActionTypes>>;
 }
-export interface MiddlewareController<Actions = LegacyActionTypes> extends Controller<RHDispatch<Actions>> {
+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'];