alinea/dist/ui/util/Observable.js

[](https://npmjs.org/package/alinea) [](https://packagephobia.com/result?p=alinea)

import {
  require_react_is
} from "../../chunks/chunk-3WZ466DU.js";
import {
  __commonJS,
  __toESM
} from "../../chunks/chunk-U5RRZUYZ.js";

// node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js
var require_hoist_non_react_statics_cjs = __commonJS({
  "node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js"(exports, module) {
    "use strict";
    var reactIs = require_react_is();
    var REACT_STATICS = {
      childContextTypes: true,
      contextType: true,
      contextTypes: true,
      defaultProps: true,
      displayName: true,
      getDefaultProps: true,
      getDerivedStateFromError: true,
      getDerivedStateFromProps: true,
      mixins: true,
      propTypes: true,
      type: true
    };
    var KNOWN_STATICS = {
      name: true,
      length: true,
      prototype: true,
      caller: true,
      callee: true,
      arguments: true,
      arity: true
    };
    var FORWARD_REF_STATICS = {
      "$$typeof": true,
      render: true,
      defaultProps: true,
      displayName: true,
      propTypes: true
    };
    var MEMO_STATICS = {
      "$$typeof": true,
      compare: true,
      defaultProps: true,
      displayName: true,
      propTypes: true,
      type: true
    };
    var TYPE_STATICS = {};
    TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
    TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
    function getStatics(component) {
      if (reactIs.isMemo(component)) {
        return MEMO_STATICS;
      }
      return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
    }
    var defineProperty = Object.defineProperty;
    var getOwnPropertyNames = Object.getOwnPropertyNames;
    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
    var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
    var getPrototypeOf = Object.getPrototypeOf;
    var objectPrototype = Object.prototype;
    function hoistNonReactStatics2(targetComponent, sourceComponent, blacklist) {
      if (typeof sourceComponent !== "string") {
        if (objectPrototype) {
          var inheritedComponent = getPrototypeOf(sourceComponent);
          if (inheritedComponent && inheritedComponent !== objectPrototype) {
            hoistNonReactStatics2(targetComponent, inheritedComponent, blacklist);
          }
        }
        var keys = getOwnPropertyNames(sourceComponent);
        if (getOwnPropertySymbols) {
          keys = keys.concat(getOwnPropertySymbols(sourceComponent));
        }
        var targetStatics = getStatics(targetComponent);
        var sourceStatics = getStatics(sourceComponent);
        for (var i = 0; i < keys.length; ++i) {
          var key = keys[i];
          if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
            var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
            try {
              defineProperty(targetComponent, key, descriptor);
            } catch (e) {
            }
          }
        }
      }
      return targetComponent;
    }
    module.exports = hoistNonReactStatics2;
  }
});

