synstate 6.2.1 → 7.0.0

package/src/core/operators/switch-map.mts

@@ -21,6 +21,10 @@ import type {
  * Projects each source value to an observable, subscribes to it, and emits its values.
  * When a new value arrives from the source, the previous inner observable is unsubscribed.
  *
+ * A value the source already holds when `switchMap` is created (a state, an
+ * observable with an initial value) is projected at once, as `map` and `filter`
+ * start from it. A completed source is not projected.
+ *
  * The projection runs in a scope of its own (see `createScope`): what it
  * creates is disposed when the next value switches away from it and when
  * `switchMap` completes. An observable it only returns — one created outside
@@ -152,7 +156,9 @@ class SwitchMapObservableClass<A, B>
 
     this.#mut_subscription = undefined;
 
-    this.attach();
+    this.attachProjectingHeldValue(parentObservable, (value, updateToken) => {
+      this.#project(value, updateToken);
+    });
   }
 
   /** Releases the inner observable, and only the one this operator made. */
@@ -162,6 +168,19 @@ class SwitchMapObservableClass<A, B>
     this.#mut_innerScope?.dispose();
   }
 
+  /** Switches to the inner observable of `value`. */
+  #project(value: A, updateToken: UpdateToken): void {
+    this.#releaseInner();
+
+    const innerScope = createScope(this.#ownerScope);
+
+    this.#mut_innerScope = innerScope;
+
+    const observable = innerScope.run(() => this.#mapToObservable(value));
+
+    this.#mut_subscription = this.subscribeInner(observable, updateToken);
+  }
+
   override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
@@ -171,15 +190,7 @@ class SwitchMapObservableClass<A, B>
       return; // skip update
     }
 
