fluidstate-preact/reactive-layer.js

Library for using fine-grained reactivity state management library fluidstate in Preact

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getReactiveLayer = void 0;
var _signalsCore = require("@preact/signals-core");
var _relativeLayerEffect = require("./relative-layer-effect");
/**
 * Returns a `ReactiveLayer` implementation backed by the `@preact/signals-core`
 * library. This function provides the bridge between `fluidstate`'s abstract
 * reactivity API and `@preact/signals-core` reactivity implementation.
 */
const getReactiveLayer = () => ({
  createAtom: (name, options) => {
    let isObserved = false;
    let i = 0;
    const preactSignal = (0, _signalsCore.signal)(i, {
      watched: () => {
        options?.onBecomeObservedListener?.();
        isObserved = true;
      },
      unwatched: () => {
        options?.onBecomeUnobservedListener?.();
        isObserved = false;
      }
    });
    const result = {
      name,
      reportObserved() {
        preactSignal.value;
        return isObserved;
      },
      reportChanged() {
        preactSignal.value = ++i;
      }
    };
    return result;
  },
  createComputedAtom: (name, calculate, options) => {
    let isInitialValue = true;
    let lastValue = null;
    let i = 0;
    const preactComputed = (0, _signalsCore.computed)(() => {
      const newValue = calculate();
      if (isInitialValue) {
        isInitialValue = false;
        lastValue = newValue;
        return i;
      }
      if (!(options?.equals ?? Object.is)(lastValue, newValue)) {
        lastValue = newValue;
        return ++i;
      }
      lastValue = newValue;
      return i;
    }, {
      watched: options?.onBecomeObservedListener,
      unwatched: options?.onBecomeUnobservedListener
    });
    const getValue = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(preactComputed), "value")?.get;
    Object.defineProperty(preactComputed, "value", {
      get: () => {
        getValue.call(preactComputed);
        return lastValue;
      }
    });
    const result = {
      name,
      get() {
        return preactComputed.value;
      }
    };
    return result;
  },
  createReaction: (fn, options) => {
    const effect = new _relativeLayerEffect.Effect(fn, options);
    const result = {
      stop: () => {
        effect.stop();
      }
    };
    return result;
  },
  untrack: action => {
    return (0, _signalsCore.untracked)(action);
  },
  runTransaction: transaction => {
    return (0, _signalsCore.batch)(transaction);
  },
  runAction: action => {
    return (0, _signalsCore.batch)(action);
  }
});
exports.getReactiveLayer = getReactiveLayer;
//# sourceMappingURL=reactive-layer.js.map