chem-rx 0.0.1 → 0.0.3

package/dist/index.cjs.js

@@ -3,17 +3,66 @@
 var rxjs = require('rxjs');
 var react = require('react');
 
-var Atom = /*#__PURE__*/function () {
-  Atom.combine = function combine() {
-    for (var _len = arguments.length, atoms = new Array(_len), _key = 0; _key < _len; _key++) {
-      atoms[_key] = arguments[_key];
+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];
+        }
+      }
     }
-    var observable = rxjs.combineLatest.apply(void 0, atoms.map(function (a) {
-      return a._behavior$;
-    }));
-    return new Atom(observable);
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
   };
-  function Atom(_value) {
+  return _setPrototypeOf(o, p);
+}
+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 = 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++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var ReadOnlyAtom = /*#__PURE__*/function () {
+  function ReadOnlyAtom(_value) {
     var _this = this;
     this._bonds = [];
     this._fromObservable = null;
@@ -22,31 +71,31 @@ var Atom = /*#__PURE__*/function () {
       this._fromObservable = _value;
       this._behavior$ = new rxjs.BehaviorSubject(null);
       this._fromObservableSubscription = _value.subscribe(function (value) {
-        _this.push(value);
+        _this._behavior$.next(value);
       });
     } else {
       // if it's just a value just use a regular behavior subject
       this._behavior$ = new rxjs.BehaviorSubject(_value);
     }
   }
-  var _proto = Atom.prototype;
-  _proto.push = function push(nextVal) {
-    this._behavior$.next(nextVal);
-  }
 
   // taken from Observable
-  ;
-  _proto.transform = function transform() {
+  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);
-    return new Atom(observable);
+    var newAtom = new ReadOnlyAtom(observable);
+    return newAtom;
+  };
+  _proto.derive = function derive(deriveFn) {
+    return this.pipe(rxjs.map(deriveFn));
   };
   _proto.subscribe = function subscribe() {
     var _this$_behavior$2;
     return (_this$_behavior$2 = this._behavior$).subscribe.apply(_this$_behavior$2, arguments);
   };
-  _proto.getValue = function getValue() {
+  _proto.value = function value() {
     return this._behavior$.getValue();
   }
 
@@ -56,11 +105,128 @@ var Atom = /*#__PURE__*/function () {
     var _this$_fromObservable;
     (_this$_fromObservable = this._fromObservableSubscription) == null ? void 0 : _this$_fromObservable.unsubscribe();
   };
-  return Atom;
+  _proto.get = function get(key) {
+    var val = this.value();
+    // @ts-ignore Can't figure out this type so i'm REALLY cheating
+    return val[key];
+  };
+  _proto.select = function select(key) {
+    var newObs = this._behavior$.pipe(rxjs.distinctUntilKeyChanged(key), rxjs.map(function (k) {
+      return k == null ? void 0 : k[key];
+    }));
+    // Can't get typescript to recognize the types here so I'm cheating
+    return Atom(newObs);
+  };
+  return ReadOnlyAtom;
 }();
+var BaseAtom = /*#__PURE__*/function (_ReadOnlyAtom) {
+  _inheritsLoose(BaseAtom, _ReadOnlyAtom);
+  function BaseAtom() {
+    return _ReadOnlyAtom.apply(this, arguments) || this;
+  }
+  var _proto2 = BaseAtom.prototype;
+  _proto2.set = function set(nextVal) {
+    this._behavior$.next(nextVal);
+  };
+  return BaseAtom;
+}(ReadOnlyAtom);
+var ArrayAtom = /*#__PURE__*/function (_ReadOnlyAtom2) {
+  _inheritsLoose(ArrayAtom, _ReadOnlyAtom2);
+  function ArrayAtom(initialValue) {
+    return _ReadOnlyAtom2.call(this, initialValue) || this;
+  }
+  var _proto3 = ArrayAtom.prototype;
+  _proto3.push = function push(nextVal) {
+    this._behavior$.next([].concat(this._behavior$.getValue(), [nextVal]));
+  };
+  return ArrayAtom;
+}(ReadOnlyAtom);
+//
+// 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>;
+//   }
+// }
+
+var ObjectAtom = /*#__PURE__*/function (_ReadOnlyAtom3) {
+  _inheritsLoose(ObjectAtom, _ReadOnlyAtom3);
+  function ObjectAtom() {
+    return _ReadOnlyAtom3.apply(this, arguments) || this;
+  }
+  var _proto4 = ObjectAtom.prototype;
+  _proto4.set = function set(nextKey, nextValue) {
+    var _extends2;
+    this._behavior$.next(_extends({}, this._behavior$.getValue(), (_extends2 = {}, _extends2[nextKey] = nextValue, _extends2)));
+  };
+  return ObjectAtom;
+}(ReadOnlyAtom);
+
+// catch-all for developers
+// export type AnyAtom<T> = BaseAtom<T> | ArrayAtom<T> | ObjectAtom<T>;
+
+// observable type (primitive)
+// observable<array> type
+// observable<object> type
+// array type
+// object type
+// primitive type
+// readonly type
+// function definition
+function Atom(_value, readOnly) {
+  if (readOnly === void 0) {
+    readOnly = false;
+  }
+  var atom;
+  if (readOnly) {
+    atom = new ReadOnlyAtom(_value);
+  } else if (Array.isArray(_value)) {
+    atom = new ArrayAtom(_value); // For arrays
+  } else if (typeof _value === "object" && _value !== null) {
+    atom = new ObjectAtom(_value); // For objects
+  } else {
+    atom = new BaseAtom(_value); // For other types
+  }
+
+  return atom;
+}
+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.getValue()),
+  var _useState = react.useState(atom.value()),
     value = _useState[0],
     setValue = _useState[1];
   react.useEffect(function () {
@@ -74,36 +240,19 @@ function useAtom(atom) {
   return value;
 }
 
-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 = 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;
+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 () {
-      if (i >= o.length) return {
-        done: true
-      };
-      return {
-        done: false,
-        value: o[i++]
-      };
+      subscription.unsubscribe();
     };
-  }
-  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }, [atom]);
+  return value;
 }
 
 function hydrateAtoms(values) {
@@ -115,29 +264,10 @@ function hydrateAtoms(values) {
   }
 }
 
