synstate 3.3.0 → 4.0.0

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,8 +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';
@@ -65,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[]]>;
@@ -76,21 +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 = [];
-  };
+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({
@@ -104,27 +107,34 @@ const createWithBufferedFromObservable = <A, B>(
               Optional.isNone(me) ? [] : [me.value],
             ] as const),
       ).value,
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    });
+
+    this.#mut_bufferedValues = [];
+
+    this.#subscription = observable.subscribe((value) => {
+      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
+    });
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
 
-        setNext([sn.value, mut_bufferedValues], updateToken);
+    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
 
-        clearBuffer();
-      },
-  );
+    this.#mut_bufferedValues = [];
+  }
 
-  observable.subscribe((value) => {
-    mut_bufferedValues = Arr.toPushed(mut_bufferedValues, value);
-  });
+  protected override teardown(): void {
+    this.#subscription.unsubscribe();
 
-  return result;
-};
+    this.#mut_bufferedValues = [];
+  }
+}

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

@@ -0,0 +1,57 @@
+import { toNode } from '../class/index.mjs';
+import { source } from '../create/index.mjs';
+import { withBufferedFrom } from './with-buffered-from.mjs';
+
+describe('withBufferedFrom teardown', () => {
+  test('unsubscribes from the buffered observable on complete', () => {
+    const data$ = source<string>();
+
+    const trigger$ = source<number>();
+
+    const result$ = trigger$.pipe(withBufferedFrom(data$));
+
+    assert.isTrue(toNode(data$).hasSubscriber);
+
+    result$.complete();
+
+    assert.isTrue(result$.isCompleted);
+
+    assert.isFalse(toNode(data$).hasSubscriber);
+  });
+
+  test('unsubscribes from the buffered observable when the parent completes', () => {
+    const data$ = source<string>();
+
+    const trigger$ = source<number>();
+
+    const result$ = trigger$.pipe(withBufferedFrom(data$));
+
+    trigger$.complete();
+
+    assert.isTrue(result$.isCompleted);
+
+    assert.isFalse(toNode(data$).hasSubscriber);
+  });
+
+  test('keeps buffering while subscribed', () => {
+    const data$ = source<string>();
+
+    const trigger$ = source<number>();
+
+    const result$ = trigger$.pipe(withBufferedFrom(data$));
+
+    const mut_history: (readonly [number, readonly string[]])[] = [];
+
+    result$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    data$.next('A');
+
+    data$.next('B');
+
+    trigger$.next(1);
+
+    assert.deepStrictEqual(mut_history, [[1, ['A', 'B']]]);
+  });
+});

package/src/core/operators/with-current-value-from.mts

@@ -1,8 +1,16 @@
+// 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, pipe } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/index.mjs';
+import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   DropInitialValueOperator,
   Observable,
+  UpdateToken,
   WithCurrentValueFromOperatorObservable,
 } from '../types/index.mjs';
 import { maxDepth } from '../utils/index.mjs';
@@ -68,7 +76,7 @@ export const withCurrentValueFrom =
     observable: Observable<B>,
   ): DropInitialValueOperator<A, readonly [A, B]> =>
   (parentObservable) =>
-    createWithCurrentValueFromObservable(parentObservable, observable);
+    new WithCurrentValueFromObservableClass(parentObservable, observable);
 
 /**
  * Alias for `withCurrentValueFrom`.
@@ -76,12 +84,14 @@ export const withCurrentValueFrom =
  */
 export const withLatestFrom = withCurrentValueFrom;
 
-const createWithCurrentValueFromObservable = <A, B>(
-  parentObservable: Observable<A>,
-  observable: Observable<B>,
-): WithCurrentValueFromOperatorObservable<A, B> =>
-  createSyncChildObservable<readonly [A, B], readonly [A]>(
-    {
+class WithCurrentValueFromObservableClass<A, B>
+  extends SyncChildObservableClass<readonly [A, B], readonly [A]>
+  implements WithCurrentValueFromOperatorObservable<A, B>
+{
+  readonly #observable: Observable<B>;
+
+  constructor(parentObservable: Observable<A>, observable: Observable<B>) {
+    super({
       parents: [parentObservable],
       depth: 1 + maxDepth([parentObservable, observable]),
       initialValue: pipe({
@@ -92,24 +102,28 @@ const createWithCurrentValueFromObservable = <A, B>(
           ? Optional.none
           : Optional.some([par.value, me.value] as const),
       ).value,
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const ps = parentObservable.getSnapshot();
+    });
+
+    this.#observable = observable;
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const ps = par.getSnapshot();
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(ps)
-        ) {
-          return; // skip update
-        }
+    if (par.updateToken !== updateToken || Optional.isNone(ps)) {
+      return; // skip update
+    }
 
-        const curr = observable.getSnapshot();
+    const curr = this.#observable.getSnapshot();
 
-        if (Optional.isNone(curr)) {
-          return; // skip update
-        }
+    if (Optional.isNone(curr)) {
+      return; // skip update
+    }
 
-        setNext([ps.value, curr.value], updateToken);
-      },
-  );
+    this.setNext([ps.value, curr.value], updateToken);
+  }
+}

package/src/core/operators/with-initial-value.mts

@@ -1,9 +1,16 @@
+// 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
 import { expectType, Optional } from 'ts-data-forge';
-import { createInitializedSyncChildObservable } from '../base/index.mjs';
+import { InitializedSyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import type {
   InitializedObservable,
   Observable,
+  UpdateToken,
   WithInitialValueOperator,
   WithInitialValueOperatorObservable,
 } from '../types/index.mjs';
@@ -56,31 +63,33 @@ import type {
 export const withInitialValue =
   <A, I = A>(initialValue: I): WithInitialValueOperator<A, A | I> =>
   (parentObservable) =>
-    createWithInitialValueObservable(parentObservable, initialValue);
+    new WithInitialValueObservableClass(parentObservable, initialValue);
 
-const createWithInitialValueObservable = <A, I>(
-  parentObservable: Observable<A>,
-  initialValue: I,
-): WithInitialValueOperatorObservable<A, I> =>
-  createInitializedSyncChildObservable<A | I, readonly [A]>(
-    {
+class WithInitialValueObservableClass<A, I>
+  extends InitializedSyncChildObservableClass<A | I, readonly [A]>
+  implements WithInitialValueOperatorObservable<A, I>
+{
+  constructor(parentObservable: Observable<A>, initialValue: I) {
+    super({
       parents: [parentObservable],
       initialValue: Optional.some(initialValue),
-    },
-    ({ setNext }) =>
-      (updateToken) => {
-        const sn = parentObservable.getSnapshot();
+    });
 
-        if (
-          parentObservable.updateToken !== updateToken ||
-          Optional.isNone(sn)
-        ) {
-          return; // skip update
-        }
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
 
-        setNext(sn.value, updateToken);
-      },
-  );
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
+
+    this.setNext(sn.value, updateToken);
+  }
+}
 
 if (import.meta.vitest !== undefined) {
   test('type test', () => {

package/src/core/predefined/operators/index.mts

@@ -5,7 +5,6 @@ export * from './map-result-ok.mjs';
 export * from './map-to.mjs';
 export * from './pluck.mjs';
 export * from './skip.mjs';
-export * from './take.mjs';
 export * from './unwrap-optional.mjs';
 export * from './unwrap-result-err.mjs';
 export * from './unwrap-result-ok.mjs';

package/src/core/scope/index.mts

@@ -0,0 +1 @@
+export * from './scope.mjs';