@data-client/core 0.1.0 → 0.2.0

package/lib/controller/Controller.d.ts

@@ -1,14 +1,134 @@
-import type { EndpointInterface } from '@data-client/normalizr';
-import BaseController, { CompatibleDispatch, GenericDispatch } from './BaseController.js';
+import type { ErrorTypes, SnapshotInterface, DenormalizeCache, Schema, Denormalize } from '@data-client/normalizr';
+import { ExpiryStatus, EndpointInterface, FetchFunction, DenormalizeNullable } from '@data-client/normalizr';
 import type { EndpointUpdateFunction } from './types.js';
-export default class Controller<D extends GenericDispatch = CompatibleDispatch> extends BaseController<D> {
+import type { ActionTypes, State } from '../types.js';
+export type GenericDispatch = (value: any) => Promise<void>;
+export type DataClientDispatch = (value: ActionTypes) => Promise<void>;
+interface ConstructorProps<D extends GenericDispatch = DataClientDispatch> {
+    dispatch?: D;
+    getState?: () => State<unknown>;
+    globalCache?: DenormalizeCache;
+}
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/Controller
+ */
+export default class Controller<D extends GenericDispatch = DataClientDispatch> {
+    /**
+     * Dispatches an action to Rest Hooks reducer.
+     *
+     * @see https://resthooks.io/docs/api/Controller#dispatch
+     */
+    readonly dispatch: D;
+    /**
+     * Gets the latest state snapshot that is fully committed.
+     *
+     * This can be useful for imperative use-cases like event handlers.
+     * This should *not* be used to render; instead useSuspense() or useCache()
+     * @see https://resthooks.io/docs/api/Controller#getState
+     */
+    readonly getState: () => State<unknown>;
+    readonly globalCache: DenormalizeCache;
+    constructor({ dispatch, getState, globalCache, }?: ConstructorProps<D>);
+    /*************** Action Dispatchers ***************/
     /**
      * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
      * @see https://resthooks.io/docs/api/Controller#fetch
      */
-    fetch: <E extends EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
+    fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
+    /**
+     * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+     * @see https://resthooks.io/docs/api/Controller#invalidate
+     */
+    invalidate: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>>(endpoint: E, ...args: readonly [...Parameters<E>] | readonly [null]) => Promise<void>;
+    /**
+     * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
+     * @see https://resthooks.io/docs/api/Controller#invalidateAll
+     */
+    invalidateAll: (options: {
+        testKey: (key: string) => boolean;
+    }) => Promise<void>;
+    /**
+     * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
+     * @see https://resthooks.io/docs/api/Controller#resetEntireStore
+     */
+    resetEntireStore: () => Promise<void>;
+    /**
+     * Stores response in cache for given Endpoint and args.
+     * @see https://resthooks.io/docs/api/Controller#set
+     */
+    setResponse: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, any]) => Promise<void>;
+    /**
+     * @deprecated use https://resthooks.io/docs/api/Controller#setResponse instead
+     */
+    receive: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, any]) => Promise<void>;
+    /**
+     * Stores the result of Endpoint and args as the error provided.
+     * @see https://resthooks.io/docs/api/Controller#setError
+     */
+    setError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, Error]) => Promise<void>;
+    /**
+     * Another name for setError
+     * @deprecated use https://resthooks.io/docs/api/Controller#setError instead
+     */
+    receiveError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
-    }>(endpoint: E, ...args_0: Parameters<E>) => ReturnType<E>;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, Error]) => Promise<void>;
+    /**
+     * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
+     * @see https://resthooks.io/docs/api/Controller#resolve
+     */
+    resolve: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, meta: {
+        args: readonly [...Parameters<E>];
+        response: Error;
+        fetchedAt: number;
+        error: true;
+    } | {
+        args: readonly [...Parameters<E>];
+        response: any;
+        fetchedAt: number;
+        error?: false | undefined;
+    }) => Promise<void>;
+    /**
+     * Marks a new subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#subscribe
+     */
+    subscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [null] | readonly [...Parameters<E>]) => Promise<void>;
+    /**
+     * Marks completion of subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#unsubscribe
+     */
+    unsubscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [null] | readonly [...Parameters<E>]) => Promise<void>;
+    /*************** More ***************/
+    /**
+     * Gets a snapshot (https://resthooks.io/docs/api/Snapshot)
+     * @see https://resthooks.io/docs/api/Controller#snapshot
+     */
+    snapshot: (state: State<unknown>, fetchedAt?: number) => SnapshotInterface;
+    /**
+     * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
+     * @see https://resthooks.io/docs/api/Controller#getError
+     */
+    getError: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "key">, Args extends readonly [null] | readonly [...Parameters<E["key"]>]>(endpoint: E, ...rest: [...Args, State<unknown>]) => ErrorTypes | undefined;
+    /**
+     * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+     * @see https://resthooks.io/docs/api/Controller#getResponse
+     */
+    getResponse: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "schema" | "key" | "invalidIfStale">, Args extends readonly [null] | readonly [...Parameters<E["key"]>]>(endpoint: E, ...rest: [...Args, State<unknown>]) => {
+        data: DenormalizeNullable<E["schema"]>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
 }
-export * from './BaseController.js';
+export type { ErrorTypes };
 //# sourceMappingURL=Controller.d.ts.map

