synstate 6.2.1 → 7.0.1

package/src/core/create/from-abortable-promise.mts

@@ -8,6 +8,7 @@
 import { Optional, Result } from 'ts-data-forge';
 import { RootObservableClass } from '../class/index.mjs';
 import type { FromPromiseObservable } from '../types/index.mjs';
+import { rethrowOutOfPromise } from '../utils/index.mjs';
 
 /**
  * Creates an observable from a Promise factory that receives an `AbortSignal`.
@@ -96,35 +97,44 @@ class FromAbortablePromiseObservableClass<A, E = unknown>
 
     const promise = factory(this.#abortController.signal);
 
+    // `onRejected` beside `onFulfilled`, so that only the promise's own
+    // rejection becomes an Err: what a subscriber throws on the Ok value is not
+    // the promise's (#2931). A `.catch` after `.then` would take both, and is
+    // also a step later.
     promise
-      .then((value) => {
-        if (this.isCompleted) {
-          return;
-        }
+      // eslint-disable-next-line unicorn/prefer-then-catch -- its suggestion, `.then(onFulfilled).catch(onRejected)`, would take what a subscriber throws too
+      .then(
+        (value) => {
+          if (this.isCompleted) {
+            return;
+          }
 
-        this.startUpdate(Result.ok(value));
-      })
-      .catch((error: unknown) => {
-        if (this.isCompleted) {
-          return;
-        }
+          this.startUpdate(Result.ok(value));
+        },
+        (error: unknown) => {
+          if (this.isCompleted) {
+            return;
+          }
 
-        // Silently ignore AbortError — it means the observable was
-        // intentionally completed (e.g., by switchMap).
-        if (error instanceof DOMException && error.name === 'AbortError') {
-          return;
-        }
+          // Silently ignore AbortError — it means the observable was
+          // intentionally completed (e.g., by switchMap).
+          if (error instanceof DOMException && error.name === 'AbortError') {
+            return;
+          }
 
-        this.startUpdate(
-          Result.err(
-            // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-            error as E,
-          ),
-        );
-      })
+          this.startUpdate(
+            Result.err(
+              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+              error as E,
+            ),
+          );
+        },
+      )
+      .catch(rethrowOutOfPromise)
       .finally(() => {
         this.complete();
-      });
+      })
+      .catch(rethrowOutOfPromise);
   }
 
   protected override teardown(): void {

package/src/core/create/from-promise.mts

@@ -7,6 +7,7 @@
 import { Optional, Result } from 'ts-data-forge';
 import { RootObservableClass } from '../class/index.mjs';
 import type { FromPromiseObservable } from '../types/index.mjs';
+import { rethrowOutOfPromise } from '../utils/index.mjs';
 
 /**
  * Creates an observable from a Promise.
@@ -66,28 +67,37 @@ class FromPromiseObservableClass<A, E = unknown>
   constructor(promise: Promise<A>) {
     super({ initialValue: Optional.none });
 
+    // `onRejected` beside `onFulfilled`, so that only the promise's own
+    // rejection becomes an Err: what a subscriber throws on the Ok value is not
+    // the promise's (#2931). A `.catch` after `.then` would take both, and is
+    // also a step later.
     promise
-      .then((value) => {
-        if (this.isCompleted) {
-          return;
-        }
+      // eslint-disable-next-line unicorn/prefer-then-catch -- its suggestion, `.then(onFulfilled).catch(onRejected)`, would take what a subscriber throws too
+      .then(
+        (value) => {
+          if (this.isCompleted) {
+            return;
+          }
 
-        this.startUpdate(Result.ok(value));
-      })
-      .catch((error: unknown) => {
-        if (this.isCompleted) {
-          return;
-        }
+          this.startUpdate(Result.ok(value));
+        },
+        (error: unknown) => {
+          if (this.isCompleted) {
+            return;
+          }
 
-        this.startUpdate(
-          Result.err(
-            // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-            error as E,
-          ),
-        );
-      })
+          this.startUpdate(
+            Result.err(
+              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+              error as E,
+            ),
+          );
+        },
+      )
+      .catch(rethrowOutOfPromise)
       .finally(() => {
         this.complete();
-      });
+      })
+      .catch(rethrowOutOfPromise);
   }
 }

package/src/core/create/from-promise.test.mts

@@ -0,0 +1,97 @@
+import { Optional, Result } from 'ts-data-forge';
+import { panic } from 'ts-std-forge';
+import { fromAbortablePromise } from './from-abortable-promise.mjs';
+import { fromPromise } from './from-promise.mjs';
+
+describe('fromPromise and fromAbortablePromise report only the promise’s own rejection as an Err (#2931)', () => {
+  test.each([
+    ['fromPromise', () => fromPromise(Promise.resolve(1))],
+    [
+      'fromAbortablePromise',
+      () => fromAbortablePromise(() => Promise.resolve(1)),
+    ],
+  ] as const)(
+    '%s: a subscriber that throws on the Ok value gets no Err',
+    async (_, create) => {
+      vi.useFakeTimers();
+
+      onTestFinished(() => {
+        vi.useRealTimers();
+      });
+
+      const mut_events: string[] = [];
+
+      const result$ = create();
+
+      result$.subscribe(
+        (r) => {
+          mut_events.push(Result.isOk(r) ? `ok ${r.value}` : 'err');
+
+          if (Result.isOk(r)) {
+            panic('bug in a subscriber');
+          }
+        },
+        () => {
+          mut_events.push('complete');
+        },
+      );
+
+      await settlePromises();
+
+      assert.deepStrictEqual(mut_events, ['ok 1', 'complete']);
+
+      // The subscriber's exception is not swallowed: it is thrown again from a
+      // task of its own.
+      expect(() => {
+        vi.runOnlyPendingTimers();
+      }).toThrow('bug in a subscriber');
+    },
+  );
+
+  const rejection = new Error('rejected');
+
+  test.each([
+    ['fromPromise', () => fromPromise(Promise.reject(rejection))],
+    [
+      'fromAbortablePromise',
+      () => fromAbortablePromise(() => Promise.reject(rejection)),
+    ],
+  ] as const)('%s: a rejection is an Err', async (_, create) => {
+    const result$ = create();
+
+    const mut_events: string[] = [];
+
+    result$.subscribe(
+      (r) => {
+        mut_events.push(
+          Result.isErr(r) && r.value === rejection ? 'err rejected' : 'ok',
+        );
+      },
+      () => {
+        mut_events.push('complete');
+      },
+    );
+
+    await settlePromises();
+
+    assert.deepStrictEqual(mut_events, ['err rejected', 'complete']);
+  });
+
+  test('fromPromise holds the value by the time an await of the same promise resumes', async () => {
+    const promise = Promise.resolve(1);
+
+    const result$ = fromPromise(promise);
+
+    await promise;
+
+    assert.deepStrictEqual(result$.getSnapshot(), Optional.some(Result.ok(1)));
+  });
+});
+
+/** Lets the promise chains already started run to their end. */
+const settlePromises = async (): Promise<void> => {
+  for (const _ of Array.from({ length: 10 })) {
+    // eslint-disable-next-line no-await-in-loop -- each await lets the chains take one more step
+    await Promise.resolve();
+  }
+};