// node_modules/micro-observables/dist/micro-observables.esm.js
var import_hoist_non_react_statics = __toESM(require_hoist_non_react_statics_cjs());
import React, { useState, useLayoutEffect, useMemo } from "react";
function _extends() {
  _extends = Object.assign || function(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
    return target;
  };
  return _extends.apply(this, arguments);
}
function _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  subClass.__proto__ = superClass;
}
function _unsupportedIterableToArray(o, minLen) {
  if (!o)
    return;
  if (typeof o === "string")
    return _arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor)
    n = o.constructor.name;
  if (n === "Map" || n === "Set")
    return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
    return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length)
    len = arr.length;
  for (var i = 0, arr2 = new Array(len); i < len; i++)
    arr2[i] = arr[i];
  return arr2;
}
function _createForOfIteratorHelperLoose(o, allowArrayLike) {
  var it;
  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
      if (it)
        o = it;
      var i = 0;
      return function() {
        if (i >= o.length)
          return {
            done: true
          };
        return {
          done: false,
          value: o[i++]
        };
      };
    }
    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  it = o[Symbol.iterator]();
  return it.next.bind(it);
}
var batchedUpdater;
var PluginManager = /* @__PURE__ */ function() {
  function PluginManager2() {
    this._plugins = [];
  }
  var _proto = PluginManager2.prototype;
  _proto.use = function use(plugin) {
    this._plugins.push(plugin);
  };
  _proto.onCreate = function onCreate(observable3, val) {
    this._plugins.forEach(function(it) {
      return it.onCreate == null ? void 0 : it.onCreate(observable3, val);
    });
  };
  _proto.onChange = function onChange(observable3, val, prevVal) {
    this._plugins.forEach(function(it) {
      return it.onChange == null ? void 0 : it.onChange(observable3, val, prevVal);
    });
  };
  _proto.onBecomeObserved = function onBecomeObserved(observable3) {
    this._plugins.forEach(function(it) {
      return it.onBecomeObserved == null ? void 0 : it.onBecomeObserved(observable3);
    });
  };
  _proto.onBecomeUnobserved = function onBecomeUnobserved(observable3) {
    this._plugins.forEach(function(it) {
      return it.onBecomeUnobserved == null ? void 0 : it.onBecomeUnobserved(observable3);
    });
  };
  _proto.onAttach = function onAttach(observable3, input) {
    this._plugins.forEach(function(it) {
      return it.onAttach == null ? void 0 : it.onAttach(observable3, input);
    });
  };
  _proto.onDetach = function onDetach(observable3, input) {
    this._plugins.forEach(function(it) {
      return it.onDetach == null ? void 0 : it.onDetach(observable3, input);
    });
  };
  return PluginManager2;
}();
var UNSET = /* @__PURE__ */ Symbol();
var plugins = /* @__PURE__ */ new PluginManager();
var capturedInputFrames = [];
var shouldCaptureNextInput = false;
var batchedObservables = [];
var batchDepth = 0;
var BaseObservable = /* @__PURE__ */ function() {
  function BaseObservable2(val, options) {
    if (options === void 0) {
      options = {};
    }
    this._prevVal = UNSET;
    this._inputs = [];
    this._outputs = [];
    this._listeners = [];
    this._attachedToInputs = false;
    this.onChange = this.subscribe;
    this._val = val;
    this._options = options;
    plugins.onCreate(this, val);
  }
  var _proto = BaseObservable2.prototype;
  _proto.get = function get() {
    var capturedInputs = capturedInputFrames[capturedInputFrames.length - 1];
    if (capturedInputs && shouldCaptureNextInput) {
      try {
        shouldCaptureNextInput = false;
        capturedInputs.push(this);
        return this._get();
      } finally {
        shouldCaptureNextInput = true;
      }
    } else {
      return this._get();
    }
  };
  _proto._get = function _get() {
    var shouldEvaluate = !this._attachedToInputs || this._prevVal !== UNSET;
    return shouldEvaluate ? this._evaluate() : this._val;
  };
  _proto._evaluate = function _evaluate() {
    return this._val;
  };
  _proto._set = function _set(val) {
    if (this._val !== val) {
      this._addToBatchRecursively();
      this._val = val;
    }
  };
  _proto.subscribe = function subscribe(listener) {
    var _this = this;
    this._listeners.push(listener);
    this._attachToInputs();
    var listenerRemoved = false;
    return function() {
      if (!listenerRemoved) {
        listenerRemoved = true;
        _this._listeners.splice(_this._listeners.indexOf(listener), 1);
        _this._detachFromInputs();
      }
    };
  };
  _proto.onBecomeObserved = function onBecomeObserved() {
  };
  _proto.onBecomeUnobserved = function onBecomeUnobserved() {
  };
  _proto.getInputs = function getInputs() {
    return this._inputs;
  };
  _proto.getOptions = function getOptions() {
    return this._options;
  };
  _proto.withOptions = function withOptions(options) {
    this._options = _extends({}, this._options, options);
    return this;
  };
  BaseObservable2._captureInputs = function _captureInputs(block) {
    try {
      var capturedInputs = [];
      capturedInputFrames.push(capturedInputs);
      shouldCaptureNextInput = true;
      block();
      return capturedInputs;
    } finally {
      capturedInputFrames.pop();
      shouldCaptureNextInput = false;
    }
  };
  _proto._addInput = function _addInput(input) {
    this._inputs.push(input);
    if (this._attachedToInputs) {
      this._attachToInput(input);
    }
  };
  _proto._removeInput = function _removeInput(input) {
    this._inputs.splice(this._inputs.indexOf(input), 1);
    if (this._attachedToInputs) {
      this._detachFromInput(input);
    }
  };
  _proto._shouldAttachToInputs = function _shouldAttachToInputs() {
    return this._listeners.length > 0 || this._outputs.length > 0;
  };
  _proto._attachToInputs = function _attachToInputs() {
    if (!this._attachedToInputs && this._shouldAttachToInputs()) {
      this._attachedToInputs = true;
      this._val = this._evaluate();
      this.onBecomeObserved();
      plugins.onBecomeObserved(this);
      for (var _iterator = _createForOfIteratorHelperLoose(this._inputs), _step; !(_step = _iterator()).done; ) {
        var input = _step.value;
        this._attachToInput(input);
        input._attachToInputs();
      }
    }
  };
  _proto._detachFromInputs = function _detachFromInputs() {
    if (this._attachedToInputs && !this._shouldAttachToInputs()) {
      this._attachedToInputs = false;
      for (var _iterator2 = _createForOfIteratorHelperLoose(this._inputs), _step2; !(_step2 = _iterator2()).done; ) {
        var input = _step2.value;
        this._detachFromInput(input);
        input._detachFromInputs();
      }
      this.onBecomeUnobserved();
      plugins.onBecomeUnobserved(this);
    }
  };
  _proto._attachToInput = function _attachToInput(input) {
    input._outputs.push(this);
    plugins.onAttach(this, input);
  };
  _proto._detachFromInput = function _detachFromInput(input) {
    input._outputs.splice(input._outputs.indexOf(this), 1);
    plugins.onDetach(this, input);
  };
  _proto._addToBatchRecursively = function _addToBatchRecursively() {
    if (this._prevVal === UNSET) {
      this._prevVal = this._val;
      for (var _iterator3 = _createForOfIteratorHelperLoose(this._outputs), _step3; !(_step3 = _iterator3()).done; ) {
        var output = _step3.value;
        output._addToBatchRecursively();
      }
      batchedObservables.push(this);
    }
  };
  BaseObservable2._batch = function _batch(block) {
    try {
      batchDepth++;
      if (batchDepth === 1 && batchedUpdater) {
        batchedUpdater(block);
      } else {
        block();
      }
    } finally {
      batchDepth--;
      if (batchDepth === 0) {
        var observablesToUpdate = batchedObservables;
        batchedObservables = [];
        for (var i = observablesToUpdate.length - 1; i >= 0; i--) {
          var observable3 = observablesToUpdate[i];
          var prevVal = observable3._prevVal;
          observable3._prevVal = UNSET;
          observable3._val = observable3._evaluate();
          var val = observable3._val;
          if (val !== prevVal) {
            for (var _iterator4 = _createForOfIteratorHelperLoose(observable3._listeners.slice()), _step4; !(_step4 = _iterator4()).done; ) {
              var listener = _step4.value;
              listener(val, prevVal);
            }
            plugins.onChange(observable3, val, prevVal);
          }
        }
      }
    }
  };
  BaseObservable2._use = function _use(plugin) {
    plugins.use(plugin);
  };
  return BaseObservable2;
}();
function memoize(func) {
  var lastArgs;
  var lastResult;
  return function(args) {
    var argsHaveChanged = false;
    if (!lastArgs || args.length !== lastArgs.length) {
      argsHaveChanged = true;
    } else {
      for (var i = 0; i < args.length; i++) {
        if (args[i] !== lastArgs[i]) {
          argsHaveChanged = true;
          break;
        }
      }
    }
    if (argsHaveChanged) {
      lastArgs = args;
      lastResult = func(args);
    }
    return lastResult;
  };
}
function observable(val, options) {
  return new WritableObservable(val, options);
}
var Observable = /* @__PURE__ */ function(_BaseObservable) {
  _inheritsLoose(Observable2, _BaseObservable);
  function Observable2(val, options) {
    var _this;
    _this = _BaseObservable.call(this, val instanceof Observable2 ? val.get() : val, options) || this;
    _this.transform = _this.select;
    _this._updateValInput(val);
    return _this;
  }
  var _proto = Observable2.prototype;
  _proto._evaluate = function _evaluate() {
    return this._valInput ? this._valInput.get() : _BaseObservable.prototype._evaluate.call(this);
  };
  _proto.select = function select(selector) {
    return new DerivedObservable([this], function(_ref) {
      var val = _ref[0];
      return selector(val);
    });
  };
  _proto.onlyIf = function onlyIf(predicate) {
    var filteredVal = void 0;
    return this.select(function(val) {
      if (predicate(val)) {
        filteredVal = val;
      }
      return filteredVal;
    });
  };
  _proto["default"] = function _default(defaultVal) {
    return this.select(function(val) {
      return val != null ? val : defaultVal;
    });
  };
  _proto.as = function as() {
    return this;
  };
  Observable2.select = function select(observables, selector) {
    return new DerivedObservable(observables, function(vals) {
      return selector.apply(void 0, vals);
    });
  };
  Observable2.from = function from() {
    for (var _len = arguments.length, observables = new Array(_len), _key = 0; _key < _len; _key++) {
      observables[_key] = arguments[_key];
    }
    return new DerivedObservable(observables, function(values) {
      return values;
    });
  };
  Observable2.merge = function merge(observables) {
    return new DerivedObservable(observables, function(values) {
      return values;
    });
  };
  Observable2.latest = function latest() {
    var prevValues;
    for (var _len2 = arguments.length, observables = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      observables[_key2] = arguments[_key2];
    }
    return new DerivedObservable(observables, function(values) {
      var val = !prevValues ? values[0] : values.find(function(it, index) {
        return it !== prevValues[index];
      });
      prevValues = values;
      return val;
    });
  };
  Observable2.compute = function compute(_compute) {
    return new ComputedObservable(_compute);
  };
  Observable2.fromPromise = function fromPromise(promise, onError) {
    var obs = observable(void 0);
    promise.then(function(val) {
      return obs.set(val);
    }, function(e) {
      return onError && obs.set(onError(e));
    });
    return obs;
  };
  _proto.toPromise = function toPromise() {
    var _this2 = this;
    return new Promise(function(resolve) {
      var unsubscribe = _this2.subscribe(function(val) {
        resolve(val);
        unsubscribe();
      });
    });
  };
  Observable2.batch = function batch(block) {
    BaseObservable._batch(block);
  };
  Observable2.use = function use(plugin) {
    BaseObservable._use(plugin);
  };
  _proto._updateValInput = function _updateValInput(val) {
    if (this._valInput !== val) {
      if (this._valInput) {
        this._removeInput(this._valInput);
        this._valInput = void 0;
      }
      if (val instanceof Observable2) {
        this._addInput(val);
        this._valInput = val;
      }
    }
  };
  return Observable2;
}(BaseObservable);
var WritableObservable = /* @__PURE__ */ function(_Observable) {
  _inheritsLoose(WritableObservable2, _Observable);
  function WritableObservable2() {
    return _Observable.apply(this, arguments) || this;
  }
  var _proto2 = WritableObservable2.prototype;
  _proto2.set = function set(val) {
    var _this3 = this;
    this._updateValInput(val);
    Observable.batch(function() {
      return _this3._set(val instanceof Observable ? val.get() : val);
    });
  };
  _proto2.update = function update(updater) {
    this.set(updater(this.get()));
  };
  _proto2.readOnly = function readOnly() {
    return this;
  };
  return WritableObservable2;
}(Observable);
var DerivedObservable = /* @__PURE__ */ function(_Observable2) {
  _inheritsLoose(DerivedObservable2, _Observable2);
  function DerivedObservable2(computeInputs, compute) {
    var _this4;
    _this4 = _Observable2.call(this, void 0) || this;
    _this4._compute = memoize(compute);
    _this4._computeInputs = computeInputs;
    for (var _iterator = _createForOfIteratorHelperLoose(computeInputs), _step; !(_step = _iterator()).done; ) {
      var input = _step.value;
      _this4._addInput(input);
    }
    return _this4;
  }
  var _proto3 = DerivedObservable2.prototype;
  _proto3._evaluate = function _evaluate() {
    var computed = this._compute(this._computeInputs.map(function(input) {
      return input.get();
    }));
    this._updateValInput(computed);
    return computed instanceof Observable ? computed.get() : computed;
  };
  return DerivedObservable2;
}(Observable);
var ComputedObservable = /* @__PURE__ */ function(_Observable3) {
  _inheritsLoose(ComputedObservable2, _Observable3);
  function ComputedObservable2(compute) {
    var _this5;
    _this5 = _Observable3.call(this, void 0) || this;
    _this5._currentInputs = /* @__PURE__ */ new Set();
    _this5._compute = compute;
    return _this5;
  }
  var _proto4 = ComputedObservable2.prototype;
  _proto4._evaluate = function _evaluate() {
    var _this6 = this;
    var value;
    var inputs = new Set(BaseObservable._captureInputs(function() {
      return value = _this6._compute();
    }));
    inputs.forEach(function(input) {
      if (!_this6._currentInputs.has(input)) {
        _this6._addInput(input);
      } else {
        _this6._currentInputs["delete"](input);
      }
    });
    this._currentInputs.forEach(function(input) {
      return _this6._removeInput(input);
    });
    this._currentInputs = inputs;
    return value;
  };
  return ComputedObservable2;
}(Observable);
function useObservable(observable3) {
  var _useState = useState({}), forceRender = _useState[1];
  var val = observable3.get();
  useLayoutEffect(function() {
    return observable3.subscribe(function() {
      return forceRender({});
    });
  }, [observable3]);
  return val;
}

// src/ui/util/Observable.ts
function wrap(micro) {
  return Object.assign(
    function() {
      if (arguments.length === 1)
        return micro.set(arguments[0]);
      return micro.get();
    },
    {
      micro,
      select(selector) {
        return wrap(
          micro.select((val) => {
            const res = selector(val);
            return "micro" in res ? res.micro : res;
          })
        );
      }
    }
  );
}
function observable2(value) {
  return wrap(observable(value));
}
function useObservable2(observable3) {
  return useObservable(
    "micro" in observable3 ? observable3.micro : observable3
  );
}
export {
  observable2 as observable,
  useObservable2 as useObservable
};