chem-rx 0.0.23 → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,423 @@
+function _extends() {
+  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 n;
+  }, _extends.apply(null, arguments);
+}
+
+const noop = () => {};
+function createSubscription(unsubscribe) {
+  let closed = false;
+  return {
+    unsubscribe: () => {
+      if (closed) return;
+      closed = true;
+      unsubscribe();
+    }
+  };
+}
+function normalizeSubscription(subscription) {
+  if (typeof subscription === "function") {
+    return createSubscription(subscription);
+  }
+  if (subscription && typeof subscription.unsubscribe === "function") {
+    return createSubscription(() => subscription.unsubscribe());
+  }
+  return createSubscription(noop);
+}
+function isAtomSource(value) {
+  return value != null && typeof value === "object" && typeof value.subscribe === "function";
+}
+function readAtomSourceValue(source) {
+  if (typeof source.getValue === "function") {
+    return source.getValue();
+  }
+  if (typeof source.value === "function") {
+    return source.value();
+  }
+  return undefined;
+}
+function toListener(observer) {
+  if (typeof observer === "function") {
+    return observer;
+  }
+  if (observer && typeof observer.next === "function") {
+    return value => observer.next == null ? void 0 : observer.next(value);
+  }
+  return noop;
+}
+function notifyListeners(listeners, value) {
+  const errors = [];
+  for (const listener of Array.from(listeners)) {
+    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");
+  }
+}
+class ValueStore {
+  constructor(value) {
+    this._listeners = [];
+    this._value = value;
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(value) {
+    this._value = value;
+  }
+  next(value) {
+    this._value = value;
+    notifyListeners(this._listeners, value);
+  }
+  subscribe(observer, options = {}) {
+    const listener = toListener(observer);
+    this._listeners.push(listener);
+    if (options.emitImmediately !== false) {
+      listener(this._value);
+    }
+    return createSubscription(() => {
+      const index = this._listeners.indexOf(listener);
+      if (index >= 0) {
+        this._listeners.splice(index, 1);
+      }
+    });
+  }
+}
+
+/**
+ * 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.
+ */
+
+class ReadOnlyAtom {
+  /**
+   * @param options.equals Comparator deciding when the value has changed.
+   *   Defaults to {@link Object.is}. Subscribers are notified only when it
+   *   returns `false`.
+   */
+  constructor(_value, dependency, options) {
+    var _options$equals;
+    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(value => {
+        this._next(value);
+      }));
+    } else {
+      this._store = new ValueStore(_value);
+    }
+  }
+
+  /**
+   * 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.
+   */
+  derive(deriveFn, options) {
+    let index = 0;
+    let hasCachedInput = false;
+    let cachedInput;
+    let cachedValue;
+    const getSnapshot = (force = false) => {
+      const input = this.value();
+      if (force || !hasCachedInput || !Object.is(cachedInput, input)) {
+        cachedInput = input;
+        cachedValue = deriveFn(input, index++);
+        hasCachedInput = true;
+      }
+      return cachedValue;
+    };
+    return new ReadOnlyAtom(getSnapshot(), {
+      getSnapshot,
+      subscribe: onDependencyChange => this._subscribe(onDependencyChange, {
+        emitImmediately: false
+      })
+    }, options);
+  }
+  subscribe(observer) {
+    return this._subscribe(observer);
+  }
+  value() {
+    if (this._dependency) {
+      this._refresh(false);
+    }
+    return this._store.getValue();
+  }
+  dispose() {
+    var _this$_dependencySubs;
+    (_this$_dependencySubs = this._dependencySubscription) == null || _this$_dependencySubs.unsubscribe();
+    this._dependencySubscription = null;
+    this._subscriberCount = 0;
+    for (const subscription of this._subscriptions.splice(0)) {
+      subscription.unsubscribe();
+    }
+  }
+  get(key) {
+    const 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.
+   */
+  select(key, options) {
+    const getSnapshot = () => {
+      const value = this.value();
+      return value == null ? void 0 : value[key];
+    };
+    return new ReadOnlyAtom(getSnapshot(), {
+      getSnapshot,
+      subscribe: onDependencyChange => this._subscribe(onDependencyChange, {
+        emitImmediately: false
+      })
+    }, options);
+  }
+  _refresh(emit, force = false) {
+    if (!this._dependency) {
+      return this._store.getValue();
+    }
+    const previousValue = this._store.getValue();
+    const nextValue = this._dependency.getSnapshot(force);
+    const shouldNotify = emit && !this._equals(previousValue, nextValue);
+    if (shouldNotify) {
+      this._store.next(nextValue);
+    } else {
+      this._store.setValue(nextValue);
+    }
+    return nextValue;
+  }
+  _retainDependency() {
+    if (!this._dependency) {
+      return;
+    }
+    this._subscriberCount += 1;
+    if (this._subscriberCount === 1) {
+      this._dependencySubscription = normalizeSubscription(this._dependency.subscribe(() => {
+        this._refresh(true, true);
+      }));
+    }
+  }
+  _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;
+    }
+  }
+
+  /** @internal */
+  _next(value) {
+    const previousValue = this._store.getValue();
+    if (this._equals(previousValue, value)) {
+      this._store.setValue(value);
+    } else {
+      this._store.next(value);
+    }
+  }
+
+  /** @internal */
+  _subscribe(observer, options) {
+    if (!this._dependency) {
+      return this._store.subscribe(observer, options);
+    }
+    this._refresh(false);
+    let subscription;
+    try {
+      this._retainDependency();
+      subscription = this._store.subscribe(observer, options);
+    } catch (error) {
+      this._releaseDependency();
+      throw error;
+    }
+    return createSubscription(() => {
+      subscription.unsubscribe();
+      this._releaseDependency();
+    });
+  }
+
+  /** @internal */
+  _addSubscription(subscription) {
+    const normalized = normalizeSubscription(subscription);
+    this._subscriptions.push(normalized);
+    return normalized;
+  }
+}
+class BaseAtom extends ReadOnlyAtom {
+  next(nextVal) {
+    this._next(nextVal);
+  }
+  set(nextKey, nextValue) {
+    const 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, {
+      [nextKey]: nextValue
+    }));
+  }
+}
+class NullableBaseAtom extends BaseAtom {
+  constructor(_value, options) {
+    super(_value, undefined, options);
+  }
+  next(nextVal) {
+    this._next(nextVal);
+  }
+  reset() {
+    this._next(undefined);
+  }
+}
+class ArrayAtom extends BaseAtom {
+  constructor(initialValue, options) {
+    if (initialValue === undefined) {
+      super([], undefined, options);
+    } else {
+      super(initialValue, undefined, options);
+    }
+  }
+  push(nextVal) {
+    this._next([...this.value(), nextVal]);
+  }
+}
+
+/**
+ * Options for the {@link Atom} factory. `readOnly` produces a
+ * {@link ReadOnlyAtom}; `equals` sets the change comparator (defaults to
+ * {@link Object.is}).
+ */
+
+// Legacy positional `readOnly` form.
+
+// Options-object form.
+
+function Atom(_value, optionsOrReadOnly) {
+  const factoryOptions = typeof optionsOrReadOnly === "boolean" ? {
+    readOnly: optionsOrReadOnly
+  } : optionsOrReadOnly != null ? optionsOrReadOnly : {};
+  const {
+    readOnly = false,
+    equals
+  } = factoryOptions;
+  const atomOptions = equals ? {
+    equals
+  } : undefined;
+  if (readOnly) {
+    return new ReadOnlyAtom(_value, undefined, atomOptions);
+  }
+  if (isAtomSource(_value)) {
+    const 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 = (...atoms) => {
+  const getSnapshot = () => atoms.map(atom => atom.value());
+  return new ReadOnlyAtom(getSnapshot(), {
+    getSnapshot,
+    subscribe: onDependencyChange => {
+      const subscriptions = atoms.map(atom => atom._subscribe(onDependencyChange, {
+        emitImmediately: false
+      }));
+      return () => {
+        for (const subscription of subscriptions) {
+          subscription.unsubscribe();
+        }
+      };
+    }
+  });
+};
+
+const hydratedAtomsSet = new WeakSet();
+function hydrateAtoms(values, options) {
+  for (const [atom, value] of values) {
+    if (!hydratedAtomsSet.has(atom) || options != null && options.force) {
+      hydratedAtomsSet.add(atom);
+      atom.next(value);
+    }
+  }
+}
+
+class Signal {
+  constructor() {
+    this._listeners = [];
+    this._listenersById = new Map();
+  }
+  ping(value, id) {
+    if (id && this._listenersById.has(id)) {
+      notifyListeners(this._listenersById.get(id), value);
+      return;
+    }
+    notifyListeners(this._listeners, value);
+    for (const listeners of this._listenersById.values()) {
+      notifyListeners(listeners, value);
+    }
+  }
+  subscribe(callback, id) {
+    var _this$_listenersById$;
+    if (!id) {
+      this._listeners.push(callback);
+      return createSubscription(() => {
+        removeListener(this._listeners, callback);
+      });
+    }
+    const listeners = (_this$_listenersById$ = this._listenersById.get(id)) != null ? _this$_listenersById$ : [];
+    listeners.push(callback);
+    this._listenersById.set(id, listeners);
+    return createSubscription(() => {
+      removeListener(listeners, callback);
+      if (listeners.length === 0) {
+        this._listenersById.delete(id);
+      }
+    });
+  }
+}
+function removeListener(listeners, callback) {
+  const index = listeners.indexOf(callback);
+  if (index >= 0) {
+    listeners.splice(index, 1);
+  }
+}
+
+export { Atom, Signal, hydrateAtoms };

package/dist/react.cjs.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var react = require('react');
+
+function useAtom(atom) {
+  return react.useSyncExternalStore(function (onStoreChange) {
+    var subscribed = false;
+    var subscription = atom.subscribe(function () {
+      if (subscribed) {
+        onStoreChange();
+      }
+    });
+    subscribed = true;
+    return function () {
+      subscription.unsubscribe();
+    };
+  }, function () {
+    return atom.value();
+  }, function () {
+    return atom.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 function () {
+      if (subscription) {
+        subscription.unsubscribe();
+      }
+    };
+  }, [signal, callback, id]);
+}
+
+function useSelectAtom(atom, key) {
+  var selectedAtom = react.useMemo(function () {
+    return atom.select(key);
+  }, [atom, key]);
+  return useAtom(selectedAtom);
+}
+
+exports.useAtom = useAtom;
+exports.useSelectAtom = useSelectAtom;
+exports.useSignal = useSignal;

package/{src/index.ts → dist/react.d.ts}

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

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/react.mjs

@@ -0,0 +1,40 @@
+import { useSyncExternalStore, useEffect, useMemo } from 'react';
+
+function useAtom(atom) {
+  return useSyncExternalStore(onStoreChange => {
+    let subscribed = false;
+    const subscription = atom.subscribe(() => {
+      if (subscribed) {
+        onStoreChange();
+      }
+    });
+    subscribed = true;
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, () => atom.value(), () => atom.value());
+}
+
+function useSignal(signal, callback, id) {
+  useEffect(() => {
+    // 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.
+
+    let subscription;
+    if (callback) {
+      subscription = signal.subscribe(callback, id);
+    }
+    return () => {
+      if (subscription) {
+        subscription.unsubscribe();
+      }
+    };
+  }, [signal, callback, id]);
+}
+
+function useSelectAtom(atom, key) {
+  const selectedAtom = useMemo(() => atom.select(key), [atom, key]);
+  return useAtom(selectedAtom);
+}
+
+export { useAtom, useSelectAtom, useSignal };

package/dist/store.d.ts

@@ -0,0 +1,30 @@
+export type AtomListener<T> = (value: T) => void;
+export type AtomSubscription = {
+    unsubscribe: () => void;
+};
+export type AtomObserver<T> = AtomListener<T> | {
+    next?: AtomListener<T>;
+};
+export type AtomSource<T> = {
+    subscribe: (observer: AtomObserver<T>) => AtomSubscription | (() => void) | void;
+    getValue?: () => T;
+    value?: () => T;
+};
+export declare function createSubscription(unsubscribe: () => void): AtomSubscription;
+export declare function normalizeSubscription(subscription: AtomSubscription | (() => void) | void): AtomSubscription;
+export declare function isAtomSource<T = unknown>(value: unknown): value is AtomSource<T>;
+export declare function readAtomSourceValue<T>(source: AtomSource<T>): T;
+export declare function toListener<T>(observer: AtomObserver<T>): AtomListener<T>;
+export declare function notifyListeners<T>(listeners: Iterable<AtomListener<T>>, value: T): void;
+export declare class ValueStore<T> {
+    private _value;
+    private _listeners;
+    constructor(value: T);
+    getValue(): T;
+    setValue(value: T): void;
+    next(value: T): void;
+    subscribe(observer: AtomObserver<T>, options?: {
+        emitImmediately?: boolean;
+    }): AtomSubscription;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,CAAC,IACtB,YAAY,CAAC,CAAC,CAAC,GACf;IACE,IAAI,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;CACxB,CAAC;AAEN,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,SAAS,EAAE,CACT,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,KACtB,gBAAgB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;CACjB,CAAC;AAIF,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,IAAI,GAAG,gBAAgB,CAU5E;AAED,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,gBAAgB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,GACnD,gBAAgB,CAUlB;AAED,wBAAgB,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAMhF;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAU/D;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAUxE;AAED,wBAAgB,eAAe,CAAC,CAAC,EAC/B,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EACpC,KAAK,EAAE,CAAC,QAmBT;AAED,qBAAa,UAAU,CAAC,CAAC;IACvB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,UAAU,CAAyB;gBAE/B,KAAK,EAAE,CAAC;IAIpB,QAAQ;IAIR,QAAQ,CAAC,KAAK,EAAE,CAAC;IAIjB,IAAI,CAAC,KAAK,EAAE,CAAC;IAKb,SAAS,CACP,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAO,GAC1C,gBAAgB;CAgBpB"}

package/dist/useAtom.d.ts

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

package/dist/useAtom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAtom.d.ts","sourceRoot":"","sources":["../src/useAtom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAElE,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GACxD,CAAC,CAcH"}
+{"version":3,"file":"useAtom.d.ts","sourceRoot":"","sources":["../src/useAtom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAkBnD"}

package/dist/useHydrateAtoms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useHydrateAtoms.d.ts","sourceRoot":"","sources":["../src/useHydrateAtoms.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAgB,MAAM,QAAQ,CAAC;AAIlE,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,EAC/D,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,QAQ9B"}
+{"version":3,"file":"useHydrateAtoms.d.ts","sourceRoot":"","sources":["../src/useHydrateAtoms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAgB,MAAM,QAAQ,CAAC;AAIlE,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,EAC/D,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,QAQ9B"}

package/dist/useSelectAtom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSelectAtom.d.ts","sourceRoot":"","sources":["../src/useSelectAtom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAElE,wBAAgB,aAAa,CAC3B,CAAC,SACG;KACG,GAAG,IAAI,CAAC,GAAG,CAAC;CACd,EACL,CAAC,SAAS,MAAM,CAAC,EACjB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EACR,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAczE"}
+{"version":3,"file":"useSelectAtom.d.ts","sourceRoot":"","sources":["../src/useSelectAtom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGlE,wBAAgB,aAAa,CAC3B,CAAC,SACG;KACG,GAAG,IAAI,CAAC,GAAG,CAAC;CACd,EACL,CAAC,SAAS,MAAM,CAAC,EACjB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EACR,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAMzE"}

package/package.json

@@ -1,9 +1,23 @@
 {
   "name": "chem-rx",
-  "version": "0.0.23",
-  "description": "react state primitives powered by rx.js",
-  "main": "dist/index.js",
+  "version": "0.2.0",
+  "description": "react state primitives with framework-agnostic atoms",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "test": "jest",
+    "clean": "rm -rf ./dist",
+    "build": "pnpm run prebuild && tsc --emitDeclarationOnly && rollup -c",
+    "prepublishOnly": "pnpm run test && pnpm run build"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dxu/chem-rx.git"
@@ -22,7 +36,6 @@
     "@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",
@@ -31,22 +44,27 @@
     "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"
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
   },
   "exports": {
-    ".": "./dist/index.js",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.mjs",
+      "require": "./dist/react.cjs.js"
+    },
     "./index.cjs.js": "./dist/index.cjs.js"
-  },
-  "scripts": {
-    "prebuild": "rimraf dist",
-    "test": "jest",
-    "clean": "rm -rf ./dist",
-    "build": "pnpm run prebuild && rollup -c",
-    "bump": "pnpm run build && pnpm version patch"
   }
-}
+}

package/.size-snapshot.json

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