chem-rx 0.0.23 → 0.2.0

package/dist/index.cjs.js

@@ -1,343 +1,467 @@
 'use strict';
 
-var rxjs = require('rxjs');
-var react = require('react');
-
+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(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-  _setPrototypeOf(subClass, superClass);
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
 }
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+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;
+  }
+}
+
+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);
   }
-  return self;
+  if (subscription && typeof subscription.unsubscribe === "function") {
+    return createSubscription(function () {
+      return subscription.unsubscribe();
+    });
+  }
+  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) {
@@ -347,52 +471,56 @@ function hydrateAtoms(values, options) {
       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;