@data-client/core 0.1.0

package/legacy/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/legacy/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/legacy/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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

package/legacy/manager/devtoolsTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":[],"sources":["../../src/manager/devtoolsTypes.ts"],"sourcesContent":["type Action = any;\ntype ActionCreator<T> = any;\n\n// taken from https://github.com/reduxjs/redux-devtools/blob/main/packages/redux-devtools-extension/src/index.ts\n\nexport interface EnhancerOptions {\n  /**\n   * the instance name to be showed on the monitor page. Default value is `document.title`.\n   * If not specified and there's no document title, it will consist of `tabId` and `instanceId`.\n   */\n  name?: string;\n  /**\n   * action creators functions to be available in the Dispatcher.\n   */\n  actionCreators?: ActionCreator<any>[] | { [key: string]: ActionCreator<any> };\n  /**\n   * if more than one action is dispatched in the indicated interval, all new actions will be collected and sent at once.\n   * It is the joint between performance and speed. When set to `0`, all actions will be sent instantly.\n   * Set it to a higher value when experiencing perf issues (also `maxAge` to a lower value).\n   *\n   * @default 500 ms.\n   */\n  latency?: number;\n  /**\n   * (> 1) - maximum allowed actions to be stored in the history tree. The oldest actions are removed once maxAge is reached. It's critical for performance.\n   *\n   * @default 50\n   */\n  maxAge?: number;\n  /**\n   * Customizes how actions and state are serialized and deserialized. Can be a boolean or object. If given a boolean, the behavior is the same as if you\n   * were to pass an object and specify `options` as a boolean. Giving an object allows fine-grained customization using the `replacer` and `reviver`\n   * functions.\n   */\n  serialize?:\n    | boolean\n    | {\n        /**\n         * - `undefined` - will use regular `JSON.stringify` to send data (it's the fast mode).\n         * - `false` - will handle also circular references.\n         * - `true` - will handle also date, regex, undefined, error objects, symbols, maps, sets and functions.\n         * - object, which contains `date`, `regex`, `undefined`, `error`, `symbol`, `map`, `set` and `function` keys.\n         *   For each of them you can indicate if to include (by setting as `true`).\n         *   For `function` key you can also specify a custom function which handles serialization.\n         *   See [`jsan`](https://github.com/kolodny/jsan) for more details.\n         */\n        options?:\n          | undefined\n          | boolean\n          | {\n              date?: true;\n              regex?: true;\n              undefined?: true;\n              error?: true;\n              symbol?: true;\n              map?: true;\n              set?: true;\n              function?: true | ((fn: (...args: any[]) => any) => string);\n            };\n        /**\n         * [JSON replacer function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter) used for both actions and states stringify.\n         * In addition, you can specify a data type by adding a [`__serializedType__`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/helpers/index.js#L4)\n         * key. So you can deserialize it back while importing or persisting data.\n         * Moreover, it will also [show a nice preview showing the provided custom type](https://cloud.githubusercontent.com/assets/7957859/21814330/a17d556a-d761-11e6-85ef-159dd12f36c5.png):\n         */\n        replacer?: (key: string, value: unknown) => any;\n        /**\n         * [JSON `reviver` function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Using_the_reviver_parameter)\n         * used for parsing the imported actions and states. See [`remotedev-serialize`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/immutable/serialize.js#L8-L41)\n         * as an example on how to serialize special data types and get them back.\n         */\n        reviver?: (key: string, value: unknown) => any;\n      };\n  /**\n   * function which takes `action` object and id number as arguments, and should return `action` object back.\n   */\n  actionSanitizer?: <A extends Action>(action: A, id: number) => A;\n  /**\n   * function which takes `state` object and index as arguments, and should return `state` object back.\n   */\n  stateSanitizer?: <S>(state: S, index: number) => S;\n  /**\n   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).\n   * If `actionsWhitelist` specified, `actionsBlacklist` is ignored.\n   * @deprecated Use actionsDenylist instead.\n   */\n  actionsBlacklist?: string | string[];\n  /**\n   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).\n   * If `actionsWhitelist` specified, `actionsBlacklist` is ignored.\n   * @deprecated Use actionsAllowlist instead.\n   */\n  actionsWhitelist?: string | string[];\n  /**\n   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).\n   * If `actionsAllowlist` specified, `actionsDenylist` is ignored.\n   */\n  actionsDenylist?: string | string[];\n  /**\n   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).\n   * If `actionsAllowlist` specified, `actionsDenylist` is ignored.\n   */\n  actionsAllowlist?: string | string[];\n  /**\n   * called for every action before sending, takes `state` and `action` object, and returns `true` in case it allows sending the current data to the monitor.\n   * Use it as a more advanced version of `actionsDenylist`/`actionsAllowlist` parameters.\n   */\n  predicate?: <S, A extends Action>(state: S, action: A) => boolean;\n  /**\n   * if specified as `false`, it will not record the changes till clicking on `Start recording` button.\n   * Available only for Redux enhancer, for others use `autoPause`.\n   *\n   * @default true\n   */\n  shouldRecordChanges?: boolean;\n  /**\n   * if specified, whenever clicking on `Pause recording` button and there are actions in the history log, will add this action type.\n   * If not specified, will commit when paused. Available only for Redux enhancer.\n   *\n   * @default \"@@PAUSED\"\"\n   */\n  pauseActionType?: string;\n  /**\n   * auto pauses when the extension’s window is not opened, and so has zero impact on your app when not in use.\n   * Not available for Redux enhancer (as it already does it but storing the data to be sent).\n   *\n   * @default false\n   */\n  autoPause?: boolean;\n  /**\n   * if specified as `true`, it will not allow any non-monitor actions to be dispatched till clicking on `Unlock changes` button.\n   * Available only for Redux enhancer.\n   *\n   * @default false\n   */\n  shouldStartLocked?: boolean;\n  /**\n   * if set to `false`, will not recompute the states on hot reloading (or on replacing the reducers). Available only for Redux enhancer.\n   *\n   * @default true\n   */\n  shouldHotReload?: boolean;\n  /**\n   * if specified as `true`, whenever there's an exception in reducers, the monitors will show the error message, and next actions will not be dispatched.\n   *\n   * @default false\n   */\n  shouldCatchErrors?: boolean;\n  /**\n   * If you want to restrict the extension, specify the features you allow.\n   * If not specified, all of the features are enabled. When set as an object, only those included as `true` will be allowed.\n   * Note that except `true`/`false`, `import` and `export` can be set as `custom` (which is by default for Redux enhancer), meaning that the importing/exporting occurs on the client side.\n   * Otherwise, you'll get/set the data right from the monitor part.\n   */\n  features?: {\n    /**\n     * start/pause recording of dispatched actions\n     */\n    pause?: boolean;\n    /**\n     * lock/unlock dispatching actions and side effects\n     */\n    lock?: boolean;\n    /**\n     * persist states on page reloading\n     */\n    persist?: boolean;\n    /**\n     * export history of actions in a file\n     */\n    export?: boolean | 'custom';\n    /**\n     * import history of actions from a file\n     */\n    import?: boolean | 'custom';\n    /**\n     * jump back and forth (time travelling)\n     */\n    jump?: boolean;\n    /**\n     * skip (cancel) actions\n     */\n    skip?: boolean;\n    /**\n     * drag and drop actions in the history list\n     */\n    reorder?: boolean;\n    /**\n     * dispatch custom actions or action creators\n     */\n    dispatch?: boolean;\n    /**\n     * generate tests for the selected actions\n     */\n    test?: boolean;\n  };\n  /**\n   * Set to true or a stacktrace-returning function to record call stack traces for dispatched actions.\n   * Defaults to false.\n   */\n  trace?: boolean | (<A extends Action>(action: A) => string);\n  /**\n   * The maximum number of stack trace entries to record per action. Defaults to 10.\n   */\n  traceLimit?: number;\n}\n\nexport interface DevToolsConfig extends EnhancerOptions {\n  type?: string;\n}\n"],"mappings":""}

