synstate 3.1.0 → 3.2.0

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/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;
 };