@data-client/core 0.1.0

package/lib/manager/DevtoolsManager.d.ts

@@ -0,0 +1,24 @@
+import type { DevToolsConfig } from './devtoolsTypes.js';
+import type { Middleware } from './LogoutManager.js';
+import type { Manager, State, ActionTypes } from '../types.js';
+export type { DevToolsConfig };
+/** 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 implements Manager {
+    protected middleware: Middleware;
+    protected devTools: undefined | any;
+    constructor(config?: DevToolsConfig, skipLogging?: (action: ActionTypes) => boolean);
+    /** Called when initial state is ready */
+    init(state: State<any>): void;
+    /** Ensures all subscriptions are cleaned up. */
+    cleanup(): void;
+    /** Attaches Manager to store
+     *
+     */
+    getMiddleware(): Middleware;
+}
+//# sourceMappingURL=DevtoolsManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DevtoolsManager.d.ts","sourceRoot":"","sources":["../../src/manager/DevtoolsManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/D,YAAY,EAAE,cAAc,EAAE,CAAC;AA8B/B;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,YAAW,OAAO;IACrD,UAAkB,UAAU,EAAE,UAAU,CAAC;IACzC,UAAkB,QAAQ,EAAE,SAAS,GAAG,GAAG,CAAC;gBAG1C,MAAM,CAAC,EAAE,cAAc,EACvB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO;IAoChD,yCAAyC;IACzC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC;IAKtB,gDAAgD;IAChD,OAAO;IAEP;;OAEG;IACH,aAAa;CAGd"}

package/lib/manager/DevtoolsManager.js