package/legacy/manager/index.js

@@ -0,0 +1,6 @@
+export { default as DefaultConnectionListener } from './DefaultConnectionListener.js';
+export { default as PollingSubscription } from './PollingSubscription.js';
+export { default as SubscriptionManager } from './SubscriptionManager.js';
+export { default as DevToolsManager } from './DevtoolsManager.js';
+export { default as LogoutManager } from './LogoutManager.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwiRGVmYXVsdENvbm5lY3Rpb25MaXN0ZW5lciIsIlBvbGxpbmdTdWJzY3JpcHRpb24iLCJTdWJzY3JpcHRpb25NYW5hZ2VyIiwiRGV2VG9vbHNNYW5hZ2VyIiwiTG9nb3V0TWFuYWdlciJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tYW5hZ2VyL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgZGVmYXVsdCBhcyBDb25uZWN0aW9uTGlzdGVuZXIgfSBmcm9tICcuL0Nvbm5lY3Rpb25MaXN0ZW5lci5qcyc7XG5leHBvcnQgeyBkZWZhdWx0IGFzIERlZmF1bHRDb25uZWN0aW9uTGlzdGVuZXIgfSBmcm9tICcuL0RlZmF1bHRDb25uZWN0aW9uTGlzdGVuZXIuanMnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBQb2xsaW5nU3Vic2NyaXB0aW9uIH0gZnJvbSAnLi9Qb2xsaW5nU3Vic2NyaXB0aW9uLmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgU3Vic2NyaXB0aW9uTWFuYWdlciB9IGZyb20gJy4vU3Vic2NyaXB0aW9uTWFuYWdlci5qcyc7XG5leHBvcnQgeyBkZWZhdWx0IGFzIERldlRvb2xzTWFuYWdlciB9IGZyb20gJy4vRGV2dG9vbHNNYW5hZ2VyLmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgTG9nb3V0TWFuYWdlciB9IGZyb20gJy4vTG9nb3V0TWFuYWdlci5qcyc7XG5leHBvcnQgdHlwZSB7IERldlRvb2xzQ29uZmlnIH0gZnJvbSAnLi9EZXZ0b29sc01hbmFnZXIuanMnO1xuIl0sIm1hcHBpbmdzIjoiQUFDQSxTQUFTQSxPQUFPLElBQUlDLHlCQUF5QixRQUFRLGdDQUFnQztBQUNyRixTQUFTRCxPQUFPLElBQUlFLG1CQUFtQixRQUFRLDBCQUEwQjtBQUN6RSxTQUFTRixPQUFPLElBQUlHLG1CQUFtQixRQUFRLDBCQUEwQjtBQUN6RSxTQUFTSCxPQUFPLElBQUlJLGVBQWUsUUFBUSxzQkFBc0I7QUFDakUsU0FBU0osT0FBTyxJQUFJSyxhQUFhLFFBQVEsb0JBQW9CIn0=

