chem-rx 0.0.23 → 0.2.0

package/dist/index.iife.js

@@ -1,341 +1,468 @@
-var chemicalRx = (function (exports, rxjs, react) {
+var chemicalRx = (function (exports) {
   'use strict';
 
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _assertThisInitialized(e) {
+    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return e;
+  }
+  function _createForOfIteratorHelperLoose(r, e) {
+    var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (t) return (t = t.call(r)).next.bind(t);
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var o = 0;
+      return function () {
+        return o >= r.length ? {
+          done: !0
+        } : {
+          done: !1,
+          value: r[o++]
+        };
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
   function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : 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 _extends = Object.assign ? Object.assign.bind() : function (n) {
+      for (var e = 1; e < arguments.length; e++) {
+        var t = arguments[e];
+        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
       }
-      return target;
-    };
-    return _extends.apply(this, arguments);
+      return n;
+    }, _extends.apply(null, arguments);
+  }
+  function _inheritsLoose(t, o) {
+    t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+  }
+  function _setPrototypeOf(t, e) {
+    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+      return t.__proto__ = e, t;
+    }, _setPrototypeOf(t, e);
   }
-  function _inheritsLoose(subClass, superClass) {
-    subClass.prototype = Object.create(superClass.prototype);
-    subClass.prototype.constructor = subClass;
-    _setPrototypeOf(subClass, superClass);
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
   }
-  function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
+
+  var noop = function noop() {};
+  function createSubscription(_unsubscribe) {
+    var closed = false;
+    return {
+      unsubscribe: function unsubscribe() {
+        if (closed) return;
+        closed = true;
+        _unsubscribe();
+      }
     };
-    return _setPrototypeOf(o, p);
   }
-  function _assertThisInitialized(self) {
-    if (self === void 0) {
-      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  function normalizeSubscription(subscription) {
+    if (typeof subscription === "function") {
+      return createSubscription(subscription);
+    }
+    if (subscription && typeof subscription.unsubscribe === "function") {
+      return createSubscription(function () {
+        return subscription.unsubscribe();
+      });
     }
-    return self;
+    return createSubscription(noop);
   }
-  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 isAtomSource(value) {
+    return value != null && typeof value === "object" && typeof value.subscribe === "function";
   }
-  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 readAtomSourceValue(source) {
+    if (typeof source.getValue === "function") {
+      return source.getValue();
+    }
+    if (typeof source.value === "function") {
+      return source.value();
+    }
+    return undefined;
   }
-  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-    if (it) return (it = it.call(o)).next.bind(it);
-    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++]
-        };
+  function toListener(observer) {
+    if (typeof observer === "function") {
+      return observer;
+    }
+    if (observer && typeof observer.next === "function") {
+      return function (value) {
+        return observer.next == null ? void 0 : observer.next(value);
       };
     }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    return noop;
   }
+  function notifyListeners(listeners, value) {
+    var errors = [];
+    for (var _i = 0, _Array$from = Array.from(listeners); _i < _Array$from.length; _i++) {
+      var listener = _Array$from[_i];
+      try {
+        listener(value);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length === 1) {
+      throw errors[0];
+    }
+    if (errors.length > 1) {
+      throw new AggregateError(errors, "Multiple atom subscribers failed");
+    }
+  }
+  var ValueStore = /*#__PURE__*/function () {
+    function ValueStore(value) {
+      this._listeners = [];
+      this._value = value;
+    }
+    var _proto = ValueStore.prototype;
+    _proto.getValue = function getValue() {
+      return this._value;
+    };
+    _proto.setValue = function setValue(value) {
+      this._value = value;
+    };
+    _proto.next = function next(value) {
+      this._value = value;
+      notifyListeners(this._listeners, value);
+    };
+    _proto.subscribe = function subscribe(observer, options) {
+      var _this = this;
+      if (options === void 0) {
+        options = {};
+      }
+      var listener = toListener(observer);
+      this._listeners.push(listener);
+      if (options.emitImmediately !== false) {
+        listener(this._value);
+      }
+      return createSubscription(function () {
+        var index = _this._listeners.indexOf(listener);
+        if (index >= 0) {
+          _this._listeners.splice(index, 1);
+        }
+      });
+    };
+    return ValueStore;
+  }();
+
+  /**
+   * Comparator used to decide whether an atom's value has changed.
+   *
+   * An atom notifies subscribers only when `equals(previous, next)` returns
+   * `false`. The default for every atom is {@link Object.is} (value equality for
+   * primitives, reference identity for objects/arrays). Supply a content
+   * comparator to dedup by data, or `() => false` to force every update to emit.
+   */
 
   var ReadOnlyAtom = /*#__PURE__*/function () {
-    function ReadOnlyAtom(_value) {
-      var _this = this;
-      this._bonds = [];
-      this._fromObservable = null;
-      this._fromObservableSubscription = null;
-      if (rxjs.isObservable(_value)) {
-        this._fromObservable = _value;
-        this._behavior$ = new rxjs.BehaviorSubject(null);
-        this._fromObservableSubscription = _value.subscribe(function (value) {
-          _this._behavior$.next(value);
-        });
+    /**
+     * @param options.equals Comparator deciding when the value has changed.
+     *   Defaults to {@link Object.is}. Subscribers are notified only when it
+     *   returns `false`.
+     */
+    function ReadOnlyAtom(_value, dependency, options) {
+      var _options$equals,
+        _this = this;
+      this._subscriptions = [];
+      this._dependency = null;
+      this._dependencySubscription = null;
+      this._subscriberCount = 0;
+      this._equals = (_options$equals = options == null ? void 0 : options.equals) != null ? _options$equals : Object.is;
+      if (dependency) {
+        this._dependency = dependency;
+        this._store = new ValueStore(_value);
+      } else if (isAtomSource(_value)) {
+        this._store = new ValueStore(readAtomSourceValue(_value));
+        this._addSubscription(_value.subscribe(function (value) {
+          _this._next(value);
+        }));
       } else {
-        // if it's just a value just use a regular behavior subject
-        this._behavior$ = new rxjs.BehaviorSubject(_value);
+        this._store = new ValueStore(_value);
       }
     }
 
-    // taken from Observable
+    /**
+     * Create a read-only atom whose value is derived from this atom.
+     *
+     * By default the derived atom notifies subscribers only when its computed
+     * output differs by {@link Object.is}. Pass `options.equals` to dedup by
+     * content (useful when `deriveFn` returns a fresh object/array each time), or
+     * `equals: () => false` to re-emit on every parent update.
+     */
     var _proto = ReadOnlyAtom.prototype;
-    _proto.pipe = function pipe() {
-      var _this$_behavior$;
-      // @ts-ignore can't match overloaded function
-      var observable = (_this$_behavior$ = this._behavior$).pipe.apply(_this$_behavior$, arguments);
-      var newAtom = new ReadOnlyAtom(observable);
-      return newAtom;
-    };
-    _proto.derive = function derive(deriveFn) {
-      return this.pipe(rxjs.map(deriveFn));
+    _proto.derive = function derive(deriveFn, options) {
+      var _this2 = this;
+      var index = 0;
+      var hasCachedInput = false;
+      var cachedInput;
+      var cachedValue;
+      var getSnapshot = function getSnapshot(force) {
+        if (force === void 0) {
+          force = false;
+        }
+        var input = _this2.value();
+        if (force || !hasCachedInput || !Object.is(cachedInput, input)) {
+          cachedInput = input;
+          cachedValue = deriveFn(input, index++);
+          hasCachedInput = true;
+        }
+        return cachedValue;
+      };
+      return new ReadOnlyAtom(getSnapshot(), {
+        getSnapshot: getSnapshot,
+        subscribe: function subscribe(onDependencyChange) {
+          return _this2._subscribe(onDependencyChange, {
+            emitImmediately: false
+          });
+        }
+      }, options);
     };
-    _proto.subscribe = function subscribe() {
-      var _this$_behavior$2;
-      return (_this$_behavior$2 = this._behavior$).subscribe.apply(_this$_behavior$2, arguments);
+    _proto.subscribe = function subscribe(observer) {
+      return this._subscribe(observer);
     };
     _proto.value = function value() {
-      return this._behavior$.getValue();
-    }
-
-    // not needed?
-    ;
+      if (this._dependency) {
+        this._refresh(false);
+      }
+      return this._store.getValue();
+    };
     _proto.dispose = function dispose() {
-      var _this$_fromObservable;
-      (_this$_fromObservable = this._fromObservableSubscription) == null ? void 0 : _this$_fromObservable.unsubscribe();
+      var _this$_dependencySubs;
+      (_this$_dependencySubs = this._dependencySubscription) == null || _this$_dependencySubs.unsubscribe();
+      this._dependencySubscription = null;
+      this._subscriberCount = 0;
+      for (var _iterator = _createForOfIteratorHelperLoose(this._subscriptions.splice(0)), _step; !(_step = _iterator()).done;) {
+        var subscription = _step.value;
+        subscription.unsubscribe();
+      }
     };
     _proto.get = function get(key) {
       var val = this.value();
       return val == null ? void 0 : val[key];
+    }
+
+    /**
+     * Create a read-only atom that tracks `key` on this atom's value.
+     *
+     * By default the selected atom notifies subscribers only when the selected
+     * value differs by {@link Object.is}. Pass `options.equals` to dedup by
+     * content instead.
+     */;
+    _proto.select = function select(key, options) {
+      var _this3 = this;
+      var getSnapshot = function getSnapshot() {
+        var value = _this3.value();
+        return value == null ? void 0 : value[key];
+      };
+      return new ReadOnlyAtom(getSnapshot(), {
+        getSnapshot: getSnapshot,
+        subscribe: function subscribe(onDependencyChange) {
+          return _this3._subscribe(onDependencyChange, {
+            emitImmediately: false
+          });
+        }
+      }, options);
     };
-    _proto.select = function select(key) {
-      // console.log("key", key);
-      var newObs = this._behavior$.pipe(rxjs.distinctUntilChanged(function (a, b) {
-        if (a === b) return true;
-        if (a && b && a[key] === b[key]) return true;
-        return false;
-      }), rxjs.map(function (k) {
-        // console.log("insideee", k, key);
+    _proto._refresh = function _refresh(emit, force) {
+      if (force === void 0) {
+        force = false;
+      }
+      if (!this._dependency) {
+        return this._store.getValue();
+      }
+      var previousValue = this._store.getValue();
+      var nextValue = this._dependency.getSnapshot(force);
+      var shouldNotify = emit && !this._equals(previousValue, nextValue);
+      if (shouldNotify) {
+        this._store.next(nextValue);
+      } else {
+        this._store.setValue(nextValue);
+      }
+      return nextValue;
+    };
+    _proto._retainDependency = function _retainDependency() {
+      var _this4 = this;
+      if (!this._dependency) {
+        return;
+      }
+      this._subscriberCount += 1;
+      if (this._subscriberCount === 1) {
+        this._dependencySubscription = normalizeSubscription(this._dependency.subscribe(function () {
+          _this4._refresh(true, true);
+        }));
+      }
+    };
+    _proto._releaseDependency = function _releaseDependency() {
+      if (!this._dependency || this._subscriberCount === 0) {
+        return;
+      }
+      this._subscriberCount -= 1;
+      if (this._subscriberCount === 0) {
+        var _this$_dependencySubs2;
+        (_this$_dependencySubs2 = this._dependencySubscription) == null || _this$_dependencySubs2.unsubscribe();
+        this._dependencySubscription = null;
+      }
+    }
 
-        return k == null ? void 0 : k[key];
-      }));
-      // console.log("obs", newObs);
-      // Can't get typescript to recognize the types here so I'm cheating
-      return Atom(newObs);
+    /** @internal */;
+    _proto._next = function _next(value) {
+      var previousValue = this._store.getValue();
+      if (this._equals(previousValue, value)) {
+        this._store.setValue(value);
+      } else {
+        this._store.next(value);
+      }
+    }
+
+    /** @internal */;
+    _proto._subscribe = function _subscribe(observer, options) {
+      var _this5 = this;
+      if (!this._dependency) {
+        return this._store.subscribe(observer, options);
+      }
+      this._refresh(false);
+      var subscription;
+      try {
+        this._retainDependency();
+        subscription = this._store.subscribe(observer, options);
+      } catch (error) {
+        this._releaseDependency();
+        throw error;
+      }
+      return createSubscription(function () {
+        subscription.unsubscribe();
+        _this5._releaseDependency();
+      });
+    }
+
+    /** @internal */;
+    _proto._addSubscription = function _addSubscription(subscription) {
+      var normalized = normalizeSubscription(subscription);
+      this._subscriptions.push(normalized);
+      return normalized;
     };
     return ReadOnlyAtom;
   }();
-  var BaseAtom = /*#__PURE__*/function (_ReadOnlyAtom) {
-    _inheritsLoose(BaseAtom, _ReadOnlyAtom);
+  var BaseAtom = /*#__PURE__*/function (_ReadOnlyAtom2) {
     function BaseAtom() {
-      return _ReadOnlyAtom.apply(this, arguments) || this;
+      return _ReadOnlyAtom2.apply(this, arguments) || this;
     }
+    _inheritsLoose(BaseAtom, _ReadOnlyAtom2);
     var _proto2 = BaseAtom.prototype;
     _proto2.next = function next(nextVal) {
-      this._behavior$.next(nextVal);
+      this._next(nextVal);
     };
     _proto2.set = function set(nextKey, nextValue) {
       var _extends2;
-      this._behavior$.next(_extends({}, this._behavior$.getValue(), (_extends2 = {}, _extends2[nextKey] = nextValue, _extends2)));
+      var currentValue = this.value();
+      if (currentValue == null || typeof currentValue !== "object") {
+        throw new TypeError("Atom.set can only be used with object values");
+      }
+      this._next(_extends({}, currentValue, (_extends2 = {}, _extends2[nextKey] = nextValue, _extends2)));
     };
     return BaseAtom;
   }(ReadOnlyAtom);
   var NullableBaseAtom = /*#__PURE__*/function (_BaseAtom) {
-    _inheritsLoose(NullableBaseAtom, _BaseAtom);
-    function NullableBaseAtom(_value) {
-      var _this2;
-      if (_value != null) {
-        _this2 = _BaseAtom.call(this, _value) || this;
-      } else {
-        // @ts-ignore
-        _this2 = _BaseAtom.call(this, undefined) || this;
-      }
-      return _assertThisInitialized(_this2);
+    function NullableBaseAtom(_value, options) {
+      return _BaseAtom.call(this, _value, undefined, options) || this;
     }
-
-    // @ts-ignore
+    _inheritsLoose(NullableBaseAtom, _BaseAtom);
     var _proto3 = NullableBaseAtom.prototype;
-    _proto3.get = function get(key) {
-      return _BaseAtom.prototype.get.call(this, key);
-    }
-
-    // @ts-ignore
-    ;
-    _proto3.select = function select(key) {
-      // @ts-ignore
-      return _BaseAtom.prototype.select.call(this, key);
-    };
     _proto3.next = function next(nextVal) {
-      // @ts-ignore
-      _BaseAtom.prototype.next.call(this, nextVal);
+      this._next(nextVal);
     };
     _proto3.reset = function reset() {
-      // @ts-ignore
-      _BaseAtom.prototype.next.call(this, undefined);
+      this._next(undefined);
     };
     return NullableBaseAtom;
   }(BaseAtom);
   var ArrayAtom = /*#__PURE__*/function (_BaseAtom2) {
-    _inheritsLoose(ArrayAtom, _BaseAtom2);
-    function ArrayAtom(initialValue) {
-      var _this3;
-      if (initialValue) {
-        _this3 = _BaseAtom2.call(this, initialValue) || this;
+    function ArrayAtom(initialValue, options) {
+      var _this6;
+      if (initialValue === undefined) {
+        _this6 = _BaseAtom2.call(this, [], undefined, options) || this;
       } else {
-        _this3 = _BaseAtom2.call(this, []) || this;
+        _this6 = _BaseAtom2.call(this, initialValue, undefined, options) || this;
       }
-      return _assertThisInitialized(_this3);
+      return _assertThisInitialized(_this6);
     }
+    _inheritsLoose(ArrayAtom, _BaseAtom2);
     var _proto4 = ArrayAtom.prototype;
     _proto4.push = function push(nextVal) {
-      this._behavior$.next([].concat(this._behavior$.getValue(), [nextVal]));
+      this._next([].concat(this.value(), [nextVal]));
     };
     return ArrayAtom;
   }(BaseAtom);
 
-  //
-  // export class ReadOnlyObjectAtom<
-  //   T extends {
-  //     [key in K]: V;
-  //   },
-  //   K extends string | number | symbol = keyof T,
-  //   V = T[K]
-  // > extends ReadOnlyAtom<T> {
-  //   get(nextKey: K) {
-  //     return this.value()[nextKey];
-  //   }
-  //
-  //   select<K extends keyof T>(
-  //     key: K
-  //   ): T[K] extends (infer W)[]
-  //     ? ArrayAtom<W>
-  //     : T[K] extends { [key in infer L]?: infer W }
-  //     ? ObjectAtom<T[K]>
-  //     : BaseAtom<T> {
-  //     const newObs = this._behavior$.pipe(
-  //       distinctUntilKeyChanged(key),
-  //       map((k) => k?.[key])
-  //     );
-  //     // Can't get typescript to recognize the types here so I'm cheating
-  //     return Atom(newObs) as unknown as T[K] extends (infer W)[]
-  //       ? ArrayAtom<W>
-  //       : T[K] extends { [key in infer L]?: infer W }
-  //       ? ObjectAtom<T[K]>
-  //       : BaseAtom<T>;
-  //   }
-  // }
-  //
-  // export class ObjectAtom<
-  //   T extends
-  //     | {
-  //         [key in K]: V;
-  //       }
-  //     | null,
-  //   K extends string | number | symbol = keyof T,
-  //   V = T extends { [key in K]: infer W } ? T[K] : null
-  // > extends ReadOnlyAtom<T> {
-  //   set(nextKey: K, nextValue: V) {
-  //     this._behavior$.next({
-  //       ...this._behavior$.getValue(),
-  //       [nextKey]: nextValue,
-  //     });
-  //   }
-  // }
+  /**
+   * Options for the {@link Atom} factory. `readOnly` produces a
+   * {@link ReadOnlyAtom}; `equals` sets the change comparator (defaults to
+   * {@link Object.is}).
+   */
 
-  // catch-all for developers
-  // export type AnyAtom<T> = BaseAtom<T> | ArrayAtom<T> | ObjectAtom<T>;
+  // Legacy positional `readOnly` form.
 
-  // observable<array> type
-  // observable<object> type
-  // nullable observable<object> type
-  // observable type (primitive)
-  // nullable observable type (primitive)
-  // array type
-  // object type
-  // nullable (unitialized) object type
-  // primitive type
-  // nullable (unitialized) primitive type
-  // readonly type
-  // function definition
-  function Atom(_value, readOnly) {
-    if (readOnly === void 0) {
-      readOnly = false;
-    }
-    var atom;
+  // Options-object form.
+
+  function Atom(_value, optionsOrReadOnly) {
+    var factoryOptions = typeof optionsOrReadOnly === "boolean" ? {
+      readOnly: optionsOrReadOnly
+    } : optionsOrReadOnly != null ? optionsOrReadOnly : {};
+    var _factoryOptions$readO = factoryOptions.readOnly,
+      readOnly = _factoryOptions$readO === void 0 ? false : _factoryOptions$readO,
+      equals = factoryOptions.equals;
+    var atomOptions = equals ? {
+      equals: equals
+    } : undefined;
     if (readOnly) {
-      atom = new ReadOnlyAtom(_value);
-    } else if (Array.isArray(_value)) {
-      atom = new ArrayAtom(_value); // For arrays
-    } else if (_value == null) {
-      atom = new NullableBaseAtom();
-    } else {
-      atom = new BaseAtom(_value); // For other types
+      return new ReadOnlyAtom(_value, undefined, atomOptions);
     }
-
-    return atom;
+    if (isAtomSource(_value)) {
+      var sourceValue = readAtomSourceValue(_value);
+      if (Array.isArray(sourceValue)) {
+        return new ArrayAtom(_value, atomOptions);
+      }
+      return new BaseAtom(_value, undefined, atomOptions);
+    }
+    if (Array.isArray(_value)) {
+      return new ArrayAtom(_value, atomOptions);
+    }
+    if (_value == null) {
+      return new NullableBaseAtom(undefined, atomOptions);
+    }
+    return new BaseAtom(_value, undefined, atomOptions);
   }
   Atom.combine = function () {
     for (var _len = arguments.length, atoms = new Array(_len), _key = 0; _key < _len; _key++) {
       atoms[_key] = arguments[_key];
     }
-    var observable = rxjs.combineLatest.apply(void 0, atoms.map(function (a) {
-      return a._behavior$;
-    }));
-    var newAtom = new ReadOnlyAtom(observable);
-    return newAtom;
-  };
-
-  function useAtom(atom) {
-    var _useState = react.useState(atom.value()),
-      value = _useState[0],
-      setValue = _useState[1];
-    react.useEffect(function () {
-      var subscription = atom.subscribe(function (val) {
-        setValue(val);
+    var getSnapshot = function getSnapshot() {
+      return atoms.map(function (atom) {
+        return atom.value();
       });
-      return function () {
-        subscription.unsubscribe();
-      };
-    }, [atom]);
-    return value;
-  }
-
-  function useSignal(signal, callback, id) {
-    react.useEffect(function () {
-      // Assuming the signal might not have an initial value method like `atom.value()`,
-      // If your signal class has a method to get the current/latest value, use it here to initialize.
-
-      var subscription;
-      if (callback) {
-        subscription = signal.subscribe(callback, id);
+    };
+    return new ReadOnlyAtom(getSnapshot(), {
+      getSnapshot: getSnapshot,
+      subscribe: function subscribe(onDependencyChange) {
+        var subscriptions = atoms.map(function (atom) {
+          return atom._subscribe(onDependencyChange, {
+            emitImmediately: false
+          });
+        });
+        return function () {
+          for (var _iterator2 = _createForOfIteratorHelperLoose(subscriptions), _step2; !(_step2 = _iterator2()).done;) {
+            var subscription = _step2.value;
+            subscription.unsubscribe();
+          }
+        };
       }
-      return function () {
-        if (subscription) {
-          subscription.unsubscribe();
-        }
-      };
-    }, [signal, callback, id]);
-  }
-
-  function useSelectAtom(atom, key) {
-    var _useState = react.useState(atom.get(key)),
-      value = _useState[0],
-      setValue = _useState[1];
-    react.useEffect(function () {
-      var subscription = atom.select(key).subscribe(function (val) {
-        setValue(val);
-      });
-      return function () {
-        subscription.unsubscribe();
-      };
-    }, [atom]);
-    return value;
-  }
+    });
+  };
 
   var hydratedAtomsSet = new WeakSet();
   function hydrateAtoms(values, options) {
@@ -345,56 +472,60 @@ var chemicalRx = (function (exports, rxjs, react) {
         value = _step$value[1];
       if (!hydratedAtomsSet.has(atom) || options != null && options.force) {
         hydratedAtomsSet.add(atom);
-        atom._behavior$.next(value);
+        atom.next(value);
       }
     }
   }
 
   var Signal = /*#__PURE__*/function () {
     function Signal() {
-      this._subjects = new Map();
-      this._defaultSubject = new rxjs.Subject();
+      this._listeners = [];
+      this._listenersById = new Map();
     }
     var _proto = Signal.prototype;
     _proto.ping = function ping(value, id) {
-      if (id && this._subjects.has(id)) {
-        var _this$_subjects$get;
-        // If an ID is provided and exists, notify only that subscription.
-        (_this$_subjects$get = this._subjects.get(id)) == null ? void 0 : _this$_subjects$get.next(value);
-      } else {
-        // No ID provided, notify all default subscribers.
-        this._defaultSubject.next(value);
-        // Additionally, notify all subscriptions as a broadcast.
-        this._subjects.forEach(function (subject) {
-          return subject.next(value);
-        });
+      if (id && this._listenersById.has(id)) {
+        notifyListeners(this._listenersById.get(id), value);
+        return;
+      }
+      notifyListeners(this._listeners, value);
+      for (var _iterator = _createForOfIteratorHelperLoose(this._listenersById.values()), _step; !(_step = _iterator()).done;) {
+        var listeners = _step.value;
+        notifyListeners(listeners, value);
       }
     };
     _proto.subscribe = function subscribe(callback, id) {
-      if (id) {
-        // If an ID is provided, subscribe to the specific ID.
-        if (!this._subjects.has(id)) {
-          this._subjects.set(id, new rxjs.Subject());
-        }
-        return this._subjects.get(id).subscribe(callback);
-      } else {
-        // No ID provided, subscribe to the default subject.
-        return this._defaultSubject.subscribe(callback);
+      var _this = this,
+        _this$_listenersById$;
+      if (!id) {
+        this._listeners.push(callback);
+        return createSubscription(function () {
+          removeListener(_this._listeners, callback);
+        });
       }
-    }
-
-    // Optionally, implement unsubscribe logic to manage subscriptions.
-    ;
+      var listeners = (_this$_listenersById$ = this._listenersById.get(id)) != null ? _this$_listenersById$ : [];
+      listeners.push(callback);
+      this._listenersById.set(id, listeners);
+      return createSubscription(function () {
+        removeListener(listeners, callback);
+        if (listeners.length === 0) {
+          _this._listenersById.delete(id);
+        }
+      });
+    };
     return Signal;
   }();
+  function removeListener(listeners, callback) {
+    var index = listeners.indexOf(callback);
+    if (index >= 0) {
+      listeners.splice(index, 1);
+    }
+  }
 
   exports.Atom = Atom;
   exports.Signal = Signal;
   exports.hydrateAtoms = hydrateAtoms;
-  exports.useAtom = useAtom;
-  exports.useSelectAtom = useSelectAtom;
-  exports.useSignal = useSignal;
 
   return exports;
 
-})({}, rxjs, React);
+})({});