package/lib/controller/Controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Controller.d.ts","sourceRoot":"","sources":["../../src/controller/Controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,cAAc,EAAE,EACrB,kBAAkB,EAClB,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,MAAM,CAAC,OAAO,OAAO,UAAU,CAC7B,CAAC,SAAS,eAAe,GAAG,kBAAkB,CAC9C,SAAQ,cAAc,CAAC,CAAC,CAAC;IACzB;;;OAGG;IACH,KAAK;;+DAYH;CACH;AAED,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"Controller.d.ts","sourceRoot":"","sources":["../../src/controller/Controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,EACN,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,YAAY,EACZ,iBAAiB,EACjB,aAAa,EAEb,mBAAmB,EAKpB,MAAM,wBAAwB,CAAC;AAYhC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAGzD,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAC5D,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvE,UAAU,gBAAgB,CAAC,CAAC,SAAS,eAAe,GAAG,kBAAkB;IACvE,QAAQ,CAAC,EAAE,CAAC,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC;AAcD;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU,CAC7B,CAAC,SAAS,eAAe,GAAG,kBAAkB;IAE9C;;;;OAIG;IACH,SAAiB,QAAQ,EAAE,CAAC,CAAC;IAC7B;;;;;;OAMG;IACH,SAAiB,QAAQ,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;IAChD,SAAiB,WAAW,EAAE,gBAAgB,CAAC;gBAEnC,EACV,QAA+B,EAC/B,QAAqB,EACrB,WAGC,GACF,GAAE,gBAAgB,CAAC,CAAC,CAAM;IAM3B,oDAAoD;IAEpD;;;OAGG;IACH,KAAK;;0IAmBH;IAEF;;;OAGG;IACH,UAAU,gKAGP,QAAQ,IAAI,CAAC,CAOQ;IAExB;;;OAGG;IACH,aAAa;uBAA8B,MAAM,KAAK,OAAO;wBACe;IAE5E;;;OAGG;IACH,gBAAgB,QAAO,QAAQ,IAAI,CAAC,CAAiC;IAErE;;;OAGG;IACH,WAAW;;kEAOR,QAAQ,IAAI,CAAC,CAOd;IAEF;;OAEG;IACwB,OAAO;;kEAO/B,QAAQ,IAAI,CAAC,CAGd;IAEF;;;OAGG;IACH,QAAQ;;oEAOL,QAAQ,IAAI,CAAC,CAQd;IAEF;;;OAGG;IACwB,YAAY;;oEAOpC,QAAQ,IAAI,CAAC,CAGd;IAEF;;;OAGG;IACH,OAAO;;;;kBASW,KAAK;mBACJ,MAAM;eACV,IAAI;;;kBAID,GAAG;mBACF,MAAM;;UAGtB,QAAQ,IAAI,CAAC,CAEd;IAEF;;;OAGG;IACH,SAAS,8JASN,QAAQ,IAAI,CAAC,CAOQ;IAExB;;;OAGG;IACH,WAAW,8JASR,QAAQ,IAAI,CAAC,CAOQ;IAExB,sCAAsC;IAStC;;;OAGG;IACH,QAAQ,UAAW,MAAM,OAAO,CAAC,cAAc,MAAM,KAAG,iBAAiB,CAEvE;IAEF;;;OAGG;IACH,QAAQ,4NAML,UAAU,GAAG,SAAS,CAavB;IAEF;;;OAGG;IACH,WAAW;;sBAQK,YAAY;mBACf,MAAM;MAkFjB;CACH;AA4CD,YAAY,EAAE,UAAU,EAAE,CAAC"}

package/lib/controller/Controller.js

@@ -1,8 +1,50 @@
-import BaseController from './BaseController.js';
+import { WeakEntityMap, ExpiryStatus, denormalizeCached, isEntity, denormalize } from '@data-client/normalizr';
+import { inferResults, validateInference } from '@data-client/normalizr';
 import createFetch from './createFetch.js';
