chem-rx 0.0.1

package/.size-snapshot.json

@@ -0,0 +1,26 @@
+{
+  "index.js": {
+    "bundled": 2254,
+    "minified": 1146,
+    "gzipped": 529,
+    "treeshaked": {
+      "rollup": {
+        "code": 13,
+        "import_statements": 13
+      },
+      "webpack": {
+        "code": 997
+      }
+    }
+  },
+  "index.cjs.js": {
+    "bundled": 2625,
+    "minified": 1302,
+    "gzipped": 570
+  },
+  "index.iife.js": {
+    "bundled": 2825,
+    "minified": 1233,
+    "gzipped": 550
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 wetonium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# chem-rx
+
+`chem-rx` wraps`rx.js` to provide a state management solution focused on
+simplicity. Useable with or without React!
+
+## Atom
+
+`chem-rx` is an atomic approach to state management, similar to
+[jotai](https://github.com/pmndrs/jotai) or
+[Recoil](https://github.com/facebookexperimental/Recoil).
+
+Atoms are state containers that take any value - object, array, or primitive.
+
+```
+import { Atom } from 'chem-rx'
+
+const numberAtom: BaseAtom = Atom(0)
+const stringAtom: BaseAtom = Atom('hello')
+const arrayAtom: ArrayAtom = Atom(['hello', 'world'])
+const objectAtom: ObjectAtom = Atom({ 'hello': 'world', 'world': 'hello' })
+```
+
+### Getting & setting values
+
+`Atom` will automatically return an instance of `BaseAtom`, `ArrayAtom`, or
+`ObjectAtom` depending on the input.
+
+```
+/*
+ * BaseAtom
+ */
+numberAtom.set(2)
+numberAtom.value()
+// 2
+
+/*
+ * ArrayAtom
+ */
+arrayAtom.push('!')
+arrayAtom.value()
+// ['hello', 'world', '!']
+arrayAtom.get(1)
+// 'world'
+
+/*
+ * ObjectAtom
+ */
+objectAtom.set('world', 'hi')
+objectAtom.value()
+// {'hello': 'world', 'world': 'hi'}
+
+objectAtom.set('sup', 'earth')
+// {'hello': 'world', 'world': 'hi', 'sup': 'earth'}
+
+objectAtom.get('world')
+// 'hi'
+```
+
+### Transforming Atoms
+
+### Composing Atoms & ReadOnlyAtoms
+
+### Subscribing to updates
+
+## Use with React
+
+### useAtom
+
+### hydrateAtoms
+
+## Use with rx.js
+
+## Why...?
+
+This library spawned out of a love for the flexibility and expressiveness of
+[rx.js](https://github.com/ReactiveX/rxjs) Observables, and the simplicity of
+atomic libraries like [jotai](https://github.com/pmndrs/jotai).
+
+Its primary focus is on ease of use and code cleanliness, and is my go-to
+library for all client-side state management

package/babel.config.js

@@ -0,0 +1,24 @@
+module.exports = (api, targets) => {
+  // https://babeljs.io/docs/en/config-files#config-function-api
+  const isTestEnv = api.env("test");
+
+  return {
+    babelrc: false,
+    ignore: ["./node_modules"],
+    presets: [
+      [
+        "@babel/preset-env",
+        {
+          loose: true,
+          modules: isTestEnv ? "commonjs" : false,
+          targets: isTestEnv ? { node: "current" } : targets,
+        },
+      ],
+      "@babel/preset-typescript",
+    ],
+    plugins: [
+      "@babel/plugin-transform-react-jsx",
+      ["@babel/plugin-transform-typescript", { isTSX: true }],
+    ],
+  };
+};

package/dist/Atom.d.ts

@@ -0,0 +1,29 @@
+import { BehaviorSubject, Observable, OperatorFunction, Subscription } from "rxjs";
+export type AtomTuple<T> = {
+    [K in keyof T]: Atom<T[K]>;
+};
+export declare class Atom<T> {
+    _behavior$: BehaviorSubject<T>;
+    _parent?: BehaviorSubject<T>[];
+    _bonds: BehaviorSubject<T>[];
+    _fromObservable: Observable<T> | null;
+    _fromObservableSubscription: Subscription | null;
+    static combine<A extends readonly unknown[]>(...atoms: readonly [...AtomTuple<A>]): Atom<A>;
+    constructor(_value: T | Observable<T>);
+    push(nextVal: T): void;
+    transform(): Atom<T>;
+    transform<A>(op1: OperatorFunction<T, A>): Atom<A>;
+    transform<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Atom<B>;
+    transform<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Atom<C>;
+    transform<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Atom<D>;
+    transform<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Atom<E>;
+    transform<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Atom<F>;
+    transform<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Atom<G>;
+    transform<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Atom<H>;
+    transform<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Atom<I>;
+    transform<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Atom<unknown>;
+    subscribe(...params: Parameters<BehaviorSubject<T>["subscribe"]>): Subscription;
+    getValue(): T;
+    dispose(): void;
+}
+//# sourceMappingURL=Atom.d.ts.map

package/dist/Atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Atom.d.ts","sourceRoot":"","sources":["../src/Atom.ts"],"names":[],"mappings":"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"}

package/dist/Signal.d.ts

@@ -0,0 +1,9 @@
+import { Subject, Subscription } from "rxjs";
+export declare class Signal<T = void> {
+    _subject$: Subject<T>;
+    constructor();
+    ping(value: T): void;
+    subscribe(...params: Parameters<Subject<T>["subscribe"]>): Subscription;
+    dispose(): void;
+}
+//# sourceMappingURL=Signal.d.ts.map

package/dist/Signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../src/Signal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAIP,YAAY,EACb,MAAM,MAAM,CAAC;AAGd,qBAAa,MAAM,CAAC,CAAC,GAAG,IAAI;IAC1B,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;;IAOtB,IAAI,CAAC,KAAK,EAAE,CAAC;IAIb,SAAS,CAAC,GAAG,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IAKxD,OAAO;CAGR"}

package/dist/hydrateAtoms.d.ts

@@ -0,0 +1,3 @@
+import { Atom } from "./Atom";
+export declare function hydrateAtoms(values: readonly [Atom<any>, any][]): void;
+//# sourceMappingURL=hydrateAtoms.d.ts.map

package/dist/hydrateAtoms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrateAtoms.d.ts","sourceRoot":"","sources":["../src/hydrateAtoms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,QAI/D"}

package/dist/index.cjs.js

@@ -0,0 +1,143 @@
+'use strict';
+
+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];
+    }
+    var observable = rxjs.combineLatest.apply(void 0, atoms.map(function (a) {
+      return a._behavior$;
+    }));
+    return new Atom(observable);
+  };
+  function Atom(_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.push(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 _this$_behavior$;
+    // @ts-ignore can't match overloaded function
+    var observable = (_this$_behavior$ = this._behavior$).pipe.apply(_this$_behavior$, arguments);
+    return new Atom(observable);
+  };
+  _proto.subscribe = function subscribe() {
+    var _this$_behavior$2;
+    return (_this$_behavior$2 = this._behavior$).subscribe.apply(_this$_behavior$2, arguments);
+  };
+  _proto.getValue = function getValue() {
+    return this._behavior$.getValue();
+  }
+
+  // not needed?
+  ;
+  _proto.dispose = function dispose() {
+    var _this$_fromObservable;
+    (_this$_fromObservable = this._fromObservableSubscription) == null ? void 0 : _this$_fromObservable.unsubscribe();
+  };
+  return Atom;
+}();
+
+function useAtom(atom) {
+  var _useState = react.useState(atom.getValue()),
+    value = _useState[0],
+    setValue = _useState[1];
+  react.useEffect(function () {
+    var subscription = atom.subscribe(function (val) {
+      setValue(val);
+    });
+    return function () {
+      subscription.unsubscribe();
+    };
+  }, [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;
+    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.");
+}
+
+function hydrateAtoms(values) {
+  for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+      atom = _step$value[0],
+      value = _step$value[1];
+    atom.push(value);
+  }
+}
+
+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;
+}();
+
+exports.Atom = Atom;
+exports.Signal = Signal;
+exports.hydrateAtoms = hydrateAtoms;
+exports.useAtom = useAtom;

package/dist/index.d.ts

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

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.iife.js

@@ -0,0 +1,145 @@
+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];
+      }
+      var observable = rxjs.combineLatest.apply(void 0, atoms.map(function (a) {
+        return a._behavior$;
+      }));
+      return new Atom(observable);
+    };
+    function Atom(_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.push(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 _this$_behavior$;
+      // @ts-ignore can't match overloaded function
+      var observable = (_this$_behavior$ = this._behavior$).pipe.apply(_this$_behavior$, arguments);
+      return new Atom(observable);
+    };
+    _proto.subscribe = function subscribe() {
+      var _this$_behavior$2;
+      return (_this$_behavior$2 = this._behavior$).subscribe.apply(_this$_behavior$2, arguments);
+    };
+    _proto.getValue = function getValue() {
+      return this._behavior$.getValue();
+    }
+
+    // not needed?
+    ;
+    _proto.dispose = function dispose() {
+      var _this$_fromObservable;
+      (_this$_fromObservable = this._fromObservableSubscription) == null ? void 0 : _this$_fromObservable.unsubscribe();
+    };
+    return Atom;
+  }();
+
+  function useAtom(atom) {
+    var _useState = react.useState(atom.getValue()),
+      value = _useState[0],
+      setValue = _useState[1];
+    react.useEffect(function () {
+      var subscription = atom.subscribe(function (val) {
+        setValue(val);
+      });
+      return function () {
+        subscription.unsubscribe();
+      };
+    }, [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;
+      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.");
+  }
+
+  function hydrateAtoms(values) {
+    for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {
+      var _step$value = _step.value,
+        atom = _step$value[0],
+        value = _step$value[1];
+      atom.push(value);
+    }
+  }
+
+  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;
+  }();
+
+  exports.Atom = Atom;
+  exports.Signal = Signal;
+  exports.hydrateAtoms = hydrateAtoms;
+  exports.useAtom = useAtom;
+
+  return exports;
+
+})({}, rxjs, React);