-    this.#releaseInner();
-
-    const innerScope = createScope(this.#ownerScope);
-
-    this.#mut_innerScope = innerScope;
-
-    const observable = innerScope.run(() => this.#mapToObservable(sn.value));
-
-    this.#mut_subscription = this.subscribeInner(observable, updateToken);
+    this.#project(sn.value, updateToken);
   }
 
   protected override teardown(): void {

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

@@ -5,13 +5,7 @@
 // @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,
-  asSafeUint,
-  expectType,
-  pipe,
-} from 'ts-data-forge';
+import { Optional, asSafeUint, expectType, type SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import type {
@@ -73,7 +67,7 @@ import { withInitialValue } from './with-initial-value.mjs';
  *
  * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  *
- * num$.next(1); // logs: 1
+ * num$.next(1); // nothing logged (already completed)
  *
  * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  * ```
@@ -98,21 +92,26 @@ class TakeWhileObservableClass<A>
     parentObservable: Observable<A>,
     predicate: (value: A, index: SafeUint | -1) => boolean,
   ) {
+    const parentSnapshot = parentObservable.getSnapshot();
+
+    const isTaking =
+      Optional.isNone(parentSnapshot) || predicate(parentSnapshot.value, -1);
+
     super({
       parents: [parentObservable],
-      initialValue: pipe(parentObservable.getSnapshot()).map((par) =>
-        Optional.isNone(par)
-          ? Optional.none
-          : predicate(par.value, -1)
-            ? par
-            : Optional.none,
-      ).value,
+      initialValue: isTaking ? parentSnapshot : Optional.none,
     });
 
     this.#mut_index = -1;
 
     this.#predicate = predicate;
 
+    // A parent value the predicate rejects ends it, as any later one would;
+    // `attach` then leaves it out of the graph.
+    if (!isTaking) {
+      this.complete();
+    }
+
     this.attach();
   }
 
@@ -125,8 +124,7 @@ class TakeWhileObservableClass<A>
       return; // skip update
     }
 
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+    this.#mut_index = asSafeUint(this.#mut_index + 1);
 
     if (this.#predicate(sn.value, this.#mut_index)) {
       this.setNext(sn.value, updateToken);

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

@@ -0,0 +1,51 @@
+import { createState } from '../../utils/index.mjs';
+import { takeWhile } from './take-while.mjs';
+
+describe(takeWhile, () => {
+  test('completes at once when the initial value fails the predicate', () => {
+    const [s$, setS] = createState(5);
+
+    const taken$ = s$.pipe(takeWhile((x) => x < 3));
+
+    const mut_events: string[] = [];
+
+    taken$.subscribe(
+      (x) => {
+        mut_events.push(`next ${x}`);
+      },
+      () => {
+        mut_events.push('complete');
+      },
+    );
+
+    assert.isTrue(taken$.isCompleted);
+
+    setS(1);
+
+    assert.deepStrictEqual(mut_events, ['complete']);
+  });
+
+  test('keeps taking after an initial value that passes the predicate', () => {
+    const [s$, setS] = createState(1);
+
+    const taken$ = s$.pipe(takeWhile((x) => x < 3));
+
+    const mut_history: number[] = [];
+
+    taken$.subscribe((x) => {
+      mut_history.push(x);
+    });
+
+    setS(2);
+
+    assert.isFalse(taken$.isCompleted);
+
+    setS(5);
+
+    assert.isTrue(taken$.isCompleted);
+
+    setS(1);
+
+    assert.deepStrictEqual(mut_history, [1, 2]);
+  });
+});

package/src/core/operators/throttle.mts

@@ -139,14 +139,15 @@ class ThrottleObservableClass<A>
       return; // skip update
     }
 
-    this.setNext(sn.value, updateToken);
-
+    // The window opens before `setNext`, which can lead back here: a value a
+    // subscriber writes to the parent falls inside it.
     this.#mut_isSkipping = true;
 
-    // set timer
     this.#mut_timerId = setTimeout(() => {
       this.#mut_isSkipping = false;
     }, this.#milliSeconds);
+
+    this.setNext(sn.value, updateToken);
   }
 
   protected override teardown(): void {

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

@@ -5,7 +5,8 @@
 // @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 { Optional, pipe } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   KeepInitialValueOperator,
@@ -93,11 +94,13 @@ class WithBufferedFromObservableClass<A, B>
   #mut_bufferedValues: readonly B[];
 
   constructor(parentObservable: Observable<A>, observable: Observable<B>) {
+    const parentSnapshot = parentObservable.getSnapshot();
+
     super({
       parents: [parentObservable],
       depth: 1 + maxDepth([parentObservable, observable]),
       initialValue: pipe({
-        par: parentObservable.getSnapshot(),
+        par: parentSnapshot,
         me: observable.getSnapshot(),
       }).map(({ par, me }) =>
         Optional.isNone(par)
@@ -115,6 +118,12 @@ class WithBufferedFromObservableClass<A, B>
       this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
     });
 
+    // `subscribe` has just pushed the buffered observable's current value,
+    // which the initial tuple already carries.
+    if (Optional.isSome(parentSnapshot)) {
+      this.#mut_bufferedValues = [];
+    }
+
     this.attach();
   }
 
@@ -127,9 +136,13 @@ class WithBufferedFromObservableClass<A, B>
       return; // skip update
     }
 
-    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
+    const buffered = this.#mut_bufferedValues;
 
+    // Emptied before `setNext`, which can lead back here: a value a subscriber
+    // writes to the buffered observable belongs to the next batch.
     this.#mut_bufferedValues = [];
+
+    this.setNext([sn.value, buffered], updateToken);
   }
 
   protected override teardown(): void {

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

@@ -1,3 +1,4 @@
+import { createState } from '../../utils/index.mjs';
 import { toNode } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import { withBufferedFrom } from './with-buffered-from.mjs';
@@ -55,3 +56,29 @@ describe('withBufferedFrom teardown', () => {
     assert.deepStrictEqual(mut_history, [[1, ['A', 'B']]]);
   });
 });
+
+describe('withBufferedFrom initial value', () => {
+  test('reports the current value of the buffered observable once when both hold one (#2767)', () => {
+    const [data$] = createState('x');
+
+    const [trigger$, setTrigger] = createState(0);
+
+    const result$ = trigger$.pipe(withBufferedFrom(data$));
+
+    const mut_history: (readonly [number, readonly string[]])[] = [];
+
+    result$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    setTrigger(1);
+
+    setTrigger(2);
+
+    assert.deepStrictEqual(mut_history, [
+      [0, ['x']],
+      [1, []],
+      [2, []],
+    ]);
+  });
+});

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

@@ -5,7 +5,7 @@
 // @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, asSafeUint } from 'ts-data-forge';
+import { Optional, asSafeUint, type SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../../class/index.mjs';
 import type {
   KeepInitialValueOperator,
@@ -112,8 +112,7 @@ class WithIndexObservableClass<A> extends SyncChildObservableClass<
       return; // skip update
     }
 
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+    this.#mut_index = asSafeUint(this.#mut_index + 1);
 
     this.setNext([this.#mut_index, sn.value], updateToken);
   }

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

@@ -1,4 +1,4 @@
-import { PositiveSafeInt } from 'ts-data-forge';
+import { isPositiveSafeInt } from 'ts-data-forge';
 import type { PositiveSafeIntWithSmallInt } from 'ts-type-forge';
 import { skipWhile } from '../../operators/index.mjs';
 import type { DropInitialValueOperator } from '../../types/index.mjs';
@@ -53,6 +53,6 @@ import type { DropInitialValueOperator } from '../../types/index.mjs';
 export const skip = <A,>(
   n: PositiveSafeIntWithSmallInt,
 ): DropInitialValueOperator<A, A> =>
-  !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
+  !isPositiveSafeInt(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
 
 const idFn = <T,>(value: T): T => value;

package/src/core/utils/index.mts

@@ -3,3 +3,4 @@ export * from './id-maker.mjs';
 export * from './max-depth.mjs';
 export * from './observable-brand.mjs';
 export * from './observable-utils.mjs';
+export * from './rethrow-out-of-promise.mjs';

package/src/core/utils/rethrow-out-of-promise.mts

@@ -0,0 +1,16 @@
+/**
+ * Throws `error` again from a task of its own, for a `.catch` after each step
+ * of a promise chain that runs subscribers (`fromPromise`): after the step that
+ * emits and after the one that completes, so that neither exception replaces
+ * the other. A subscriber's exception then surfaces as an uncaught error, as
+ * one thrown during an update a timer started does (`debounce`, `timer`),
+ * rather than as a rejection or not at all.
+ */
+export const rethrowOutOfPromise = (error: unknown): void => {
+  setTimeout(() => {
+    // The subscriber's own exception, passed on unchanged.
+    // @sumi-expect-error exceptions/no-throw
+    // eslint-disable-next-line @typescript-eslint/only-throw-error -- the subscriber's own exception, passed on unchanged
+    throw error;
+  }, 0);
+};