@data-client/core 0.15.0 → 0.15.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @data-client/core
 
+## 0.15.3
+
+### Patch Changes
+
+- [#3691](https://github.com/reactive/data-client/pull/3691) [`bf3ac79`](https://github.com/reactive/data-client/commit/bf3ac7966dc615b1dc6cc6c6d600148fdca4e354) Thanks [@ntucker](https://github.com/ntucker)! - Fix CommonJS compatibility for `/mock` subpath exports.
+
+  Jest and other CommonJS consumers can now import from `@data-client/react/mock` and `@data-client/core/mock` without ESM parsing errors.
+
+- [`ed4ec6d`](https://github.com/reactive/data-client/commit/ed4ec6dc516ac9e3977de7ec9018bff962626133) Thanks [@ntucker](https://github.com/ntucker)! - Fix image links in package README
+
 ## 0.15.0
 
 ### Minor Changes

package/README.md

@@ -1,7 +1,7 @@
 <h1>
 <div align="center">
 <a href="https://dataclient.io" target="_blank" rel="noopener">
-  <img alt="Reactive Data Client" src="./data_client_logo_and_text.svg?sanitize=true">
+  <img alt="Reactive Data Client" src="https://raw.githubusercontent.com/reactive/data-client/master/packages/core/data_client_logo_and_text.svg?sanitize=true">
 </a>
 </div>
 </h1>

package/dist/mock.js

@@ -0,0 +1,1242 @@
+'use strict';
+
+var normalizr = require('@data-client/normalizr');
+
+function expireReducer(state, action) {
+  const meta = {
+    ...state.meta
+  };
+  Object.keys(meta).forEach(key => {
+    if (action.testKey(key)) {
+      meta[key] = {
+        ...meta[key],
+        // 1 instead of 0 so we can do 'falsy' checks to see if it is set
+        expiresAt: 1
+      };
+    }
+  });
+  return {
+    ...state,
+    meta
+  };
+}
+
+function createMeta(expiryLength, fetchedAt) {
+  const now = Date.now();
+  return {
+    fetchedAt: fetchedAt != null ? fetchedAt : now,
+    date: now,
+    expiresAt: now + expiryLength
+  };
+}
+
+const FETCH = 'rdc/fetch';
+const SET = 'rdc/set';
+const SET_RESPONSE = 'rdc/setresponse';
+const OPTIMISTIC = 'rdc/optimistic';
+const RESET = 'rdc/reset';
+const SUBSCRIBE = 'rdc/subscribe';
+const UNSUBSCRIBE = 'rdc/unsubscribe';
+const INVALIDATE = 'rdc/invalidate';
+const INVALIDATEALL = 'rdc/invalidateall';
+const EXPIREALL = 'rdc/expireall';
+const GC = 'rdc/gc';
+const FETCH_TYPE = FETCH;
+
+function createOptimistic(endpoint, args, fetchedAt) {
+  var _endpoint$dataExpiryL, _endpoint$dataExpiryL2;
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && ((_endpoint$dataExpiryL = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL : 0) < 0) {
+    throw new Error('Negative expiry length are not allowed.');
+  }
+  return {
+    type: OPTIMISTIC,
+    key: endpoint.key(...args),
+    args,
+    endpoint,
+    meta: createMeta((_endpoint$dataExpiryL2 = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL2 : 60000, fetchedAt)
+  };
+}
+
+function fetchReducer(state, action) {
+  if (action.endpoint.getOptimisticResponse && action.endpoint.sideEffect) {
+    const setAction = createOptimistic(action.endpoint, action.args, action.meta.fetchedAt);
+    return {
+      ...state,
+      optimistic: [...state.optimistic, setAction]
+    };
+  }
+  return state;
+}
+
+function invalidateReducer(state, action) {
+  const endpoints = {
+    ...state.endpoints
+  };
+  const meta = {
+    ...state.meta
+  };
+  const invalidateKey = key => {
+    delete endpoints[key];
+    const itemMeta = {
+      ...meta[key],
+      expiresAt: 0,
+      invalidated: true
+    };
+    delete itemMeta.error;
+    meta[key] = itemMeta;
+  };
+  if (action.type === INVALIDATE) {
+    invalidateKey(action.key);
+  } else {
+    Object.keys(endpoints).forEach(key => {
+      if (action.testKey(key)) {
+        invalidateKey(key);
+      }
+    });
+  }
+  return {
+    ...state,
+    endpoints,
+    meta
+  };
+}
+
+function setReducer(state, action, controller) {
+  let value;
+  if (typeof action.value === 'function') {
+    const previousValue = controller.get(action.schema, ...action.args, state);
+    if (previousValue === undefined) return state;
+    value = action.value(previousValue);
+  } else {
+    value = action.value;
+  }
+  try {
+    const {
+      entities,
+      indexes,
+      entitiesMeta
+    } = normalizr.normalize(action.schema, value, action.args, state, action.meta);
+    return {
+      entities,
+      endpoints: state.endpoints,
+      indexes,
+      meta: state.meta,
+      entitiesMeta,
+      optimistic: state.optimistic,
+      lastReset: state.lastReset
+    };
+    // reducer must update the state, so in case of processing errors we simply compute the endpoints inline
+  } catch (error) {
+    // this is not always bubbled up, so let's double sure this doesn't fail silently
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+      console.error(error);
+    }
+    return state;
+  }
+}
+
+class AbortOptimistic extends Error {}
+
+function setResponseReducer(state, action, controller) {
+  if (action.error) {
+    return reduceError(state, action, action.response);
+  }
+  try {
+    var _state$meta$action$ke;
+    let response;
+    // for true set's response is contained in action
+    if (action.type === OPTIMISTIC) {
+      // this should never happen
+      /* istanbul ignore if */
+      if (!action.endpoint.getOptimisticResponse) return state;
+      try {
+        // compute optimistic response based on current state
+        response = action.endpoint.getOptimisticResponse.call(action.endpoint, controller.snapshot(state, action.meta.fetchedAt), ...action.args);
+      } catch (e) {
+        // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
+        if (e.constructor === AbortOptimistic) {
+          return state;
+        }
+        throw e;
+      }
+    } else {
+      response = action.response;
+    }
+    const {
+      result,
+      entities,
+      indexes,
+      entitiesMeta
+    } = normalizr.normalize(action.endpoint.schema, response, action.args, state, action.meta);
+    const endpoints = {
+      ...state.endpoints,
+      [action.key]: result
+    };
+    try {
+      if (action.endpoint.update) {
+        const updaters = action.endpoint.update(result, ...action.args);
+        Object.keys(updaters).forEach(key => {
+          endpoints[key] = updaters[key](endpoints[key]);
+        });
+      }
+      // no reason to completely fail because of user-code error
+      // integrity of this state update is still guaranteed
+    } catch (error) {
+      console.error(`The following error occured during Endpoint.update() for ${action.key}`);
+      console.error(error);
+    }
+    return {
+      entities,
+      endpoints,
+      indexes,
+      meta: {
+        ...state.meta,
+        [action.key]: {
+          date: action.meta.date,
+          fetchedAt: action.meta.fetchedAt,
+          expiresAt: action.meta.expiresAt,
+          prevExpiresAt: (_state$meta$action$ke = state.meta[action.key]) == null ? void 0 : _state$meta$action$ke.expiresAt
+        }
+      },
+      entitiesMeta,
+      optimistic: filterOptimistic(state, action),
+      lastReset: state.lastReset
+    };
+    // reducer must update the state, so in case of processing errors we simply compute the endpoints inline
+  } catch (error) {
+    if (typeof error === 'object') {
+      error.message = `Error processing ${action.key}\n\nFull Schema: ${JSON.stringify(action.endpoint.schema, undefined, 2)}\n\nError:\n${error.message}`;
+      if ('response' in action) error.response = action.response;
+      error.status = 400;
+    }
+
+    // this is not always bubbled up, so let's double sure this doesn't fail silently
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+      console.error(error);
+    }
+    return reduceError(state, action, error);
+  }
+}
+function reduceError(state, action, error) {
+  if (error.name === 'AbortError') {
+    // In case we abort simply undo the optimistic update and act like no fetch even occured
+    // We still want those watching promises from fetch directly to observed the abort, but we don't want to
+    // Trigger errors in this case. This means theoretically improperly built aborts useSuspense() could suspend forever.
+    return {
+      ...state,
+      optimistic: filterOptimistic(state, action)
+    };
+  }
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      [action.key]: {
+        date: action.meta.date,
+        fetchedAt: action.meta.fetchedAt,
+        expiresAt: action.meta.expiresAt,
+        error,
+        errorPolicy: action.endpoint.errorPolicy == null ? void 0 : action.endpoint.errorPolicy(error)
+      }
+    },
+    optimistic: filterOptimistic(state, action)
+  };
+}
+/** Filter all requests with same serialization that did not start after the resolving request */
+function filterOptimistic(state, resolvingAction) {
+  return state.optimistic.filter(optimisticAction => optimisticAction.key !== resolvingAction.key || (optimisticAction.type === OPTIMISTIC ? optimisticAction.meta.fetchedAt !== resolvingAction.meta.fetchedAt : optimisticAction.meta.date > resolvingAction.meta.date));
+}
+
+function createReducer(controller) {
+  return function reducer(state, action) {
+    if (!state) state = initialState$1;
+    switch (action.type) {
+      case GC:
+        // inline deletes are fine as these should have 0 refcounts
+        action.entities.forEach(({
+          key,
+          pk
+        }) => {
+          var _entities$key, _entitiesMeta$key;
+          (_entities$key = state.entities[key]) == null || delete _entities$key[pk];
+          (_entitiesMeta$key = state.entitiesMeta[key]) == null || delete _entitiesMeta$key[pk];
+        });
+        action.endpoints.forEach(fetchKey => {
+          delete state.endpoints[fetchKey];
+          delete state.meta[fetchKey];
+        });
+        return state;
+      case FETCH:
+        return fetchReducer(state, action);
+      case OPTIMISTIC:
+      // eslint-disable-next-line no-fallthrough
+      case SET_RESPONSE:
+        return setResponseReducer(state, action, controller);
+      case SET:
+        return setReducer(state, action, controller);
+      case INVALIDATEALL:
+      case INVALIDATE:
+        return invalidateReducer(state, action);
+      case EXPIREALL:
+        return expireReducer(state, action);
+      case RESET:
+        return {
+          ...initialState$1,
+          lastReset: action.date
+        };
+      default:
+        // A reducer must always return a valid state.
+        // Alternatively you can throw an error if an invalid action is dispatched.
+        return state;
+    }
+  };
+}
+const initialState$1 = {
+  entities: {},
+  endpoints: {},
+  indexes: {},
+  meta: {},
+  entitiesMeta: {},
+  optimistic: [],
+  lastReset: 0
+};
+
+var __INTERNAL__ = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  INVALID: normalizr.INVALID,
+  MemoCache: normalizr.MemoCache,
+  initialState: initialState$1
+});
+
+function createSubscription(endpoint, {
+  args
+}) {
+  return {
+    type: SUBSCRIBE,
+    key: endpoint.key(...args),
+    args,
+    endpoint
+  };
+}
+function createUnsubscription(endpoint, {
+  args
+}) {
+  return {
+    type: UNSUBSCRIBE,
+    key: endpoint.key(...args),
+    args,
+    endpoint
+  };
+}
+
+const ensurePojo =
+// FormData doesn't exist in node
+/* istanbul ignore else we don't run coverage when we test node*/
+typeof FormData !== 'undefined' ? body => body instanceof FormData ? Object.fromEntries(body.entries()) : body : /* istanbul ignore next */body => body;
+
+function createSetResponse(endpoint, {
+  args,
+  fetchedAt,
+  response,
+  error = false
+}) {
+  var _endpoint$errorExpiry, _endpoint$dataExpiryL;
+  const expiryLength = error ? (_endpoint$errorExpiry = endpoint.errorExpiryLength) != null ? _endpoint$errorExpiry : 1000 : (_endpoint$dataExpiryL = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL : 60000;
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
+    throw new Error('Negative expiry length are not allowed.');
+  }
+  return {
+    type: SET_RESPONSE,
+    key: endpoint.key(...args),
+    response,
+    args: args.map(ensurePojo),
+    endpoint,
+    meta: createMeta(expiryLength, fetchedAt),
+    error
+  };
+}
+
+function createSet(schema, {
+  args,
+  fetchedAt,
+  value
+}) {
+  return {
+    type: SET,
+    value,
+    args: args.map(ensurePojo),
+    schema,
+    meta: createMeta(60000, fetchedAt)
+  };
+}
+
+function createReset() {
+  return {
+    type: RESET,
+    date: Date.now()
+  };
+}
+
+function createInvalidateAll(testKey) {
+  return {
+    type: INVALIDATEALL,
+    testKey
+  };
+}
+
+function createInvalidate(endpoint, {
+  args
+}) {
+  return {
+    type: INVALIDATE,
+    key: endpoint.key(...args)
+  };
+}
+
+/**
+ * Requesting a fetch to begin
+ */
+function createFetch(endpoint, {
+  args
+}) {
+  let resolve = 0;
+  let reject = 0;
+  const promise = new Promise((a, b) => {
+    [resolve, reject] = [a, b];
+  });
+  const meta = {
+    fetchedAt: Date.now(),
+    resolve,
+    reject,
+    promise
+  };
+  return {
+    type: FETCH,
+    key: endpoint.key(...args),
+    args,
+    endpoint,
+    meta
+  };
+}
+
+function createExpireAll(testKey) {
+  return {
+    type: EXPIREALL,
+    testKey
+  };
+}
+
+class ImmortalGCPolicy {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  init() {}
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  cleanup() {}
+  createCountRef() {
+    return () => () => undefined;
+  }
+}
+
+function selectMeta(state, fetchKey) {
+  return state.meta[fetchKey];
+}
+
+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 DataProvider
+  /* istanbul ignore next */
+  return initialState$1;
+};
+
+/**
+ * Imperative control of Reactive Data Client store
+ * @see https://dataclient.io/docs/api/Controller
+ */
+class Controller {
+  /**
+   * Dispatches an action to Reactive Data Client reducer.
+   *
+   * @see https://dataclient.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://dataclient.io/docs/api/Controller#getState
+   */
+
+  /**
+   * Singleton to maintain referential equality between calls
+   */
+
+  /**
+   * Handles garbage collection
+   */
+
+  constructor({
+    dispatch = unsetDispatch,
+    getState = unsetState,
+    memo = new normalizr.MemoCache(),
+    gcPolicy = new ImmortalGCPolicy()
+  } = {}) {
+    this._dispatch = dispatch;
+    this.getState = getState;
+    this.memo = memo;
+    this.gcPolicy = gcPolicy;
+  }
+
+  // TODO: drop when drop support for destructuring (0.14 and below)
+  set dispatch(dispatch) {
+    /* istanbul ignore next */
+    this._dispatch = dispatch;
+  }
+
+  // TODO: drop when drop support for destructuring (0.14 and below)
+  get dispatch() {
+    return this._dispatch;
+  }
+  bindMiddleware({
+    dispatch,
+    getState
+  }) {
+    this._dispatch = dispatch;
+    this.getState = getState;
+  }
+
+  /*************** Action Dispatchers ***************/
+
+  /**
+   * Fetches the endpoint with given args, updating the Reactive Data Client cache with the response or error upon completion.
+   * @see https://dataclient.io/docs/api/Controller#fetch
+   */
+  fetch = (endpoint, ...args) => {
+    const action = createFetch(endpoint, {
+      args
+    });
+    this.dispatch(action);
+    if (endpoint.schema) {
+      return action.meta.promise.then(input => normalizr.denormalize(endpoint.schema, input, {}, args));
+    }
+    return action.meta.promise;
+  };
+
+  /**
+   * Fetches only if endpoint is considered 'stale'; otherwise returns undefined
+   * @see https://dataclient.io/docs/api/Controller#fetchIfStale
+   */
+  fetchIfStale = (endpoint, ...args) => {
+    const {
+      data,
+      expiresAt,
+      expiryStatus
+    } = this.getResponseMeta(endpoint, ...args, this.getState());
+    if (expiryStatus !== normalizr.ExpiryStatus.Invalid && Date.now() <= expiresAt) return data;
+    return this.fetch(endpoint, ...args);
+  };
+
+  /**
+   * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+   * @see https://dataclient.io/docs/api/Controller#invalidate
+   */
+  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://dataclient.io/docs/api/Controller#invalidateAll
+   * @returns Promise that resolves when invalidation is commited.
+   */
+  invalidateAll = options => this.dispatch(createInvalidateAll(key => options.testKey(key)));
+
+  /**
+   * Sets all matching endpoint result keys to be STALE.
+   * @see https://dataclient.io/docs/api/Controller#expireAll
+   * @returns Promise that resolves when expiry is commited. *NOT* fetch promise
+   */
+  expireAll = options => this.dispatch(createExpireAll(key => options.testKey(key)));
+
+  /**
+   * Resets the entire Reactive Data Client cache. All inflight requests will not resolve.
+   * @see https://dataclient.io/docs/api/Controller#resetEntireStore
+   */
+  resetEntireStore = () => this.dispatch(createReset());
+
+  /**
+   * Sets value for the Queryable and args.
+   * @see https://dataclient.io/docs/api/Controller#set
+   */
+
+  set(schema, ...rest) {
+    const value = rest[rest.length - 1];
+    const action = createSet(schema, {
+      args: rest.slice(0, rest.length - 1),
+      value
+    });
+    // TODO: reject with error if this fails in reducer
+    return this.dispatch(action);
+  }
+
+  /**
+   * Sets response for the Endpoint and args.
+   * @see https://dataclient.io/docs/api/Controller#setResponse
+   */
+  setResponse = (endpoint, ...rest) => {
+    const response = rest[rest.length - 1];
+    const action = createSetResponse(endpoint, {
+      args: rest.slice(0, rest.length - 1),
+      response
+    });
+    return this.dispatch(action);
+  };
+
+  /**
+   * Sets an error response for the Endpoint and args.
+   * @see https://dataclient.io/docs/api/Controller#setError
+   */
+  setError = (endpoint, ...rest) => {
+    const response = rest[rest.length - 1];
+    const action = createSetResponse(endpoint, {
+      args: rest.slice(0, rest.length - 1),
+      response,
+      error: true
+    });
+    return this.dispatch(action);
+  };
+
+  /**
+   * Resolves an inflight fetch.
+   * @see https://dataclient.io/docs/api/Controller#resolve
+   */
+  resolve = (endpoint, meta) => {
+    return this.dispatch(createSetResponse(endpoint, meta));
+  };
+
+  /**
+   * Marks a new subscription to a given Endpoint.
+   * @see https://dataclient.io/docs/api/Controller#subscribe
+   */
+  subscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createSubscription(endpoint, {
+    args: args
+  })) : Promise.resolve();
+
+  /**
+   * Marks completion of subscription to a given Endpoint.
+   * @see https://dataclient.io/docs/api/Controller#unsubscribe
+   */
+  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://dataclient.io/docs/api/Snapshot)
+   * @see https://dataclient.io/docs/api/Controller#snapshot
+   */
+  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://dataclient.io/docs/api/Controller#getError
+   */
+
+  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 error = state.endpoints[key];
+    if (error !== 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://dataclient.io/docs/api/Controller#getResponse
+   */
+
+  getResponse(endpoint, ...rest) {
+    // TODO: breaking: only return data
+    return this.getResponseMeta(endpoint, ...rest);
+  }
+
+  /**
+   * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+   * @see https://dataclient.io/docs/api/Controller#getResponseMeta
+   */
+
+  getResponseMeta(endpoint, ...rest) {
+    const state = rest[rest.length - 1];
+    // this is typescript generics breaking
+    const args = rest.slice(0, rest.length - 1)
+    // handle FormData
+    .map(ensurePojo);
+    const isActive = args.length !== 1 || args[0] !== null;
+    const key = isActive ? endpoint.key(...args) : '';
+    const cacheEndpoints = isActive ? state.endpoints[key] : undefined;
+    const schema = endpoint.schema;
+    const meta = selectMeta(state, key);
+    let expiresAt = meta == null ? void 0 : meta.expiresAt;
+    // if we have no endpoint entry, and our endpoint has a schema - try querying the store
+    const shouldQuery = cacheEndpoints === undefined && schema !== undefined;
+    const input = shouldQuery ?
+    // nothing in endpoints cache, so try querying if we have a schema to do so
+    this.memo.buildQueryKey(schema, args, state, key) : cacheEndpoints;
+    if (!isActive) {
+      // when not active simply return the query input without denormalizing
+      return {
+        data: input,
+        expiryStatus: normalizr.ExpiryStatus.Valid,
+        expiresAt: Infinity,
+        countRef: () => () => undefined
+      };
+    }
+    let isInvalid = false;
+    if (shouldQuery) {
+      isInvalid = !normalizr.validateQueryKey(input);
+      // endpoint without entities
+    } else if (!schema || !schemaHasEntity(schema)) {
+      return {
+        data: cacheEndpoints,
+        expiryStatus: this.getExpiryStatus(!cacheEndpoints, !!endpoint.invalidIfStale, meta),
+        expiresAt: expiresAt || 0,
+        countRef: this.gcPolicy.createCountRef({
+          key
+        })
+      };
+    }
+    const {
+      data,
+      paths
+    } = this.memo.denormalize(schema, input, state.entities, args);
+    if (!expiresAt) {
+      // note: isInvalid can only be true if shouldQuery is true
+      if (isInvalid) expiresAt = 1;
+      // fallback to entity expiry time
+      else expiresAt = entityExpiresAt(paths, state.entitiesMeta);
+    }
+    return {
+      data,
+      expiryStatus: this.getExpiryStatus(typeof data === 'symbol', !!endpoint.invalidIfStale || isInvalid, meta),
+      expiresAt,
+      countRef: this.gcPolicy.createCountRef({
+        key,
+        paths
+      })
+    };
+  }
+
+  /**
+   * Queries the store for a Querable schema
+   * @see https://dataclient.io/docs/api/Controller#get
+   */
+  get(schema, ...rest) {
+    const state = rest[rest.length - 1];
+    // this is typescript generics breaking
+    const args = rest.slice(0, rest.length - 1).map(ensurePojo);
+    const {
+      data
+    } = this.memo.query(schema, args, state);
+    return typeof data === 'symbol' ? undefined : data;
+  }
+
+  /**
+   * Queries the store for a Querable schema; providing related metadata
+   * @see https://dataclient.io/docs/api/Controller#getQueryMeta
+   */
+  getQueryMeta(schema, ...rest) {
+    const state = rest[rest.length - 1];
+    // this is typescript generics breaking
+    const args = rest.slice(0, rest.length - 1).map(ensurePojo);
+    const {
+      data,
+      paths
+    } = this.memo.query(schema, args, state);
+    return {
+      data: typeof data === 'symbol' ? undefined : data,
+      countRef: this.gcPolicy.createCountRef({
+        paths
+      })
+    };
+  }
+  getExpiryStatus(invalidData, invalidIfStale, meta = {}) {
+    // https://dataclient.io/docs/concepts/expiry-policy#expiry-status
+    // we don't track the difference between stale or fresh because that is tied to triggering
+    // conditions
+    return meta.invalidated || invalidData && !meta.error ? normalizr.ExpiryStatus.Invalid : invalidData || invalidIfStale ? normalizr.ExpiryStatus.InvalidIfStale : normalizr.ExpiryStatus.Valid;
+  }
+}
+
+// benchmark: https://www.measurethat.net/Benchmarks/Show/24691/0/min-reducer-vs-imperative-with-paths
+// earliest expiry dictates age
+function entityExpiresAt(paths, entitiesMeta) {
+  let expiresAt = Infinity;
+  for (const {
+    key,
+    pk
+  } of paths) {
+    var _entitiesMeta$key;
+    const entityExpiry = (_entitiesMeta$key = entitiesMeta[key]) == null || (_entitiesMeta$key = _entitiesMeta$key[pk]) == null ? void 0 : _entitiesMeta$key.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 queried.
+ */
+function schemaHasEntity(schema) {
+  if (normalizr.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 {
+  static abort = new AbortOptimistic();
+  state;
+  controller;
+  fetchedAt;
+  abort = Snapshot.abort;
+  constructor(controller, state, fetchedAt = 0) {
+    this.state = state;
+    this.controller = controller;
+    this.fetchedAt = fetchedAt;
+  }
+
+  /*************** Data Access ***************/
+  /** @see https://dataclient.io/docs/api/Snapshot#getResponse */
+
+  getResponse(endpoint, ...args) {
+    return this.controller.getResponse(endpoint, ...args, this.state);
+  }
+
+  /** @see https://dataclient.io/docs/api/Snapshot#getResponseMeta */
+
+  getResponseMeta(endpoint, ...args) {
+    return this.controller.getResponseMeta(endpoint, ...args, this.state);
+  }
+
+  /** @see https://dataclient.io/docs/api/Snapshot#getError */
+
+  getError(endpoint, ...args) {
+    return this.controller.getError(endpoint, ...args, this.state);
+  }
+
+  /**
+   * Retrieved memoized value for any Querable schema
+   * @see https://dataclient.io/docs/api/Snapshot#get
+   */
+  get(schema, ...args) {
+    return this.controller.get(schema, ...args, this.state);
+  }
+
+  /**
+   * Queries the store for a Querable schema; providing related metadata
+   * @see https://dataclient.io/docs/api/Snapshot#getQueryMeta
+   */
+  getQueryMeta(schema, ...args) {
+    return this.controller.getQueryMeta(schema, ...args, this.state);
+  }
+}
+
+var _DevToolsManager;
+let DEFAULT_CONFIG = {};
+if (process.env.NODE_ENV !== 'production') {
+  var _globalThis$document;
+  const extraEndpointKeys = ['dataExpiryLength', 'errorExpiryLength', 'errorPolicy', 'invalidIfStale', 'pollFrequency', 'getOptimisticResponse', 'update'];
+  function serializeEndpoint(endpoint) {
+    var _toJSON, _endpoint$schema;
+    const serial = {
+      name: endpoint.name,
+      schema: (_toJSON = (_endpoint$schema = endpoint.schema) == null || _endpoint$schema.toJSON == null ? void 0 : _endpoint$schema.toJSON()) != null ? _toJSON : endpoint.schema,
+      sideEffect: endpoint.sideEffect
+    };
+    extraEndpointKeys.forEach(key => {
+      if (key in endpoint) serial[key] = endpoint[key];
+    });
+    return serial;
+  }
+  const HASINTL = typeof Intl !== 'undefined';
+  DEFAULT_CONFIG = {
+    name: `Data Client: ${(_globalThis$document = globalThis.document) == null ? void 0 : _globalThis$document.title}`,
+    autoPause: true,
+    features: {
+      pause: true,
+      // start/pause recording of dispatched actions
+      lock: true,
+      // lock/unlock dispatching actions and side effects
+      persist: false,
+      // persist states on page reloading
+      export: true,
+      // export history of actions in a file
+      import: 'custom',
+      // import history of actions from a file
+      jump: true,
+      // jump back and forth (time travelling)
+      skip: true,
+      // skip (cancel) actions
+      reorder: true,
+      // drag and drop actions in the history list
+      dispatch: false,
+      // dispatch custom actions or action creators
+      test: false // generate tests for the selected actions
+    },
+    actionSanitizer: action => {
+      if (!('endpoint' in action)) return action;
+      return {
+        ...action,
+        endpoint: serializeEndpoint(action.endpoint)
+      };
+    },
+    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://dataclient.io/docs/api/DevToolsManager
+ */
+class DevToolsManager {
+  constructor(config, skipLogging) {
+    this.started = false;
+    this.actions = [];
+    this.maxBufferLength = 100;
+    /* istanbul ignore next */
+    this.devTools = typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__.connect({
+      ...DEFAULT_CONFIG,
+      ...config
+    });
+    // we cut it in half so we should double so we don't lose
+    if (config != null && config.maxAge) this.maxBufferLength = config.maxAge * 2;
+    if (skipLogging) this.skipLogging = skipLogging;
+  }
+  handleAction(action, state) {
+    if (this.started) {
+      this.devTools.send(action, state);
+    } else {
+      // avoid this getting too big in case this is long running
+      // we cut in half so we aren't constantly reallocating
+      if (this.actions.length > this.maxBufferLength) this.actions = this.actions.slice(this.maxBufferLength / 2);
+      // queue actions
+      this.actions.push([action, state]);
+    }
+  }
+
+  /** Called when initial state is ready */
+  init(state) {
+    if (process.env.NODE_ENV !== 'production' && this.devTools) {
+      this.devTools.init(state);
+      this.devTools.subscribe(msg => {
+        switch (msg.type) {
+          case 'START':
+            this.started = true;
+            if (this.actions.length) {
+              this.actions.forEach(([action, state]) => {
+                this.handleAction(action, state);
+              });
+              this.actions = [];
+            }
+            break;
+          case 'STOP':
+            this.started = false;
+            break;
+          case 'DISPATCH':
+            if (msg.payload.type === 'RESET') {
+              this.controller.resetEntireStore();
+            }
+            break;
+        }
+      });
+    }
+  }
+
+  /** Ensures all subscriptions are cleaned up. */
+  cleanup() {}
+}
+_DevToolsManager = DevToolsManager;
+(() => {
+  /* istanbul ignore if */
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV !== 'production') {
+    _DevToolsManager.prototype.middleware = function (controller) {
+      if (!this.devTools) return next => action => next(action);
+      this.controller = controller;
+      const reducer = createReducer(controller);
+      let state = controller.getState();
+      return next => action => {
+        var _this$skipLogging;
+        const shouldSkip = (_this$skipLogging = this.skipLogging) == null ? void 0 : _this$skipLogging.call(this, action);
+        const ret = next(action);
+        if (this.started) {
+          // we track state changes here since getState() will only update after a batch commit
+          state = reducer(state, action);
+        } else {
+          state = controller.getState();
+        }
+        ret.then(() => {
+          if (shouldSkip) return;
+          this.handleAction(action, state.optimistic.reduce(reducer, state));
+        });
+        return ret;
+      };
+    };
+  } else {
+    _DevToolsManager.prototype.middleware = () => next => action => next(action);
+  }
+})();
+
+async function collapseFixture(fixture, args, interceptorData) {
+  let error = 'error' in fixture ? fixture.error : false;
+  let response = fixture.response;
+  if (typeof fixture.response === 'function') {
+    try {
+      response = await fixture.response.apply(interceptorData, args);
+      // dispatch goes through user-code that can sometimes fail.
+      // let's ensure we always handle errors
+    } catch (e) {
+      response = e;
+      error = true;
+    }
+  }
+  return {
+    response,
+    error
+  };
+}
+
+function createFixtureMap(fixtures = []) {
+  const map = new Map();
+  const computed = [];
+  for (const fixture of fixtures) {
+    if ('args' in fixture) {
+      if (typeof fixture.response !== 'function') {
+        const key = fixture.endpoint.key(...fixture.args);
+        map.set(key, fixture);
+      } else {
+        // this has to be a typo. probably needs to remove args
+        console.warn(`Fixture found with function response, and explicit args. Interceptors should not specify args.
+${fixture.endpoint.name}: ${JSON.stringify(fixture.args)}
+
+Treating as Interceptor`);
+        computed.push(fixture);
+      }
+    } else {
+      computed.push(fixture);
+    }
+  }
+  return [map, computed];
+}
+
+function MockController(Base, {
+  fixtures = [],
+  getInitialInterceptorData = () => ({})
+}) {
+  const [fixtureMap, interceptors] = createFixtureMap(fixtures);
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return class MockedController extends Base {
+    // legacy compatibility (re-declaration)
+    // TODO: drop when drop support for destructuring (0.14 and below)
+
+    fixtureMap = fixtureMap;
+    interceptors = interceptors;
+    interceptorData = getInitialInterceptorData();
+    constructor(...args) {
+      super(...args);
+
+      // legacy compatibility
+      // TODO: drop when drop support for destructuring (0.14 and below)
+      if (!this._dispatch) {
+        this._dispatch = args[0].dispatch;
+      }
+    }
+
+    // legacy compatibility - we need this to work with 0.14 and below as they do not have this setter
+    // TODO: drop when drop support for destructuring (0.14 and below)
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    set dispatch(dispatch) {
+      this._dispatch = dispatch;
+    }
+    get dispatch() {
+      return action => {
+        var _actionTypes$FETCH;
+        // support legacy that has _TYPE suffix
+        if (action.type === ((_actionTypes$FETCH = FETCH) != null ? _actionTypes$FETCH : FETCH_TYPE)) {
+          // eslint-disable-next-line prefer-const
+          let {
+            key,
+            args
+          } = action;
+          let fixture;
+          if (this.fixtureMap.has(key)) {
+            fixture = this.fixtureMap.get(key);
+            if (!args) args = fixture.args;
+            // exact matches take priority; now test ComputedFixture
+          } else {
+            for (const cfix of this.interceptors) {
+              if (cfix.endpoint.testKey(key)) {
+                fixture = cfix;
+                break;
+              }
+            }
+          }
+          // we have a match
+          if (fixture !== undefined) {
+            var _fixture$delay;
+            const replacedAction = {
+              ...action
+            };
+            const delayMs = typeof fixture.delay === 'function' ? fixture.delay(...args) : (_fixture$delay = fixture.delay) != null ? _fixture$delay : 0;
+            if ('fetchResponse' in fixture) {
+              const {
+                fetchResponse
+              } = fixture;
+              fixture = {
+                endpoint: fixture.endpoint,
+                response(...args) {
+                  const endpoint = action.endpoint.extend({
+                    fetchResponse: (input, init) => {
+                      const ret = fetchResponse.call(this, input, init);
+                      return Promise.resolve(new Response(JSON.stringify(ret), {
+                        status: 200,
+                        headers: new Headers({
+                          'Content-Type': 'application/json'
+                        })
+                      }));
+                    }
+                  });
+                  return endpoint(...args);
+                }
+              };
+            }
+            const fetch = async () => {
+              if (!fixture) {
+                throw new Error('No fixture found');
+              }
+              // delayCollapse determines when the fixture function is 'collapsed' (aka 'run')
+              // collapsed: https://en.wikipedia.org/wiki/Copenhagen_interpretation
+              if (fixture.delayCollapse) {
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+              }
+              const result = await collapseFixture(fixture, args, this.interceptorData);
+              if (!fixture.delayCollapse && delayMs) {
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+              }
+              if (result.error) {
+                throw result.response;
+              }
+              return result.response;
+            };
+            if (typeof replacedAction.endpoint.extend === 'function') {
+              replacedAction.endpoint = replacedAction.endpoint.extend({
+                fetch
+              });
+            } else {
+              // TODO: full testing of this
+              replacedAction.endpoint = fetch;
+              replacedAction.endpoint.__proto__ = action.endpoint;
+            }
+
+            // TODO: make super.dispatch (once we drop support for destructuring)
+            return this._dispatch(replacedAction);
+          }
+        }
+        // TODO: make super.dispatch (once we drop support for destructuring)
+        return this._dispatch(action);
+      };
+    }
+  };
+}
+
+const {
+  initialState
+} = __INTERNAL__;
+function mockInitialState(fixtures = []) {
+  const actions = [];
+  const dispatch = action => {
+    actions.push(action);
+    return Promise.resolve();
+  };
+  const controller = new Controller({
+    dispatch
+  });
+  const reducer = createReducer(controller);
+  fixtures.forEach(fixture => {
+    dispatchFixture(fixture, fixture.args, controller);
+  });
+  return actions.reduce(reducer, initialState);
+}
+function dispatchFixture(fixture, args, controller, fetchedAt) {
+  // eslint-disable-next-line prefer-const
+  let {
+    endpoint
+  } = fixture;
+  const {
+    response,
+    error
+  } = fixture;
+  if (controller.resolve) {
+    controller.resolve(endpoint, {
+      args,
+      response,
+      error,
+      fetchedAt: Date.now()
+    });
+  } else {
+    if (error === true) {
+      controller.setError(endpoint, ...args, response);
+    } else {
+      controller.setResponse(endpoint, ...args, response);
+    }
+  }
+}
+
+exports.MockController = MockController;
+exports.collapseFixture = collapseFixture;
+exports.createFixtureMap = createFixtureMap;
+exports.mockInitialState = mockInitialState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@data-client/core",
-  "version": "0.15.0",
+  "version": "0.15.3",
   "description": "Async State Management without the Management. REST, GraphQL, SSE, Websockets, Fetch",
   "sideEffects": false,
   "main": "dist/index.js",
@@ -56,6 +56,7 @@
     },
     "./mock": {
       "types": "./lib/mock/index.d.ts",
+      "require": "./dist/mock.js",
       "default": "./lib/mock/index.js"
     },
     "./package.json": "./package.json"
@@ -72,9 +73,7 @@
     "node.mjs",
     "legacy",
     "LICENSE",
-    "README.md",
-    "./typescript.svg",
-    "./data_client_logo_and_text.svg"
+    "README.md"
   ],
   "scripts": {
     "build:lib": "NODE_ENV=production BROWSERSLIST_ENV='2020' POLYFILL_TARGETS='chrome>88,safari>14' yarn g:babel --out-dir lib",
@@ -140,7 +139,7 @@
   },
   "devDependencies": {
     "@anansi/browserslist-config": "^1.4.2",
-    "@data-client/endpoint": "0.15.0",
+    "@data-client/endpoint": "0.15.2",
     "@types/jest": "30.0.0",
     "@types/node": "^24.0.0",
     "rollup-plugins": "1.0.0"

package/data_client_logo_and_text.svg

@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 23.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="69 220 1136 205" height="100" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:current;}
-	.st1{fill:#3E96DB;}
-</style>
-<g>
-	<g>
-		<g>
-			<path class="st0" d="M448.61,325.58l5.27,10.28h-11.52l-5.27-10.28l-5.51-10.78l-0.25-0.49c-1.81-2.96-5.02-4.94-8.72-4.94
-				h-10.28v26.49h-10.28v-57.59h36.37c4.28,0,8.15,1.73,10.94,4.53c2.8,2.88,4.53,6.75,4.53,11.02c0,6.25-3.7,11.68-9.05,14.15
-				c-1.4,0.66-2.88,1.07-4.44,1.23L448.61,325.58z M438.41,299.09c0.74,0,1.48-0.16,2.14-0.49c1.89-0.82,3.13-2.72,3.13-4.77
-				c0-1.89-0.99-3.21-1.56-3.78c-0.66-0.66-1.89-1.48-3.7-1.48h-26.08v10.61L438.41,299.09z"/>
-			<path class="st0" d="M518.13,293.74v5.35h37.02v10.28h-37.02v10.86c0,2.88,2.39,5.27,5.27,5.27h42.04v10.28H523.4
-				c-8.56,0-15.47-6.99-15.47-15.55v-26.49c0-8.56,6.91-15.55,15.47-15.55h42.04v10.28H523.4
-				C520.52,288.48,518.13,290.86,518.13,293.74z"/>
-			<path class="st0" d="M674.79,335.78h-11.52L658,325.5l-12.59-24.68l-12.59,24.68l-5.27,10.28h-11.52l5.27-10.28l24.11-47.31
-				l24.11,47.31L674.79,335.78z"/>
-			<path class="st0" d="M727.61,306.99c0,10.2,8.31,18.51,18.51,18.51h28.8v10.28h-28.8c-15.88,0-28.8-12.92-28.8-28.8
-				s12.92-28.8,28.8-28.8h28.8v10.28h-28.8C735.92,288.48,727.61,296.79,727.61,306.99z"/>
-			<path class="st0" d="M886.32,278.27v10.28h-23.61v47.31h-10.28v-47.31h-23.61v-10.28H886.32z"/>
-			<path class="st0" d="M940.3,335.78v-57.59h10.28v57.59H940.3z"/>
-			<path class="st0" d="M1059.85,278.19l-5.27,10.28l-24.11,47.31l-24.11-47.31l-5.27-10.28h11.52l5.27,10.28l12.59,24.68
-				l12.59-24.68l5.27-10.28H1059.85z"/>
-			<path class="st0" d="M1117.19,293.74v5.35h37.02v10.28h-37.02v10.86c0,2.88,2.39,5.27,5.27,5.27h42.04v10.28h-42.04
-				c-8.56,0-15.47-6.99-15.47-15.55v-26.49c0-8.56,6.91-15.55,15.47-15.55h42.04v10.28h-42.04
-				C1119.58,288.48,1117.19,290.86,1117.19,293.74z"/>
-		</g>
-		<g>
-			<path class="st0" d="M562.83,376.16h9.02c6.88,0,11.55,4.34,11.55,10.7c0,6.36-4.68,10.7-11.55,10.7h-9.02V376.16z M571.67,394.9
-				c5.29,0,8.68-3.24,8.68-8.04c0-4.8-3.39-8.04-8.68-8.04h-5.78v16.08H571.67z"/>
-			<path class="st0" d="M625.16,392.21h-11.37l-2.35,5.35h-3.15l9.69-21.4H621l9.72,21.4h-3.21L625.16,392.21z M624.09,389.76
-				l-4.62-10.48l-4.62,10.48H624.09z"/>
-			<path class="st0" d="M660.83,378.82h-7.34v-2.66h17.7v2.66h-7.34v18.74h-3.03V378.82z"/>
-			<path class="st0" d="M710.84,392.21h-11.37l-2.35,5.35h-3.15l9.69-21.4h3.03l9.72,21.4h-3.21L710.84,392.21z M709.77,389.76
-				l-4.62-10.48l-4.62,10.48H709.77z"/>
-			<path class="st0" d="M773.57,386.86c0-6.33,4.83-10.94,11.34-10.94c3.3,0,6.17,1.13,8.13,3.33l-1.99,1.93
-				c-1.65-1.74-3.67-2.54-6.02-2.54c-4.83,0-8.41,3.48-8.41,8.22c0,4.74,3.58,8.22,8.41,8.22c2.35,0,4.37-0.83,6.02-2.57l1.99,1.93
-				c-1.96,2.2-4.83,3.36-8.16,3.36C778.4,397.8,773.57,393.19,773.57,386.86z"/>
-			<path class="st0" d="M821.16,376.16h3.06v18.74h11.59v2.66h-14.64V376.16z"/>
-			<path class="st0" d="M863.07,376.16h3.06v21.4h-3.06V376.16z"/>
-			<path class="st0" d="M911.82,394.9v2.66h-15.53v-21.4h15.1v2.66h-12.04v6.57h10.73v2.6h-10.73v6.91H911.82z"/>
-			<path class="st0" d="M958.93,376.16v21.4h-2.51l-12.84-15.96v15.96h-3.06v-21.4h2.51l12.84,15.96v-15.96H958.93z"/>
-			<path class="st0" d="M993.35,378.82h-7.34v-2.66h17.7v2.66h-7.34v18.74h-3.03V378.82z"/>
-		</g>
-	</g>
-	<g>
-		<path class="st1" d="M275.11,347.41c-21.84,54.68-67.33,87.9-101.61,74.21c-1.86-0.74-3.65-1.61-5.36-2.59
-			c31.37,7.82,68.88-18.56,86.22-61.96c18.43-46.13,7.09-94.02-25.32-106.97c-19.2-7.67-41.49-1.36-60.3,14.65
-			c23.82-34.07,57.23-51.76,83.86-41.13C286.87,237.31,296.95,292.74,275.11,347.41z"/>
-		<path class="st1" d="M215.54,391.87c-67.76-21.72-114.76-64.06-104.98-94.57c0.53-1.66,1.22-3.24,2.06-4.76
-			c-3.46,28.09,34.11,62.97,87.9,80.22c57.17,18.33,111.01,9.8,120.25-19.05c5.48-17.09-5.92-37.48-28-55.07
-			c44.07,22.77,70.76,53.62,63.16,77.33C346.16,406.48,283.3,413.6,215.54,391.87z"/>
-		<path class="st1" d="M161.63,326.13c37.03-27.02,76.92-35.4,89.08-18.72c0.66,0.91,1.22,1.86,1.7,2.88
-			c-13.31-12.47-45.72-6.16-75.13,15.29c-31.25,22.79-47.25,54.05-35.75,69.82c6.81,9.34,21.75,11.15,39.29,6.34
-			c-28.58,14.29-54.78,16.46-64.23,3.51C104.44,388.57,124.6,353.15,161.63,326.13z"/>
-		<circle class="st1" cx="212.69" cy="340.87" r="11.83"/>
-		<circle class="st1" cx="143.77" cy="298.83" r="11.83"/>
-		<circle class="st1" cx="318.02" cy="274.77" r="11.83"/>
-	</g>
-</g>
-</svg>

package/typescript.svg

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="21px" height="21px" viewBox="0 0 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid">
-	<g>
-		<polygon fill="#007ACC" transform="translate(128.000000, 128.000000) scale(1, -1) translate(-128.000000, -128.000000) " points="0 128 0 0 128 0 256 0 256 128 256 256 128 256 0 256"></polygon>
-		<path d="M146.658132,223.436863 L146.739401,212.953054 L130.079084,212.953054 L113.418767,212.953054 L113.418767,165.613371 L113.418767,118.273689 L101.63464,118.273689 L89.8505126,118.273689 L89.8505126,165.613371 L89.8505126,212.953054 L73.1901951,212.953054 L56.5298776,212.953054 L56.5298776,223.233689 C56.5298776,228.922577 56.6517824,233.676863 56.8143221,233.798768 C56.9362269,233.961308 77.2130522,234.042577 101.797179,234.001943 L146.536227,233.880038 L146.658132,223.436863 Z" fill="#FFFFFF" transform="translate(101.634640, 176.142993) rotate(-180.000000) translate(-101.634640, -176.142993) "></path>
-		<path d="M206.566631,234.272145 C213.068219,232.646748 218.025679,229.761668 222.57679,225.048018 C224.933616,222.528653 228.428219,217.936907 228.712663,216.839764 C228.793933,216.514684 217.659965,209.037859 210.914568,204.852462 C210.670758,204.689922 209.69552,205.74643 208.598377,207.371827 C205.306949,212.166748 201.852981,214.239129 196.570441,214.604843 C188.809171,215.133097 183.811076,211.069605 183.851711,204.283573 C183.851711,202.292462 184.136155,201.114049 184.948854,199.488653 C186.65552,195.953414 189.825044,193.840399 199.7806,189.533097 C218.106949,181.649922 225.949489,176.448653 230.825679,169.053097 C236.270758,160.804208 237.489806,147.638494 233.792028,137.845478 C229.728536,127.199129 219.651076,119.966113 205.469489,117.568653 C201.080917,116.796589 190.678377,116.918494 185.964727,117.771827 C175.684092,119.600399 165.931711,124.679764 159.917743,131.343891 C157.560917,133.944526 152.969171,140.730557 153.253616,141.218176 C153.37552,141.380716 154.432028,142.030875 155.610441,142.721668 C156.748219,143.371827 161.05552,145.850557 165.119012,148.207383 L172.473933,152.474049 L174.01806,150.198494 C176.171711,146.907065 180.885362,142.396589 183.729806,140.893097 C191.897425,136.585795 203.112663,137.195319 208.639012,142.15278 C210.995838,144.30643 211.971076,146.541351 211.971076,149.83278 C211.971076,152.799129 211.605362,154.099446 210.061235,156.334367 C208.070123,159.178811 204.006631,161.576272 192.466314,166.574367 C179.259965,172.263256 173.571076,175.798494 168.369806,181.406113 C165.362822,184.656907 162.518377,189.858176 161.339965,194.206113 C160.364727,197.822621 160.120917,206.884208 160.892981,210.541351 C163.61552,223.300716 173.245996,232.199764 187.143139,234.841034 C191.653616,235.694367 202.137425,235.369287 206.566631,234.272145 Z" fill="#FFFFFF" transform="translate(194.578507, 176.190240) scale(1, -1) translate(-194.578507, -176.190240) "></path>
-	</g>
-</svg>