@data-client/core 0.1.0

package/legacy/index.js

@@ -0,0 +1,22 @@
+Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, key) {
+  return Object.prototype.hasOwnProperty.call(it, key);
+};
+import * as _INTERNAL__ from './internal.js';
+export { _INTERNAL__ as __INTERNAL__ };
+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 { default as createFetch } from './controller/createFetch.js';
+export { default as createReceive } from './controller/createReceive.js';
+export * from './controller/types.js';
+import * as _legacyActions from './state/legacy-actions/index.js';
+export { _legacyActions as legacyActions };
+import * as _actionTypes from './actionTypes.js';
+export { _actionTypes as actionTypes };
+/* istanbul ignore next */
+export * from './types.js';
+export * from './manager/index.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/internal.js

@@ -0,0 +1,4 @@
+export { inferResults, DELETED } from '@data-client/normalizr';
+export { default as RIC } from './state/RIC.js';
+export { initialState } from './state/reducer/createReducer.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJpbmZlclJlc3VsdHMiLCJERUxFVEVEIiwiZGVmYXVsdCIsIlJJQyIsImluaXRpYWxTdGF0ZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9pbnRlcm5hbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBpbmZlclJlc3VsdHMsIERFTEVURUQgfSBmcm9tICdAZGF0YS1jbGllbnQvbm9ybWFsaXpyJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgUklDIH0gZnJvbSAnLi9zdGF0ZS9SSUMuanMnO1xuZXhwb3J0IHsgaW5pdGlhbFN0YXRlIH0gZnJvbSAnLi9zdGF0ZS9yZWR1Y2VyL2NyZWF0ZVJlZHVjZXIuanMnO1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxZQUFZLEVBQUVDLE9BQU8sUUFBUSx3QkFBd0I7QUFDOUQsU0FBU0MsT0FBTyxJQUFJQyxHQUFHLFFBQVEsZ0JBQWdCO0FBQy9DLFNBQVNDLFlBQVksUUFBUSxrQ0FBa0MifQ==

package/legacy/legacyActions.js

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

package/legacy/manager/ConnectionListener.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL21hbmFnZXIvQ29ubmVjdGlvbkxpc3RlbmVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGludGVyZmFjZSBDb25uZWN0aW9uTGlzdGVuZXIge1xuICBpc09ubGluZTogKCkgPT4gYm9vbGVhbjtcbiAgYWRkT25saW5lTGlzdGVuZXI6IChoYW5kbGVyOiAoKSA9PiB2b2lkKSA9PiB2b2lkO1xuICByZW1vdmVPbmxpbmVMaXN0ZW5lcjogKGhhbmRsZXI6ICgpID0+IHZvaWQpID0+IHZvaWQ7XG4gIGFkZE9mZmxpbmVMaXN0ZW5lcjogKGhhbmRsZXI6ICgpID0+IHZvaWQpID0+IHZvaWQ7XG4gIHJlbW92ZU9mZmxpbmVMaXN0ZW5lcjogKGhhbmRsZXI6ICgpID0+IHZvaWQpID0+IHZvaWQ7XG59XG4iXSwibWFwcGluZ3MiOiIifQ==

package/legacy/manager/DefaultConnectionListener.js

@@ -0,0 +1,40 @@
+export class BrowserConnectionListener {
+  isOnline() {
+    if (navigator.onLine !== undefined) {
+      return navigator.onLine;
+    }
+    return true;
+  }
+  addOnlineListener(handler) {
+    addEventListener('online', handler);
+  }
+  removeOnlineListener(handler) {
+    removeEventListener('online', handler);
+  }
+  addOfflineListener(handler) {
+    addEventListener('offline', handler);
+  }
+  removeOfflineListener(handler) {
+    removeEventListener('offline', handler);
+  }
+}
+export class AlwaysOnlineConnectionListener {
+  isOnline() {
+    /* istanbul ignore next */
+    return true;
+  }
+  addOnlineListener() {}
+  removeOnlineListener() {}
+  addOfflineListener() {}
+  removeOfflineListener() {}
+}
+let DefaultConnectionListener;
+/* istanbul ignore if */
+if (typeof navigator !== 'undefined' && typeof addEventListener === 'function') {
+  DefaultConnectionListener = BrowserConnectionListener;
+} else {
+  /* istanbul ignore next */
+  DefaultConnectionListener = AlwaysOnlineConnectionListener;
+}
+export default DefaultConnectionListener;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/manager/DevtoolsManager.js

