synstate 0.1.0

package/src/core/types/observable-family.mts

@@ -0,0 +1,259 @@
+import { expectType, type Result } from 'ts-data-forge';
+import {
+  type AsyncChildObservable,
+  type InitializedObservable,
+  type InitializedRootObservable,
+  type InitializedSyncChildObservable,
+  type Observable,
+  type RootObservable,
+  type SyncChildObservable,
+  type Unwrap,
+} from './observable.mjs';
+import { type NonEmptyUnknownList } from './types.mjs';
+
+// RootObservable
+
+export type InitializedSourceObservable<A> = Readonly<{
+  next: (value: A) => void;
+}> &
+  InitializedRootObservable<A>;
+
+export type SourceObservable<A> = Readonly<{
+  next: (value: A) => void;
+}> &
+  RootObservable<A>;
+
+export type OfObservable<A> = Readonly<{
+  emit: () => OfObservable<A>;
+}> &
+  RootObservable<A>;
+
+export type FromArrayObservable<A> = Readonly<{
+  emit: () => FromArrayObservable<A>;
+}> &
+  RootObservable<A>;
+
+export type FromPromiseObservable<A, E = unknown> = RootObservable<
+  Result<A, E>
+>;
+
+export type FromSubscribableObservable<A, E = unknown> = RootObservable<
+  Result<A, E>
+>;
+
+export type IntervalObservable = Readonly<{
+  start: () => IntervalObservable;
+}> &
+  RootObservable<SafeUint>;
+
+export type TimerObservable = Readonly<{
+  start: () => TimerObservable;
+}> &
+  RootObservable<0>;
+
+// InitializedSyncChildObservable
+
+export type WithInitialValueOperatorObservable<
+  A,
+  I = A,
+> = InitializedSyncChildObservable<A | I, readonly [A]>;
+
+export type ScanOperatorObservable<A, B> = InitializedSyncChildObservable<
+  B,
+  readonly [A]
+>;
+
+// SyncChildObservable
+
+namespace SyncFlowInternals {
+  type Cast<A> = A extends NonEmptyUnknownList ? A : never;
+
+  type EveryInitialized<OS extends NonEmptyArray<Observable<unknown>>> =
+    OS extends NonEmptyArray<InitializedObservable<unknown>> ? true : false;
+
+  type IsInitialized<O> = readonly [O] extends readonly [
+    InitializedObservable<unknown>,
+  ]
+    ? true
+    : false;
+
+  /** Evaluates True | false as true instead of boolean */
+  type LogicalValue<B extends boolean> = readonly [B] extends readonly [true]
+    ? true
+    : readonly [B] extends readonly [false]
+      ? false
+      : true;
+
+  type SomeInitializedImpl<OS extends Observable<unknown>> =
+    // union distribution
+    LogicalValue<OS extends OS ? IsInitialized<OS> : never>;
+
+  type SomeInitialized<OS extends NonEmptyArray<Observable<unknown>>> =
+    SomeInitializedImpl<OS[number]>;
+
+  expectType<EveryInitialized<readonly [Observable<1>]>, false>('=');
+
+  expectType<EveryInitialized<readonly [InitializedObservable<1>]>, true>('=');
+
+  expectType<
+    EveryInitialized<
+      readonly [InitializedObservable<1>, InitializedObservable<2>]
+    >,
+    true
+  >('=');
+
+  expectType<
+    EveryInitialized<readonly [Observable<1>, InitializedObservable<2>]>,
+    false
+  >('=');
+
+  expectType<SomeInitialized<readonly [Observable<1>]>, false>('=');
+
+  expectType<SomeInitialized<readonly [InitializedObservable<1>]>, true>('=');
+
+  expectType<
+    SomeInitialized<
+      readonly [InitializedObservable<1>, InitializedObservable<2>]
+    >,
+    true
+  >('=');
+
+  expectType<
+    SomeInitialized<readonly [Observable<1>, InitializedObservable<2>]>,
+    true
+  >('=');
+
+  type InitializedCombineObservableImpl<A extends NonEmptyUnknownList> =
+    InitializedSyncChildObservable<A, A>;
+
+  export type CombineObservableImpl<A extends NonEmptyUnknownList> =
+    SyncChildObservable<A, A>;
+
+  export type CombineObservableRefinedImpl<
+    OS extends NonEmptyArray<Observable<unknown>>,
+  > =
+    EveryInitialized<OS> extends true
+      ? InitializedCombineObservableImpl<Cast<Unwrap<OS>>>
+      : CombineObservableImpl<Unwrap<OS>>;
+
+  type InitializedZipObservableImpl<A extends NonEmptyUnknownList> =
+    InitializedSyncChildObservable<A, A>;
+
+  export type ZipObservableImpl<A extends NonEmptyUnknownList> =
+    SyncChildObservable<A, A>;
+
+  export type ZipObservableRefinedImpl<
+    OS extends NonEmptyArray<Observable<unknown>>,
+  > =
+    EveryInitialized<OS> extends true
+      ? InitializedZipObservableImpl<Cast<Unwrap<OS>>>
+      : ZipObservableImpl<Unwrap<OS>>;
+
+  type InitializedMergeObservableImpl<P extends NonEmptyUnknownList> =
+    InitializedSyncChildObservable<ArrayElement<P>, P>;
+
+  export type MergeObservableImpl<P extends NonEmptyUnknownList> =
+    SyncChildObservable<ArrayElement<P>, P>;
+
+  export type MergeObservableRefinedImpl<
+    OS extends NonEmptyArray<Observable<unknown>>,
+  > =
+    SomeInitialized<OS> extends true
+      ? InitializedMergeObservableImpl<Cast<Unwrap<OS>>>
+      : MergeObservableImpl<Unwrap<OS>>;
+}
+
+export type CombineObservable<A extends NonEmptyUnknownList> =
+  SyncFlowInternals.CombineObservableImpl<A>;
+
+export type CombineObservableRefined<
+  OS extends NonEmptyArray<Observable<unknown>>,
+> = SyncFlowInternals.CombineObservableRefinedImpl<OS>;
+
+export type ZipObservable<A extends NonEmptyUnknownList> =
+  SyncFlowInternals.ZipObservableImpl<A>;
+
+export type ZipObservableRefined<
+  OS extends NonEmptyArray<Observable<unknown>>,
+> = SyncFlowInternals.ZipObservableRefinedImpl<OS>;
+
+export type MergeObservable<A extends NonEmptyUnknownList> =
+  SyncFlowInternals.MergeObservableImpl<A>;
+
+export type MergeObservableRefined<
+  OS extends NonEmptyArray<Observable<unknown>>,
+> = SyncFlowInternals.MergeObservableRefinedImpl<OS>;
+
+export type MapWithIndexOperatorObservable<A, B> = SyncChildObservable<
+  B,
+  readonly [A]
+>;
+
+export type PairwiseOperatorObservable<A> = SyncChildObservable<
+  readonly [A, A],
+  readonly [A]
+>;
+
+export type TakeWhileOperatorObservable<A> = SyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+export type TakeUntilOperatorObservable<A> = SyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+export type SkipWhileOperatorObservable<A> = SyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+export type SkipUntilOperatorObservable<A> = SyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+export type WithCurrentValueFromOperatorObservable<A, B> = SyncChildObservable<
+  readonly [A, B],
+  readonly [A]
+>;
+
+export type WithBufferedFromOperatorObservable<A, B> = SyncChildObservable<
+  readonly [A, readonly B[]],
+  readonly [A]
+>;
+
+export type FilterOperatorObservable<A> = SyncChildObservable<A, readonly [A]>;
+
+export type SkipIfNoChangeOperatorObservable<A> = SyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+export type ThrottleTimeOperatorObservable<A> = SyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+// AsyncChildObservable
+
+export type AuditTimeOperatorObservable<A> = AsyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+export type DebounceTimeOperatorObservable<A> = AsyncChildObservable<
+  A,
+  readonly [A]
+>;
+
+export type SwitchMapOperatorObservable<A, B> = AsyncChildObservable<
+  B,
+  readonly [A]
+>;
+
+export type MergeMapOperatorObservable<A, B> = AsyncChildObservable<
+  B,
+  readonly [A]
+>;