package/legacy/middlewareTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/newActions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/next/Controller.js

@@ -0,0 +1,24 @@
+import { denormalize } from '@data-client/normalizr';
+import BaseController from '../controller/BaseController.js';
+import createFetch from '../controller/createFetch.js';
+export default class Controller extends BaseController {
+  constructor(..._args) {
+    super(..._args);
+    /**
+     * 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
+     */
+    this.fetch = (endpoint, ...args) => {
+      const action = createFetch(endpoint, {
+        args
+      });
+      this.dispatch(action);
+      if (endpoint.schema) {
+        return action.meta.promise.then(input => denormalize(input, endpoint.schema, {}, args));
+      }
+      return action.meta.promise;
+    };
+  }
+}
+export * from '../controller/BaseController.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/next/index.js

@@ -0,0 +1,3 @@
+export { default as Controller } from './Controller.js';
+export * from './Controller.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwiQ29udHJvbGxlciJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9uZXh0L2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGRlZmF1bHQgYXMgQ29udHJvbGxlciB9IGZyb20gJy4vQ29udHJvbGxlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL0NvbnRyb2xsZXIuanMnO1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxPQUFPLElBQUlDLFVBQVUsUUFBUSxpQkFBaUI7QUFDdkQsY0FBYyxpQkFBaUIifQ==

package/legacy/previousActions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/state/RIC.js

