fluidstate-mobx/reactive-layer.js

MobX-based reactive layer for fluidstate

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getReactiveLayer = void 0;
var _mobx = require("mobx");
/**
 * Returns a `ReactiveLayer` implementation backed by the MobX library.
 * This function provides the bridge between `fluidstate`'s abstract reactivity
 * API and MobX's concrete implementation.
 */
const getReactiveLayer = () => ({
  createAtom: (name, options) => {
    const atom = (0, _mobx.createAtom)(name, options?.onBecomeObservedListener, options?.onBecomeUnobservedListener);
    return {
      reportObserved: () => atom.reportObserved(),
      reportChanged: () => atom.reportChanged()
    };
  },
  createComputedAtom: function (name, calculate, options) {
    const computedAtom = (0, _mobx.computed)(calculate, {
      name,
      equals: options?.equals
    });

    // MobX's `computed` does not accept observer listeners in its options,
    // so we attach them separately using `onBecomeObserved` and `onBecomeUnobserved`.
    if (options?.onBecomeObservedListener) {
      (0, _mobx.onBecomeObserved)(computedAtom, options.onBecomeObservedListener);
    }
    if (options?.onBecomeUnobservedListener) {
      (0, _mobx.onBecomeUnobserved)(computedAtom, options.onBecomeUnobservedListener);
    }
    return {
      get: () => {
        return computedAtom.get();
      }
    };
  },
  createReaction: (effect, options) => {
    const dispose = (0, _mobx.autorun)(effect, {
      scheduler: options?.scheduler
    });
    return {
      stop: () => {
        dispose();
      }
    };
  },
  untrack: action => {
    return (0, _mobx.untracked)(action);
  },
  runTransaction: transactionFn => {
    return (0, _mobx.transaction)(transactionFn);
  },
  runAction: action => {
    return (0, _mobx.runInAction)(action);
  }
});
exports.getReactiveLayer = getReactiveLayer;
//# sourceMappingURL=reactive-layer.js.map