@data-client/core 0.1.0

package/lib/manager/PollingSubscription.d.ts

@@ -0,0 +1,45 @@
+import type { Schema } from '@data-client/normalizr';
+import ConnectionListener from './ConnectionListener.js';
+import { Subscription, SubscriptionInit } from './SubscriptionManager.js';
+import type { State, Dispatch } 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
+ */
+export default class PollingSubscription implements Subscription {
+    protected readonly schema: Schema | undefined;
+    protected readonly fetch: () => Promise<any>;
+    protected readonly key: string;
+    protected frequency: number;
+    protected frequencyHistogram: Map<number, number>;
+    protected dispatch: Dispatch<any>;
+    protected getState: () => State<unknown>;
+    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);
+    /** Subscribe to a frequency */
+    add(frequency?: number): void;
+    /** Unsubscribe from a frequency */
+    remove(frequency?: number): boolean;
+    /** Cleanup means clearing out background interval. */
+    cleanup(): void;
+    /** Trigger request for latest resource */
+    protected update(): void;
+    /** What happens when browser goes offline */
+    protected offlineListener: () => void;
+    /** What happens when browser comes online */
+    protected onlineListener: () => void;
+    /** Run polling process with current frequency
+     *
+     * Will clean up old poll interval on next run
+     */
+    protected run(): void;
+    /** Last fetch time */
+    protected lastFetchTime(): number;
+}
+//# sourceMappingURL=PollingSubscription.d.ts.map

package/lib/manager/PollingSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PollingSubscription.d.ts","sourceRoot":"","sources":["../../src/manager/PollingSubscription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAExE,OAAO,kBAAkB,MAAM,yBAAyB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE1E,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,YAAY;IAC9D,mBAA2B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACtD,mBAA2B,KAAK,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IACrD,mBAA2B,GAAG,EAAE,MAAM,CAAC;IACvC,UAAkB,SAAS,EAAE,MAAM,CAAC;IACpC,SAAS,CAAC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAa;IAC9D,UAAkB,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC1C,UAAkB,QAAQ,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;IACjD,UAAkB,UAAU,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IAC9D,UAAkB,cAAc,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IAClE,UAAkB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;IAC1D,QAAgB,kBAAkB,CAAqB;gBAGrD,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,gBAAgB,EAC7D,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,EACvB,kBAAkB,CAAC,EAAE,kBAAkB;IAsBzC,+BAA+B;IAC/B,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM;IAkBtB,mCAAmC;IACnC,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM;IAgCzB,sDAAsD;IACtD,OAAO;IAiBP,0CAA0C;IAC1C,SAAS,CAAC,MAAM;IAahB,6CAA6C;IAC7C,SAAS,CAAC,eAAe,aAIvB;IAEF,6CAA6C;IAC7C,SAAS,CAAC,cAAc,aAetB;IAEF;;;OAGG;IACH,SAAS,CAAC,GAAG;IAmBb,sBAAsB;IACtB,SAAS,CAAC,aAAa;CAGxB"}

package/lib/manager/PollingSubscription.js

