fluidstate/primitives/reactive-atom.js

Library for fine-grained reactivity state management

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createAtom = void 0;
var _reactiveLayer = require("./reactive-layer");
var _reactiveRemoteAtoms = require("./reactive-remote-atoms");
var _reactiveTracking = require("./reactive-tracking");
/**
 * Creates a reactive atom, which is a fundamental unit of reactivity.
 * This atom does not hold a value itself but can be reported as observed or changed.
 * It interacts with the underlying reactive layer and manages observations
 * from any registered reactive remotes.
 *
 * The `onBecomeObservedListener` and `onBecomeUnobservedListener` options from
 * the underlying reactive layer are respected.
 *
 * When `reportObserved` is called:
 * 1. It notifies any reactive remotes that are currently tracking, potentially
 *    creating remote-specific atoms if they don't exist yet.
 * 2. It reports observation to the underlying reactive layer.
 * 3. It returns `true` if the atom was observed either by the local layer or by any remote.
 *
 * When `reportChanged` is called:
 * 1. It reports the change to the underlying reactive layer, which in turn
 *    notifies its dependents.
 * 2. This change will also propagate to remote atoms that were created to mirror this atom.
 *
 * @param name - A descriptive name for the atom, useful for debugging.
 * @param options - Optional configuration for the atom, including listeners
 *   for when the atom becomes observed or unobserved by the local layer.
 * @returns An `Atom` object with `reportObserved` and `reportChanged` methods.
 */
const createAtom = (name, options) => {
  const layerAtom = (0, _reactiveLayer.getReactiveLayer)().createAtom(name, {
    onBecomeObservedListener: options?.onBecomeObservedListener,
    onBecomeUnobservedListener: options?.onBecomeUnobservedListener
  });
  const atom = {
    reportObserved() {
      const isRemoteObserved = (0, _reactiveRemoteAtoms.observeRemoteAtoms)(atom, layerAtom, name);
      // We only report observation to the local layer if it's currently
      // in a tracking context.
      const layerObserved = (0, _reactiveTracking.isTrackingDerivation)() && !!layerAtom.reportObserved();
      return isRemoteObserved || layerObserved;
    },
    reportChanged() {
      layerAtom.reportChanged();
    }
  };
  return atom;
};
exports.createAtom = createAtom;
//# sourceMappingURL=reactive-atom.js.map