-export default class Controller extends BaseController {
-  constructor(..._args) {
-    super(..._args);
+import createInvalidate from './createInvalidate.js';
+import createInvalidateAll from './createInvalidateAll.js';
+import createReset from './createReset.js';
+import createSet from './createSet.js';
+import { createUnsubscription, createSubscription } from './createSubscription.js';
+import { initialState } from '../state/reducer/createReducer.js';
+import selectMeta from '../state/selectMeta.js';
+const unsetDispatch = action => {
+  throw new Error(`Dispatching while constructing your middleware is not allowed. ` + `Other middleware would not be applied to this dispatch.`);
+};
+const unsetState = () => {
+  // This is only the value until it is set by the CacheProvider
+  /* istanbul ignore next */
+  return initialState;
+};
+
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/Controller
+ */
+export default class Controller {
+  /**
+   * Dispatches an action to Rest Hooks reducer.
+   *
+   * @see https://resthooks.io/docs/api/Controller#dispatch
+   */
+
+  /**
+   * Gets the latest state snapshot that is fully committed.
+   *
+   * This can be useful for imperative use-cases like event handlers.
+   * This should *not* be used to render; instead useSuspense() or useCache()
+   * @see https://resthooks.io/docs/api/Controller#getState
+   */
+
+  constructor({
+    dispatch = unsetDispatch,
+    getState = unsetState,
+    globalCache = {
+      entities: {},
+      results: {}
+    }
+  } = {}) {
+    /*************** Action Dispatchers ***************/
     /**
      * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
      * @see https://resthooks.io/docs/api/Controller#fetch
@@ -12,9 +54,237 @@ export default class Controller extends BaseController {
         args
       });
       this.dispatch(action);
+      if (endpoint.schema) {
+        return action.meta.promise.then(input => denormalize(input, endpoint.schema, {}, args));
+      }
       return action.meta.promise;
     };
+    /**
+     * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+     * @see https://resthooks.io/docs/api/Controller#invalidate
+     */
+    this.invalidate = (endpoint, ...args) => args[0] !== null ? this.dispatch(createInvalidate(endpoint, {
+      args: args
+    })) : Promise.resolve();
+    /**
+     * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
+     * @see https://resthooks.io/docs/api/Controller#invalidateAll
+     */
+    this.invalidateAll = options => this.dispatch(createInvalidateAll(key => options.testKey(key)));
+    /**
+     * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
+     * @see https://resthooks.io/docs/api/Controller#resetEntireStore
+     */
+    this.resetEntireStore = () => this.dispatch(createReset());
+    /**
+     * Stores response in cache for given Endpoint and args.
+     * @see https://resthooks.io/docs/api/Controller#set
+     */
+    this.setResponse = (endpoint, ...rest) => {
+      const response = rest[rest.length - 1];
+      const action = createSet(endpoint, {
+        args: rest.slice(0, rest.length - 1),
+        response
+      });
+      return this.dispatch(action);
+    };
+    /**
+     * @deprecated use https://resthooks.io/docs/api/Controller#setResponse instead
+     */
+    /* istanbul ignore next */
+    this.receive = (endpoint, ...rest) => {
+      /* istanbul ignore next */
+      return this.setResponse(endpoint, ...rest);
+    };
+    /**
+     * Stores the result of Endpoint and args as the error provided.
+     * @see https://resthooks.io/docs/api/Controller#setError
+     */
+    this.setError = (endpoint, ...rest) => {
+      const response = rest[rest.length - 1];
+      const action = createSet(endpoint, {
+        args: rest.slice(0, rest.length - 1),
+        response,
+        error: true
+      });
+      return this.dispatch(action);
+    };
+    /**
+     * Another name for setError
+     * @deprecated use https://resthooks.io/docs/api/Controller#setError instead
+     */
+    /* istanbul ignore next */
+    this.receiveError = (endpoint, ...rest) => {
+      /* istanbul ignore next */
+      return this.setError(endpoint, ...rest);
+    };
+    /**
+     * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
+     * @see https://resthooks.io/docs/api/Controller#resolve
+     */
+    this.resolve = (endpoint, meta) => {
+      return this.dispatch(createSet(endpoint, meta));
+    };
+    /**
+     * Marks a new subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#subscribe
+     */
+    this.subscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createSubscription(endpoint, {
+      args: args
+    })) : Promise.resolve();
+    /**
+     * Marks completion of subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#unsubscribe
+     */
+    this.unsubscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createUnsubscription(endpoint, {
+      args: args
+    })) : Promise.resolve();
+    /*************** More ***************/
+    /* TODO:
+    abort = <E extends EndpointInterface>(
+      endpoint: E,
+      ...args: readonly [...Parameters<E>]
+    ): Promise<void>
+    */
+    /**
+     * Gets a snapshot (https://resthooks.io/docs/api/Snapshot)
+     * @see https://resthooks.io/docs/api/Controller#snapshot
+     */
+    this.snapshot = (state, fetchedAt) => {
+      return new Snapshot(this, state, fetchedAt);
+    };
+    /**
+     * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
+     * @see https://resthooks.io/docs/api/Controller#getError
+     */
+    this.getError = (endpoint, ...rest) => {
+      if (rest[0] === null) return;
+      const state = rest[rest.length - 1];
+      // this is typescript generics breaking
+      const args = rest.slice(0, rest.length - 1);
+      const key = endpoint.key(...args);
+      const meta = selectMeta(state, key);
+      const results = state.results[key];
+      if (results !== undefined && (meta == null ? void 0 : meta.errorPolicy) === 'soft') return;
+      return meta == null ? void 0 : meta.error;
+    };
+    /**
+     * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+     * @see https://resthooks.io/docs/api/Controller#getResponse
+     */
+    this.getResponse = (endpoint, ...rest) => {
+      const state = rest[rest.length - 1];
+      // this is typescript generics breaking
+      const args = rest.slice(0, rest.length - 1);
+      const isActive = args.length !== 1 || args[0] !== null;
+      const key = isActive ? endpoint.key(...args) : '';
+      const cacheResults = isActive ? state.results[key] : undefined;
+      const schema = endpoint.schema;
+      const meta = selectMeta(state, key);
+      let expiresAt = meta == null ? void 0 : meta.expiresAt;
+      let invalidResults = false;
+      let results;
+      if (cacheResults === undefined && endpoint.schema !== undefined) {
+        results = inferResults(endpoint.schema, args, state.indexes, state.entities);
+        invalidResults = !validateInference(results);
+        if (!expiresAt && invalidResults) expiresAt = 1;
+      } else {
+        results = cacheResults;
+      }
+      if (!isActive) {
+        return {
+          data: results,
+          expiryStatus: ExpiryStatus.Valid,
+          expiresAt: Infinity
+        };
+      }
+      if (!endpoint.schema || !schemaHasEntity(endpoint.schema)) {
+        return {
+          data: results,
+          expiryStatus: meta != null && meta.invalidated ? ExpiryStatus.Invalid : cacheResults && !endpoint.invalidIfStale ? ExpiryStatus.Valid : ExpiryStatus.InvalidIfStale,
+          expiresAt: expiresAt || 0
+        };
+      }
+      if (!this.globalCache.results[key]) this.globalCache.results[key] = new WeakEntityMap();
+
+      // second argument is false if any entities are missing
+      // eslint-disable-next-line prefer-const
+      const {
+        data,
+        paths
+      } = denormalizeCached(results, schema, state.entities, this.globalCache.entities, this.globalCache.results[key], args);
+      const invalidDenormalize = typeof data === 'symbol';
+
+      // fallback to entity expiry time
+      if (!expiresAt) {
+        expiresAt = entityExpiresAt(paths, state.entityMeta);
+      }
+
+      // https://resthooks.io/docs/concepts/expiry-policy#expiry-status
+      // we don't track the difference between stale or fresh because that is tied to triggering
+      // conditions
+      const expiryStatus = meta != null && meta.invalidated || invalidDenormalize && !(meta != null && meta.error) ? ExpiryStatus.Invalid : invalidDenormalize || endpoint.invalidIfStale || invalidResults ? ExpiryStatus.InvalidIfStale : ExpiryStatus.Valid;
+      return {
+        data,
+        expiryStatus,
+        expiresAt
+      };
+    };
+    this.dispatch = dispatch;
+    this.getState = getState;
+    this.globalCache = globalCache;
+  }
+}
+
+// benchmark: https://www.measurethat.net/Benchmarks/Show/24691/0/min-reducer-vs-imperative-with-paths
+// earliest expiry dictates age
+function entityExpiresAt(paths, entityMeta) {
+  let expiresAt = Infinity;
+  for (const {
+    pk,
+    key
+  } of paths) {
+    var _entityMeta$key, _entityMeta$key$pk;
+    const entityExpiry = (_entityMeta$key = entityMeta[key]) == null ? void 0 : (_entityMeta$key$pk = _entityMeta$key[pk]) == null ? void 0 : _entityMeta$key$pk.expiresAt;
+    // expiresAt will always resolve to false with any comparison
+    if (entityExpiry < expiresAt) expiresAt = entityExpiry;
+  }
+  return expiresAt;
+}
+
+/** Determine whether the schema has any entities.
+ *
+ * Without entities, denormalization is not needed, and results should not be inferred.
+ */
+function schemaHasEntity(schema) {
+  if (isEntity(schema)) return true;
+  if (Array.isArray(schema)) return schema.length !== 0 && schemaHasEntity(schema[0]);
+  if (schema && (typeof schema === 'object' || typeof schema === 'function')) {
+    const nestedSchema = 'schema' in schema ? schema.schema : schema;
+    if (typeof nestedSchema === 'function') {
+      return schemaHasEntity(nestedSchema);
+    }
+    return Object.values(nestedSchema).some(x => schemaHasEntity(x));
+  }
+  return false;
+}
+class Snapshot {
+  constructor(controller, state, fetchedAt = 0) {
+    this.state = void 0;
+    this.controller = void 0;
+    this.fetchedAt = void 0;
+    /*************** Data Access ***************/
+    /** @see https://resthooks.io/docs/api/Snapshot#getResponse */
+    this.getResponse = (endpoint, ...args) => {
+      return this.controller.getResponse(endpoint, ...args, this.state);
+    };
+    /** @see https://resthooks.io/docs/api/Snapshot#getError */
+    this.getError = (endpoint, ...args) => {
+      return this.controller.getError(endpoint, ...args, this.state);
+    };
+    this.state = state;
+    this.controller = controller;
+    this.fetchedAt = fetchedAt;
   }
 }
