synstate 3.1.0 → 3.2.1

package/src/core/create/counter.test.mts

@@ -1,3 +1,4 @@
+import { Arr } from 'ts-data-forge';
 import { counter } from './counter.mjs';
 
 describe(counter, () => {
@@ -8,4 +9,186 @@ describe(counter, () => {
 
     assert.isTrue(counter$.isCompleted);
   });
+
+  test('emits 0 right after start(), then 1, 2, … every interval', () => {
+    vi.useFakeTimers();
+
+    const start = Date.now();
+
+    const counter$ = counter(100);
+
+    const mut_history: number[] = [];
+
+    counter$.subscribe((n) => {
+      mut_history.push(n);
+    });
+
+    vi.advanceTimersToNextTimer();
+
+    assert.deepStrictEqual(mut_history, [0]);
+
+    assert.strictEqual(vi.getMockedSystemTime()?.getTime(), start);
+
+    vi.advanceTimersToNextTimer().advanceTimersToNextTimer();
+
+    assert.deepStrictEqual(mut_history, [0, 1, 2]);
+
+    counter$.complete();
+
+    vi.useRealTimers();
+  });
+
+  test('emitInitial: false skips the 0 and starts with 1 after one interval', () => {
+    vi.useFakeTimers();
+
+    const start = Date.now();
+
+    const counter$ = counter(100, { emitInitial: false });
+
+    const mut_history: number[] = [];
+
+    counter$.subscribe((n) => {
+      mut_history.push(n);
+    });
+
+    vi.advanceTimersToNextTimer();
+
+    assert.deepStrictEqual(mut_history, [1]);
+
+    assert.strictEqual(vi.getMockedSystemTime()?.getTime(), start + 100);
+
+    vi.advanceTimersToNextTimer().advanceTimersToNextTimer();
+
+    assert.deepStrictEqual(mut_history, [1, 2, 3]);
+
+    counter$.complete();
+
+    vi.useRealTimers();
+  });
+
+  test('emitInitial: false still clears the interval on complete', () => {
+    vi.useFakeTimers();
+
+    const counter$ = counter(100, { emitInitial: false });
+
+    const mut_history: number[] = [];
+
+    counter$.subscribe((n) => {
+      mut_history.push(n);
+    });
+
+    vi.advanceTimersToNextTimer();
+
+    counter$.complete();
+
+    assert.strictEqual(vi.getTimerCount(), 0);
+
+    assert.deepStrictEqual(mut_history, [1]);
+
+    vi.useRealTimers();
+  });
+
+  test.each([
+    { emitInitial: true, expected: [0, 1, 2], firstAt: 0 },
+    { emitInitial: false, expected: [1, 2, 3], firstAt: 100 },
+  ] as const)(
+    'startManually: false, emitInitial: $emitInitial starts at creation',
+    ({ emitInitial, expected, firstAt }) => {
+      vi.useFakeTimers();
+
+      const start = Date.now();
+
+      const counter$ = counter(100, { startManually: false, emitInitial });
+
+      const mut_history: number[] = [];
+
+      counter$.subscribe((n) => {
+        mut_history.push(n);
+      });
+
+      vi.advanceTimersToNextTimer();
+
+      assert.deepStrictEqual<readonly number[]>(
+        mut_history,
+        Arr.take(expected, 1),
+      );
+
+      assert.strictEqual(vi.getMockedSystemTime()?.getTime(), start + firstAt);
+
+      vi.advanceTimersToNextTimer().advanceTimersToNextTimer();
+
+      assert.deepStrictEqual<readonly number[]>(mut_history, expected);
+
+      counter$.complete();
+
+      vi.useRealTimers();
+    },
+  );
+
+  test.each([
+    { emitInitial: true, expected: [0, 1, 2], firstAt: 0 },
+    { emitInitial: false, expected: [1, 2, 3], firstAt: 100 },
+  ] as const)(
+    'startManually: true, emitInitial: $emitInitial waits for start()',
+    ({ emitInitial, expected, firstAt }) => {
+      vi.useFakeTimers();
+
+      const counter$ = counter(100, { startManually: true, emitInitial });
+
+      const mut_history: number[] = [];
+
+      counter$.subscribe((n) => {
+        mut_history.push(n);
+      });
+
+      assert.strictEqual(vi.getTimerCount(), 0);
+
+      vi.setSystemTime(Date.now() + 1000);
+
+      const start = Date.now();
+
+      counter$.start();
+
+      vi.advanceTimersToNextTimer();
+
+      assert.deepStrictEqual<readonly number[]>(
+        mut_history,
+        Arr.take(expected, 1),
+      );
+
+      assert.strictEqual(vi.getMockedSystemTime()?.getTime(), start + firstAt);
+
+      vi.advanceTimersToNextTimer().advanceTimersToNextTimer();
+
+      assert.deepStrictEqual<readonly number[]>(mut_history, expected);
+
+      counter$.complete();
+
+      assert.strictEqual(vi.getTimerCount(), 0);
+
+      vi.useRealTimers();
+    },
+  );
+
+  test('completing before the first emission cancels the pending 0', () => {
+    vi.useFakeTimers();
+
+    const counter$ = counter(100);
+
+    const mut_history: number[] = [];
+
+    counter$.subscribe((n) => {
+      mut_history.push(n);
+    });
+
+    counter$.complete();
+
+    assert.strictEqual(vi.getTimerCount(), 0);
+
+    vi.runAllTimers();
+
+    assert.deepStrictEqual(mut_history, []);
+
+    vi.useRealTimers();
+  });
 });

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

