synstate 2.0.1 → 3.0.0

package/src/core/class/circular-dependency.test.mts

@@ -1,251 +0,0 @@
-/* eslint-disable functional/immutable-data */
-/* eslint-disable no-new */
-import { Optional } from 'ts-data-forge';
-import { combine, merge } from '../combine/index.mjs';
-import { source } from '../create/index.mjs';
-import { map } from '../operators/index.mjs';
-import {
-  AsyncChildObservableClass,
-  SyncChildObservableClass,
-} from './child-observable-class.mjs';
-import { RootObservableClass } from './root-observable-class.mjs';
-
-describe('circular dependency detection', () => {
-  describe('cycle in ancestor graph', () => {
-    test('should throw when parent chain contains a cycle (A -> B -> A)', () => {
-      const root = new RootObservableClass({
-        initialValue: Optional.some(0),
-      });
-
-      const childA = new SyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
-
-      const childB = new SyncChildObservableClass({
-        parents: [childA],
-        initialValue: Optional.some(0),
-      });
-
-      // Mutate childA.parents to create a cycle: childA -> childB -> childA
-      Object.defineProperty(childA, 'parents', {
-        value: [childB],
-        writable: false,
-        configurable: true,
-      });
-
-      expect(() => {
-        new SyncChildObservableClass({
-          parents: [childA],
-          initialValue: Optional.some(0),
-        });
-      }).toThrow(
-        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
-      );
-    });
-
-    test('should throw when AsyncChildObservable parent chain contains a cycle', () => {
-      const root = new RootObservableClass({
-        initialValue: Optional.some(0),
-      });
-
-      const childA = new AsyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
-
-      const childB = new SyncChildObservableClass({
-        parents: [childA],
-        initialValue: Optional.some(0),
-      });
-
-      // Create cycle: childA -> childB -> childA
-      Object.defineProperty(childA, 'parents', {
-        value: [childB],
-        writable: false,
-        configurable: true,
-      });
-
-      expect(() => {
-        new AsyncChildObservableClass({
-          parents: [childA],
-          initialValue: Optional.some(0),
-        });
-      }).toThrow(
-        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
-      );
-    });
-
-    test('should throw when a cycle exists through a chain of 3 observables', () => {
-      const root = new RootObservableClass({
-        initialValue: Optional.some(0),
-      });
-
-      const childA = new SyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
-
-      const childB = new SyncChildObservableClass({
-        parents: [childA],
-        initialValue: Optional.some(0),
-      });
-
-      const childC = new SyncChildObservableClass({
-        parents: [childB],
-        initialValue: Optional.some(0),
-      });
-
-      // Create cycle: childA -> childC -> childB -> childA
-      Object.defineProperty(childA, 'parents', {
-        value: [childC],
-        writable: false,
-        configurable: true,
-      });
-
-      expect(() => {
-        new SyncChildObservableClass({
-          parents: [childA],
-          initialValue: Optional.some(0),
-        });
-      }).toThrow(
-        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
-      );
-    });
-
-    test('should throw when the new child itself appears as an ancestor', () => {
-      const root = new RootObservableClass({
-        initialValue: Optional.some(0),
-      });
-
-      const childA = new SyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
-
-      // Make childA's parents reference childA itself (self-loop)
-      Object.defineProperty(childA, 'parents', {
-        value: [childA],
-        writable: false,
-        configurable: true,
-      });
-
-      expect(() => {
-        new SyncChildObservableClass({
-          parents: [childA],
-          initialValue: Optional.some(0),
-        });
-      }).toThrow(
-        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
-      );
-    });
-  });
-
-  describe('valid DAG patterns should not throw', () => {
-    test('diamond dependency is not a cycle', () => {
-      const root = new RootObservableClass({
-        initialValue: Optional.some(0),
-      });
-
-      const left = new SyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
-
-      const right = new SyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
-
-      // Diamond: root -> left -> combined, root -> right -> combined
-      expect(() => {
-        new SyncChildObservableClass({
-          parents: [left, right],
-          initialValue: Optional.some(0),
-        });
-      }).not.toThrow();
-    });
-
-    test('linear chain is not a cycle', () => {
-      const root = new RootObservableClass({
-        initialValue: Optional.some(0),
-      });
-
-      const a = new SyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
-
-      const b = new SyncChildObservableClass({
-        parents: [a],
-        initialValue: Optional.some(0),
-      });
-
-      expect(() => {
-        new SyncChildObservableClass({
-          parents: [b],
-          initialValue: Optional.some(0),
-        });
-      }).not.toThrow();
-    });
-
-    test('multiple roots converging is not a cycle', () => {
-      const root1 = new RootObservableClass({
-        initialValue: Optional.some(1),
-      });
-
-      const root2 = new RootObservableClass({
-        initialValue: Optional.some(2),
-      });
-
-      const child1 = new SyncChildObservableClass({
-        parents: [root1],
-        initialValue: Optional.some(0),
-      });
-
-      const child2 = new SyncChildObservableClass({
-        parents: [root2],
-        initialValue: Optional.some(0),
-      });
-
-      expect(() => {
-        new SyncChildObservableClass({
-          parents: [child1, child2],
-          initialValue: Optional.some(0),
-        });
-      }).not.toThrow();
-    });
-
-    test('combine with source observables works', () => {
-      const a$ = source<number>();
-
-      const b$ = source<string>();
-
-      expect(() => {
-        combine([a$, b$]);
-      }).not.toThrow();
-    });
-
-    test('combine with derived observables works', () => {
-      const a$ = source<number>();
-
-      const b$ = source<number>();
-
-      const mapped$ = a$.pipe(map((x) => x * 2));
-
-      expect(() => {
-        combine([mapped$, b$]);
-      }).not.toThrow();
-    });
-
-    test('merge with source observables works', () => {
-      const a$ = source<number>();
-
-      const b$ = source<number>();
-
-      expect(() => {
-        merge([a$, b$]);
-      }).not.toThrow();
-    });
-  });
-});

