synstate 3.4.0 → 4.0.0

package/src/core/operators/take-until.mts

@@ -1,10 +1,18 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   KeepInitialValueOperator,
   Observable,
   Subscription,
   TakeUntilOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -60,56 +68,52 @@ export const takeUntil = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
-    createTakeUntilObservable(
+    new TakeUntilObservableClass(
       parentObservable,
       notifier,
     )) as KeepInitialValueOperator<A, A>;
 
-const createTakeUntilObservable = <A,>(
-  parentObservable: Observable<A>,
-  notifier: Observable<unknown>,
-): TakeUntilOperatorObservable<A> => {
-  let mut_subscription: Subscription | undefined = undefined;
+class TakeUntilObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements TakeUntilOperatorObservable<A>
+{
+  /** Unset only while the `subscribe` in the constructor runs. */
+  readonly #subscription: Subscription | undefined;
 
-  const observable = createSyncChildObservable<A, readonly [A]>(
-    {
+  constructor(parentObservable: Observable<A>, notifier: Observable<unknown>) {
+    super({
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot(),
-      onComplete: () => {
-        mut_subscription?.unsubscribe();
-      },
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    });
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    const complete = (): void => {
+      this.complete();
+    };
 
-        setNext(sn.value, updateToken);
-      },
-  );
+    // A notifier that already holds a value completes this observable inside
+    // `subscribe`, before the subscription is stored.
+    this.#subscription = notifier.subscribe(complete, complete);
 
-  const subscription = notifier.subscribe(
-    () => {
-      observable.complete();
-    },
-    () => {
-      observable.complete();
-    },
-  );
+    if (this.isCompleted) {
+      this.#subscription.unsubscribe();
+    }
 
-  // A notifier that already holds a value completes `observable` inside
-  // `subscribe`, before `onComplete` can see the subscription.
-  if (observable.isCompleted) {
-    subscription.unsubscribe();
-  } else {
-    mut_subscription = subscription;
+    this.attach();
   }
 
-  return observable;
-};
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
+
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
+
+    this.setNext(sn.value, updateToken);
+  }
+
+  protected override teardown(): void {
+    this.#subscription?.unsubscribe();
+  }
+}

package/src/core/operators/take-while.mts

@@ -1,3 +1,10 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import {
   Optional,
   SafeUint,
@@ -5,13 +12,14 @@ import {
   expectType,
   pipe,
 } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import type {
   DropInitialValueOperator,
   InitializedObservable,
   Observable,
   TakeWhileOperatorObservable,
+  UpdateToken,
 } from '../types/index.mjs';
 import { withInitialValue } from './with-initial-value.mjs';
 
@@ -75,16 +83,22 @@ export const takeWhile =
     predicate: (value: A, index: SafeUint | -1) => boolean,
   ): DropInitialValueOperator<A, A> =>
   (parentObservable) =>
-    createTakeWhileObservable(parentObservable, predicate);
+    new TakeWhileObservableClass(parentObservable, predicate);
 
 /* implementation */
 