@@ -71,7 +71,6 @@ import type { FromPromiseObservable } from '../types/index.mjs';
  */
 export const fromAbortablePromise = <A, E = unknown>(
   // @sumi-expect-error readonly/require-readonly-parameter
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   factory: (signal: AbortSignal) => Promise<A>,
 ): FromPromiseObservable<A, E> => {
   const abortController = new AbortController();
@@ -108,7 +107,6 @@ export const fromAbortablePromise = <A, E = unknown>(
           startUpdate(
             Result.err(
               // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-              // eslint-disable-next-line total-functions/no-unsafe-type-assertion
               error as E,
             ),
           );

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

@@ -71,7 +71,6 @@ export const fromPromise = <A, E = unknown>(
           startUpdate(
             Result.err(
               // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-              // eslint-disable-next-line total-functions/no-unsafe-type-assertion
               error as E,
             ),
           );

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

@@ -77,7 +77,6 @@ export const fromSubscribable = <A, E = unknown>(
           startUpdate(
             Result.err(
               // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-              // eslint-disable-next-line total-functions/no-unsafe-type-assertion
               error as E,
             ),
           );

package/src/core/create/just.mts

@@ -40,6 +40,5 @@ export const just = <const A,>(value: A): InitializedRootObservable<A> => {
   obs.complete();
 
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   return obs as InitializedRootObservable<A>;
 };

package/src/core/operators/audit.mts

@@ -105,7 +105,6 @@ export const audit = <A,>(
   milliSeconds: number,
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createAuditObservable(
       parentObservable,

package/src/core/operators/debounce.mts

@@ -96,7 +96,6 @@ export const debounce = <A,>(
   milliSeconds: number,
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createDebounceObservable(
       parentObservable,

package/src/core/operators/filter.mts

@@ -1,6 +1,8 @@
 import {
   asSafeUint,
   expectType,
+  isNotUndefined,
+  isString,
   Optional,
   pipe,
   SafeUint,
@@ -68,6 +70,11 @@ export function filter<A, B extends A>(
   predicate: (value: A, index: SafeUint | -1) => value is B,
 ): DropInitialValueOperator<A, B>;
 
+// A type-guard predicate and a boolean one are both functions at run time, so
+// this set only refines the return type (#1952). It stays overloaded because
+// one signature with a union parameter infers `unknown` for a generic guard
+// such as `isNotUndefined`; see the type test below.
+// @sumi-expect-error functions/no-refinement-overload
 export function filter<A>(
   predicate: (value: A, index: SafeUint | -1) => boolean,
 ): DropInitialValueOperator<A, A>;
@@ -139,4 +146,38 @@ if (import.meta.vitest !== undefined) {
 
     expectType<typeof _d, Observable<number>>('=');
   }
+
+  {
+    const s = source<number | undefined>();
+
+    const _guarded = s.pipe(filter((x): x is number => x !== undefined));
+
+    expectType<typeof _guarded, Observable<number>>('=');
+
+    const _inferred = s.pipe(filter((x) => x !== undefined));
+
+    expectType<typeof _inferred, Observable<number>>('=');
+
+    // A generic guard is what a single signature with a union parameter
+    // loses (it infers `unknown`), and why this set stays overloaded.
+    const _generic = s.pipe(filter(isNotUndefined));
+
+    expectType<typeof _generic, Observable<number>>('=');
+
+    const _withIndex = s.pipe(filter((x, i) => i === -1 || x === 0));
+
+    expectType<typeof _withIndex, Observable<number | undefined>>('=');
+  }
+
+  {
+    const _d = source<unknown>().pipe(filter(isString));
+
+    expectType<typeof _d, Observable<string>>('=');
+
+    const _standalone = filter((x: number) => x > 0);
+
+    expectType<typeof _standalone, DropInitialValueOperator<number, number>>(
+      '=',
+    );
+  }
 }

package/src/core/operators/map.mts

@@ -51,7 +51,6 @@ export const map = <A, B>(
   mapFn: (x: A, index: SafeUint | -1) => B,
 ): KeepInitialValueOperator<A, B> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createMapObservable(parentObservable, mapFn)) as KeepInitialValueOperator<
     A,

package/src/core/operators/skip-if-no-change.mts

@@ -71,7 +71,6 @@ export const skipIfNoChange = <A,>(
   eq: (x: A, y: A) => boolean = (x, y) => Object.is(x, y),
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createSkipIfNoChangeObservable(
       parentObservable,

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

@@ -58,7 +58,6 @@ export const takeUntil = <A,>(
   notifier: Observable<unknown>,
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createTakeUntilObservable(
       parentObservable,

package/src/core/operators/throttle.mts

@@ -89,7 +89,6 @@ export const throttle = <A,>(
   milliSeconds: number,
 ): KeepInitialValueOperator<A, A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createThrottleObservable(
       parentObservable,

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

@@ -64,7 +64,6 @@ export const withBufferedFrom = <A, B>(
   observable: Observable<B>,
 ): KeepInitialValueOperator<A, readonly [A, readonly B[]]> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createWithBufferedFromObservable(
       parentObservable,

package/src/core/predefined/operators/unwrap-optional.mts

@@ -47,5 +47,4 @@ export const unwrapOptional = <
   O extends UnknownOptional,
 >(): KeepInitialValueOperator<O, Optional.Unwrap<O> | undefined> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   map(Optional.unwrap as Fn<O, Optional.Unwrap<O> | undefined>);

package/src/core/predefined/operators/unwrap-result-ok.mts

@@ -47,5 +47,4 @@ export const unwrapResultOk = <
   R extends UnknownResult,
 >(): KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   map(Result.unwrapOk as Fn<R, Result.UnwrapOk<R> | undefined>);

package/src/core/types/observable.mts

@@ -25,6 +25,7 @@ type CreateObservableType<A, Kind extends ObservableKind> = Readonly<{
   // reactive dependency tree structure
   depth: Kind extends 'root' ? 0 : number;
   addChild: <B>(child: ChildObservable<B>) => void;
+  deleteChild: <B>(child: ChildObservable<B>) => void;
 
   // state
   getSnapshot: () => Optional<A>;
@@ -84,6 +85,7 @@ namespace ObservableTypeConverter {
   > = O &
     Readonly<{
       addDescendant: <B>(child: ChildObservable<B>) => void;
+      deleteDescendant: <B>(child: ChildObservable<B>) => void;
     }>;
 }
 

package/src/core/utils/id-maker.mts

@@ -9,7 +9,6 @@ function* idMaker<T extends symbol>(): Generator<T, T, T> {
 
   while (true) {
     // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     yield Symbol(mut_i.toString()) as T;
 
     mut_i += 1;

package/src/core/utils/utils.mts

@@ -52,6 +52,5 @@ export const binarySearch = <N extends number>(
   }
 
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   return mut_mid as NegativeInt32 | Uint32;
 };