package/dist/index.js

@@ -0,0 +1,86 @@
+import { combineLatest, isObservable, BehaviorSubject, Subject } from 'rxjs';
+import { useState, useEffect } from 'react';
+
+class Atom {
+  static combine(...atoms) {
+    const observable = combineLatest(...atoms.map(a => a._behavior$));
+    return new Atom(observable);
+  }
+  constructor(_value) {
+    this._bonds = [];
+    this._fromObservable = null;
+    this._fromObservableSubscription = null;
+    if (isObservable(_value)) {
+      this._fromObservable = _value;
+      this._behavior$ = new BehaviorSubject(null);
+      this._fromObservableSubscription = _value.subscribe(value => {
+        this.push(value);
+      });
+    } else {
+      // if it's just a value just use a regular behavior subject
+      this._behavior$ = new BehaviorSubject(_value);
+    }
+  }
+  push(nextVal) {
+    this._behavior$.next(nextVal);
+  }
+
+  // taken from Observable
+
+  transform(...operations) {
+    // @ts-ignore can't match overloaded function
+    const observable = this._behavior$.pipe(...operations);
+    return new Atom(observable);
+  }
+  subscribe(...params) {
+    return this._behavior$.subscribe(...params);
+  }
+  getValue() {
+    return this._behavior$.getValue();
+  }
+
+  // not needed?
+  dispose() {
+    var _this$_fromObservable;
+    (_this$_fromObservable = this._fromObservableSubscription) == null ? void 0 : _this$_fromObservable.unsubscribe();
+  }
+}
+
+function useAtom(atom) {
+  const [value, setValue] = useState(atom.getValue());
+  useEffect(() => {
+    const subscription = atom.subscribe(val => {
+      setValue(val);
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [atom]);
+  return value;
+}
+
+function hydrateAtoms(values) {
+  for (const [atom, value] of values) {
+    atom.push(value);
+  }
+}
+
+class Signal {
+  constructor() {
+    // if it's just a value just use a regular behavior subject
+    this._subject$ = new Subject();
+  }
+  ping(value) {
+    this._subject$.next(value);
+  }
+  subscribe(...params) {
+    return this._subject$.subscribe(...params);
+  }
+
+  // not needed?
+  dispose() {
+    this._subject$.unsubscribe();
+  }
+}
+
+export { Atom, Signal, hydrateAtoms, useAtom };

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+declare class GenericClass<T> {
+}
+export type GetGenericType<C extends GenericClass<any>> = C extends GenericClass<infer T> ? T : unknown;
+export type KeyOfValueType<T, V> = {
+    [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+export type IsObject<T> = T extends object ? T : never;
+export type IsntObject<T> = T extends object ? never : T;
+export type IsntFunction<T> = T extends Function ? never : T;
+export type OmitKeysWithNeverValues<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export declare function assertUnreachable(_value?: never): never;
+type ValidFunction<Arguments extends unknown[], ReturnType> = unknown[] extends Arguments ? unknown extends ReturnType ? never : (...args: Arguments) => ReturnType : (...args: Arguments) => ReturnType;
+export type Overloads<T extends (...args: unknown[]) => unknown> = T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+    (...args: infer A8): infer R8;
+    (...args: infer A9): infer R9;
+    (...args: infer A10): infer R10;
+    (...args: infer A11): infer R11;
+    (...args: infer A12): infer R12;
+} ? ValidFunction<A1, R1> | ValidFunction<A2, R2> | ValidFunction<A3, R3> | ValidFunction<A4, R4> | ValidFunction<A5, R5> | ValidFunction<A6, R6> | ValidFunction<A7, R7> | ValidFunction<A8, R8> | ValidFunction<A9, R9> | ValidFunction<A10, R10> | ValidFunction<A11, R11> | ValidFunction<A12, R12> : never;
+export type OverloadedParameters<T extends (...args: any[]) => unknown> = Parameters<Overloads<T>>;
+export type OverloadedReturnType<T extends (...args: any[]) => unknown> = ReturnType<Overloads<T>>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/useAtom.d.ts

@@ -0,0 +1,3 @@
+import { Atom } from "./Atom";
+export declare function useAtom<T>(atom: Atom<T>): T;
+//# sourceMappingURL=useAtom.d.ts.map

package/dist/useAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAtom.d.ts","sourceRoot":"","sources":["../src/useAtom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAc3C"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "chem-rx",
+  "version": "0.0.1",
+  "description": "react state primitives powered by rx.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dxu/chem-rx.git"
+  },
+  "author": "dxu",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dxu/chem-rx/issues"
+  },
+  "homepage": "https://github.com/dxu/chem-rx#readme",
+  "devDependencies": {
+    "@babel/core": "^7.22.10",
+    "@babel/plugin-transform-react-jsx": "^7.22.5",
+    "@babel/plugin-transform-typescript": "^7.22.10",
+    "@babel/preset-env": "^7.22.10",
+    "@babel/preset-typescript": "^7.22.5",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-node-resolve": "^15.1.0",
+    "@rollup/plugin-typescript": "^11.1.2",
+    "@types/jest": "^29.5.3",
+    "@types/react": "^18.2.20",
+    "jest": "^29.6.2",
+    "rimraf": "^5.0.1",
+    "rollup": "^3.28.0",
+    "rollup-plugin-size-snapshot": "^0.12.0",
+    "rollup-plugin-typescript2": "^0.35.0",
+    "rollup-plugin-visualizer": "^5.9.2",
+    "rxjs": "^7.8.1",
+    "typescript": "^5.1.6"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0",
+    "rxjs": "^7.5.7"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./index.cjs.js": "./dist/index.cjs.js"
+  },
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "test": "jest",
+    "clean": "rm -rf ./dist",
+    "build": "npm run prebuild && rollup -c"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,92 @@
+const path = require("path");
+
+const { visualizer } = require("rollup-plugin-visualizer");
+
+const babel = require("@rollup/plugin-babel");
+const resolve = require("@rollup/plugin-node-resolve");
+const typescript = require("@rollup/plugin-typescript");
+// const { sizeSnapshot } = require("rollup-plugin-size-snapshot");
+
+const createBabelConfig = require("./babel.config");
+
+const { root } = path.parse(process.cwd());
+const external = (id) => !id.startsWith(".") && !id.startsWith(root);
+const extensions = [".js", ".ts", ".tsx"];
+const getBabelOptions = (targets) => ({
+  babelHelpers: "bundled",
+  ...createBabelConfig({ env: (env) => env === "build" }, targets),
+  extensions,
+});
+
+function createDeclarationConfig(input, output) {
+  return {
+    input,
+    output: {
+      dir: output,
+    },
+    external,
+    plugins: [
+      typescript({
+        declaration: true,
+        emitDeclarationOnly: true,
+        outDir: output,
+      }),
+    ],
+  };
+}
+
+function createESMConfig(input, output) {
+  return {
+    input,
+    output: { file: output, format: "esm" },
+    external,
+    plugins: [
+      babel(getBabelOptions({ node: 8 })),
+      // sizeSnapshot(),
+      resolve({ extensions }),
+      visualizer(),
+    ],
+  };
+}
+
+function createCommonJSConfig(input, output) {
+  return {
+    input,
+    output: { file: output, format: "cjs", exports: "named" },
+    external,
+    plugins: [
+      babel(getBabelOptions({ ie: 11 })),
+      // sizeSnapshot(),
+      resolve({ extensions }),
+    ],
+  };
+}
+
+function createIIFEConfig(input, output, globalName) {
+  return {
+    input,
+    output: {
+      file: output,
+      format: "iife",
+      exports: "named",
+      name: globalName,
+      globals: {
+        react: "React",
+        rxjs: "rxjs",
+      },
+    },
+    external,
+    plugins: [
+      babel(getBabelOptions({ ie: 11 })),
+      // sizeSnapshot(),
+      resolve({ extensions }),
+    ],
+  };
+}
+
+module.exports = [
+  createDeclarationConfig(`src/index.ts`, "dist"),
+  createESMConfig("src/index.ts", "dist/index.js"),
+  createCommonJSConfig("src/index.ts", "dist/index.cjs.js"),
+  createIIFEConfig("src/index.ts", "dist/index.iife.js", "chemicalRx"),
+];

package/src/Atom.ts

@@ -0,0 +1,200 @@
+import {
+  BehaviorSubject,
+  combineLatest,
+  isObservable,
+  map,
+  Observable,
+  OperatorFunction,
+  Subscription,
+} from "rxjs";
+import { OverloadedParameters, OverloadedReturnType } from "./types";
+
+export type AtomTuple<T> = {
+  [K in keyof T]: ReadOnlyAtom<T[K]>;
+};
+
+// export class ReadOnlyAtom<T> {}
+
+export class ReadOnlyAtom<T> {
+  _behavior$: BehaviorSubject<T>;
+
+  _parent?: BehaviorSubject<T>[];
+  _bonds: BehaviorSubject<T>[] = [];
+
+  _fromObservable: Observable<T> | null = null;
+  _fromObservableSubscription: Subscription | null = null;
+
+  constructor(_value: T | Observable<T>) {
+    if (isObservable(_value)) {
+      this._fromObservable = _value;
+      this._behavior$ = new BehaviorSubject<T>(null!);
+      this._fromObservableSubscription = _value.subscribe((value) => {
+        this._behavior$.next(value);
+      });
+    } else {
+      // if it's just a value just use a regular behavior subject
+      this._behavior$ = new BehaviorSubject<T>(_value);
+    }
+  }
+
+  // taken from Observable
+  pipe(): ReadOnlyAtom<T>;
+  pipe<A>(op1: OperatorFunction<T, A>): ReadOnlyAtom<A>;
+  pipe<A, B>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>
+  ): ReadOnlyAtom<B>;
+  pipe<A, B, C>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>
+  ): ReadOnlyAtom<C>;
+  pipe<A, B, C, D>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>
+  ): ReadOnlyAtom<D>;
+  pipe<A, B, C, D, E>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>
+  ): ReadOnlyAtom<E>;
+  pipe<A, B, C, D, E, F>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>
+  ): ReadOnlyAtom<F>;
+  pipe<A, B, C, D, E, F, G>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>
+  ): ReadOnlyAtom<G>;
+  pipe<A, B, C, D, E, F, G, H>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>,
+    op8: OperatorFunction<G, H>
+  ): ReadOnlyAtom<H>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>,
+    op8: OperatorFunction<G, H>,
+    op9: OperatorFunction<H, I>
+  ): ReadOnlyAtom<I>;
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunction<T, A>,
+    op2: OperatorFunction<A, B>,
+    op3: OperatorFunction<B, C>,
+    op4: OperatorFunction<C, D>,
+    op5: OperatorFunction<D, E>,
+    op6: OperatorFunction<E, F>,
+    op7: OperatorFunction<F, G>,
+    op8: OperatorFunction<G, H>,
+    op9: OperatorFunction<H, I>,
+    ...operations: OperatorFunction<any, any>[]
+  ): ReadOnlyAtom<unknown>;
+
+  pipe(
+    ...operations: OverloadedParameters<Observable<T>["pipe"]>
+  ): ReadOnlyAtom<any> {
+    // @ts-ignore can't match overloaded function
+    const observable = this._behavior$.pipe(...operations);
+    const newAtom = new ReadOnlyAtom(observable);
+
+    return newAtom;
+  }
+
+  transform(transformFn: (value: T, index: number) => any): ReadOnlyAtom<any> {
+    return this.pipe(map(transformFn));
+  }
+
+  subscribe(...params: Parameters<BehaviorSubject<T>["subscribe"]>) {
+    return this._behavior$.subscribe(...params);
+  }
+
+  value() {
+    return this._behavior$.getValue();
+  }
+
+  // not needed?
+  dispose() {
+    this._fromObservableSubscription?.unsubscribe();
+  }
+}
+
+export class BaseAtom<T> extends ReadOnlyAtom<T> {
+  set(nextVal: T) {
+    this._behavior$.next(nextVal);
+  }
+}
+
+export class ArrayAtom<T> extends ReadOnlyAtom<T[]> {
+  push(nextVal: T) {
+    this._behavior$.next([...this._behavior$.getValue(), nextVal]);
+  }
+  get(idx: number) {
+    return this.value()[idx];
+  }
+}
+
+export class ObjectAtom<
+  T extends Record<K, V>,
+  K extends keyof T = keyof T,
+  V = T[K]
+> extends ReadOnlyAtom<T> {
+  set(nextKey: K, nextValue: V) {
+    this._behavior$.next({
+      ...this._behavior$.getValue(),
+      [nextKey]: nextValue,
+    });
+  }
+  get(nextKey: K) {
+    return this.value()[nextKey];
+  }
+}
+
+export function Atom<T>(value: T[]): ArrayAtom<T>;
+export function Atom<T extends object, K extends keyof T = keyof T>(
+  _value: T
+): ObjectAtom<T>;
+export function Atom<T>(_value: Observable<T> | T): BaseAtom<T>;
+export function Atom<T>(
+  _value: T | Observable<T>
+): BaseAtom<T> | ArrayAtom<T> | ObjectAtom<T> {
+  let atom;
+  if (Array.isArray(_value)) {
+    atom = new ArrayAtom<T>(_value); // For arrays
+  } else if (typeof _value === "object" && _value !== null) {
+    atom = new ObjectAtom<T>(_value); // For objects
+  } else {
+    atom = new BaseAtom(_value); // For other types
+  }
+  return atom;
+}
+
+Atom.combine = <A extends readonly unknown[]>(
+  ...atoms: readonly [...AtomTuple<A>]
+): ReadOnlyAtom<A> => {
+  const observable = combineLatest(...atoms.map((a) => a._behavior$));
+  const newAtom = new ReadOnlyAtom(observable) as unknown as ReadOnlyAtom<A>;
+  return newAtom;
+};