-export * from './BaseController.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJCYXNlQ29udHJvbGxlciIsImNyZWF0ZUZldGNoIiwiQ29udHJvbGxlciIsImNvbnN0cnVjdG9yIiwiX2FyZ3MiLCJmZXRjaCIsImVuZHBvaW50IiwiYXJncyIsImFjdGlvbiIsImRpc3BhdGNoIiwibWV0YSIsInByb21pc2UiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJvbGxlci9Db250cm9sbGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRW5kcG9pbnRJbnRlcmZhY2UgfSBmcm9tICdAZGF0YS1jbGllbnQvbm9ybWFsaXpyJztcblxuaW1wb3J0IEJhc2VDb250cm9sbGVyLCB7XG4gIENvbXBhdGlibGVEaXNwYXRjaCxcbiAgR2VuZXJpY0Rpc3BhdGNoLFxufSBmcm9tICcuL0Jhc2VDb250cm9sbGVyLmpzJztcbmltcG9ydCBjcmVhdGVGZXRjaCBmcm9tICcuL2NyZWF0ZUZldGNoLmpzJztcbmltcG9ydCB0eXBlIHsgRW5kcG9pbnRVcGRhdGVGdW5jdGlvbiB9IGZyb20gJy4vdHlwZXMuanMnO1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBDb250cm9sbGVyPFxuICBEIGV4dGVuZHMgR2VuZXJpY0Rpc3BhdGNoID0gQ29tcGF0aWJsZURpc3BhdGNoLFxuPiBleHRlbmRzIEJhc2VDb250cm9sbGVyPEQ+IHtcbiAgLyoqXG4gICAqIEZldGNoZXMgdGhlIGVuZHBvaW50IHdpdGggZ2l2ZW4gYXJncywgdXBkYXRpbmcgdGhlIFJlc3QgSG9va3MgY2FjaGUgd2l0aCB0aGUgcmVzcG9uc2Ugb3IgZXJyb3IgdXBvbiBjb21wbGV0aW9uLlxuICAgKiBAc2VlIGh0dHBzOi8vcmVzdGhvb2tzLmlvL2RvY3MvYXBpL0NvbnRyb2xsZXIjZmV0Y2hcbiAgICovXG4gIGZldGNoID0gPFxuICAgIEUgZXh0ZW5kcyBFbmRwb2ludEludGVyZmFjZSAmIHsgdXBkYXRlPzogRW5kcG9pbnRVcGRhdGVGdW5jdGlvbjxFPiB9LFxuICA+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLmFyZ3M6IHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEU+XVxuICApOiBSZXR1cm5UeXBlPEU+ID0+IHtcbiAgICBjb25zdCBhY3Rpb24gPSBjcmVhdGVGZXRjaChlbmRwb2ludCwge1xuICAgICAgYXJncyxcbiAgICB9KTtcbiAgICB0aGlzLmRpc3BhdGNoKGFjdGlvbik7XG5cbiAgICByZXR1cm4gYWN0aW9uLm1ldGEucHJvbWlzZSBhcyBSZXR1cm5UeXBlPEU+O1xuICB9O1xufVxuXG5leHBvcnQgKiBmcm9tICcuL0Jhc2VDb250cm9sbGVyLmpzJztcbiJdLCJtYXBwaW5ncyI6IkFBRUEsT0FBT0EsY0FBYyxNQUdkLHFCQUFxQjtBQUM1QixPQUFPQyxXQUFXLE1BQU0sa0JBQWtCO0FBRzFDLGVBQWUsTUFBTUMsVUFBVSxTQUVyQkYsY0FBYyxDQUFJO0VBQUFHLFlBQUEsR0FBQUMsS0FBQTtJQUFBLFNBQUFBLEtBQUE7SUFDMUI7QUFDRjtBQUNBO0FBQ0E7SUFIRSxLQUlBQyxLQUFLLEdBQUcsQ0FHTkMsUUFBVyxFQUNYLEdBQUdDLElBQWlDLEtBQ2xCO01BQ2xCLE1BQU1DLE1BQU0sR0FBR1AsV0FBVyxDQUFDSyxRQUFRLEVBQUU7UUFDbkNDO01BQ0YsQ0FBQyxDQUFDO01BQ0YsSUFBSSxDQUFDRSxRQUFRLENBQUNELE1BQU0sQ0FBQztNQUVyQixPQUFPQSxNQUFNLENBQUNFLElBQUksQ0FBQ0MsT0FBTztJQUM1QixDQUFDO0VBQUE7QUFDSDtBQUVBLGNBQWMscUJBQXFCIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["WeakEntityMap","ExpiryStatus","denormalizeCached","isEntity","denormalize","inferResults","validateInference","createFetch","createInvalidate","createInvalidateAll","createReset","createSet","createUnsubscription","createSubscription","initialState","selectMeta","unsetDispatch","action","Error","unsetState","Controller","constructor","dispatch","getState","globalCache","entities","results","fetch","endpoint","args","schema","meta","promise","then","input","invalidate","Promise","resolve","invalidateAll","options","key","testKey","resetEntireStore","setResponse","rest","response","length","slice","receive","setError","error","receiveError","subscribe","unsubscribe","snapshot","state","fetchedAt","Snapshot","getError","undefined","errorPolicy","getResponse","isActive","cacheResults","expiresAt","invalidResults","indexes","data","expiryStatus","Valid","Infinity","schemaHasEntity","invalidated","Invalid","invalidIfStale","InvalidIfStale","paths","invalidDenormalize","entityExpiresAt","entityMeta","pk","_entityMeta$key","_entityMeta$key$pk","entityExpiry","Array","isArray","nestedSchema","Object","values","some","x","controller"],"sources":["../../src/controller/Controller.ts"],"sourcesContent":["import type {\n  ErrorTypes,\n  SnapshotInterface,\n  DenormalizeCache,\n  Schema,\n  Denormalize,\n} from '@data-client/normalizr';\nimport {\n  WeakEntityMap,\n  ExpiryStatus,\n  EndpointInterface,\n  FetchFunction,\n  ResolveType,\n  DenormalizeNullable,\n  Path,\n  denormalizeCached,\n  isEntity,\n  denormalize,\n} from '@data-client/normalizr';\nimport { inferResults, validateInference } from '@data-client/normalizr';\n\nimport createFetch from './createFetch.js';\nimport createInvalidate from './createInvalidate.js';\nimport createInvalidateAll from './createInvalidateAll.js';\nimport createReset from './createReset.js';\nimport createSet from './createSet.js';\nimport {\n  createUnsubscription,\n  createSubscription,\n} from './createSubscription.js';\nimport type { EndpointUpdateFunction } from './types.js';\nimport { initialState } from '../state/reducer/createReducer.js';\nimport selectMeta from '../state/selectMeta.js';\nimport type { ActionTypes, State } from '../types.js';\n\nexport type GenericDispatch = (value: any) => Promise<void>;\nexport type DataClientDispatch = (value: ActionTypes) => Promise<void>;\n\ninterface ConstructorProps<D extends GenericDispatch = DataClientDispatch> {\n  dispatch?: D;\n  getState?: () => State<unknown>;\n  globalCache?: DenormalizeCache;\n}\n\nconst unsetDispatch = (action: unknown): Promise<void> => {\n  throw new Error(\n    `Dispatching while constructing your middleware is not allowed. ` +\n      `Other middleware would not be applied to this dispatch.`,\n  );\n};\nconst unsetState = (): State<unknown> => {\n  // This is only the value until it is set by the CacheProvider\n  /* istanbul ignore next */\n  return initialState;\n};\n\n/**\n * Imperative control of Rest Hooks store\n * @see https://resthooks.io/docs/api/Controller\n */\nexport default class Controller<\n  D extends GenericDispatch = DataClientDispatch,\n> {\n  /**\n   * Dispatches an action to Rest Hooks reducer.\n   *\n   * @see https://resthooks.io/docs/api/Controller#dispatch\n   */\n  declare readonly dispatch: D;\n  /**\n   * Gets the latest state snapshot that is fully committed.\n   *\n   * This can be useful for imperative use-cases like event handlers.\n   * This should *not* be used to render; instead useSuspense() or useCache()\n   * @see https://resthooks.io/docs/api/Controller#getState\n   */\n  declare readonly getState: () => State<unknown>;\n  declare readonly globalCache: DenormalizeCache;\n\n  constructor({\n    dispatch = unsetDispatch as any,\n    getState = unsetState,\n    globalCache = {\n      entities: {},\n      results: {},\n    },\n  }: ConstructorProps<D> = {}) {\n    this.dispatch = dispatch;\n    this.getState = getState;\n    this.globalCache = globalCache;\n  }\n\n  /*************** Action Dispatchers ***************/\n\n  /**\n   * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.\n   * @see https://resthooks.io/docs/api/Controller#fetch\n   */\n  fetch = <\n    E extends EndpointInterface & { update?: EndpointUpdateFunction<E> },\n  >(\n    endpoint: E,\n    ...args: readonly [...Parameters<E>]\n  ): E['schema'] extends undefined | null\n    ? ReturnType<E>\n    : Promise<Denormalize<E['schema']>> => {\n    const action = createFetch(endpoint, {\n      args,\n    });\n    this.dispatch(action);\n\n    if (endpoint.schema) {\n      return action.meta.promise.then(input =>\n        denormalize(input, endpoint.schema, {}, args),\n      ) as any;\n    }\n    return action.meta.promise as any;\n  };\n\n  /**\n   * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.\n   * @see https://resthooks.io/docs/api/Controller#invalidate\n   */\n  invalidate = <E extends EndpointInterface>(\n    endpoint: E,\n    ...args: readonly [...Parameters<E>] | readonly [null]\n  ): Promise<void> =>\n    args[0] !== null\n      ? this.dispatch(\n          createInvalidate(endpoint, {\n            args: args as readonly [...Parameters<E>],\n          }),\n        )\n      : Promise.resolve();\n\n  /**\n   * Forces refetching and suspense on useSuspense on all matching endpoint result keys.\n   * @see https://resthooks.io/docs/api/Controller#invalidateAll\n   */\n  invalidateAll = (options: { testKey: (key: string) => boolean }) =>\n    this.dispatch(createInvalidateAll((key: string) => options.testKey(key)));\n\n  /**\n   * Resets the entire Rest Hooks cache. All inflight requests will not resolve.\n   * @see https://resthooks.io/docs/api/Controller#resetEntireStore\n   */\n  resetEntireStore = (): Promise<void> => this.dispatch(createReset());\n\n  /**\n   * Stores response in cache for given Endpoint and args.\n   * @see https://resthooks.io/docs/api/Controller#set\n   */\n  setResponse = <\n    E extends EndpointInterface & {\n      update?: EndpointUpdateFunction<E>;\n    },\n  >(\n    endpoint: E,\n    ...rest: readonly [...Parameters<E>, any]\n  ): Promise<void> => {\n    const response: ResolveType<E> = rest[rest.length - 1];\n    const action = createSet(endpoint, {\n      args: rest.slice(0, rest.length - 1) as Parameters<E>,\n      response,\n    });\n    return this.dispatch(action);\n  };\n\n  /**\n   * @deprecated use https://resthooks.io/docs/api/Controller#setResponse instead\n   */\n  /* istanbul ignore next */ receive = <\n    E extends EndpointInterface & {\n      update?: EndpointUpdateFunction<E>;\n    },\n  >(\n    endpoint: E,\n    ...rest: readonly [...Parameters<E>, any]\n  ): Promise<void> => {\n    /* istanbul ignore next */\n    return this.setResponse(endpoint, ...rest);\n  };\n\n  /**\n   * Stores the result of Endpoint and args as the error provided.\n   * @see https://resthooks.io/docs/api/Controller#setError\n   */\n  setError = <\n    E extends EndpointInterface & {\n      update?: EndpointUpdateFunction<E>;\n    },\n  >(\n    endpoint: E,\n    ...rest: readonly [...Parameters<E>, Error]\n  ): Promise<void> => {\n    const response: Error = rest[rest.length - 1];\n    const action = createSet(endpoint, {\n      args: rest.slice(0, rest.length - 1) as Parameters<E>,\n      response,\n      error: true,\n    });\n    return this.dispatch(action);\n  };\n\n  /**\n   * Another name for setError\n   * @deprecated use https://resthooks.io/docs/api/Controller#setError instead\n   */\n  /* istanbul ignore next */ receiveError = <\n    E extends EndpointInterface & {\n      update?: EndpointUpdateFunction<E>;\n    },\n  >(\n    endpoint: E,\n    ...rest: readonly [...Parameters<E>, Error]\n  ): Promise<void> => {\n    /* istanbul ignore next */\n    return this.setError(endpoint, ...rest);\n  };\n\n  /**\n   * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`\n   * @see https://resthooks.io/docs/api/Controller#resolve\n   */\n  resolve = <\n    E extends EndpointInterface & {\n      update?: EndpointUpdateFunction<E>;\n    },\n  >(\n    endpoint: E,\n    meta:\n      | {\n          args: readonly [...Parameters<E>];\n          response: Error;\n          fetchedAt: number;\n          error: true;\n        }\n      | {\n          args: readonly [...Parameters<E>];\n          response: any;\n          fetchedAt: number;\n          error?: false;\n        },\n  ): Promise<void> => {\n    return this.dispatch(createSet(endpoint, meta as any));\n  };\n\n  /**\n   * Marks a new subscription to a given Endpoint.\n   * @see https://resthooks.io/docs/api/Controller#subscribe\n   */\n  subscribe = <\n    E extends EndpointInterface<\n      FetchFunction,\n      Schema | undefined,\n      undefined | false\n    >,\n  >(\n    endpoint: E,\n    ...args: readonly [...Parameters<E>] | readonly [null]\n  ): Promise<void> =>\n    args[0] !== null\n      ? this.dispatch(\n          createSubscription(endpoint, {\n            args: args as readonly [...Parameters<E>],\n          }),\n        )\n      : Promise.resolve();\n\n  /**\n   * Marks completion of subscription to a given Endpoint.\n   * @see https://resthooks.io/docs/api/Controller#unsubscribe\n   */\n  unsubscribe = <\n    E extends EndpointInterface<\n      FetchFunction,\n      Schema | undefined,\n      undefined | false\n    >,\n  >(\n    endpoint: E,\n    ...args: readonly [...Parameters<E>] | readonly [null]\n  ): Promise<void> =>\n    args[0] !== null\n      ? this.dispatch(\n          createUnsubscription(endpoint, {\n            args: args as readonly [...Parameters<E>],\n          }),\n        )\n      : Promise.resolve();\n\n  /*************** More ***************/\n\n  /* TODO:\n  abort = <E extends EndpointInterface>(\n    endpoint: E,\n    ...args: readonly [...Parameters<E>]\n  ): Promise<void>\n  */\n\n  /**\n   * Gets a snapshot (https://resthooks.io/docs/api/Snapshot)\n   * @see https://resthooks.io/docs/api/Controller#snapshot\n   */\n  snapshot = (state: State<unknown>, fetchedAt?: number): SnapshotInterface => {\n    return new Snapshot(this, state, fetchedAt);\n  };\n\n  /**\n   * Gets the error, if any, for a given endpoint. Returns undefined for no errors.\n   * @see https://resthooks.io/docs/api/Controller#getError\n   */\n  getError = <\n    E extends Pick<EndpointInterface, 'key'>,\n    Args extends readonly [...Parameters<E['key']>] | readonly [null],\n  >(\n    endpoint: E,\n    ...rest: [...Args, State<unknown>]\n  ): ErrorTypes | undefined => {\n    if (rest[0] === null) return;\n    const state = rest[rest.length - 1] as State<unknown>;\n    // this is typescript generics breaking\n    const args: any = rest.slice(0, rest.length - 1) as Parameters<E['key']>;\n    const key = endpoint.key(...args);\n\n    const meta = selectMeta(state, key);\n    const results = state.results[key];\n\n    if (results !== undefined && meta?.errorPolicy === 'soft') return;\n\n    return meta?.error as any;\n  };\n\n  /**\n   * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.\n   * @see https://resthooks.io/docs/api/Controller#getResponse\n   */\n  getResponse = <\n    E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,\n    Args extends readonly [...Parameters<E['key']>] | readonly [null],\n  >(\n    endpoint: E,\n    ...rest: [...Args, State<unknown>]\n  ): {\n    data: DenormalizeNullable<E['schema']>;\n    expiryStatus: ExpiryStatus;\n    expiresAt: number;\n  } => {\n    const state = rest[rest.length - 1] as State<unknown>;\n    // this is typescript generics breaking\n    const args: any = rest.slice(0, rest.length - 1) as Parameters<E['key']>;\n    const isActive = args.length !== 1 || args[0] !== null;\n    const key = isActive ? endpoint.key(...args) : '';\n    const cacheResults = isActive ? state.results[key] : undefined;\n    const schema = endpoint.schema;\n    const meta = selectMeta(state, key);\n    let expiresAt = meta?.expiresAt;\n\n    let invalidResults = false;\n    let results;\n    if (cacheResults === undefined && endpoint.schema !== undefined) {\n      results = inferResults(\n        endpoint.schema,\n        args,\n        state.indexes,\n        state.entities,\n      );\n      invalidResults = !validateInference(results);\n      if (!expiresAt && invalidResults) expiresAt = 1;\n    } else {\n      results = cacheResults;\n    }\n\n    if (!isActive) {\n      return {\n        data: results as any,\n        expiryStatus: ExpiryStatus.Valid,\n        expiresAt: Infinity,\n      };\n    }\n\n    if (!endpoint.schema || !schemaHasEntity(endpoint.schema)) {\n      return {\n        data: results,\n        expiryStatus: meta?.invalidated\n          ? ExpiryStatus.Invalid\n          : cacheResults && !endpoint.invalidIfStale\n          ? ExpiryStatus.Valid\n          : ExpiryStatus.InvalidIfStale,\n        expiresAt: expiresAt || 0,\n      } as {\n        data: DenormalizeNullable<E['schema']>;\n        expiryStatus: ExpiryStatus;\n        expiresAt: number;\n      };\n    }\n\n    if (!this.globalCache.results[key])\n      this.globalCache.results[key] = new WeakEntityMap();\n\n    // second argument is false if any entities are missing\n    // eslint-disable-next-line prefer-const\n    const { data, paths } = denormalizeCached(\n      results,\n      schema,\n      state.entities,\n      this.globalCache.entities,\n      this.globalCache.results[key],\n      args,\n    ) as { data: DenormalizeNullable<E['schema']>; paths: Path[] };\n    const invalidDenormalize = typeof data === 'symbol';\n\n    // fallback to entity expiry time\n    if (!expiresAt) {\n      expiresAt = entityExpiresAt(paths, state.entityMeta);\n    }\n\n    // https://resthooks.io/docs/concepts/expiry-policy#expiry-status\n    // we don't track the difference between stale or fresh because that is tied to triggering\n    // conditions\n    const expiryStatus =\n      meta?.invalidated || (invalidDenormalize && !meta?.error)\n        ? ExpiryStatus.Invalid\n        : invalidDenormalize || endpoint.invalidIfStale || invalidResults\n        ? ExpiryStatus.InvalidIfStale\n        : ExpiryStatus.Valid;\n\n    return { data, expiryStatus, expiresAt };\n  };\n}\n\n// benchmark: https://www.measurethat.net/Benchmarks/Show/24691/0/min-reducer-vs-imperative-with-paths\n// earliest expiry dictates age\nfunction entityExpiresAt(\n  paths: Path[],\n  entityMeta: {\n    readonly [entityKey: string]: {\n      readonly [pk: string]: {\n        readonly date: number;\n        readonly expiresAt: number;\n        readonly fetchedAt: number; // This is only the value until it is set by the CacheProvider\n      };\n    };\n  },\n) {\n  let expiresAt = Infinity;\n  for (const { pk, key } of paths) {\n    const entityExpiry = entityMeta[key]?.[pk]?.expiresAt;\n    // expiresAt will always resolve to false with any comparison\n    if (entityExpiry < expiresAt) expiresAt = entityExpiry;\n  }\n  return expiresAt;\n}\n\n/** Determine whether the schema has any entities.\n *\n * Without entities, denormalization is not needed, and results should not be inferred.\n */\nfunction schemaHasEntity(schema: Schema): boolean {\n  if (isEntity(schema)) return true;\n  if (Array.isArray(schema))\n    return schema.length !== 0 && schemaHasEntity(schema[0]);\n  if (schema && (typeof schema === 'object' || typeof schema === 'function')) {\n    const nestedSchema =\n      'schema' in schema ? (schema.schema as Record<string, Schema>) : schema;\n    if (typeof nestedSchema === 'function') {\n      return schemaHasEntity(nestedSchema);\n    }\n    return Object.values(nestedSchema).some(x => schemaHasEntity(x));\n  }\n  return false;\n}\n\nexport type { ErrorTypes };\n\nclass Snapshot<T = unknown> implements SnapshotInterface {\n  private state: State<T>;\n  private controller: Controller;\n  readonly fetchedAt: number;\n\n  constructor(controller: Controller, state: State<T>, fetchedAt = 0) {\n    this.state = state;\n    this.controller = controller;\n    this.fetchedAt = fetchedAt;\n  }\n\n  /*************** Data Access ***************/\n  /** @see https://resthooks.io/docs/api/Snapshot#getResponse */\n  getResponse = <\n    E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,\n    Args extends readonly [...Parameters<E['key']>],\n  >(\n    endpoint: E,\n    ...args: Args\n  ): {\n    data: DenormalizeNullable<E['schema']>;\n    expiryStatus: ExpiryStatus;\n    expiresAt: number;\n  } => {\n    return this.controller.getResponse(endpoint, ...args, this.state);\n  };\n\n  /** @see https://resthooks.io/docs/api/Snapshot#getError */\n  getError = <\n    E extends Pick<EndpointInterface, 'key'>,\n    Args extends readonly [...Parameters<E['key']>],\n  >(\n    endpoint: E,\n    ...args: Args\n  ): ErrorTypes | undefined => {\n    return this.controller.getError(endpoint, ...args, this.state);\n  };\n}\n"],"mappings":"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"}