package/src/core/types/observable-kind.mts

@@ -0,0 +1,5 @@
+export type ObservableKind = 'root' | 'sync child' | 'async child';
+
+export type ManagerObservableKind = StrictExclude<ObservableKind, 'sync child'>;
+
+export type ChildObservableKind = StrictExclude<ObservableKind, 'root'>;

package/src/core/types/observable.mts

@@ -0,0 +1,218 @@
+import { expectType, type Optional } from 'ts-data-forge';
+import { type ObservableId, type UpdaterSymbol } from './id.mjs';
+import { type ObservableKind } from './observable-kind.mjs';
+import { type NonEmptyUnknownList, type Subscription } from './types.mjs';
+
+/**
+ * Inheritance
+ *
+ * ```txt
+ * ObservableBase
+ *   |
+ *   +- SyncChildObservable    \                       \
+ *   |                          +-- ChildObservable     \
+ *   +- AsyncChildObservable   X                         +-- Observable
+ *   |                          +-- ManagerObservable   /
+ *   +- RootObservableType     /                       /
+ * ```
+ */
+
+type CreateObservableType<A, Kind extends ObservableKind> = Readonly<{
+  id: ObservableId;
+  kind: Kind;
+
+  // reactive dependency tree structure
+  depth: ObservableKind extends 'root' ? 0 : number;
+  addChild: <B>(child: ChildObservable<B>) => void;
+
+  // state
+  getSnapshot: () => Optional<A>;
+  isCompleted: boolean;
+  updaterSymbol: UpdaterSymbol;
+  hasSubscriber: boolean;
+  hasChild: boolean;
+  hasActiveChild: () => boolean;
+
+  tryUpdate: (updaterSymbol: UpdaterSymbol) => void;
+  tryComplete: () => void;
+  complete: () => void;
+  subscribe: (onNext: (v: A) => void, onComplete?: () => void) => Subscription;
+
+  pipe: PipeMethod<A>;
+}>;
+
+/** @internal */
+type PipeMethod<A> = (<B>(
+  operator: WithInitialValueOperator<A, B>,
+) => InitializedObservable<B>) &
+  (<B>(operator: DropInitialValueOperator<A, B>) => Observable<B>) &
+  (<B>(operator: KeepInitialValueOperator<A, B>) => Observable<B>);
+
+export type ObservableBase<A> = CreateObservableType<A, ObservableKind>;
+
+/** @internal */
+namespace ObservableTypeConverter {
+  export type ToInitialized<
+    A,
+    O extends CreateObservableType<A, ObservableKind>,
+  > = StrictOmit<O, 'pipe' | 'getSnapshot'> &
+    Readonly<{
+      getSnapshot: () => Some<A>;
+
+      pipe: PipeMethodForInitialized<A>;
+    }>;
+
+  type PipeMethodForInitialized<A> = (<B>(
+    operator: WithInitialValueOperator<A, B>,
+  ) => InitializedObservable<B>) &
+    (<B>(operator: DropInitialValueOperator<A, B>) => Observable<B>) &
+    (<B>(operator: KeepInitialValueOperator<A, B>) => InitializedObservable<B>);
+
+  export type ToChild<
+    A,
+    O extends CreateObservableType<A, ObservableKind>,
+    P extends NonEmptyUnknownList = NonEmptyUnknownList,
+  > = O &
+    Readonly<{
+      parents: Wrap<P>;
+    }>;
+
+  export type ToManager<
+    A,
+    O extends CreateObservableType<A, 'async child' | 'root'>,
+  > = O &
+    Readonly<{
+      addDescendant: <B>(child: ChildObservable<B>) => void;
+    }>;
+}
+
+export type SyncChildObservable<
+  A,
+  P extends NonEmptyUnknownList = NonEmptyUnknownList,
+> = ObservableTypeConverter.ToChild<
+  A,
+  CreateObservableType<A, 'sync child'>,
+  P
+>;
+
+export type InitializedSyncChildObservable<
+  A,
+  P extends NonEmptyUnknownList = NonEmptyUnknownList,
+> = ObservableTypeConverter.ToInitialized<A, SyncChildObservable<A, P>>;
+
+export type AsyncChildObservable<
+  A,
+  P extends NonEmptyUnknownList = NonEmptyUnknownList,
+> = ObservableTypeConverter.ToManager<
+  A,
+  ObservableTypeConverter.ToChild<A, CreateObservableType<A, 'async child'>, P>
+>;
+
+export type InitializedAsyncChildObservable<
+  A,
+  P extends NonEmptyUnknownList = NonEmptyUnknownList,
+> = ObservableTypeConverter.ToInitialized<A, AsyncChildObservable<A, P>>;
+
+export type ChildObservable<
+  A,
+  P extends NonEmptyUnknownList = NonEmptyUnknownList,
+> = AsyncChildObservable<A, P> | SyncChildObservable<A, P>;
+
+export type RootObservable<A> = ObservableTypeConverter.ToManager<
+  A,
+  CreateObservableType<A, 'root'>
+>;
+
+export type InitializedRootObservable<A> =
+  ObservableTypeConverter.ToInitialized<A, RootObservable<A>>;
+
+export type Observable<A> =
+  | AsyncChildObservable<A>
+  | RootObservable<A>
+  | SyncChildObservable<A>;
+
+export type InitializedObservable<A> =
+  | InitializedAsyncChildObservable<A>
+  | InitializedRootObservable<A>
+  | InitializedSyncChildObservable<A>;
+
+export type ManagerObservable<A> = AsyncChildObservable<A> | RootObservable<A>;
+
+/* operator types */
+
+/** Type of operator that converts Observable to InitializedObservable */
+export type WithInitialValueOperator<A, B> = (
+  src: Observable<A>,
+) => InitializedObservable<B>;
+
+/** Type of operator that converts Observable to non-initialized Observable */
+export type DropInitialValueOperator<A, B> = (
+  src: InitializedObservable<A> | Observable<A>,
+) => Observable<B>;
+
+/** Type of operator that preserves whether Observable has initial value */
+export type KeepInitialValueOperator<A, B> = (
+  src: InitializedObservable<A>,
+) => InitializedObservable<B>;
+
+export type Operator<A, B> =
+  | WithInitialValueOperator<A, B>
+  | DropInitialValueOperator<A, B>
+  | KeepInitialValueOperator<A, B>;
+
+export const isManagerObservable = <A,>(
+  obs: Observable<A>,
+): obs is ManagerObservable<A> => obs.kind !== 'sync child';
+
+export const isRootObservable = <A,>(
+  obs: Observable<A>,
+): obs is RootObservable<A> => obs.kind === 'root';
+
+export const isChildObservable = <A,>(
+  obs: Observable<A>,
+): obs is ChildObservable<A> =>
+  obs.kind === 'sync child' || obs.kind === 'async child';
+
+export type ObservableValue<A> = A extends Observable<infer B> ? B : never;
+
+export type Unwrap<A extends readonly Observable<unknown>[]> = Readonly<{
+  [P in keyof A]: ObservableValue<A[P]>;
+}>;
+
+export type Wrap<A extends readonly unknown[]> = Readonly<{
+  [P in keyof A]: Observable<A[P]>;
+}>;
+
+export type WrapInitialized<A extends readonly unknown[]> = Readonly<{
+  [P in keyof A]: InitializedObservable<A[P]>;
+}>;
+
+// type GetDestTypeOfOperator<Op extends Operator<unknown, unknown>> =
+//   Op extends Operator<unknown, infer B> ? B : never;
+
+expectType<keyof AsyncChildObservable<unknown>, 'addDescendant'>('>=');
+
+expectType<keyof RootObservable<unknown>, 'addDescendant'>('>=');
+
+expectType<Unwrap<Wrap<readonly [1, 2, 3]>>, readonly [1, 2, 3]>('=');
+
+expectType<number, ObservableValue<Observable<number>>>('<=');
+
+expectType<number, ObservableValue<Observable<string>>>('!<=');
+
+expectType<
+  readonly [number, string],
+  Unwrap<readonly [Observable<number>, Observable<string>]>
+>('<=');
+
+expectType<number, ObservableValue<Observable<string>>>('!<=');
+
+expectType<
+  readonly [Observable<number>, Observable<number>],
+  Wrap<readonly [number, number]>
+>('<=');
+
+expectType<
+  readonly [Observable<number>, Observable<string>],
+  Wrap<readonly [number, number]>
+>('!<=');