-var Signal = /*#__PURE__*/function () {
-  function Signal() {
-    // if it's just a value just use a regular behavior subject
-    this._subject$ = new rxjs.Subject();
-  }
-  var _proto = Signal.prototype;
-  _proto.ping = function ping(value) {
-    this._subject$.next(value);
-  };
-  _proto.subscribe = function subscribe() {
-    var _this$_subject$;
-    return (_this$_subject$ = this._subject$).subscribe.apply(_this$_subject$, arguments);
-  }
-
-  // not needed?
-  ;
-  _proto.dispose = function dispose() {
-    this._subject$.unsubscribe();
-  };
-  return Signal;
-}();
+function Signal() {}
 
 exports.Atom = Atom;
 exports.Signal = Signal;
 exports.hydrateAtoms = hydrateAtoms;
 exports.useAtom = useAtom;
+exports.useSelectAtom = useSelectAtom;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { Atom } from "./Atom";
 export { useAtom } from "./useAtom";
+export { useSelectAtom } from "./useSelectAtom";
 export { hydrateAtoms } from "./hydrateAtoms";
 export { Signal } from "./Signal";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.iife.js

@@ -1,17 +1,66 @@
 var chemicalRx = (function (exports, rxjs, react) {
   'use strict';
 
-  var Atom = /*#__PURE__*/function () {
-    Atom.combine = function combine() {
-      for (var _len = arguments.length, atoms = new Array(_len), _key = 0; _key < _len; _key++) {
-        atoms[_key] = arguments[_key];
+  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];
+          }
+        }
       }
-      var observable = rxjs.combineLatest.apply(void 0, atoms.map(function (a) {
-        return a._behavior$;
-      }));
-      return new Atom(observable);
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
+  function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+    _setPrototypeOf(subClass, superClass);
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
     };
