react-cache-promise/dist/umd/react-async-states.development.js

react-cache-promise

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactAsyncStates = {}, global.React));
})(this, (function (exports, React) { 'use strict';

  function _interopNamespaceDefault(e) {
    var n = Object.create(null);
    if (e) {
      Object.keys(e).forEach(function (k) {
        if (k !== 'default') {
          var d = Object.getOwnPropertyDescriptor(e, k);
          Object.defineProperty(n, k, d.get ? d : {
            enumerable: true,
            get: function () { return e[k]; }
          });
        }
      });
    }
    n.default = e;
    return Object.freeze(n);
  }

  var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);

  var promiseCache = new Map();
  var reverseCache = new Map();
  function createCache(arg, promise) {
      var subscriptionCache = {
          subscribe: subscribe,
          state: null,
          active: true,
      };
      promise.then(function (fulfilledValue) {
          if (subscriptionCache.active) {
              subscriptionCache.state = { status: "fulfilled", value: fulfilledValue };
              if (subscriptionCache.listeners) {
                  Object.values(subscriptionCache.listeners).forEach(function (cb) {
                      React__namespace.startTransition(function () { return cb(fulfilledValue); });
                  });
              }
          }
      }, function (error) {
          if (subscriptionCache.active) {
              subscriptionCache.state = { status: "rejected", reason: error };
              if (subscriptionCache.listeners) {
                  Object.values(subscriptionCache.listeners).forEach(function (cb) {
                      React__namespace.startTransition(function () { return cb(error); });
                  });
              }
          }
      });
      function subscribe(cb) {
          if (!subscriptionCache.index) {
              subscriptionCache.index = 0;
          }
          if (!subscriptionCache.listeners) {
              subscriptionCache.listeners = [];
          }
          var id = ++subscriptionCache.index;
          subscriptionCache.listeners[id] = cb;
          return function () {
              delete subscriptionCache.listeners[id];
          };
      }
      return subscriptionCache;
  }
  function patchQuery(fn, getCacheArg) {
      function modified() {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          var arg = getCacheArg.apply(null, args);
          var cachedPromise = promiseCache.get(arg);
          if (cachedPromise) {
              return cachedPromise;
          }
          var promise = fn.apply(null, args);
          promiseCache.set(arg, promise);
          reverseCache.set(promise, createCache(arg, promise));
          return promise;
      }
      return modified;
  }
  function usePromise(promise) {
      var subscription = reverseCache.get(promise);
      var state = subscription.state;
      if (state === null) {
          throw promise;
      }
      if (state.status === "rejected") {
          throw state.reason;
      }
      var rerender = React__namespace.useState()[1];
      React__namespace.useEffect(function () { return subscription.subscribe(rerender); }, [subscription]);
      return state.value;
  }
  function evict(arg) {
      var promise = promiseCache.get(arg);
      if (!promise) {
          return;
      }
      var subscription = reverseCache.get(promise);
      if (!subscription) {
          return;
      }
      var returnValue = promiseCache.delete(arg) && reverseCache.delete(promise);
      subscription.active = false;
      subscription.state = null;
      var listeners = subscription.listeners;
      if (listeners) {
          var newObject_1 = {};
          Object.values(listeners).forEach(function (cb) {
              React__namespace.startTransition(function () { return cb(newObject_1); });
          });
      }
      return returnValue;
  }

  exports.evict = evict;
  exports.patchQuery = patchQuery;
  exports.usePromise = usePromise;

}));
//# sourceMappingURL=react-async-states.development.js.map