@@ -0,0 +1,3 @@
+const RIC = typeof requestIdleCallback === 'function' ? requestIdleCallback : cb => setTimeout(cb, 0);
+export default RIC;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSSUMiLCJyZXF1ZXN0SWRsZUNhbGxiYWNrIiwiY2IiLCJzZXRUaW1lb3V0Il0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0YXRlL1JJQy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJjb25zdCBSSUMgPVxuICB0eXBlb2YgcmVxdWVzdElkbGVDYWxsYmFjayA9PT0gJ2Z1bmN0aW9uJ1xuICAgID8gcmVxdWVzdElkbGVDYWxsYmFja1xuICAgIDogY2IgPT4gc2V0VGltZW91dChjYiwgMCk7XG5leHBvcnQgZGVmYXVsdCBSSUM7XG4iXSwibWFwcGluZ3MiOiJBQUFBLE1BQU1BLEdBQUcsR0FDUCxPQUFPQyxtQkFBbUIsS0FBSyxVQUFVLEdBQ3JDQSxtQkFBbUIsR0FDbkJDLEVBQUUsSUFBSUMsVUFBVSxDQUFDRCxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBQzdCLGVBQWVGLEdBQUcifQ==

package/legacy/state/applyUpdatersToResults.js

@@ -0,0 +1,4 @@
+export default function applyUpdatersToResults(results, result, updaters) {
+  return Object.assign({}, results, Object.fromEntries(Object.entries(updaters).map(([fetchKey, updater]) => [fetchKey, updater(result, results[fetchKey])])));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhcHBseVVwZGF0ZXJzVG9SZXN1bHRzIiwicmVzdWx0cyIsInJlc3VsdCIsInVwZGF0ZXJzIiwiT2JqZWN0IiwiYXNzaWduIiwiZnJvbUVudHJpZXMiLCJlbnRyaWVzIiwibWFwIiwiZmV0Y2hLZXkiLCJ1cGRhdGVyIl0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0YXRlL2FwcGx5VXBkYXRlcnNUb1Jlc3VsdHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTY2hlbWEsIE5vcm1hbGl6ZSwgVXBkYXRlRnVuY3Rpb24gfSBmcm9tICdAZGF0YS1jbGllbnQvbm9ybWFsaXpyJztcblxudHlwZSBSZXN1bHRTdGF0ZUZyb21VcGRhdGVGdW5jdGlvbnM8XG4gIFNvdXJjZVNjaGVtYSBleHRlbmRzIFNjaGVtYSxcbiAgVXBkYXRlRnVuY3Rpb25zIGV4dGVuZHMge1xuICAgIFtrZXk6IHN0cmluZ106IFVwZGF0ZUZ1bmN0aW9uPFNvdXJjZVNjaGVtYSwgYW55PjtcbiAgfSxcbj4gPSB7IFtLIGluIGtleW9mIFVwZGF0ZUZ1bmN0aW9uc106IGFueSB9O1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBhcHBseVVwZGF0ZXJzVG9SZXN1bHRzPFxuICBTb3VyY2VTY2hlbWEgZXh0ZW5kcyBTY2hlbWEsXG4gIFVwZGF0ZUZ1bmN0aW9ucyBleHRlbmRzIHtcbiAgICBba2V5OiBzdHJpbmddOiBVcGRhdGVGdW5jdGlvbjxTb3VyY2VTY2hlbWEsIGFueT47XG4gIH0sXG4+KFxuICByZXN1bHRzOiBSZXN1bHRTdGF0ZUZyb21VcGRhdGVGdW5jdGlvbnM8U291cmNlU2NoZW1hLCBVcGRhdGVGdW5jdGlvbnM+LFxuICByZXN1bHQ6IE5vcm1hbGl6ZTxTb3VyY2VTY2hlbWE+LFxuICB1cGRhdGVyczogVXBkYXRlRnVuY3Rpb25zLFxuKSB7XG4gIHJldHVybiB7XG4gICAgLi4ucmVzdWx0cyxcbiAgICAuLi5PYmplY3QuZnJvbUVudHJpZXMoXG4gICAgICBPYmplY3QuZW50cmllcyh1cGRhdGVycykubWFwKChbZmV0Y2hLZXksIHVwZGF0ZXJdKSA9PiBbXG4gICAgICAgIGZldGNoS2V5LFxuICAgICAgICB1cGRhdGVyKHJlc3VsdCwgcmVzdWx0c1tmZXRjaEtleV0pLFxuICAgICAgXSksXG4gICAgKSxcbiAgfTtcbn1cbiJdLCJtYXBwaW5ncyI6IkFBU0EsZUFBZSxTQUFTQSxzQkFBc0JBLENBTTVDQyxPQUFzRSxFQUN0RUMsTUFBK0IsRUFDL0JDLFFBQXlCLEVBQ3pCO0VBQ0EsT0FBQUMsTUFBQSxDQUFBQyxNQUFBLEtBQ0tKLE9BQU8sRUFDUEcsTUFBTSxDQUFDRSxXQUFXLENBQ25CRixNQUFNLENBQUNHLE9BQU8sQ0FBQ0osUUFBUSxDQUFDLENBQUNLLEdBQUcsQ0FBQyxDQUFDLENBQUNDLFFBQVEsRUFBRUMsT0FBTyxDQUFDLEtBQUssQ0FDcERELFFBQVEsRUFDUkMsT0FBTyxDQUFDUixNQUFNLEVBQUVELE9BQU8sQ0FBQ1EsUUFBUSxDQUFDLENBQUMsQ0FDbkMsQ0FDSCxDQUFDO0FBRUwifQ==

package/legacy/state/legacy-actions/createFetch.js

@@ -0,0 +1,62 @@
+// TODO(breaking): remove file - not used
+
+import { FETCH_TYPE } from '../../actionTypes.js';
+/** Requesting a fetch to begin
+ *
+ * @param fetchShape
+ * @param param1 { params, body, throttle, updateParams }
+ */
+export default function createFetch(fetchShape, {
+  params,
+  body,
+  throttle,
+  updateParams
+}) {
+  const {
+    schema,
+    type,
+    getFetchKey,
+    options
+  } = fetchShape;
+  const key = getFetchKey(params);
+  let resolve = 0;
+  let reject = 0;
+  const promise = new Promise((a, b) => {
+    [resolve, reject] = [a, b];
+  });
+  const meta = {
+    schema,
+    type,
+    args: [params, body],
+    key,
+    throttle,
+    options,
+    resolve,
+    reject,
+    promise,
+    createdAt: Date.now()
+  };
+  if (fetchShape.update) {
+    meta.update = fetchShape.update;
+  }
+
+  // for simplicity we simply override if updateParams are defined - usage together is silly to support as we are migrating
+  if (updateParams) {
+    meta.update = newresult => {
+      const updateMap = {};
+      updateParams.forEach(([toShape, toParams, updateFn]) => {
+        updateMap[toShape.getFetchKey(toParams)] = existing => updateFn(newresult, existing);
+      });
+      return updateMap;
+    };
+  }
+  if (options != null && options.optimisticUpdate) {
+    meta.optimisticResponse = options.optimisticUpdate(params, body);
+  }
+  return {
+    type: FETCH_TYPE,
+    payload: () => fetchShape.fetch(params, body),
+    meta
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/state/legacy-actions/createReceive.js

@@ -0,0 +1,37 @@
+import { RECEIVE_TYPE } from '../../actionTypes.js';
+/** Update state with data
+ *
+ * @param data
+ * @param param1 { schema, key, type, updaters, dataExpiryLength }
+ */
+export default function createReceive(data, {
+  schema,
+  key,
+  args,
+  updaters,
+  fetchedAt = 0,
+  update,
+  dataExpiryLength
+}) {
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && dataExpiryLength < 0) {
+    throw new Error('Negative dataExpiryLength are not allowed.');
+  }
+  const now = Date.now();
+  const meta = {
+    schema,
+    key,
+    args,
+    date: now,
+    fetchedAt,
+    expiresAt: now + dataExpiryLength
+  };
+  meta.updaters = updaters;
+  meta.update = update;
+  return {
+    type: RECEIVE_TYPE,
+    payload: data,
+    meta
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/state/legacy-actions/createReceiveError.js

@@ -0,0 +1,28 @@
+import { RECEIVE_TYPE } from '../../actionTypes.js';
+export default function createReceiveError(error, {
+  schema,
+  key,
+  options,
+  errorExpiryLength = 60000,
+  fetchedAt = 0
+}) {
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && errorExpiryLength < 0) {
+    throw new Error('Negative errorExpiryLength are not allowed.');
+  }
+  const now = Date.now();
+  return {
+    type: RECEIVE_TYPE,
+    payload: error,
+    meta: {
+      schema,
+      key,
+      date: now,
+      fetchedAt,
+      expiresAt: now + errorExpiryLength,
+      errorPolicy: options == null ? void 0 : options.errorPolicy
+    },
+    error: true
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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