package/src/core/types/types.mts

@@ -0,0 +1,40 @@
+import { expectType, type Queue } from 'ts-data-forge';
+
+export type TupleToQueueTuple<T extends readonly unknown[]> = Readonly<{
+  [P in keyof T]: Queue<T[P]>;
+}>;
+
+export type NonEmptyUnknownList = readonly [unknown, ...unknown[]];
+
+export type Subscriber<A> = Readonly<{
+  onNext: (v: A) => void;
+  onComplete: () => void;
+}>;
+
+export type Subscription = Readonly<{
+  unsubscribe: () => void;
+}>;
+
+export type Subscribable<A> = Readonly<{
+  subscribe: (
+    onNext: (nextValue: A) => void,
+    onError?: (error?: unknown) => void,
+    onComplete?: () => void,
+  ) => Subscription;
+}>;
+
+// type tests
+
+expectType<
+  TupleToQueueTuple<readonly [number, string, boolean]>,
+  readonly [Queue<number>, Queue<string>, Queue<boolean>]
+>('=');
+
+// Subscriber is covariant
+expectType<Subscriber<number>, Subscriber<1>>('<=');
+
+expectType<Subscriber<1>, Subscriber<number>>('!<=');
+
+expectType<Subscriber<number>, Subscriber<'1'>>('!<=');
+
+expectType<Subscriber<'1'>, Subscriber<number>>('!<=');