@@ -0,0 +1,74 @@
+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({
+      ...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/lib/manager/LogoutManager.d.ts

@@ -0,0 +1,25 @@
+import Controller from '../controller/Controller.js';
+import { UnknownError } from '../index.js';
+import type { CombinedActionTypes } from '../types.js';
+import { Manager } from '../types.js';
+/** Handling network unauthorized indicators like HTTP 401
+ *
+ * @see https://resthooks.io/docs/api/LogoutManager
+ */
+export default class LogoutManager implements Manager<CombinedActionTypes> {
+    protected middleware: Middleware;
+    constructor({ handleLogout, shouldLogout }?: Props);
+    cleanup(): void;
+    getMiddleware(): Middleware;
+    protected shouldLogout(error: UnknownError): boolean;
+    handleLogout(controller: Controller<Dispatch>): void;
+}
+type Dispatch = (value: CombinedActionTypes) => Promise<void>;
+export type Middleware = <C extends Controller<Dispatch>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
+type HandleLogout = (controller: Controller<Dispatch>) => void;
+interface Props {
+    handleLogout?: HandleLogout;
+    shouldLogout?: (error: UnknownError) => boolean;
+}
+export {};
+//# sourceMappingURL=LogoutManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LogoutManager.d.ts","sourceRoot":"","sources":["../../src/manager/LogoutManager.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,YAAW,OAAO,CAAC,mBAAmB,CAAC;IACxE,UAAkB,UAAU,EAAE,UAAU,CAAC;gBAE7B,EAAE,YAAY,EAAE,YAAY,EAAE,GAAE,KAAU;IAetD,OAAO;IAEP,aAAa;IAIb,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY;IAK1C,YAAY,CAAC,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC;CAG9C;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAG9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,SAAS,UAAU,CAAC,QAAQ,CAAC,EACtD,UAAU,EAAE,CAAC,KACV,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC;AAE5C,KAAK,YAAY,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;AAE/D,UAAU,KAAK;IACb,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC;CACjD"}

package/lib/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/lib/manager/NetworkManager.d.ts

@@ -0,0 +1,82 @@
+import Controller from '../controller/Controller.js';
+import type { FetchAction, ReceiveAction, Manager, ActionTypes, Middleware, State } from '../types.js';
+export declare class ResetError extends Error {
+    name: string;
+    constructor();
+}
+/** 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 implements Manager {
+    protected fetched: {
+        [k: string]: Promise<any>;
+    };
+    protected resolvers: {
+        [k: string]: (value?: any) => void;
+    };
+    protected rejectors: {
+        [k: string]: (value?: any) => void;
+    };
+    protected fetchedAt: {
+        [k: string]: number;
+    };
+    readonly dataExpiryLength: number;
+    readonly errorExpiryLength: number;
+    protected middleware: Middleware;
+    protected getState: () => State<unknown>;
+    protected controller: Controller;
+    cleanupDate?: number;
+    constructor(dataExpiryLength?: number, errorExpiryLength?: number);
+    /** Used by DevtoolsManager to determine whether to log an action */
+    skipLogging(action: ActionTypes): boolean;
+    /** On mount */
+    init(): void;
+    /** Ensures all promises are completed by rejecting remaining. */
+    cleanup(): void;
+    allSettled(): Promise<PromiseSettledResult<any>[]> | undefined;
+    /** Clear all promise state */
+    protected clearAll(): void;
+    /** Clear promise state for a given key */
+    protected clear(key: string): void;
+    protected getLastReset(): number;
+    /** 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.
+     */
+    protected handleFetch(action: FetchAction, dispatch: (action: any) => Promise<void>, controller: Controller): Promise<any>;
+    /** Called when middleware intercepts a receive action.
+     *
+     * Will resolve the promise associated with receive key.
+     */
+    protected handleReceive(action: ReceiveAction): void;
+    /** 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(): 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.
+     */
+    protected throttle(key: string, fetch: () => Promise<any>, createdAt: number): Promise<any>;
+}
+//# sourceMappingURL=NetworkManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkManager.d.ts","sourceRoot":"","sources":["../../src/manager/NetworkManager.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAOrD,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,OAAO,EACP,WAAW,EAEX,UAAU,EACV,KAAK,EACN,MAAM,aAAa,CAAC;AAErB,qBAAa,UAAW,SAAQ,KAAK;IACnC,IAAI,SAAgB;;CAKrB;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,OAAO;IACpD,SAAS,CAAC,OAAO,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAA;KAAE,CAAuB;IACvE,SAAS,CAAC,SAAS,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;KAAE,CAAM;IACjE,SAAS,CAAC,SAAS,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;KAAE,CAAM;IACjE,SAAS,CAAC,SAAS,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAM;IAClD,SAAiB,gBAAgB,EAAE,MAAM,CAAC;IAC1C,SAAiB,iBAAiB,EAAE,MAAM,CAAC;IAC3C,UAAkB,UAAU,EAAE,UAAU,CAAC;IACzC,SAAS,CAAC,QAAQ,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC,CAAsB;IAC9D,SAAS,CAAC,UAAU,EAAE,UAAU,CAAoB;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;gBAEjB,gBAAgB,SAAQ,EAAE,iBAAiB,SAAO;IA8D9D,oEAAoE;IACpE,WAAW,CAAC,MAAM,EAAE,WAAW;IAK/B,eAAe;IACf,IAAI;IAIJ,iEAAiE;IACjE,OAAO;IAMP,UAAU;IAKV,8BAA8B;IAC9B,SAAS,CAAC,QAAQ;IAMlB,0CAA0C;IAC1C,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM;IAQ3B,SAAS,CAAC,YAAY;IAQtB;;;;;;;OAOG;IACH,SAAS,CAAC,WAAW,CACnB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EACxC,UAAU,EAAE,UAAU;IA4GxB;;;OAGG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,aAAa;IAe7C;;;;;;OAMG;IACH,aAAa;IAIb;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,CAChB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EACzB,SAAS,EAAE,MAAM;CA2BpB"}

package/lib/manager/NetworkManager.js

@@ -0,0 +1,295 @@
+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 = {
+                ...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, {
+              ...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, {
+              ...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","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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"}