chem-rx 0.0.23 → 0.2.0

package/src/Atom.ts

@@ -1,374 +0,0 @@
-import {
-  BehaviorSubject,
-  combineLatest,
-  distinctUntilChanged,
-  distinctUntilKeyChanged,
-  isObservable,
-  map,
-  Observable,
-  OperatorFunction,
-  Subscription,
-} from "rxjs";
-import { OverloadedParameters } from "./types";
-
-export type AtomTuple<T> = {
-  [K in keyof T]: ReadOnlyAtom<T[K]>;
-};
-
-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;
-  }
-
-  derive<A>(deriveFn: (value: T, index: number) => A): ReadOnlyAtom<A> {
-    return this.pipe(map(deriveFn));
-  }
-
-  subscribe(...params: Parameters<BehaviorSubject<T>["subscribe"]>) {
-    return this._behavior$.subscribe(...params);
-  }
-
-  value() {
-    return this._behavior$.getValue();
-  }
-
-  // not needed?
-  dispose() {
-    this._fromObservableSubscription?.unsubscribe();
-  }
-
-  get<K extends keyof T>(
-    key: K
-    // key: T extends (infer W)[]
-    //   ? number
-    //   : T extends { [key in keyof T]: infer W }
-    //   ? keyof T
-    //   : undefined
-  ): T extends (infer W)[] ? T[number] : T[K] {
-    const val = this.value() as T;
-    return val?.[key] as T extends (infer W)[] ? T[number] : T[K];
-  }
-
-  select<K extends keyof T>(
-    key: K
-  ): T[K] extends (infer W)[] ? ArrayAtom<W> : BaseAtom<T[K]> {
-    // console.log("key", key);
-    const newObs = this._behavior$.pipe(
-      distinctUntilChanged((a, b) => {
-        if (a === b) return true;
-        if (a && b && a[key] === b[key]) return true;
-        return false;
-      }),
-      map((k) => {
-        // console.log("insideee", k, key);
-
-        return k?.[key];
-      })
-    );
-    // console.log("obs", newObs);
-    // 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>
-      : BaseAtom<T[K]>;
-  }
-}
-
-export class BaseAtom<T> extends ReadOnlyAtom<T> {
-  next(nextVal: T) {
-    this._behavior$.next(nextVal);
-  }
-
-  set(nextKey: keyof T, nextValue: T[keyof T]) {
-    this._behavior$.next({
-      ...this._behavior$.getValue(),
-      [nextKey]: nextValue,
-    });
-  }
-}
-
-export class NullableBaseAtom<T> extends BaseAtom<T> {
-  constructor(_value?: T | Observable<T>) {
-    if (_value != null) {
-      super(_value);
-    } else {
-      // @ts-ignore
-      super(undefined);
-    }
-  }
-
-  // @ts-ignore
-  get<K extends keyof T>(
-    key: K
-    // key: T extends (infer W)[]
-    //   ? number
-    //   : T extends { [key in keyof T]: infer W }
-    //   ? keyof T
-    //   : undefined
-  ): (T extends (infer W)[] ? T[number] : T[K]) | undefined {
-    return super.get(key);
-  }
-
-  // @ts-ignore
-  select<K extends keyof T>(
-    key: K
-  ): T extends (infer W)[] ? ArrayAtom<W> : NullableBaseAtom<T[K]> {
-    // @ts-ignore
-    return super.select(key);
-  }
-
-  next(nextVal: T | null | undefined) {
-    // @ts-ignore
-    super.next(nextVal);
-  }
-
-  reset() {
-    // @ts-ignore
-    super.next(undefined);
-  }
-}
-
-export class ArrayAtom<T> extends BaseAtom<T[]> {
-  constructor(initialValue?: T[]) {
-    if (initialValue) {
-      super(initialValue);
-    } else {
-      super([]);
-    }
-  }
-
-  push(nextVal: T) {
-    this._behavior$.next([...this._behavior$.getValue(), nextVal]);
-  }
-}
-
-//
-// 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,
-//     });
-//   }
-// }
-
-// catch-all for developers
-// export type AnyAtom<T> = BaseAtom<T> | ArrayAtom<T> | ObjectAtom<T>;
-
-// observable<array> type
-export function Atom<T extends any[]>(
-  value?: Observable<T>
-): ArrayAtom<T[number]>;
-
-// observable<object> type
-export function Atom<T>(
-  value: T extends {
-    [key in keyof T]: infer V;
-  }
-    ? Observable<T>
-    : never
-): BaseAtom<T>;
-
-// nullable observable<object> type
-export function Atom<T>(
-  value?: T extends {
-    [key in keyof T]: infer V;
-  }
-    ? Observable<T>
-    : never
-): NullableBaseAtom<T>;
-
-// observable type (primitive)
-export function Atom<T>(
-  value?: T extends { [key: string]: infer V } | any[] ? never : Observable<T>
-): BaseAtom<T>;
-
-// nullable observable type (primitive)
-export function Atom<T>(
-  value?: T extends { [key: string]: infer V } | any[] ? never : Observable<T>
-): NullableBaseAtom<T>;
-
-// array type
-export function Atom<T extends any[]>(value?: T): ArrayAtom<T[number]>;
-
-// object type
-export function Atom<T extends { [key: string]: T[keyof T] }>(
-  value: T
-): BaseAtom<T>;
-
-// nullable (unitialized) object type
-export function Atom<T extends { [key: string]: T[keyof T] }>(
-  value?: T
-): NullableBaseAtom<T>;
-
-// primitive type
-export function Atom<T>(value: T): BaseAtom<T>;
-
-// nullable (unitialized) primitive type
-export function Atom<T>(value?: T): NullableBaseAtom<T>;
-
-// readonly type
-export function Atom<T>(value: T, readOnly?: boolean): ReadOnlyAtom<T>;
-
-// function definition
-export function Atom<T>(_value: T, readOnly: boolean = false) {
-  let atom;
-  if (readOnly) {
-    atom = new ReadOnlyAtom(_value);
-  } else if (Array.isArray(_value)) {
-    atom = new ArrayAtom<T>(_value); // For arrays
-  } else if (_value == null) {
-    atom = new NullableBaseAtom();
-  } 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

@@ -1,38 +0,0 @@
-import { Subject, Subscription } from "rxjs";
-
-export class Signal<T = any> {
-  private _subjects: Map<string, Subject<T>>;
-  private _defaultSubject: Subject<T>;
-
-  constructor() {
-    this._subjects = new Map();
-    this._defaultSubject = new Subject<T>();
-  }
-
-  ping(value: T, id?: string) {
-    if (id && this._subjects.has(id)) {
-      // If an ID is provided and exists, notify only that subscription.
-      this._subjects.get(id)?.next(value);
-    } else {
-      // No ID provided, notify all default subscribers.
-      this._defaultSubject.next(value);
-      // Additionally, notify all subscriptions as a broadcast.
-      this._subjects.forEach((subject) => subject.next(value));
-    }
-  }
-
-  subscribe(callback: (value: T) => void, id?: string): Subscription {
-    if (id) {
-      // If an ID is provided, subscribe to the specific ID.
-      if (!this._subjects.has(id)) {
-        this._subjects.set(id, new Subject<T>());
-      }
-      return this._subjects.get(id)!.subscribe(callback);
-    } else {
-      // No ID provided, subscribe to the default subject.
-      return this._defaultSubject.subscribe(callback);
-    }
-  }
-
-  // Optionally, implement unsubscribe logic to manage subscriptions.
-}

package/src/types.ts

@@ -1,66 +0,0 @@
-// 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

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

package/src/useHydrateAtoms.ts

@@ -1,16 +0,0 @@
-import { useEffect } from "react";
-import { BaseAtom, NullableBaseAtom, ReadOnlyAtom } from "./Atom";
-
-const hydratedAtomsSet: WeakSet<ReadOnlyAtom<any>> = new WeakSet();
-
-export function hydrateAtoms(
-  values: readonly [NullableBaseAtom<any> | BaseAtom<any>, any][],
-  options?: { force?: boolean }
-) {
-  for (const [atom, value] of values) {
-    if (!hydratedAtomsSet.has(atom) || options?.force) {
-      hydratedAtomsSet.add(atom);
-      atom._behavior$.next(value);
-    }
-  }
-}

package/src/useSelectAtom.ts

@@ -1,25 +0,0 @@
-import { useEffect, useState } from "react";
-import { BaseAtom, NullableBaseAtom, ReadOnlyAtom } from "./Atom";
-
-export function useSelectAtom<
-  T extends
-    | {
-        [key in K]: V;
-      },
-  K extends keyof T,
-  V = T[K]
->(atom: NullableBaseAtom<T> | BaseAtom<T> | ReadOnlyAtom<T>, key: K): T[K] {
-  const [value, setValue] = useState<T[K]>(atom.get(key)!);
-
-  useEffect(() => {
-    const subscription = atom.select(key).subscribe((val) => {
-      setValue(val as T[K]);
-    });
-
-    return () => {
-      subscription.unsubscribe();
-    };
-  }, [atom]);
-
-  return value;
-}

package/src/useSignal.ts

@@ -1,24 +0,0 @@
-import { useEffect, useState } from "react";
-import { Signal } from "./Signal";
-import { Subscription } from "rxjs";
-
-export function useSignal<T>(
-  signal: Signal<T>,
-  callback?: (update: T) => void,
-  id?: string
-) {
-  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: Subscription;
-    if (callback) {
-      subscription = signal.subscribe(callback, id);
-    }
-    return () => {
-      if (subscription) {
-        subscription.unsubscribe();
-      }
-    };
-  }, [signal, callback, id]);
-}