package/src/Signal.ts

@@ -0,0 +1,30 @@
+import {
+  Subject,
+  isObservable,
+  Observable,
+  OperatorFunction,
+  Subscription,
+} from "rxjs";
+import { OverloadedParameters, OverloadedReturnType } from "./types";
+
+export class Signal<T = void> {
+  _subject$: Subject<T>;
+
+  constructor() {
+    // if it's just a value just use a regular behavior subject
+    this._subject$ = new Subject<T>();
+  }
+
+  ping(value: T) {
+    this._subject$.next(value);
+  }
+
+  subscribe(...params: Parameters<Subject<T>["subscribe"]>) {
+    return this._subject$.subscribe(...params);
+  }
+
+  // not needed?
+  dispose() {
+    this._subject$.unsubscribe();
+  }
+}

package/src/hydrateAtoms.ts

@@ -0,0 +1,7 @@
+import { Atom } from "./Atom";
+
+export function hydrateAtoms(values: readonly [Atom<any>, any][]) {
+  for (const [atom, value] of values) {
+    atom.push(value);
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { Atom } from "./Atom";
+export { useAtom } from "./useAtom";
+export { hydrateAtoms } from "./hydrateAtoms";
+export { Signal } from "./Signal";

package/src/types.ts

@@ -0,0 +1,66 @@
+// Helper types if needed
+
+class GenericClass<T> {}
+export type GetGenericType<C extends GenericClass<any>> =
+  C extends GenericClass<infer T> ? T : unknown;
+
+export type KeyOfValueType<T, V> = {
+  [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+
+export type IsObject<T> = T extends object ? T : never;
+export type IsntObject<T> = T extends object ? never : T;
+export type IsntFunction<T> = T extends Function ? never : T;
+
+export type OmitKeysWithNeverValues<T> = {
+  [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+
+export function assertUnreachable(_value?: never): never {
+  throw new Error("Statement should be unreachable");
+}
+
+// https://github.com/microsoft/TypeScript/issues/32164
+
+type ValidFunction<
+  Arguments extends unknown[],
+  ReturnType
+> = unknown[] extends Arguments
+  ? unknown extends ReturnType
+    ? never
+    : (...args: Arguments) => ReturnType
+  : (...args: Arguments) => ReturnType;
+
+export type Overloads<T extends (...args: unknown[]) => unknown> = T extends {
+  (...args: infer A1): infer R1;
+  (...args: infer A2): infer R2;
+  (...args: infer A3): infer R3;
+  (...args: infer A4): infer R4;
+  (...args: infer A5): infer R5;
+  (...args: infer A6): infer R6;
+  (...args: infer A7): infer R7;
+  (...args: infer A8): infer R8;
+  (...args: infer A9): infer R9;
+  (...args: infer A10): infer R10;
+  (...args: infer A11): infer R11;
+  (...args: infer A12): infer R12;
+}
+  ?
+      | ValidFunction<A1, R1>
+      | ValidFunction<A2, R2>
+      | ValidFunction<A3, R3>
+      | ValidFunction<A4, R4>
+      | ValidFunction<A5, R5>
+      | ValidFunction<A6, R6>
+      | ValidFunction<A7, R7>
+      | ValidFunction<A8, R8>
+      | ValidFunction<A9, R9>
+      | ValidFunction<A10, R10>
+      | ValidFunction<A11, R11>
+      | ValidFunction<A12, R12>
+  : never;
+
+export type OverloadedParameters<T extends (...args: any[]) => unknown> =
+  Parameters<Overloads<T>>;
+export type OverloadedReturnType<T extends (...args: any[]) => unknown> =
+  ReturnType<Overloads<T>>;

package/src/useAtom.ts

@@ -0,0 +1,18 @@
+import { useEffect, useState } from "react";
+import { Atom } from "./Atom";
+
+export function useAtom<T>(atom: Atom<T>): T {
+  const [value, setValue] = useState<T>(atom.getValue());
+
+  useEffect(() => {
+    const subscription = atom.subscribe((val) => {
+      setValue(val);
+    });
+
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [atom]);
+
+  return value;
+}

package/tests/atom.test.ts

@@ -0,0 +1,125 @@
+import {
+  ArrayAtom,
+  Atom,
+  BaseAtom,
+  ObjectAtom,
+  ReadOnlyAtom,
+} from "../src/Atom";
+import { map, of } from "rxjs";
+
+test("Base Atom values test", () => {
+  const atom = Atom("aweofij");
+  expect(atom instanceof BaseAtom).toBe(true);
+  expect(atom.value()).toBe("aweofij");
+
+  atom.set("apro");
+
+  expect(atom.value()).toBe("apro");
+});
+
+test("Object Atom values test", () => {
+  const atom = Atom<{ [key: string]: string }>({
+    firstKey: "firstValue",
+    secondKey: "secondValue",
+  });
+  expect(atom instanceof ObjectAtom).toBe(true);
+  expect(atom.value()["firstKey"]).toBe("firstValue");
+
+  expect(atom.value()["secondKey"]).toBe("secondValue");
+  atom.set("secondKey", "newSecondValue");
+  expect(atom.value()["secondKey"]).toBe("newSecondValue");
+
+  expect(atom.value()["thirdKey"]).toBeUndefined();
+  expect(atom.value()).not.toHaveProperty("thirdKey");
+  atom.set("thirdKey", "thirdValue");
+  expect(atom.value()["thirdKey"]).toBe("thirdValue");
+});
+
+test("Object Atom get function test", () => {
+  const atom = Atom<{ [key: string]: string }>({
+    firstKey: "firstValue",
+    secondKey: "secondValue",
+  });
+  expect(atom instanceof ObjectAtom).toBe(true);
+  expect(atom.get("firstKey")).toBe("firstValue");
+
+  expect(atom.get("secondKey")).toBe("secondValue");
+  atom.set("secondKey", "newSecondValue");
+  expect(atom.get("secondKey")).toBe("newSecondValue");
+
+  expect(atom.get("thirdKey")).toBeUndefined();
+  expect(atom.value()).not.toHaveProperty("thirdKey");
+  atom.set("thirdKey", "thirdValue");
+  expect(atom.get("thirdKey")).toBe("thirdValue");
+});
+
+test("Array Atom values test", () => {
+  const atom = Atom(["first"]);
+  expect(atom instanceof ArrayAtom).toBe(true);
+  expect(atom.value().length).toBe(1);
+  expect(atom.value()[0]).toBe("first");
+
+  atom.push("second");
+  expect(atom.value().length).toBe(2);
+  expect(atom.value()[1]).toBe("second");
+});
+
+test("Array Atom get index test", () => {
+  const atom = Atom(["first"]);
+  expect(atom instanceof ArrayAtom).toBe(true);
+  expect(atom.value().length).toBe(1);
+  expect(atom.get(0)).toBe("first");
+
+  atom.push("second");
+  expect(atom.value().length).toBe(2);
+  expect(atom.get(1)).toBe("second");
+});
+
+test("Test native pipe", () => {
+  const atom = Atom(3);
+  expect(atom instanceof BaseAtom).toBe(true);
+  expect(atom.value()).toBe(3);
+
+  const transformedAtom = atom.pipe(map((x) => x * x));
+  expect(transformedAtom instanceof ReadOnlyAtom).toBe(true);
+  expect(transformedAtom).not.toHaveProperty("push");
+
+  expect(transformedAtom.value()).toBe(9);
+});
+
+test("Test transform", () => {
+  const atom = Atom(3);
+  expect(atom instanceof BaseAtom).toBe(true);
+  expect(atom.value()).toBe(3);
+
+  const transformedAtom = atom.transform((x) => x * x);
+  expect(transformedAtom instanceof ReadOnlyAtom).toBe(true);
+  expect(transformedAtom).not.toHaveProperty("push");
+
+  expect(transformedAtom.value()).toBe(9);
+});
+
+test("Test combine", () => {
+  const normalizedData = Atom<{ [key: string]: { name: string } }>({
+    a: { name: "a" },
+    b: { name: "b" },
+    c: { name: "c" },
+  });
+  const ids = Atom<string[]>(["a", "b", "c"]);
+  const combined = Atom.combine(normalizedData, ids).transform(
+    ([normed, ids]) => {
+      return ids.map((id) => normed[id]);
+    }
+  );
+  expect(combined).not.toHaveProperty("push");
+
+  expect(combined instanceof ReadOnlyAtom).toBe(true);
+
+  expect(combined instanceof ReadOnlyAtom).toBe(true);
+  expect(combined).not.toHaveProperty("push");
+  const combinedValue = combined.value();
+  expect(combinedValue.length).toBe(3);
+  expect(combinedValue[0].name).toBe("a");
+  expect(combinedValue[1].name).toBe("b");
+  expect(combinedValue[2].name).toBe("c");
+});

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": true,
+    "rootDir": "./src",
+    "target": "esnext",
+    "strict": true,
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "baseUrl": ".",
+    "outDir": "dist",
+    "paths": {
+      "chemical-rx": ["./src/index.ts"],
+      "chemical-rx/*": ["./src/*.ts"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}