-const createTakeWhileObservable = <A,>(
-  parentObservable: Observable<A>,
-  predicate: (value: A, index: SafeUint | -1) => boolean,
-): TakeWhileOperatorObservable<A> =>
-  createSyncChildObservable(
-    {
+class TakeWhileObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements TakeWhileOperatorObservable<A>
+{
+  readonly #predicate: (value: A, index: SafeUint | -1) => boolean;
+  #mut_index: SafeUint | -1;
+
+  constructor(
+    parentObservable: Observable<A>,
+    predicate: (value: A, index: SafeUint | -1) => boolean,
+  ) {
+    super({
       parents: [parentObservable],
       initialValue: pipe(parentObservable.getSnapshot()).map((par) =>
         Optional.isNone(par)
@@ -93,31 +107,34 @@ const createTakeWhileObservable = <A,>(
             ? par
             : Optional.none,
       ).value,
-    },
-    ({ setNext, complete }) => {
-      let mut_index: SafeUint | -1 = -1;
-
-      return (updateToken) => {
-        const sn = parentObservable.getSnapshot();
-
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
-
-        mut_index =
-          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
-
-        if (predicate(sn.value, mut_index)) {
-          setNext(sn.value, updateToken);
-        } else {
-          complete();
-        }
-      };
-    },
-  );
+    });
+
+    this.#mut_index = -1;
+
+    this.#predicate = predicate;
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
+
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
+
+    this.#mut_index =
+      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+
+    if (this.#predicate(sn.value, this.#mut_index)) {
+      this.setNext(sn.value, updateToken);
+    } else {
+      this.complete();
+    }
+  }
+}
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

package/src/core/operators/take.mts

@@ -0,0 +1,138 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
+import { Optional, expectType } from 'ts-data-forge';
+import type { PositiveSafeIntWithSmallInt } from 'ts-type-forge';
+import { SyncChildObservableClass } from '../class/index.mjs';
+import { source } from '../create/index.mjs';
+import type {
+  DropInitialValueOperator,
+  InitializedObservable,
+  Observable,
+  TakeOperatorObservable,
+  UpdateToken,
+} from '../types/index.mjs';
+import { withInitialValue } from './with-initial-value.mjs';
+
+/**
+ * Takes only the first `n` emissions from the source observable, then completes.
+ * It completes in the same update as the `n`th emission, after passing that
+ * value on. The initial value is passed on and not counted.
+ *
+ * @template A - The type of values from the source
+ * @param n - The number of values to take
+ * @returns An operator that takes the first n emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  num$    1     2     3     4 (ignored)
+ * //  taken$  1     2     3|(completes)
+ * //
+ * //  Explanation:
+ * //  - take emits only the first n values, completing with the nth
+ * //  - Subsequent emissions from the source are ignored
+ *
+ * const num$ = source<number>();
+ *
+ * const taken$ = num$.pipe(take(3));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * taken$.subscribe((x) => {
+ *   valueHistory.push(x);
+ * });
+ *
+ * num$.next(1);
+ *
+ * num$.next(2);
+ *
+ * num$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ *
+ * assert.isTrue(taken$.isCompleted);
+ *
+ * num$.next(4); // ignored (already completed)
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ * ```
+ */
+export const take =
+  <A,>(n: PositiveSafeIntWithSmallInt): DropInitialValueOperator<A, A> =>
+  (parentObservable) =>
+    new TakeObservableClass(parentObservable, n);
+
+/* implementation */
+
+class TakeObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements TakeOperatorObservable<A>
+{
+  readonly #n: PositiveSafeIntWithSmallInt;
+  #mut_count: number;
+
+  constructor(parentObservable: Observable<A>, n: PositiveSafeIntWithSmallInt) {
+    super({
+      parents: [parentObservable],
+      initialValue: parentObservable.getSnapshot(),
+    });
+
+    this.#mut_count = 0;
+
+    this.#n = n;
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
+
+    if (
+      this.#mut_count >= this.#n ||
+      par.updateToken !== updateToken ||
+      Optional.isNone(sn)
+    ) {
+      return; // skip update
+    }
+
+    this.#mut_count += 1;
+
+    this.setNext(sn.value, updateToken);
+
+    if (this.#mut_count >= this.#n) {
+      this.completeAfterPropagation();
+    }
+  }
+}
+
+if (import.meta.vitest !== undefined) {
+  test('type test', () => {
+    expect(1).toBe(1); // dummy
+  });
+
+  {
+    const s: Observable<number> = source<number>();
+
+    const _d1 = s.pipe(take(3));
+
+    expectType<typeof _d1, Observable<number>>('=');
+  }
+
+  {
+    const s = source<number>();
+
+    const m: InitializedObservable<number> = s.pipe(withInitialValue(0));
+
+    const _d = m.pipe(take(3));
+
+    expectType<typeof _d, Observable<number>>('=');
+  }
+}

package/src/core/operators/throttle.mts

@@ -1,10 +1,18 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   KeepInitialValueOperator,
   Observable,
   ThrottleOperatorObservable,
   TimerId,
+  UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -90,51 +98,60 @@ export const throttle = <A,>(
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
-    createThrottleObservable(
+    new ThrottleObservableClass(
       parentObservable,
       milliSeconds,
     )) as KeepInitialValueOperator<A, A>;
 
-const createThrottleObservable = <A,>(
-  parentObservable: Observable<A>,
-  milliSeconds: number,
-): ThrottleOperatorObservable<A> => {
-  let mut_timerId: TimerId | undefined = undefined;
-
-  let mut_isSkipping = false;
-
-  const resetTimer = (): void => {
-    if (mut_timerId !== undefined) {
-      clearTimeout(mut_timerId);
-    }
-  };
+class ThrottleObservableClass<A>
+  extends SyncChildObservableClass<A, readonly [A]>
+  implements ThrottleOperatorObservable<A>
+{
+  readonly #milliSeconds: number;
+  #mut_timerId: TimerId | undefined;
+  #mut_isSkipping: boolean;
 
-  return createSyncChildObservable(
-    {
+  constructor(parentObservable: Observable<A>, milliSeconds: number) {
+    super({
       parents: [parentObservable],
       initialValue: parentObservable.getSnapshot(),
-      onComplete: resetTimer,
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    });
+
+    this.#mut_timerId = undefined;
+
+    this.#mut_isSkipping = false;
+
+    this.#milliSeconds = milliSeconds;
 
-        if (
-          mut_isSkipping ||
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    this.attach();
+  }
 
-        setNext(sn.value, updateToken);
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-        mut_isSkipping = true;
+    const sn = par.getSnapshot();
 
-        // set timer
-        mut_timerId = setTimeout(() => {
-          mut_isSkipping = false;
-        }, milliSeconds);
-      },
-  );
-};
+    if (
+      this.#mut_isSkipping ||
+      par.updateToken !== updateToken ||
+      Optional.isNone(sn)
+    ) {
+      return; // skip update
+    }
+
+    this.setNext(sn.value, updateToken);
+
+    this.#mut_isSkipping = true;
+
+    // set timer
+    this.#mut_timerId = setTimeout(() => {
+      this.#mut_isSkipping = false;
+    }, this.#milliSeconds);
+  }
+
+  protected override teardown(): void {
+    if (this.#mut_timerId !== undefined) {
+      clearTimeout(this.#mut_timerId);
+    }
+  }
+}

package/src/core/operators/with-buffered-from.mts

@@ -1,9 +1,17 @@
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
 import { Arr, Optional, pipe } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   KeepInitialValueOperator,
   Observable,
   Subscription,
+  UpdateToken,
   WithBufferedFromOperatorObservable,
 } from '../types/index.mjs';
 import { maxDepth } from '../utils/index.mjs';
@@ -66,7 +74,7 @@ export const withBufferedFrom = <A, B>(
 ): KeepInitialValueOperator<A, readonly [A, readonly B[]]> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
-    createWithBufferedFromObservable(
+    new WithBufferedFromObservableClass(
       parentObservable,
       observable,
     )) as KeepInitialValueOperator<A, readonly [A, readonly B[]]>;
@@ -77,23 +85,15 @@ export const withBufferedFrom = <A, B>(
  */
 export const withBuffered = withBufferedFrom;
 
-const createWithBufferedFromObservable = <A, B>(
-  parentObservable: Observable<A>,
-  observable: Observable<B>,
-): WithBufferedFromOperatorObservable<A, B> => {
-  let mut_bufferedValues: readonly B[] = [];
-
-  const clearBuffer = (): void => {
-    mut_bufferedValues = [];
-  };
-
-  let mut_subscription: Subscription | undefined = undefined;
+class WithBufferedFromObservableClass<A, B>
+  extends SyncChildObservableClass<readonly [A, readonly B[]], readonly [A]>
+  implements WithBufferedFromOperatorObservable<A, B>
+{
+  readonly #subscription: Subscription;
+  #mut_bufferedValues: readonly B[];
 
-  const result = createSyncChildObservable<
-    readonly [A, readonly B[]],
-    readonly [A]
-  >(
-    {
+  constructor(parentObservable: Observable<A>, observable: Observable<B>) {
+    super({
       parents: [parentObservable],
       depth: 1 + maxDepth([parentObservable, observable]),
       initialValue: pipe({
@@ -107,36 +107,34 @@ const createWithBufferedFromObservable = <A, B>(
               Optional.isNone(me) ? [] : [me.value],
             ] as const),
       ).value,
-      onComplete: () => {
-        mut_subscription?.unsubscribe();
+    });
+
+    this.#mut_bufferedValues = [];
+
+    this.#subscription = observable.subscribe((value) => {
+      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
+    });
 
-        clearBuffer();
-      },
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    this.attach();
+  }
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
 
-        setNext([sn.value, mut_bufferedValues], updateToken);
+    const sn = par.getSnapshot();
 
-        clearBuffer();
-      },
-  );
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
 
-  // A child completed at creation has already run `onComplete`; subscribing
-  // after it would leave a subscription nothing releases.
-  if (!result.isCompleted) {
-    mut_subscription = observable.subscribe((value) => {
-      mut_bufferedValues = Arr.toPushed(mut_bufferedValues, value);
-    });
+    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
+
+    this.#mut_bufferedValues = [];
   }
 
-  return result;
-};
+  protected override teardown(): void {
+    this.#subscription.unsubscribe();
+
+    this.#mut_bufferedValues = [];
+  }
+}

package/src/core/operators/with-buffered-from.test.mts

@@ -1,3 +1,4 @@
+import { toNode } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import { withBufferedFrom } from './with-buffered-from.mjs';
 
@@ -9,13 +10,13 @@ describe('withBufferedFrom teardown', () => {
 
     const result$ = trigger$.pipe(withBufferedFrom(data$));
 
-    assert.isTrue(data$.hasSubscriber);
+    assert.isTrue(toNode(data$).hasSubscriber);
 
     result$.complete();
 
     assert.isTrue(result$.isCompleted);
 
-    assert.isFalse(data$.hasSubscriber);
+    assert.isFalse(toNode(data$).hasSubscriber);
   });
 
   test('unsubscribes from the buffered observable when the parent completes', () => {
@@ -29,7 +30,7 @@ describe('withBufferedFrom teardown', () => {
 
     assert.isTrue(result$.isCompleted);
 
-    assert.isFalse(data$.hasSubscriber);
+    assert.isFalse(toNode(data$).hasSubscriber);
   });
 
   test('keeps buffering while subscribed', () => {