fluidstate/abstractions/reactive-promise.js

Library for fine-grained reactivity state management

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.providePromiseAtomName = exports.getResult = exports.PromiseStatus = void 0;
var _reactiveNames = require("../extras/reactive-names");
var _reactiveAtom = require("../primitives/reactive-atom");
/**
 * Represents the possible states of a reactive promise.
 */
let PromiseStatus;
/**
 * A discriminated union representing the outcome of a reactive promise.
 * It can be in one of three states: Loading, Success, or Error.
 */
exports.PromiseStatus = PromiseStatus;
(function (PromiseStatus) {
  PromiseStatus[PromiseStatus["Loading"] = 0] = "Loading";
  PromiseStatus[PromiseStatus["Success"] = 1] = "Success";
  PromiseStatus[PromiseStatus["Error"] = 2] = "Error";
})(PromiseStatus || (exports.PromiseStatus = PromiseStatus = {}));
const promiseAtomNameMap = new WeakMap();
const promiseAtomMap = new WeakMap();
const promiseResultMap = new WeakMap();
const providePromiseAtomName = (promise, nameOptions) => {
  promiseAtomNameMap.set(promise, nameOptions);
};

/**
 * Retrieves the current result of a given promise in a reactive way.
 *
 * This function wraps a native promise and makes its resolution (or rejection)
 * a signal in the reactive system. When the promise settles, any reactive
 * computations or reactions that depend on this result will be re-evaluated.
 *
 * If this is the first time `getResult` is called for a particular promise,
 * it initializes the reactive tracking for that promise and subscribes the
 * current reactions to it.
 *
 * @param promise The native promise to get the reactive result for.
 * @returns A `PromiseResult` object representing the current state and value (or error) of the promise.
 *          This result is reactive and will cause an update when the promise settles.
 */
exports.providePromiseAtomName = providePromiseAtomName;
const getResult = promise => {
  let promiseResult = promiseResultMap.get(promise);
  let promiseAtom = promiseAtomMap.get(promise);
  let promiseAtomName = promiseAtomNameMap.get(promise);
  if (!promiseResult || !promiseAtom) {
    promiseResult = {
      status: PromiseStatus.Loading
    };
    promiseAtom = (0, _reactiveAtom.createAtom)((0, _reactiveNames.createPromiseAtomName)((0, _reactiveNames.createAtomNameFromOptions)(promiseAtomName)));
    promiseResultMap.set(promise, promiseResult);
    promiseAtomMap.set(promise, promiseAtom);
    promise.then(result => {
      promiseResult = {
        status: PromiseStatus.Success,
        result
      };
      promiseResultMap.set(promise, promiseResult);
      promiseAtom.reportChanged();
    }).catch(error => {
      promiseResult = {
        status: PromiseStatus.Error,
        error
      };
      promiseResultMap.set(promise, promiseResult);
      promiseAtom.reportChanged();
    });
  }
  promiseAtom.reportObserved();
  return promiseResult;
};
exports.getResult = getResult;
//# sourceMappingURL=reactive-promise.js.map