-    function Atom(_value) {
+    return _setPrototypeOf(o, p);
+  }
+  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 = 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++]
+        };
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  var ReadOnlyAtom = /*#__PURE__*/function () {
+    function ReadOnlyAtom(_value) {
       var _this = this;
       this._bonds = [];
       this._fromObservable = null;
@@ -20,31 +69,31 @@ var chemicalRx = (function (exports, rxjs, react) {
         this._fromObservable = _value;
         this._behavior$ = new rxjs.BehaviorSubject(null);
         this._fromObservableSubscription = _value.subscribe(function (value) {
-          _this.push(value);
+          _this._behavior$.next(value);
         });
       } else {
         // if it's just a value just use a regular behavior subject
         this._behavior$ = new rxjs.BehaviorSubject(_value);
       }
     }
-    var _proto = Atom.prototype;
-    _proto.push = function push(nextVal) {
-      this._behavior$.next(nextVal);
-    }
 
     // taken from Observable
-    ;
-    _proto.transform = function transform() {
+    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);
-      return new Atom(observable);
+      var newAtom = new ReadOnlyAtom(observable);
+      return newAtom;
+    };
+    _proto.derive = function derive(deriveFn) {
+      return this.pipe(rxjs.map(deriveFn));
     };
     _proto.subscribe = function subscribe() {
       var _this$_behavior$2;
       return (_this$_behavior$2 = this._behavior$).subscribe.apply(_this$_behavior$2, arguments);
     };
-    _proto.getValue = function getValue() {
+    _proto.value = function value() {
       return this._behavior$.getValue();
     }
 
@@ -54,11 +103,128 @@ var chemicalRx = (function (exports, rxjs, react) {
       var _this$_fromObservable;
       (_this$_fromObservable = this._fromObservableSubscription) == null ? void 0 : _this$_fromObservable.unsubscribe();
     };
-    return Atom;
+    _proto.get = function get(key) {
+      var val = this.value();
+      // @ts-ignore Can't figure out this type so i'm REALLY cheating
+      return val[key];
+    };
+    _proto.select = function select(key) {
+      var newObs = this._behavior$.pipe(rxjs.distinctUntilKeyChanged(key), rxjs.map(function (k) {
+        return k == null ? void 0 : k[key];
+      }));
+      // Can't get typescript to recognize the types here so I'm cheating
+      return Atom(newObs);
+    };
+    return ReadOnlyAtom;
   }();
+  var BaseAtom = /*#__PURE__*/function (_ReadOnlyAtom) {
+    _inheritsLoose(BaseAtom, _ReadOnlyAtom);
+    function BaseAtom() {
+      return _ReadOnlyAtom.apply(this, arguments) || this;
+    }
+    var _proto2 = BaseAtom.prototype;
+    _proto2.set = function set(nextVal) {
+      this._behavior$.next(nextVal);
+    };
+    return BaseAtom;
+  }(ReadOnlyAtom);
+  var ArrayAtom = /*#__PURE__*/function (_ReadOnlyAtom2) {
+    _inheritsLoose(ArrayAtom, _ReadOnlyAtom2);
+    function ArrayAtom(initialValue) {
+      return _ReadOnlyAtom2.call(this, initialValue) || this;
+    }
+    var _proto3 = ArrayAtom.prototype;
+    _proto3.push = function push(nextVal) {
+      this._behavior$.next([].concat(this._behavior$.getValue(), [nextVal]));
+    };
+    return ArrayAtom;
+  }(ReadOnlyAtom);
+  //
+  // 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>;
+  //   }
+  // }
+
+  var ObjectAtom = /*#__PURE__*/function (_ReadOnlyAtom3) {
+    _inheritsLoose(ObjectAtom, _ReadOnlyAtom3);
+    function ObjectAtom() {
+      return _ReadOnlyAtom3.apply(this, arguments) || this;
+    }
+    var _proto4 = ObjectAtom.prototype;
+    _proto4.set = function set(nextKey, nextValue) {
+      var _extends2;
+      this._behavior$.next(_extends({}, this._behavior$.getValue(), (_extends2 = {}, _extends2[nextKey] = nextValue, _extends2)));
+    };
+    return ObjectAtom;
+  }(ReadOnlyAtom);
+
+  // catch-all for developers
+  // export type AnyAtom<T> = BaseAtom<T> | ArrayAtom<T> | ObjectAtom<T>;
+
+  // observable type (primitive)
+  // observable<array> type
+  // observable<object> type
+  // array type
+  // object type
+  // primitive type
+  // readonly type
+  // function definition
+  function Atom(_value, readOnly) {
+    if (readOnly === void 0) {
+      readOnly = false;
+    }
+    var atom;
+    if (readOnly) {
+      atom = new ReadOnlyAtom(_value);
+    } else if (Array.isArray(_value)) {
+      atom = new ArrayAtom(_value); // For arrays
+    } else if (typeof _value === "object" && _value !== null) {
+      atom = new ObjectAtom(_value); // For objects
+    } else {
+      atom = new BaseAtom(_value); // For other types
+    }
+
+    return atom;
+  }
+  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.getValue()),
+    var _useState = react.useState(atom.value()),
       value = _useState[0],
       setValue = _useState[1];
     react.useEffect(function () {
@@ -72,36 +238,19 @@ var chemicalRx = (function (exports, rxjs, react) {
     return value;
   }
 
-  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 = 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;
+  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 () {
-        if (i >= o.length) return {
-          done: true
-        };
-        return {
-          done: false,
-          value: o[i++]
-        };
+        subscription.unsubscribe();
       };
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }, [atom]);
+    return value;
   }
 
   function hydrateAtoms(values) {
@@ -113,32 +262,13 @@ var chemicalRx = (function (exports, rxjs, react) {
     }
   }
 
-  var Signal = /*#__PURE__*/function () {
-    function Signal() {
-      // if it's just a value just use a regular behavior subject
-      this._subject$ = new rxjs.Subject();
-    }
-    var _proto = Signal.prototype;
-    _proto.ping = function ping(value) {
-      this._subject$.next(value);
-    };
-    _proto.subscribe = function subscribe() {
-      var _this$_subject$;
-      return (_this$_subject$ = this._subject$).subscribe.apply(_this$_subject$, arguments);
-    }
-
-    // not needed?
-    ;
-    _proto.dispose = function dispose() {
-      this._subject$.unsubscribe();
-    };
-    return Signal;
-  }();
+  function Signal() {}
 
   exports.Atom = Atom;
   exports.Signal = Signal;
   exports.hydrateAtoms = hydrateAtoms;
   exports.useAtom = useAtom;
+  exports.useSelectAtom = useSelectAtom;
 
   return exports;