package/src/core/create/source.mts

@@ -4,7 +4,8 @@
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
-import { Arr, Optional } from 'ts-data-forge';
+import { Optional } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import { RootObservableClass } from '../class/index.mjs';
 import type {
   InitializedSourceObservable,

package/src/core/operators/filter.mts

@@ -12,7 +12,7 @@ import {
   isString,
   Optional,
   pipe,
-  SafeUint,
+  type SafeUint,
 } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
@@ -132,8 +132,7 @@ class FilterObservableClass<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/flat-map-initial-value.test.mts

@@ -0,0 +1,269 @@
+import { Optional } from 'ts-data-forge';
+import { panic } from 'ts-std-forge';
+import { toNode } from '../class/index.mjs';
+import { just, source } from '../create/index.mjs';
+import { onScopeDispose } from '../scope/index.mjs';
+import type { Observable } from '../types/index.mjs';
+import { filter } from './filter.mjs';
+import { map } from './map.mjs';
+import { mergeMap } from './merge-map.mjs';
+import { skipWhile } from './skip-while.mjs';
+import { switchMap } from './switch-map.mjs';
+
+describe('the value the source holds when the operator is created is projected', () => {
+  test('switchMap: a sync inner gives the operator its value at once', () => {
+    const a$ = source<number>(1);
+
+    const s$ = a$.pipe(switchMap((x) => just(x * 10)));
+
+    assert.deepStrictEqual(s$.getSnapshot(), Optional.some(10));
+
+    const mut_history: number[] = [];
+
+    s$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    a$.next(2);
+
+    assert.deepStrictEqual(mut_history, [10, 20]);
+  });
+
+  test('switchMap: a later value of the first inner is passed on', () => {
+    const a$ = source<number>(1);
+
+    const inner$ = source<string>();
+
+    const mut_projected: number[] = [];
+
+    const s$ = a$.pipe(
+      switchMap((x) => {
+        mut_projected.push(x);
+
+        return inner$;
+      }),
+    );
+
+    assert.deepStrictEqual(mut_projected, [1]);
+
+    const mut_history: string[] = [];
+
+    s$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    inner$.next('a');
+
+    assert.deepStrictEqual(mut_history, ['a']);
+  });
+
+  test('switchMap: the next value of the source switches away from the first inner', () => {
+    const a$ = source<number>(1);
+
+    const first$ = source<string>();
+
+    const second$ = source<string>();
+
+    const s$ = a$.pipe(switchMap((x) => (x === 1 ? first$ : second$)));
+
+    const mut_history: string[] = [];
+
+    s$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    a$.next(2);
+
+    first$.next('stale');
+
+    second$.next('b');
+
+    assert.deepStrictEqual(mut_history, ['b']);
+  });
+
+  test('switchMap: what the first projection created is disposed when it is switched away from', () => {
+    const a$ = source<number>(1);
+
+    const mut_disposed: number[] = [];
+
+    const s$ = a$.pipe(
+      switchMap((x) => {
+        onScopeDispose(() => {
+          mut_disposed.push(x);
+        });
+
+        return just(x);
+      }),
+    );
+
+    s$.subscribe(() => undefined);
+
+    assert.deepStrictEqual(mut_disposed, []);
+
+    a$.next(2);
+
+    assert.deepStrictEqual(mut_disposed, [1]);
+  });
+
+  test('switchMap: a source with no value projects nothing until it emits', () => {
+    const a$ = source<number>();
+
+    const mut_projected: number[] = [];
+
+    const s$ = a$.pipe(
+      switchMap((x) => {
+        mut_projected.push(x);
+
+        return just(x);
+      }),
+    );
+
+    assert.isTrue(Optional.isNone(s$.getSnapshot()));
+
+    a$.next(1);
+
+    assert.deepStrictEqual(mut_projected, [1]);
+  });
+
+  test('switchMap: a value carried through filter and map is projected', () => {
+    const a$ = source<Optional<number>>(Optional.some(42));
+
+    const s$ = a$
+      .pipe(filter(Optional.isSome))
+      .pipe(map((some) => some.value))
+      .pipe(switchMap((id) => just(`item ${id.toString()}`)));
+
+    assert.deepStrictEqual(s$.getSnapshot(), Optional.some('item 42'));
+  });
+
+  test('switchMap: a completed source projects nothing and completes', () => {
+    const a$ = just(1);
+
+    const mut_projected: number[] = [];
+
+    const s$ = a$.pipe(
+      switchMap((x) => {
+        mut_projected.push(x);
+
+        return just(x);
+      }),
+    );
+
+    assert.deepStrictEqual(mut_projected, []);
+
+    assert.isTrue(s$.isCompleted);
+  });
+
+  test('mergeMap: a completed source projects nothing and completes', () => {
+    const a$ = just(1);
+
+    const mut_projected: number[] = [];
+
+    const s$ = a$.pipe(
+      mergeMap((x) => {
+        mut_projected.push(x);
+
+        return just(x);
+      }),
+    );
+
+    assert.deepStrictEqual(mut_projected, []);
+
+    assert.isTrue(s$.isCompleted);
+  });
+
+  test('mergeMap: the first inner and the later ones are merged', () => {
+    const a$ = source<number>(1);
+
+    const first$ = source<string>();
+
+    const second$ = source<string>();
+
+    const s$ = a$.pipe(mergeMap((x) => (x === 1 ? first$ : second$)));
+
+    const mut_history: string[] = [];
+
+    s$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    a$.next(2);
+
+    first$.next('a');
+
+    second$.next('b');
+
+    assert.deepStrictEqual(mut_history, ['a', 'b']);
+  });
+
+  test('mergeMap: a sync inner gives the operator its value at once', () => {
+    const a$ = source<number>(1);
+
+    const s$ = a$.pipe(mergeMap((x) => just(x * 10)));
+
+    assert.deepStrictEqual(s$.getSnapshot(), Optional.some(10));
+  });
+
+  test('switchMap: a first projection that throws leaves nothing attached to the source', () => {
+    const a$ = source<number>(1);
+
+    const mut_projected: number[] = [];
+
+    assert.throws(() => {
+      a$.pipe(
+        switchMap((x) => {
+          mut_projected.push(x);
+
+          // Made in the projection's scope before it throws.
+          a$.pipe(map((v) => v + 1));
+
+          if (x === 1) {
+            panic('first');
+          }
+
+          return just(x);
+        }),
+      );
+    }, /first/u);
+
+    assert.isFalse(toNode(a$).hasChild);
+
+    a$.next(2);
+
+    assert.deepStrictEqual(mut_projected, [1]);
+  });
+
+  test('mergeMap: a first projection that throws leaves nothing attached to the source', () => {
+    const a$ = source<number>(1);
+
+    assert.throws(() => {
+      a$.pipe(
+        mergeMap((): Observable<number> => {
+          a$.pipe(map((v) => v + 1));
+
+          panic('first');
+        }),
+      );
+    }, /first/u);
+
+    assert.isFalse(toNode(a$).hasChild);
+  });
+
+  test('switchMap: skipWhile on the held value before it keeps that value from being projected', () => {
+    const a$ = source<number>(1);
+
+    const mut_projected: number[] = [];
+
+    a$.pipe(skipWhile((_, index) => index === -1)).pipe(
+      switchMap((x) => {
+        mut_projected.push(x);
+
+        return just(x);
+      }),
+    );
+
+    a$.next(2);
+
+    assert.deepStrictEqual(mut_projected, [2]);
+  });
+});

package/src/core/operators/flat-map-sync-inner.test.mts

@@ -24,7 +24,8 @@ describe('an inner observable that holds a value is passed on in the update that
 
     a$.next(3);
 
-    assert.deepStrictEqual(mut_history, ['m2,s2', 'm3,s3']);
+    // 'm1,s1' from the value `a$` held when the operators were created.
+    assert.deepStrictEqual(mut_history, ['m1,s1', 'm2,s2', 'm3,s3']);
   });
 
   test('switchMap: a child of both it and its parent emits once per update', () => {
@@ -43,6 +44,7 @@ describe('an inner observable that holds a value is passed on in the update that
     a$.next(3);
 
     assert.deepStrictEqual(mut_history, [
+      [1, 10],
       [2, 20],
       [3, 30],
     ]);
@@ -85,6 +87,6 @@ describe('an inner observable that holds a value is passed on in the update that
 
     a$.next(2);
 
-    assert.deepStrictEqual(mut_history, ['m2,s2']);
+    assert.deepStrictEqual(mut_history, ['m1,s1', 'm2,s2']);
   });
 });