package/lib/controller/createFetch.d.ts

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

package/lib/controller/createFetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createFetch.d.ts","sourceRoot":"","sources":["../../src/controller/createFetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,yBAAyB,CAAC;AAEjC;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,CAAC,SAAS,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAA;CAAE,EAEpE,QAAQ,EAAE,CAAC,EACX,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,GAC9C,qBAAqB,CAAC,CAAC,CAAC,CAoC1B"}
+{"version":3,"file":"createFetch.d.ts","sourceRoot":"","sources":["../../src/controller/createFetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,CAAC,SAAS,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAA;CAAE,EAEpE,QAAQ,EAAE,CAAC,EACX,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,GAC9C,WAAW,CAAC,CAAC,CAAC,CAwBhB"}

package/lib/controller/createFetch.js

@@ -12,26 +12,15 @@ export default function createFetch(endpoint, {
     [resolve, reject] = [a, b];
   });
   const meta = {
-    schema: endpoint.schema,
-    type: endpoint.sideEffect ? 'mutate' : 'read',
     args,
     key,
     throttle: !endpoint.sideEffect,
-    options: endpoint,
     resolve,
     reject,
     promise,
-    createdAt: Date.now()
+    createdAt: Date.now(),
+    nm: false
   };
-  if (endpoint.update) {
-    meta.update = endpoint.update;
-  }
-
-  // TODO: Remove once EOL on this deprecated piece
-  /* istanbul ignore if */
-  if (endpoint.optimisticUpdate) {
-    meta.optimisticResponse = endpoint.optimisticUpdate(...args);
-  }
   return {
     type: FETCH_TYPE,
     payload: () => endpoint(...args),
@@ -39,4 +28,4 @@ export default function createFetch(endpoint, {
     endpoint
   };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/controller/createInvalidate.d.ts

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

package/lib/controller/createInvalidate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createInvalidate.d.ts","sourceRoot":"","sources":["../../src/controller/createInvalidate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,CAAC,SAAS,iBAAiB,EAClE,QAAQ,EAAE,CAAC,EACX,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,GAC9C,gBAAgB,CAOlB"}
+{"version":3,"file":"createInvalidate.d.ts","sourceRoot":"","sources":["../../src/controller/createInvalidate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,CAAC,SAAS,iBAAiB,EAClE,QAAQ,EAAE,CAAC,EACX,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,GAC9C,gBAAgB,CAOlB"}

package/lib/controller/createInvalidate.js

@@ -9,4 +9,4 @@ export default function createInvalidate(endpoint, {
     }
   };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJJTlZBTElEQVRFX1RZUEUiLCJjcmVhdGVJbnZhbGlkYXRlIiwiZW5kcG9pbnQiLCJhcmdzIiwidHlwZSIsIm1ldGEiLCJrZXkiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJvbGxlci9jcmVhdGVJbnZhbGlkYXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRW5kcG9pbnRJbnRlcmZhY2UgfSBmcm9tICdAZGF0YS1jbGllbnQvbm9ybWFsaXpyJztcblxuaW1wb3J0IHsgSU5WQUxJREFURV9UWVBFIH0gZnJvbSAnLi4vYWN0aW9uVHlwZXMuanMnO1xuaW1wb3J0IHR5cGUgeyBJbnZhbGlkYXRlQWN0aW9uIH0gZnJvbSAnLi4vbmV3QWN0aW9ucy5qcyc7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGNyZWF0ZUludmFsaWRhdGU8RSBleHRlbmRzIEVuZHBvaW50SW50ZXJmYWNlPihcbiAgZW5kcG9pbnQ6IEUsXG4gIHsgYXJncyB9OiB7IGFyZ3M6IHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEU+XSB9LFxuKTogSW52YWxpZGF0ZUFjdGlvbiB7XG4gIHJldHVybiB7XG4gICAgdHlwZTogSU5WQUxJREFURV9UWVBFLFxuICAgIG1ldGE6IHtcbiAgICAgIGtleTogZW5kcG9pbnQua2V5KC4uLmFyZ3MpLFxuICAgIH0sXG4gIH07XG59XG4iXSwibWFwcGluZ3MiOiJBQUVBLFNBQVNBLGVBQWUsUUFBUSxtQkFBbUI7QUFHbkQsZUFBZSxTQUFTQyxnQkFBZ0JBLENBQ3RDQyxRQUFXLEVBQ1g7RUFBRUM7QUFBNEMsQ0FBQyxFQUM3QjtFQUNsQixPQUFPO0lBQ0xDLElBQUksRUFBRUosZUFBZTtJQUNyQkssSUFBSSxFQUFFO01BQ0pDLEdBQUcsRUFBRUosUUFBUSxDQUFDSSxHQUFHLENBQUMsR0FBR0gsSUFBSTtJQUMzQjtFQUNGLENBQUM7QUFDSCJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJJTlZBTElEQVRFX1RZUEUiLCJjcmVhdGVJbnZhbGlkYXRlIiwiZW5kcG9pbnQiLCJhcmdzIiwidHlwZSIsIm1ldGEiLCJrZXkiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJvbGxlci9jcmVhdGVJbnZhbGlkYXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRW5kcG9pbnRJbnRlcmZhY2UgfSBmcm9tICdAZGF0YS1jbGllbnQvbm9ybWFsaXpyJztcblxuaW1wb3J0IHsgSU5WQUxJREFURV9UWVBFIH0gZnJvbSAnLi4vYWN0aW9uVHlwZXMuanMnO1xuaW1wb3J0IHR5cGUgeyBJbnZhbGlkYXRlQWN0aW9uIH0gZnJvbSAnLi4vdHlwZXMuanMnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBjcmVhdGVJbnZhbGlkYXRlPEUgZXh0ZW5kcyBFbmRwb2ludEludGVyZmFjZT4oXG4gIGVuZHBvaW50OiBFLFxuICB7IGFyZ3MgfTogeyBhcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFPl0gfSxcbik6IEludmFsaWRhdGVBY3Rpb24ge1xuICByZXR1cm4ge1xuICAgIHR5cGU6IElOVkFMSURBVEVfVFlQRSxcbiAgICBtZXRhOiB7XG4gICAgICBrZXk6IGVuZHBvaW50LmtleSguLi5hcmdzKSxcbiAgICB9LFxuICB9O1xufVxuIl0sIm1hcHBpbmdzIjoiQUFFQSxTQUFTQSxlQUFlLFFBQVEsbUJBQW1CO0FBR25ELGVBQWUsU0FBU0MsZ0JBQWdCQSxDQUN0Q0MsUUFBVyxFQUNYO0VBQUVDO0FBQTRDLENBQUMsRUFDN0I7RUFDbEIsT0FBTztJQUNMQyxJQUFJLEVBQUVKLGVBQWU7SUFDckJLLElBQUksRUFBRTtNQUNKQyxHQUFHLEVBQUVKLFFBQVEsQ0FBQ0ksR0FBRyxDQUFDLEdBQUdILElBQUk7SUFDM0I7RUFDRixDQUFDO0FBQ0gifQ==

package/lib/controller/createInvalidateAll.d.ts

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

package/lib/controller/createInvalidateAll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createInvalidateAll.d.ts","sourceRoot":"","sources":["../../src/controller/createInvalidateAll.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAChC,mBAAmB,CAKrB"}
+{"version":3,"file":"createInvalidateAll.d.ts","sourceRoot":"","sources":["../../src/controller/createInvalidateAll.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAChC,mBAAmB,CAKrB"}

package/lib/controller/createInvalidateAll.js

@@ -5,4 +5,4 @@ export default function createInvalidateAll(testKey) {
     testKey
   };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJJTlZBTElEQVRFQUxMX1RZUEUiLCJjcmVhdGVJbnZhbGlkYXRlQWxsIiwidGVzdEtleSIsInR5cGUiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJvbGxlci9jcmVhdGVJbnZhbGlkYXRlQWxsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElOVkFMSURBVEVBTExfVFlQRSB9IGZyb20gJy4uL2FjdGlvblR5cGVzLmpzJztcbmltcG9ydCB0eXBlIHsgSW52YWxpZGF0ZUFsbEFjdGlvbiB9IGZyb20gJy4uL25ld0FjdGlvbnMuanMnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBjcmVhdGVJbnZhbGlkYXRlQWxsKFxuICB0ZXN0S2V5OiAoa2V5OiBzdHJpbmcpID0+IGJvb2xlYW4sXG4pOiBJbnZhbGlkYXRlQWxsQWN0aW9uIHtcbiAgcmV0dXJuIHtcbiAgICB0eXBlOiBJTlZBTElEQVRFQUxMX1RZUEUsXG4gICAgdGVzdEtleSxcbiAgfTtcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0Esa0JBQWtCLFFBQVEsbUJBQW1CO0FBR3RELGVBQWUsU0FBU0MsbUJBQW1CQSxDQUN6Q0MsT0FBaUMsRUFDWjtFQUNyQixPQUFPO0lBQ0xDLElBQUksRUFBRUgsa0JBQWtCO0lBQ3hCRTtFQUNGLENBQUM7QUFDSCJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJJTlZBTElEQVRFQUxMX1RZUEUiLCJjcmVhdGVJbnZhbGlkYXRlQWxsIiwidGVzdEtleSIsInR5cGUiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJvbGxlci9jcmVhdGVJbnZhbGlkYXRlQWxsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElOVkFMSURBVEVBTExfVFlQRSB9IGZyb20gJy4uL2FjdGlvblR5cGVzLmpzJztcbmltcG9ydCB0eXBlIHsgSW52YWxpZGF0ZUFsbEFjdGlvbiB9IGZyb20gJy4uL3R5cGVzLmpzJztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gY3JlYXRlSW52YWxpZGF0ZUFsbChcbiAgdGVzdEtleTogKGtleTogc3RyaW5nKSA9PiBib29sZWFuLFxuKTogSW52YWxpZGF0ZUFsbEFjdGlvbiB7XG4gIHJldHVybiB7XG4gICAgdHlwZTogSU5WQUxJREFURUFMTF9UWVBFLFxuICAgIHRlc3RLZXksXG4gIH07XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGtCQUFrQixRQUFRLG1CQUFtQjtBQUd0RCxlQUFlLFNBQVNDLG1CQUFtQkEsQ0FDekNDLE9BQWlDLEVBQ1o7RUFDckIsT0FBTztJQUNMQyxJQUFJLEVBQUVILGtCQUFrQjtJQUN4QkU7RUFDRixDQUFDO0FBQ0gifQ==