package/src/core/utils/id-maker.mts

@@ -0,0 +1,31 @@
+import {
+  type ObservableId,
+  type SubscriberId,
+  type UpdaterSymbol,
+} from '../types/index.mjs';
+
+function* idMaker<T extends symbol>(): Generator<T, T, T> {
+  let mut_i = 0;
+
+  while (true) {
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    yield Symbol(mut_i.toString()) as T;
+
+    mut_i += 1;
+  }
+}
+
+const observableIdMaker = idMaker<ObservableId>();
+
+const subscriberIdMaker = idMaker<SubscriberId>();
+
+const updaterSymbolMaker = idMaker<UpdaterSymbol>();
+
+export const issueObservableId = (): ObservableId =>
+  observableIdMaker.next().value;
+
+export const issueSubscriberId = (): SubscriberId =>
+  subscriberIdMaker.next().value;
+
+export const issueUpdaterSymbol = (): UpdaterSymbol =>
+  updaterSymbolMaker.next().value;

package/src/core/utils/index.mts

@@ -0,0 +1,4 @@
+export * from './id-maker.mjs';
+export * from './max-depth.mjs';
+export * from './observable-utils.mjs';
+export * from './utils.mjs';

package/src/core/utils/max-depth.mts

@@ -0,0 +1,7 @@
+import { Arr, Optional, pipe } from 'ts-data-forge';
+import { type Observable } from '../types/index.mjs';
+
+export const maxDepth = (parents: readonly Observable<unknown>[]): number =>
+  pipe(Arr.maxBy(parents, (p) => p.depth))
+    .mapOptional((o) => o.depth)
+    .map(Optional.unwrapOr(0)).value;