package/src/core/class/index.mts

@@ -1,3 +0,0 @@
-export * from './child-observable-class.mjs';
-export * from './observable-base-class.mjs';
-export * from './root-observable-class.mjs';

package/src/core/class/observable-base-class.mts

@@ -1,187 +0,0 @@
-import { Arr, Optional } from 'ts-data-forge';
-import { type MutableMap } from 'ts-type-forge';
-import {
-  type ChildObservable,
-  type InitializedObservable,
-  type Observable,
-  type ObservableBase,
-  type Operator,
-  type Subscriber,
-  type SubscriberId,
-  type Subscription,
-  type UpdateToken,
-  type WithInitialValueOperator,
-} from '../types/index.mjs';
-import {
-  issueObservableId,
-  issueSubscriberId,
-  issueUpdateToken,
-  toSubscriber,
-} from '../utils/index.mjs';
-
-export class ObservableBaseClass<
-  A,
-  Kind extends ObservableBase<A>['kind'],
-  Depth extends ObservableBase<A>['depth'],
-> implements ObservableBase<A> {
-  #mut_children: readonly ChildObservable<unknown>[];
-  readonly #subscribers: MutableMap<SubscriberId, Subscriber<A>>;
-  #mut_currentValue: ReturnType<ObservableBase<A>['getSnapshot']>;
-  #mut_isCompleted: ObservableBase<A>['isCompleted'];
-  #mut_updateToken: ObservableBase<A>['updateToken'];
-  readonly id;
-  readonly kind: Kind;
-  readonly depth: Depth;
-
-  constructor({
-    kind,
-    depth,
-    initialValue,
-  }: Readonly<{
-    kind: Kind;
-    depth: Depth;
-    initialValue: ReturnType<ObservableBase<A>['getSnapshot']>;
-  }>) {
-    this.kind = kind;
-
-    this.depth = depth;
-
-    this.id = issueObservableId();
-
-    this.#mut_currentValue = initialValue;
-
-    this.#mut_children = [];
-
-    this.#subscribers = new Map<SubscriberId, Subscriber<A>>();
-
-    this.#mut_isCompleted = false;
-
-    this.#mut_updateToken = issueUpdateToken();
-  }
-
-  #addSubscriber(s: Subscriber<A>): SubscriberId {
-    // return the id of added subscriber
-    const id = issueSubscriberId();
-
-    this.#subscribers.set(id, s);
-
-    return id;
-  }
-
-  #removeSubscriber(id: SubscriberId): void {
-    this.#subscribers.delete(id);
-  }
-
-  addChild<B>(child: ChildObservable<B>): void {
-    this.#mut_children = Arr.toPushed(
-      this.#mut_children,
-
-      child as ChildObservable<unknown>,
-    );
-  }
-
-  getSnapshot(): ReturnType<ObservableBase<A>['getSnapshot']> {
-    return this.#mut_currentValue;
-  }
-
-  protected getCurrentValue(): ReturnType<ObservableBase<A>['getSnapshot']> {
-    return this.#mut_currentValue;
-  }
-
-  get isCompleted(): boolean {
-    return this.#mut_isCompleted;
-  }
-
-  get updateToken(): UpdateToken {
-    return this.#mut_updateToken;
-  }
-
-  get hasSubscriber(): boolean {
-    return this.#subscribers.size > 0;
-  }
-
-  get hasChild(): boolean {
-    return Arr.isNonEmpty(this.#mut_children);
-  }
-
-  hasActiveChild(): boolean {
-    return this.#mut_children.some((c) => !c.isCompleted);
-  }
-
-  protected setNext(nextValue: A, updateToken: UpdateToken): void {
-    this.#mut_updateToken = updateToken;
-
-    this.#mut_currentValue = Optional.some(nextValue);
-
-    for (const s of this.#subscribers.values()) {
-      s.onNext(nextValue);
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-  tryUpdate(_updateToken: UpdateToken): void {
-    throw new Error('not implemented');
-  }
-
-  tryComplete(): void {
-    if (!this.hasSubscriber && !this.hasActiveChild()) {
-      this.complete();
-    }
-  }
-
-  complete(): void {
-    if (this.isCompleted) return; // terminate only once
-
-    // change state
-    this.#mut_isCompleted = true;
-
-    // run subscribers for the current value
-    for (const s of this.#subscribers.values()) {
-      s.onComplete();
-    }
-
-    // remove all subscribers
-    this.#subscribers.clear();
-
-    // propagate to children
-    for (const o of this.#mut_children) {
-      o.tryComplete();
-    }
-  }
-
-  pipe<B>(operator: WithInitialValueOperator<A, B>): InitializedObservable<B>;
-  pipe<B>(operator: Operator<A, B>): Observable<B>;
-  pipe<B>(operator: Operator<A, B>): Observable<B> {
-    return operator(
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      this as unknown as InitializedObservable<A>,
-    );
-  }
-
-  subscribe(onNext: (v: A) => void, onComplete?: () => void): Subscription {
-    // first emit
-    const curr = this.getSnapshot();
-
-    if (Optional.isSome(curr)) {
-      onNext(curr.value);
-    }
-
-    if (this.isCompleted) {
-      if (onComplete !== undefined) {
-        onComplete();
-      }
-
-      return { unsubscribe: () => {} };
-    }
-
-    const id: SubscriberId = this.#addSubscriber(
-      toSubscriber(onNext, onComplete),
-    );
-
-    return {
-      unsubscribe: () => {
-        this.#removeSubscriber(id);
-      },
-    };
-  }
-}

package/src/core/class/root-observable-class.mts

@@ -1,73 +0,0 @@
-import { Arr, Optional } from 'ts-data-forge';
-import { type MutableSet } from 'ts-type-forge';
-import {
-  isRootObservable,
-  type ChildObservable,
-  type ObservableId,
-  type RootObservable,
-} from '../types/index.mjs';
-import { binarySearch, issueUpdateToken } from '../utils/index.mjs';
-import { ObservableBaseClass } from './observable-base-class.mjs';
-
-export class RootObservableClass<A>
-  extends ObservableBaseClass<A, 'root', 0>
-  implements RootObservable<A>
-{
-  #mut_propagationOrder: readonly ChildObservable<unknown>[];
-  protected readonly _descendantsIdSet: MutableSet<ObservableId>;
-
-  constructor({
-    initialValue,
-  }: Readonly<{
-    initialValue: Optional<A>;
-  }>) {
-    super({
-      kind: 'root',
-      depth: 0,
-      initialValue,
-    });
-
-    this.#mut_propagationOrder = [];
-
-    this._descendantsIdSet = new Set<ObservableId>();
-  }
-
-  addDescendant<B>(child: ChildObservable<B>): void {
-    if (this._descendantsIdSet.has(child.id)) return;
-
-    this._descendantsIdSet.add(child.id);
-
-    const insertPos = binarySearch(
-      this.#mut_propagationOrder.map((a) => a.depth),
-      child.depth,
-    );
-
-    this.#mut_propagationOrder = Arr.toInserted(
-      this.#mut_propagationOrder,
-      insertPos,
-      child,
-    );
-  }
-
-  startUpdate(nextValue: A): void {
-    const updateToken = issueUpdateToken();
-
-    this.setNext(nextValue, updateToken);
-
-    for (const p of this.#mut_propagationOrder) {
-      p.tryUpdate(updateToken);
-    }
-  }
-}
-
-if (import.meta.vitest !== undefined) {
-  test('isRootObservable', () => {
-    assert.isTrue(
-      isRootObservable(
-        new RootObservableClass({
-          initialValue: Optional.some(0),
-        }),
-      ),
-    );
-  });
-}