@@ -0,0 +1,159 @@
+import DefaultConnectionListener from './DefaultConnectionListener.js';
+import createFetch from '../controller/createFetch.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
+ */
+export default class PollingSubscription {
+  constructor({
+    key,
+    schema,
+    fetch,
+    frequency,
+    getState
+  }, dispatch, connectionListener) {
+    this.frequencyHistogram = new Map();
+    /** What happens when browser goes offline */
+    this.offlineListener = () => {
+      // this clears existing listeners, so no need to clear offline listener
+      this.cleanup();
+      this.connectionListener.addOnlineListener(this.onlineListener);
+    };
+    /** What happens when browser comes online */
+    this.onlineListener = () => {
+      this.connectionListener.removeOnlineListener(this.onlineListener);
+      const now = Date.now();
+      this.startId = setTimeout(() => {
+        if (this.startId) {
+          delete this.startId;
+          this.update();
+          this.run();
+        } else if (process.env.NODE_ENV !== 'production') {
+          console.warn(`Poll setTimeout for ${this.key} still running, but timeoutId deleted`);
+        }
+      }, Math.max(0, this.lastFetchTime() - now + this.frequency));
+      this.connectionListener.addOfflineListener(this.offlineListener);
+    };
+    if (frequency === undefined) throw new Error('frequency needed for polling subscription');
+    this.schema = schema;
+    this.fetch = fetch;
+    this.frequency = frequency;
+    this.key = key;
+    this.frequencyHistogram.set(this.frequency, 1);
+    this.dispatch = dispatch;
+    this.getState = getState;
+    this.connectionListener = connectionListener || new DefaultConnectionListener();
+
+    // Kickstart running since this is initialized after the online notif is sent
+    if (this.connectionListener.isOnline()) {
+      this.onlineListener();
+    } else {
+      this.offlineListener();
+    }
+  }
+
+  /** Subscribe to a frequency */
+  add(frequency) {
+    if (frequency === undefined) return;
+    if (this.frequencyHistogram.has(frequency)) {
+      this.frequencyHistogram.set(frequency, this.frequencyHistogram.get(frequency) + 1);
+    } else {
+      this.frequencyHistogram.set(frequency, 1);
+
+      // new min so restart service
+      if (frequency < this.frequency) {
+        this.frequency = frequency;
+        this.run();
+      }
+    }
+  }
+
+  /** Unsubscribe from a frequency */
+  remove(frequency) {
+    if (frequency === undefined) return false;
+    if (this.frequencyHistogram.has(frequency)) {
+      this.frequencyHistogram.set(frequency, this.frequencyHistogram.get(frequency) - 1);
+      if (this.frequencyHistogram.get(frequency) < 1) {
+        this.frequencyHistogram.delete(frequency);
+
+        // nothing subscribed to this anymore...it is invalid
+        if (this.frequencyHistogram.size === 0) {
+          this.cleanup();
+          return true;
+        }
+
+        // this was the min, so find the next size
+        if (frequency <= this.frequency) {
+          this.frequency = Math.min(...this.frequencyHistogram.keys());
+          this.run();
+        }
+      }
+    } /* istanbul ignore next */else if (process.env.NODE_ENV !== 'production') {
+      console.error(`Mismatched remove: ${frequency} is not subscribed for ${this.key}`);
+    }
+    return false;
+  }
+
+  /** Cleanup means clearing out background interval. */
+  cleanup() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      delete this.intervalId;
+    }
+    if (this.lastIntervalId) {
+      clearInterval(this.lastIntervalId);
+      delete this.lastIntervalId;
+    }
+    if (this.startId) {
+      clearTimeout(this.startId);
+      delete this.startId;
+    }
+    this.connectionListener.removeOnlineListener(this.onlineListener);
+    this.connectionListener.removeOfflineListener(this.offlineListener);
+  }
+
+  /** Trigger request for latest resource */
+  update() {
+    const endpoint = () => this.fetch();
+    endpoint.schema = this.schema;
+    endpoint.key = () => this.key;
+    endpoint.dataExpiryLength = this.frequency / 2;
+    endpoint.errorExpiryLength = this.frequency / 10;
+    endpoint.errorPolicy = () => 'soft';
+    const action = createFetch(endpoint, {
+      args: []
+    });
+    // stop any errors here from bubbling
+    action.meta.promise.catch(e => null);
+    this.dispatch(action);
+  }
+  /** Run polling process with current frequency
+   *
+   * Will clean up old poll interval on next run
+   */
+  run() {
+    if (this.startId) return;
+    if (this.intervalId) this.lastIntervalId = this.intervalId;
+    this.intervalId = setInterval(() => {
+      // since we don't know how long into the last poll it was before resetting
+      // we wait til the next fetch to clear old intervals
+      if (this.lastIntervalId) {
+        clearInterval(this.lastIntervalId);
+        delete this.lastIntervalId;
+      }
+      if (this.intervalId) this.update();else if (process.env.NODE_ENV !== 'production') {
+        console.warn(`Poll intervalId for ${this.key} still running, but intervalId deleted`);
+      }
+    }, this.frequency);
+  }
+
+  /** Last fetch time */
+  lastFetchTime() {
+    var _this$getState$meta$t, _this$getState$meta$t2;
+    return (_this$getState$meta$t = (_this$getState$meta$t2 = this.getState().meta[this.key]) == null ? void 0 : _this$getState$meta$t2.date) != null ? _this$getState$meta$t : 0;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DefaultConnectionListener","createFetch","PollingSubscription","constructor","key","schema","fetch","frequency","getState","dispatch","connectionListener","frequencyHistogram","Map","offlineListener","cleanup","addOnlineListener","onlineListener","removeOnlineListener","now","Date","startId","setTimeout","update","run","process","env","NODE_ENV","console","warn","Math","max","lastFetchTime","addOfflineListener","undefined","Error","set","isOnline","add","has","get","remove","delete","size","min","keys","error","intervalId","clearInterval","lastIntervalId","clearTimeout","removeOfflineListener","endpoint","dataExpiryLength","errorExpiryLength","errorPolicy","action","args","meta","promise","catch","e","setInterval","_this$getState$meta$t","_this$getState$meta$t2","date"],"sources":["../../src/manager/PollingSubscription.ts"],"sourcesContent":["import type { EndpointInterface, Schema } from '@data-client/normalizr';\n\nimport ConnectionListener from './ConnectionListener.js';\nimport DefaultConnectionListener from './DefaultConnectionListener.js';\nimport { Subscription, SubscriptionInit } from './SubscriptionManager.js';\nimport createFetch from '../controller/createFetch.js';\nimport type { State, Dispatch } from '../types.js';\n\n/**\n * PollingSubscription keeps a given resource updated by\n * dispatching a fetch at a rate equal to the minimum update\n * interval requested.\n *\n * @see https://resthooks.io/docs/api/PollingSubscription\n */\nexport default class PollingSubscription implements Subscription {\n  protected declare readonly schema: Schema | undefined;\n  protected declare readonly fetch: () => Promise<any>;\n  protected declare readonly key: string;\n  protected declare frequency: number;\n  protected frequencyHistogram: Map<number, number> = new Map();\n  protected declare dispatch: Dispatch<any>;\n  protected declare getState: () => State<unknown>;\n  protected declare intervalId?: ReturnType<typeof setInterval>;\n  protected declare lastIntervalId?: ReturnType<typeof setInterval>;\n  protected declare startId?: ReturnType<typeof setTimeout>;\n  private declare connectionListener: ConnectionListener;\n\n  constructor(\n    { key, schema, fetch, frequency, getState }: SubscriptionInit,\n    dispatch: Dispatch<any>,\n    connectionListener?: ConnectionListener,\n  ) {\n    if (frequency === undefined)\n      throw new Error('frequency needed for polling subscription');\n    this.schema = schema;\n    this.fetch = fetch;\n    this.frequency = frequency;\n    this.key = key;\n    this.frequencyHistogram.set(this.frequency, 1);\n    this.dispatch = dispatch;\n    this.getState = getState;\n    this.connectionListener =\n      connectionListener || new DefaultConnectionListener();\n\n    // Kickstart running since this is initialized after the online notif is sent\n    if (this.connectionListener.isOnline()) {\n      this.onlineListener();\n    } else {\n      this.offlineListener();\n    }\n  }\n\n  /** Subscribe to a frequency */\n  add(frequency?: number) {\n    if (frequency === undefined) return;\n    if (this.frequencyHistogram.has(frequency)) {\n      this.frequencyHistogram.set(\n        frequency,\n        (this.frequencyHistogram.get(frequency) as number) + 1,\n      );\n    } else {\n      this.frequencyHistogram.set(frequency, 1);\n\n      // new min so restart service\n      if (frequency < this.frequency) {\n        this.frequency = frequency;\n        this.run();\n      }\n    }\n  }\n\n  /** Unsubscribe from a frequency */\n  remove(frequency?: number) {\n    if (frequency === undefined) return false;\n    if (this.frequencyHistogram.has(frequency)) {\n      this.frequencyHistogram.set(\n        frequency,\n        (this.frequencyHistogram.get(frequency) as number) - 1,\n      );\n      if ((this.frequencyHistogram.get(frequency) as number) < 1) {\n        this.frequencyHistogram.delete(frequency);\n\n        // nothing subscribed to this anymore...it is invalid\n        if (this.frequencyHistogram.size === 0) {\n          this.cleanup();\n          return true;\n        }\n\n        // this was the min, so find the next size\n        if (frequency <= this.frequency) {\n          this.frequency = Math.min(...this.frequencyHistogram.keys());\n          this.run();\n        }\n      }\n    } /* istanbul ignore next */ else if (\n      process.env.NODE_ENV !== 'production'\n    ) {\n      console.error(\n        `Mismatched remove: ${frequency} is not subscribed for ${this.key}`,\n      );\n    }\n    return false;\n  }\n\n  /** Cleanup means clearing out background interval. */\n  cleanup() {\n    if (this.intervalId) {\n      clearInterval(this.intervalId);\n      delete this.intervalId;\n    }\n    if (this.lastIntervalId) {\n      clearInterval(this.lastIntervalId);\n      delete this.lastIntervalId;\n    }\n    if (this.startId) {\n      clearTimeout(this.startId);\n      delete this.startId;\n    }\n    this.connectionListener.removeOnlineListener(this.onlineListener);\n    this.connectionListener.removeOfflineListener(this.offlineListener);\n  }\n\n  /** Trigger request for latest resource */\n  protected update() {\n    const endpoint: EndpointInterface = () => this.fetch();\n    (endpoint as any).schema = this.schema;\n    endpoint.key = () => this.key;\n    (endpoint as any).dataExpiryLength = this.frequency / 2;\n    (endpoint as any).errorExpiryLength = this.frequency / 10;\n    endpoint.errorPolicy = () => 'soft' as const;\n    const action = createFetch(endpoint, { args: [] });\n    // stop any errors here from bubbling\n    (action.meta.promise as Promise<any>).catch(e => null);\n    this.dispatch(action);\n  }\n\n  /** What happens when browser goes offline */\n  protected offlineListener = () => {\n    // this clears existing listeners, so no need to clear offline listener\n    this.cleanup();\n    this.connectionListener.addOnlineListener(this.onlineListener);\n  };\n\n  /** What happens when browser comes online */\n  protected onlineListener = () => {\n    this.connectionListener.removeOnlineListener(this.onlineListener);\n    const now = Date.now();\n    this.startId = setTimeout(() => {\n      if (this.startId) {\n        delete this.startId;\n        this.update();\n        this.run();\n      } else if (process.env.NODE_ENV !== 'production') {\n        console.warn(\n          `Poll setTimeout for ${this.key} still running, but timeoutId deleted`,\n        );\n      }\n    }, Math.max(0, this.lastFetchTime() - now + this.frequency));\n    this.connectionListener.addOfflineListener(this.offlineListener);\n  };\n\n  /** Run polling process with current frequency\n   *\n   * Will clean up old poll interval on next run\n   */\n  protected run() {\n    if (this.startId) return;\n    if (this.intervalId) this.lastIntervalId = this.intervalId;\n    this.intervalId = setInterval(() => {\n      // since we don't know how long into the last poll it was before resetting\n      // we wait til the next fetch to clear old intervals\n      if (this.lastIntervalId) {\n        clearInterval(this.lastIntervalId);\n        delete this.lastIntervalId;\n      }\n      if (this.intervalId) this.update();\n      else if (process.env.NODE_ENV !== 'production') {\n        console.warn(\n          `Poll intervalId for ${this.key} still running, but intervalId deleted`,\n        );\n      }\n    }, this.frequency);\n  }\n\n  /** Last fetch time */\n  protected lastFetchTime() {\n    return this.getState().meta[this.key]?.date ?? 0;\n  }\n}\n"],"mappings":"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"}

package/lib/manager/SubscriptionManager.d.ts

@@ -0,0 +1,55 @@
+import type { Schema } from '@data-client/normalizr';
+import type { 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;
+}
+/** Interface handling a single resource subscription */
+export interface Subscription {
+    add(frequency?: number): void;
+    remove(frequency?: number): boolean;
+    cleanup(): void;
+}
+/** The static class that constructs Subscription */
+export interface SubscriptionConstructable {
+    new (init: SubscriptionInit, dispatch: Dispatch<any>): 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
+ */
+export default class SubscriptionManager<S extends SubscriptionConstructable> implements Manager {
+    protected subscriptions: {
+        [key: string]: InstanceType<S>;
+    };
+    protected readonly Subscription: S;
+    protected middleware: Middleware;
+    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;
+    /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.
+     *
+     */
+    protected handleUnsubscribe(action: UnsubscribeAction, dispatch: (action: any) => Promise<void>): void;
+    /** Attaches Manager to store
+     *
+     * Intercepts 'rest-hooks/subscribe'/'rest-hooks/unsubscribe' 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
+     *
+     */
+    getMiddleware(): Middleware;
+}
+//# sourceMappingURL=SubscriptionManager.d.ts.map

package/lib/manager/SubscriptionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubscriptionManager.d.ts","sourceRoot":"","sources":["../../src/manager/SubscriptionManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGrD,OAAO,KAAK,EACV,OAAO,EACP,KAAK,EAEL,UAAU,EACV,QAAQ,EACR,iBAAiB,EACjB,eAAe,EAChB,MAAM,aAAa,CAAC;AAIrB,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,wDAAwD;AACxD,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,oDAAoD;AACpD,MAAM,WAAW,yBAAyB;IACxC,KAAK,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC;CACrE;AAED;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB,CAAC,CAAC,SAAS,yBAAyB,CAC1E,YAAW,OAAO;IAElB,SAAS,CAAC,aAAa,EAAE;QACvB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;KAChC,CAAM;IAEP,mBAA2B,YAAY,EAAE,CAAC,CAAC;IAC3C,UAAkB,UAAU,EAAE,UAAU,CAAC;gBAE7B,YAAY,EAAE,CAAC;IAwB3B,gDAAgD;IAChD,OAAO;IAMP;;OAEG;IACH,SAAS,CAAC,eAAe,CACvB,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EACxC,QAAQ,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC;IAiChC;;OAEG;IACH,SAAS,CAAC,iBAAiB,CACzB,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC;IAgB1C;;;;;;;OAOG;IACH,aAAa;CAGd"}

package/lib/manager/SubscriptionManager.js

@@ -0,0 +1,117 @@
+import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../actionTypes.js';
+
+/** Properties sent to Subscription constructor */
+
+/** Interface handling a single resource subscription */
+
+/** The static class that constructs 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
+ */
+export default class SubscriptionManager {
+  constructor(Subscription) {
+    this.subscriptions = {};
+    this.Subscription = Subscription;
+    this.middleware = ({
+      dispatch,
+      getState
+    }) => {
+      return next => action => {
+        switch (action.type) {
+          case SUBSCRIBE_TYPE:
+            try {
+              this.handleSubscribe(action, dispatch, getState);
+            } catch (e) {
+              console.error(e);
+            }
+            return Promise.resolve();
+          case UNSUBSCRIBE_TYPE:
+            this.handleUnsubscribe(action, dispatch);
+            return Promise.resolve();
+          default:
+            return next(action);
+        }
+      };
+    };
+  }
+
+  /** Ensures all subscriptions are cleaned up. */
+  cleanup() {
+    for (const key in this.subscriptions) {
+      this.subscriptions[key].cleanup();
+    }
+  }
+
+  /** Called when middleware intercepts 'rest-hooks/subscribe' action.
+   *
+   */
+  handleSubscribe(action, dispatch, getState) {
+    let options;
+    if (action.endpoint) {
+      const {
+        endpoint
+      } = action;
+      const {
+        args
+      } = action.meta;
+      options = {
+        schema: endpoint.schema,
+        fetch: () => endpoint(...args),
+        frequency: endpoint.pollFrequency,
+        key: endpoint.key(...args),
+        getState
+      };
+    } else {
+      var _action$meta$options;
+      options = {
+        key: action.meta.key,
+        frequency: (_action$meta$options = action.meta.options) == null ? void 0 : _action$meta$options.pollFrequency,
+        schema: action.meta.schema,
+        fetch: action.meta.fetch,
+        getState
+      };
+    }
+    if (options.key in this.subscriptions) {
+      this.subscriptions[options.key].add(options.frequency);
+    } else {
+      this.subscriptions[options.key] = new this.Subscription(options, dispatch);
+    }
+  }
+
+  /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.
+   *
+   */
+  handleUnsubscribe(action, dispatch) {
+    var _action$meta$options2;
+    const key = action.meta.key;
+    const frequency = (_action$meta$options2 = action.meta.options) == null ? void 0 : _action$meta$options2.pollFrequency;
+
+    /* istanbul ignore else */
+    if (key in this.subscriptions) {
+      const empty = this.subscriptions[key].remove(frequency);
+      if (empty) {
+        delete this.subscriptions[key];
+      }
+    } else if (process.env.NODE_ENV !== 'production') {
+      console.error(`Mismatched unsubscribe: ${key} is not subscribed`);
+    }
+  }
+
+  /** Attaches Manager to store
+   *
+   * Intercepts 'rest-hooks/subscribe'/'rest-hooks/unsubscribe' 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
+   *
+   */
+  getMiddleware() {
+    return this.middleware;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SUBSCRIBE_TYPE","UNSUBSCRIBE_TYPE","SubscriptionManager","constructor","Subscription","subscriptions","middleware","dispatch","getState","next","action","type","handleSubscribe","e","console","error","Promise","resolve","handleUnsubscribe","cleanup","key","options","endpoint","args","meta","schema","fetch","frequency","pollFrequency","_action$meta$options","add","_action$meta$options2","empty","remove","process","env","NODE_ENV","getMiddleware"],"sources":["../../src/manager/SubscriptionManager.ts"],"sourcesContent":["import type { Schema } from '@data-client/normalizr';\n\nimport { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../actionTypes.js';\nimport type {\n  Manager,\n  State,\n  MiddlewareAPI,\n  Middleware,\n  Dispatch,\n  UnsubscribeAction,\n  SubscribeAction,\n} from '../types.js';\n\ntype Actions = UnsubscribeAction | SubscribeAction;\n\n/** Properties sent to Subscription constructor */\nexport interface SubscriptionInit {\n  schema?: Schema | undefined;\n  fetch: () => Promise<any>;\n  key: string;\n  getState: () => State<unknown>;\n  frequency?: number | undefined;\n}\n\n/** Interface handling a single resource subscription */\nexport interface Subscription {\n  add(frequency?: number): void;\n  remove(frequency?: number): boolean;\n  cleanup(): void;\n}\n\n/** The static class that constructs Subscription */\nexport interface SubscriptionConstructable {\n  new (init: SubscriptionInit, dispatch: Dispatch<any>): Subscription;\n}\n\n/** Handles subscription actions -> fetch or receive actions\n *\n * Constructor takes a SubscriptionConstructable class to control how\n * subscriptions are handled. (e.g., polling, websockets)\n *\n * @see https://resthooks.io/docs/api/SubscriptionManager\n */\nexport default class SubscriptionManager<S extends SubscriptionConstructable>\n  implements Manager\n{\n  protected subscriptions: {\n    [key: string]: InstanceType<S>;\n  } = {};\n\n  protected declare readonly Subscription: S;\n  protected declare middleware: Middleware;\n\n  constructor(Subscription: S) {\n    this.Subscription = Subscription;\n\n    this.middleware = <C extends MiddlewareAPI>({ dispatch, getState }: C) => {\n      return (next: C['dispatch']): C['dispatch'] =>\n        action => {\n          switch (action.type) {\n            case SUBSCRIBE_TYPE:\n              try {\n                this.handleSubscribe(action, dispatch, getState);\n              } catch (e) {\n                console.error(e);\n              }\n              return Promise.resolve();\n            case UNSUBSCRIBE_TYPE:\n              this.handleUnsubscribe(action, dispatch);\n              return Promise.resolve();\n            default:\n              return next(action);\n          }\n        };\n    };\n  }\n\n  /** Ensures all subscriptions are cleaned up. */\n  cleanup() {\n    for (const key in this.subscriptions) {\n      this.subscriptions[key].cleanup();\n    }\n  }\n\n  /** Called when middleware intercepts 'rest-hooks/subscribe' action.\n   *\n   */\n  protected handleSubscribe(\n    action: SubscribeAction,\n    dispatch: (action: any) => Promise<void>,\n    getState: () => State<unknown>,\n  ) {\n    let options: SubscriptionInit;\n    if (action.endpoint) {\n      const { endpoint } = action;\n      const { args } = action.meta;\n      options = {\n        schema: endpoint.schema,\n        fetch: () => endpoint(...args),\n        frequency: endpoint.pollFrequency,\n        key: endpoint.key(...args),\n        getState,\n      };\n    } else {\n      options = {\n        key: action.meta.key,\n        frequency: action.meta.options?.pollFrequency,\n        schema: action.meta.schema,\n        fetch: action.meta.fetch,\n        getState,\n      };\n    }\n\n    if (options.key in this.subscriptions) {\n      this.subscriptions[options.key].add(options.frequency);\n    } else {\n      this.subscriptions[options.key] = new this.Subscription(\n        options,\n        dispatch,\n      ) as InstanceType<S>;\n    }\n  }\n\n  /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.\n   *\n   */\n  protected handleUnsubscribe(\n    action: UnsubscribeAction,\n    dispatch: (action: any) => Promise<void>,\n  ) {\n    const key = action.meta.key;\n    const frequency = action.meta.options?.pollFrequency;\n\n    /* istanbul ignore else */\n    if (key in this.subscriptions) {\n      const empty = this.subscriptions[key].remove(frequency);\n      if (empty) {\n        delete this.subscriptions[key];\n      }\n    } else if (process.env.NODE_ENV !== 'production') {\n      console.error(`Mismatched unsubscribe: ${key} is not subscribed`);\n    }\n  }\n\n  /** Attaches Manager to store\n   *\n   * Intercepts 'rest-hooks/subscribe'/'rest-hooks/unsubscribe' to register resources that\n   * need to be kept up to date.\n   *\n   * Will possibly dispatch 'rest-hooks/fetch' or 'rest-hooks/receive' to keep resources fresh\n   *\n   */\n  getMiddleware() {\n    return this.middleware;\n  }\n}\n"],"mappings":"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"}

package/lib/manager/applyManager.d.ts

@@ -0,0 +1,10 @@
+import type Controller from '../controller/Controller.js';
+import type { 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>> {
+    getState: () => ReducerState<R>;
+    dispatch: Dispatch<R>;
+}
+export type Middleware = <R extends Reducer<any, any>>({ dispatch, }: MiddlewareAPI<R>) => (next: Dispatch<R>) => Dispatch<R>;
+//# sourceMappingURL=applyManager.d.ts.map

package/lib/manager/applyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyManager.d.ts","sourceRoot":"","sources":["../../src/manager/applyManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,6BAA6B,CAAC;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,EAAE,UAAU,GACrB,UAAU,EAAE,CAcd;AAGD,MAAM,WAAW,aAAa,CAC5B,CAAC,SAAS,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;IAE/C,QAAQ,EAAE,MAAM,YAAY,CAAC,CAAC,CAAC,CAAC;IAChC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;CACvB;AACD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,SAAS,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EACrD,QAAQ,GACT,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC"}

package/lib/manager/applyManager.js

@@ -0,0 +1,23 @@
+export default function applyManager(managers, controller) {
+  return managers.map(manager => {
+    const middleware = manager.getMiddleware();
+    return ({
+      dispatch,
+      getState
+    }) => {
+      controller.dispatch = dispatch;
+      controller.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);
+    };
+  });
+}
+
+/* These should be compatible with redux */
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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