@@ -0,0 +1,73 @@
+var _globalThis$document;
+import createReducer from '../state/reducer/createReducer.js';
+const HASINTL = typeof Intl !== 'undefined';
+const DEFAULT_CONFIG = {
+  name: `Rest Hooks: ${(_globalThis$document = globalThis.document) == null ? void 0 : _globalThis$document.title}`,
+  autoPause: true,
+  serialize: {
+    options: undefined,
+    /* istanbul ignore next */
+    replacer: HASINTL ? (key, value) => {
+      if (typeof value === 'number' && typeof key === 'string' && isFinite(value) && (key === 'date' || key.endsWith('At'))) {
+        return Intl.DateTimeFormat('en-US', {
+          hour: 'numeric',
+          minute: 'numeric',
+          second: 'numeric',
+          fractionalSecondDigits: 3
+        }).format(value);
+      }
+      return value;
+    } : undefined
+  }
+};
+
+/** Integrates with https://github.com/reduxjs/redux-devtools
+ *
+ * Options: https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md
+ *
+ * @see https://resthooks.io/docs/api/DevToolsManager
+ */
+export default class DevToolsManager {
+  constructor(config, skipLogging) {
+    /* istanbul ignore next */
+    this.devTools = typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__.connect(Object.assign({}, DEFAULT_CONFIG, {
+      config
+    }));
+
+    /* istanbul ignore if */
+    /* istanbul ignore next */
+    if (this.devTools) {
+      this.middleware = controller => {
+        const reducer = createReducer(controller);
+        return next => action => {
+          const ret = next(action);
+          ret.then(() => {
+            if (skipLogging != null && skipLogging(action)) return;
+            const state = controller.getState();
+            this.devTools.send(action, state.optimistic.reduce(reducer, state), undefined, 'REST_HOOKS');
+          });
+          return ret;
+        };
+      };
+    } else {
+      this.middleware = () => next => action => next(action);
+    }
+  }
+
+  /** Called when initial state is ready */
+  init(state) {
+    /* istanbul ignore if */
+    if (this.devTools) this.devTools.init(state);
+  }
+
+  /** Ensures all subscriptions are cleaned up. */
+  cleanup() {}
+
+  /** Attaches Manager to store
+   *
+   */
+  getMiddleware() {
+    return this.middleware;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/manager/LogoutManager.js

@@ -0,0 +1,34 @@
+import { SET_TYPE } from '../actionTypes.js';
+/** Handling network unauthorized indicators like HTTP 401
+ *
+ * @see https://resthooks.io/docs/api/LogoutManager
+ */
+export default class LogoutManager {
+  constructor({
+    handleLogout,
+    shouldLogout
+  } = {}) {
+    if (handleLogout) this.handleLogout = handleLogout;
+    if (shouldLogout) this.shouldLogout = shouldLogout;
+    this.middleware = controller => next => async action => {
+      await next(action);
+      if (action.type === SET_TYPE && action.error && this.shouldLogout(action.payload)) {
+        this.handleLogout(controller);
+      }
+    };
+  }
+  cleanup() {}
+  getMiddleware() {
+    return this.middleware;
+  }
+  shouldLogout(error) {
+    // 401 indicates reauthorization is needed
+    return error.status === 401;
+  }
+  handleLogout(controller) {
+    controller.resetEntireStore();
+  }
+}
+
+// this further restricts the types to be future compatible
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/manager/NetworkManager.js

@@ -0,0 +1,291 @@
+import { SET_TYPE, FETCH_TYPE, RESET_TYPE } from '../actionTypes.js';
+import Controller from '../controller/Controller.js';
+import { initialState } from '../internal.js';
+import { createReceive, createReceiveError } from '../state/legacy-actions/index.js';
+import RIC from '../state/RIC.js';
+export class ResetError extends Error {
+  constructor() {
+    super('Aborted due to RESET');
+    this.name = 'ResetError';
+  }
+}
+
+/** Handles all async network dispatches
+ *
+ * Dedupes concurrent requests by keeping track of all fetches in flight
+ * and returning existing promises for requests already in flight.
+ *
+ * Interfaces with store via a redux-compatible middleware.
+ *
+ * @see https://resthooks.io/docs/api/NetworkManager
+ */
+export default class NetworkManager {
+  constructor(dataExpiryLength = 60000, errorExpiryLength = 1000) {
+    this.fetched = Object.create(null);
+    this.resolvers = {};
+    this.rejectors = {};
+    this.fetchedAt = {};
+    this.getState = () => initialState;
+    this.controller = new Controller();
+    this.dataExpiryLength = dataExpiryLength;
+    this.errorExpiryLength = errorExpiryLength;
+    this.middleware = ({
+      dispatch,
+      getState,
+      controller
+    }) => {
+      this.getState = getState;
+      this.controller = controller;
+      return next => action => {
+        var _action$endpoint;
+        switch (action.type) {
+          case FETCH_TYPE:
+            this.handleFetch(action, dispatch, controller);
+            // This is the only case that causes any state change
+            // It's important to intercept other fetches as we don't want to trigger reducers during
+            // render - so we need to stop 'readonly' fetches which can be triggered in render
+            if (action.meta.optimisticResponse !== undefined || ((_action$endpoint = action.endpoint) == null ? void 0 : _action$endpoint.getOptimisticResponse) !== undefined && action.endpoint.sideEffect) {
+              return next(action);
+            }
+            return Promise.resolve();
+          case SET_TYPE:
+            // only receive after new state is computed
+            return next(action).then(() => {
+              if (action.meta.key in this.fetched) {
+                var _controller$getState$;
+                // Note: meta *must* be set by reducer so this should be safe
+                const error = (_controller$getState$ = controller.getState().meta[action.meta.key]) == null ? void 0 : _controller$getState$.error;
+                // processing errors result in state meta having error, so we should reject the promise
+                if (error) {
+                  // TODO: use only new action types
+                  this.handleReceive(createReceiveError(error, action.meta));
+                } else {
+                  this.handleReceive(action);
+                }
+              }
+            });
+          case RESET_TYPE:
+            {
+              const rejectors = Object.assign({}, this.rejectors);
+              this.clearAll();
+              return next(action).then(() => {
+                // there could be external listeners to the promise
+                // this must happen after commit so our own rejector knows not to dispatch an error based on this
+                for (const k in rejectors) {
+                  rejectors[k](new ResetError());
+                }
+              });
+            }
+          default:
+            return next(action);
+        }
+      };
+    };
+  }
+
+  /** Used by DevtoolsManager to determine whether to log an action */
+  skipLogging(action) {
+    /* istanbul ignore next */
+    return action.type === FETCH_TYPE && action.meta.key in this.fetched;
+  }
+
+  /** On mount */
+  init() {
+    delete this.cleanupDate;
+  }
+
+  /** Ensures all promises are completed by rejecting remaining. */
+  cleanup() {
+    // ensure no dispatches after unmount
+    // this must be reversible (done in init) so useEffect() remains symmetric
+    this.cleanupDate = Date.now();
+  }
+  allSettled() {
+    const fetches = Object.values(this.fetched);
+    if (fetches.length) return Promise.allSettled(fetches);
+  }
+
+  /** Clear all promise state */
+  clearAll() {
+    for (const k in this.rejectors) {
+      this.clear(k);
+    }
+  }
+
+  /** Clear promise state for a given key */
+  clear(key) {
+    this.fetched[key].catch(() => {});
+    delete this.resolvers[key];
+    delete this.rejectors[key];
+    delete this.fetched[key];
+    delete this.fetchedAt[key];
+  }
+  getLastReset() {
+    if (this.cleanupDate) return this.cleanupDate;
+    const lastReset = this.controller.getState().lastReset;
+    if (lastReset instanceof Date) return lastReset.valueOf();
+    if (typeof lastReset !== 'number') return -Infinity;
+    return lastReset;
+  }
+
+  /** Called when middleware intercepts 'rest-hooks/fetch' action.
+   *
+   * Will then start a promise for a key and potentially start the network
+   * fetch.
+   *
+   * Uses throttle only when instructed by action meta. This is valuable
+   * for ensures mutation requests always go through.
+   */
+  handleFetch(action, dispatch, controller) {
+    const fetch = action.payload;
+    const {
+      key,
+      throttle,
+      resolve,
+      reject
+    } = action.meta;
+    // TODO(breaking): remove support for Date type in 'Receive' action
+    const createdAt = typeof action.meta.createdAt !== 'number' ? action.meta.createdAt.getTime() : action.meta.createdAt;
+    const deferedFetch = () => {
+      let promise = fetch();
+      const resolvePromise = promise => promise.then(data => {
+        resolve(data);
+        return data;
+      }).catch(error => {
+        reject(error);
+        throw error;
+      });
+      // schedule non-throttled resolutions in a microtask before receive
+      // this enables users awaiting their fetch to trigger any react updates needed to deal
+      // with upcoming changes because of the fetch (for instance avoiding suspense if something is deleted)
+      if (!throttle && action.endpoint) {
+        promise = resolvePromise(promise);
+      }
+      promise = promise.then(data => {
+        let lastReset = this.getLastReset();
+
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production' && isNaN(lastReset)) {
+          console.error('state.lastReset is NaN. Only positive timestamps are valid.');
+          lastReset = 0;
+        }
+
+        // don't update state with promises started before last clear
+        if (createdAt >= lastReset) {
+          // we still check for controller in case someone didn't have type protection since this didn't always exist
+          if (action.endpoint && this.controller) {
+            this.controller.resolve(action.endpoint, {
+              args: action.meta.args,
+              response: data,
+              fetchedAt: createdAt
+            });
+          } else {
+            var _action$meta$options$, _action$meta$options;
+            // TODO(breaking): is this branch still possible? remove in next major update
+            // does this throw if the reducer fails? - no because reducer is wrapped in try/catch
+            this.controller.dispatch(createReceive(data, Object.assign({}, action.meta, {
+              fetchedAt: createdAt,
+              dataExpiryLength: (_action$meta$options$ = (_action$meta$options = action.meta.options) == null ? void 0 : _action$meta$options.dataExpiryLength) != null ? _action$meta$options$ : this.dataExpiryLength
+            })));
+          }
+        }
+        return data;
+      }).catch(error => {
+        const lastReset = this.getLastReset();
+        // don't update state with promises started before last clear
+        if (createdAt >= lastReset) {
+          if (action.endpoint && this.controller) {
+            this.controller.resolve(action.endpoint, {
+              args: action.meta.args,
+              response: error,
+              fetchedAt: createdAt,
+              error: true
+            });
+          } else {
+            var _action$meta$options$2, _action$meta$options2;
+            this.controller.dispatch(createReceiveError(error, Object.assign({}, action.meta, {
+              errorExpiryLength: (_action$meta$options$2 = (_action$meta$options2 = action.meta.options) == null ? void 0 : _action$meta$options2.errorExpiryLength) != null ? _action$meta$options$2 : this.errorExpiryLength,
+              fetchedAt: createdAt
+            })));
+          }
+        }
+        throw error;
+      });
+      // legacy behavior schedules resolution after dispatch
+      if (!throttle && !action.endpoint) {
+        promise = resolvePromise(promise);
+      }
+      return promise;
+    };
+    if (throttle) {
+      return this.throttle(key, deferedFetch, createdAt).then(data => resolve(data)).catch(error => reject(error));
+    } else {
+      return deferedFetch().catch(() => {});
+    }
+  }
+
+  /** Called when middleware intercepts a receive action.
+   *
+   * Will resolve the promise associated with receive key.
+   */
+  handleReceive(action) {
+    // this can still turn out to be untrue since this is async
+    if (action.meta.key in this.fetched) {
+      let promiseHandler;
+      if (action.error) {
+        promiseHandler = this.rejectors[action.meta.key];
+      } else {
+        promiseHandler = this.resolvers[action.meta.key];
+      }
+      promiseHandler(action.payload);
+      // since we're resolved we no longer need to keep track of this promise
+      this.clear(action.meta.key);
+    }
+  }
+
+  /** Attaches NetworkManager to store
+   *
+   * Intercepts 'rest-hooks/fetch' actions to start requests.
+   *
+   * Resolve/rejects a request when matching 'rest-hooks/receive' event
+   * is seen.
+   */
+  getMiddleware() {
+    return this.middleware;
+  }
+
+  /** Ensures only one request for a given key is in flight at any time
+   *
+   * Uses key to either retrieve in-flight promise, or if not
+   * create a new promise and call fetch.
+   *
+   * Note: The new promise is not actually tied to fetch at all,
+   * but is resolved when the expected 'recieve' action is processed.
+   * This ensures promises are resolved only once their data is processed
+   * by the reducer.
+   */
+  throttle(key, fetch, createdAt) {
+    const lastReset = this.getLastReset();
+    // we're already fetching so reuse the promise
+    // fetches after reset do not count
+    if (key in this.fetched && this.fetchedAt[key] > lastReset) {
+      return this.fetched[key];
+    }
+    this.fetched[key] = new Promise((resolve, reject) => {
+      this.resolvers[key] = resolve;
+      this.rejectors[key] = reject;
+    });
+    this.fetchedAt[key] = createdAt;
+
+    // since our real promise is resolved via the wrapReducer(),
+    // we should just stop all errors here.
+    // TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)
+    RIC(() => {
+      fetch().catch(() => null);
+    }, {
+      timeout: 500
+    });
+    return this.fetched[key];
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SET_TYPE","FETCH_TYPE","RESET_TYPE","Controller","initialState","createReceive","createReceiveError","RIC","ResetError","Error","constructor","name","NetworkManager","dataExpiryLength","errorExpiryLength","fetched","Object","create","resolvers","rejectors","fetchedAt","getState","controller","middleware","dispatch","next","action","_action$endpoint","type","handleFetch","meta","optimisticResponse","undefined","endpoint","getOptimisticResponse","sideEffect","Promise","resolve","then","key","_controller$getState$","error","handleReceive","assign","clearAll","k","skipLogging","init","cleanupDate","cleanup","Date","now","allSettled","fetches","values","length","clear","catch","getLastReset","lastReset","valueOf","Infinity","fetch","payload","throttle","reject","createdAt","getTime","deferedFetch","promise","resolvePromise","data","process","env","NODE_ENV","isNaN","console","args","response","_action$meta$options$","_action$meta$options","options","_action$meta$options$2","_action$meta$options2","promiseHandler","getMiddleware","timeout"],"sources":["../../src/manager/NetworkManager.ts"],"sourcesContent":["import { SET_TYPE, FETCH_TYPE, RESET_TYPE } from '../actionTypes.js';\nimport Controller from '../controller/Controller.js';\nimport { initialState } from '../internal.js';\nimport {\n  createReceive,\n  createReceiveError,\n} from '../state/legacy-actions/index.js';\nimport RIC from '../state/RIC.js';\nimport type {\n  FetchAction,\n  ReceiveAction,\n  Manager,\n  ActionTypes,\n  MiddlewareAPI,\n  Middleware,\n  State,\n} from '../types.js';\n\nexport class ResetError extends Error {\n  name = 'ResetError';\n\n  constructor() {\n    super('Aborted due to RESET');\n  }\n}\n\n/** Handles all async network dispatches\n *\n * Dedupes concurrent requests by keeping track of all fetches in flight\n * and returning existing promises for requests already in flight.\n *\n * Interfaces with store via a redux-compatible middleware.\n *\n * @see https://resthooks.io/docs/api/NetworkManager\n */\nexport default class NetworkManager implements Manager {\n  protected fetched: { [k: string]: Promise<any> } = Object.create(null);\n  protected resolvers: { [k: string]: (value?: any) => void } = {};\n  protected rejectors: { [k: string]: (value?: any) => void } = {};\n  protected fetchedAt: { [k: string]: number } = {};\n  declare readonly dataExpiryLength: number;\n  declare readonly errorExpiryLength: number;\n  protected declare middleware: Middleware;\n  protected getState: () => State<unknown> = () => initialState;\n  protected controller: Controller = new Controller();\n  declare cleanupDate?: number;\n\n  constructor(dataExpiryLength = 60000, errorExpiryLength = 1000) {\n    this.dataExpiryLength = dataExpiryLength;\n    this.errorExpiryLength = errorExpiryLength;\n\n    this.middleware = <C extends MiddlewareAPI>({\n      dispatch,\n      getState,\n      controller,\n    }: C) => {\n      this.getState = getState;\n      this.controller = controller;\n      return (next: C['dispatch']): C['dispatch'] =>\n        (action): Promise<void> => {\n          switch (action.type) {\n            case FETCH_TYPE:\n              this.handleFetch(action, dispatch, controller);\n              // This is the only case that causes any state change\n              // It's important to intercept other fetches as we don't want to trigger reducers during\n              // render - so we need to stop 'readonly' fetches which can be triggered in render\n              if (\n                action.meta.optimisticResponse !== undefined ||\n                (action.endpoint?.getOptimisticResponse !== undefined &&\n                  action.endpoint.sideEffect)\n              ) {\n                return next(action);\n              }\n              return Promise.resolve();\n            case SET_TYPE:\n              // only receive after new state is computed\n              return next(action).then(() => {\n                if (action.meta.key in this.fetched) {\n                  // Note: meta *must* be set by reducer so this should be safe\n                  const error =\n                    controller.getState().meta[action.meta.key]?.error;\n                  // processing errors result in state meta having error, so we should reject the promise\n                  if (error) {\n                    // TODO: use only new action types\n                    this.handleReceive(createReceiveError(error, action.meta));\n                  } else {\n                    this.handleReceive(action);\n                  }\n                }\n              });\n            case RESET_TYPE: {\n              const rejectors = { ...this.rejectors };\n\n              this.clearAll();\n              return next(action).then(() => {\n                // there could be external listeners to the promise\n                // this must happen after commit so our own rejector knows not to dispatch an error based on this\n                for (const k in rejectors) {\n                  rejectors[k](new ResetError());\n                }\n              });\n            }\n            default:\n              return next(action);\n          }\n        };\n    };\n  }\n\n  /** Used by DevtoolsManager to determine whether to log an action */\n  skipLogging(action: ActionTypes) {\n    /* istanbul ignore next */\n    return action.type === FETCH_TYPE && action.meta.key in this.fetched;\n  }\n\n  /** On mount */\n  init() {\n    delete this.cleanupDate;\n  }\n\n  /** Ensures all promises are completed by rejecting remaining. */\n  cleanup() {\n    // ensure no dispatches after unmount\n    // this must be reversible (done in init) so useEffect() remains symmetric\n    this.cleanupDate = Date.now();\n  }\n\n  allSettled() {\n    const fetches = Object.values(this.fetched);\n    if (fetches.length) return Promise.allSettled(fetches);\n  }\n\n  /** Clear all promise state */\n  protected clearAll() {\n    for (const k in this.rejectors) {\n      this.clear(k);\n    }\n  }\n\n  /** Clear promise state for a given key */\n  protected clear(key: string) {\n    this.fetched[key].catch(() => {});\n    delete this.resolvers[key];\n    delete this.rejectors[key];\n    delete this.fetched[key];\n    delete this.fetchedAt[key];\n  }\n\n  protected getLastReset() {\n    if (this.cleanupDate) return this.cleanupDate;\n    const lastReset = this.controller.getState().lastReset;\n    if (lastReset instanceof Date) return lastReset.valueOf();\n    if (typeof lastReset !== 'number') return -Infinity;\n    return lastReset;\n  }\n\n  /** Called when middleware intercepts 'rest-hooks/fetch' action.\n   *\n   * Will then start a promise for a key and potentially start the network\n   * fetch.\n   *\n   * Uses throttle only when instructed by action meta. This is valuable\n   * for ensures mutation requests always go through.\n   */\n  protected handleFetch(\n    action: FetchAction,\n    dispatch: (action: any) => Promise<void>,\n    controller: Controller,\n  ) {\n    const fetch = action.payload;\n    const { key, throttle, resolve, reject } = action.meta;\n    // TODO(breaking): remove support for Date type in 'Receive' action\n    const createdAt =\n      typeof action.meta.createdAt !== 'number'\n        ? action.meta.createdAt.getTime()\n        : action.meta.createdAt;\n\n    const deferedFetch = () => {\n      let promise = fetch();\n      const resolvePromise = (\n        promise: Promise<string | number | object | null>,\n      ) =>\n        promise\n          .then(data => {\n            resolve(data);\n            return data;\n          })\n          .catch(error => {\n            reject(error);\n            throw error;\n          });\n      // schedule non-throttled resolutions in a microtask before receive\n      // this enables users awaiting their fetch to trigger any react updates needed to deal\n      // with upcoming changes because of the fetch (for instance avoiding suspense if something is deleted)\n      if (!throttle && action.endpoint) {\n        promise = resolvePromise(promise);\n      }\n      promise = promise\n        .then(data => {\n          let lastReset = this.getLastReset();\n\n          /* istanbul ignore else */\n          if (process.env.NODE_ENV !== 'production' && isNaN(lastReset)) {\n            console.error(\n              'state.lastReset is NaN. Only positive timestamps are valid.',\n            );\n            lastReset = 0;\n          }\n\n          // don't update state with promises started before last clear\n          if (createdAt >= lastReset) {\n            // we still check for controller in case someone didn't have type protection since this didn't always exist\n            if (action.endpoint && this.controller) {\n              this.controller.resolve(action.endpoint, {\n                args: action.meta.args as any,\n                response: data,\n                fetchedAt: createdAt,\n              });\n            } else {\n              // TODO(breaking): is this branch still possible? remove in next major update\n              // does this throw if the reducer fails? - no because reducer is wrapped in try/catch\n              this.controller.dispatch(\n                createReceive(data, {\n                  ...action.meta,\n                  fetchedAt: createdAt,\n                  dataExpiryLength:\n                    action.meta.options?.dataExpiryLength ??\n                    this.dataExpiryLength,\n                }),\n              );\n            }\n          }\n          return data;\n        })\n        .catch(error => {\n          const lastReset = this.getLastReset();\n          // don't update state with promises started before last clear\n          if (createdAt >= lastReset) {\n            if (action.endpoint && this.controller) {\n              this.controller.resolve(action.endpoint, {\n                args: action.meta.args as any,\n                response: error,\n                fetchedAt: createdAt,\n                error: true,\n              });\n            } else {\n              this.controller.dispatch(\n                createReceiveError(error, {\n                  ...action.meta,\n                  errorExpiryLength:\n                    action.meta.options?.errorExpiryLength ??\n                    this.errorExpiryLength,\n                  fetchedAt: createdAt,\n                }),\n              );\n            }\n          }\n          throw error;\n        });\n      // legacy behavior schedules resolution after dispatch\n      if (!throttle && !action.endpoint) {\n        promise = resolvePromise(promise);\n      }\n      return promise;\n    };\n\n    if (throttle) {\n      return this.throttle(key, deferedFetch, createdAt)\n        .then(data => resolve(data))\n        .catch(error => reject(error));\n    } else {\n      return deferedFetch().catch(() => {});\n    }\n  }\n\n  /** Called when middleware intercepts a receive action.\n   *\n   * Will resolve the promise associated with receive key.\n   */\n  protected handleReceive(action: ReceiveAction) {\n    // this can still turn out to be untrue since this is async\n    if (action.meta.key in this.fetched) {\n      let promiseHandler: (value?: any) => void;\n      if (action.error) {\n        promiseHandler = this.rejectors[action.meta.key];\n      } else {\n        promiseHandler = this.resolvers[action.meta.key];\n      }\n      promiseHandler(action.payload);\n      // since we're resolved we no longer need to keep track of this promise\n      this.clear(action.meta.key);\n    }\n  }\n\n  /** Attaches NetworkManager to store\n   *\n   * Intercepts 'rest-hooks/fetch' actions to start requests.\n   *\n   * Resolve/rejects a request when matching 'rest-hooks/receive' event\n   * is seen.\n   */\n  getMiddleware() {\n    return this.middleware;\n  }\n\n  /** Ensures only one request for a given key is in flight at any time\n   *\n   * Uses key to either retrieve in-flight promise, or if not\n   * create a new promise and call fetch.\n   *\n   * Note: The new promise is not actually tied to fetch at all,\n   * but is resolved when the expected 'recieve' action is processed.\n   * This ensures promises are resolved only once their data is processed\n   * by the reducer.\n   */\n  protected throttle(\n    key: string,\n    fetch: () => Promise<any>,\n    createdAt: number,\n  ) {\n    const lastReset = this.getLastReset();\n    // we're already fetching so reuse the promise\n    // fetches after reset do not count\n    if (key in this.fetched && this.fetchedAt[key] > lastReset) {\n      return this.fetched[key];\n    }\n\n    this.fetched[key] = new Promise((resolve, reject) => {\n      this.resolvers[key] = resolve;\n      this.rejectors[key] = reject;\n    });\n    this.fetchedAt[key] = createdAt;\n\n    // since our real promise is resolved via the wrapReducer(),\n    // we should just stop all errors here.\n    // TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)\n    RIC(\n      () => {\n        fetch().catch(() => null);\n      },\n      { timeout: 500 },\n    );\n\n    return this.fetched[key];\n  }\n}\n"],"mappings":"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"}