package/src/core/utils/observable-utils.mts

@@ -0,0 +1,10 @@
+import { type Subscriber } from '../types/index.mjs';
+
+export const toSubscriber = <A,>(
+  onNext: (v: A) => void,
+  onComplete?: () => void,
+): Subscriber<A> =>
+  ({
+    onNext,
+    onComplete: onComplete ?? (() => {}),
+  }) as const;

package/src/core/utils/utils.mts

@@ -0,0 +1,51 @@
+import { Arr, asSafeInt, asUint32, SafeInt } from 'ts-data-forge';
+
+export const halfInt = (x: SafeInt): SafeInt =>
+  x % 2 === 0
+    ? SafeInt.div(x, 2)
+    : x > 0
+      ? SafeInt.div(SafeInt.sub(x, 1), 2) // (x-1) / 2. e.g. 3 -> 1, 5 -> 2
+      : SafeInt.div(SafeInt.add(x, 1), 2); // (x+1) / 2. e.g. -3 -> -1, -5 -> -2
+
+/** Returns the position where x should be inserted in a sorted array. */
+export const binarySearch = <N extends number>(
+  sortedArray: readonly N[],
+  x: N,
+): NegativeInt32 | Uint32 => {
+  const uint32Result = asUint32(0);
+
+  if (Arr.isArrayOfLength(sortedArray, 0)) {
+    return uint32Result;
+  }
+
+  const left0 = asSafeInt(0);
+
+  let mut_left: SafeInt = left0;
+
+  let mut_right: SafeInt = SafeInt.sub(Arr.length(sortedArray), 1);
+
+  let mut_mid: SafeInt = SafeInt.add(
+    mut_left,
+    halfInt(SafeInt.sub(mut_right, mut_left)),
+  );
+
+  // loop while x is in the range of [left, right)
+  while (mut_left <= mut_right) {
+    const curr = sortedArray[mut_mid];
+
+    if (x === curr) break;
+
+    if (curr === undefined) break;
+
+    if (curr > x) {
+      mut_right = SafeInt.sub(mut_mid, 1);
+    } else {
+      mut_left = SafeInt.add(mut_mid, 1);
+    }
+
+    mut_mid = SafeInt.add(mut_left, halfInt(SafeInt.sub(mut_right, mut_left)));
+  }
+
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  return mut_mid as NegativeInt32 | Uint32;
+};