refactor(every): Improve types, address comments

- Every now infers correctly when `Boolean` constructor is used.

api_guard/dist/types/operators/index.d.ts

@@ -96,8 +96,7 @@ export declare function endWith<T, A, B, C, D, E>(v1: A, v2: B, v3: C, v4: D, v5
 export declare function endWith<T, A, B, C, D, E, F>(v1: A, v2: B, v3: C, v4: D, v5: E, v6: F, scheduler: SchedulerLike): OperatorFunction<T, T | A | B | C | D | E | F>;
 export declare function endWith<T, A extends any[] = T[]>(...args: A): OperatorFunction<T, T | ValueFromArray<A>>;
 
-export declare function every<T, S extends T>(predicate: (value: T, index: number, source: Observable<T>) => value is S, thisArg?: any): OperatorFunction<T, S>;
-export declare function every<T>(predicate: BooleanConstructor, thisArg?: any): OperatorFunction<T, TruthyTypesOf<T>>;
+export declare function every<T>(predicate: BooleanConstructor, thisArg?: any): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>;
 export declare function every<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): OperatorFunction<T, boolean>;
 
 export declare function exhaust<T>(): OperatorFunction<ObservableInput<T>, T>;
@@ -316,7 +315,9 @@ export declare function takeLast<T>(count: number): MonoTypeOperatorFunction<T>;
 export declare function takeUntil<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T>;
 
 export declare function takeWhile<T>(predicate: (value: T, index: number) => false, inclusive?: boolean): OperatorFunction<T, never>;
-export declare function takeWhile<T>(predicate: BooleanConstructor, inclusive?: boolean): OperatorFunction<T, Exclude<T, Falsy> extends never ? never : T>;
+export declare function takeWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, Exclude<T, Falsy> extends never ? never : T>;
+export declare function takeWhile<T>(predicate: BooleanConstructor, inclusive: false): OperatorFunction<T, Exclude<T, Falsy> extends never ? never : T>;
+export declare function takeWhile<T>(predicate: BooleanConstructor, inclusive: true): MonoTypeOperatorFunction<T>;
 export declare function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>;
 export declare function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S, inclusive: false): OperatorFunction<T, S>;
 export declare function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive?: boolean): MonoTypeOperatorFunction<T>;

spec-dtslint/operators/every-spec.ts

@@ -38,6 +38,9 @@ it('should expect function parameter', () => {
 });
 
 it('should handle the Boolean constructor', () => {
-  const a = of(0 as const, '' as const, false as const, null, undefined, -0 as const, 0n as const).pipe(every(Boolean)); // $ExpectType Observable<never>
-  const b = of(0 as const, '' as const, 'hi there' as const, false as const, null, undefined, -0 as const, 0n as const).pipe(every(Boolean)); // $ExpectType Observable<"hi there">
+  const a = of(0 as const, '' as const, false as const, null, undefined, -0 as const, 0n as const).pipe(every(Boolean)); // $ExpectType Observable<false>
+  const b = of(0 as const, '' as const, 'hi there' as const, false as const, null, undefined, -0 as const, 0n as const).pipe(every(Boolean)); // $ExpectType Observable<boolean>
+  const c = of('test' as const, true as const, 1 as const, [], {}).pipe(every(Boolean)); // $ExpectType Observable<boolean>
+  const d = of(NaN, NaN, NaN).pipe(every(Boolean)); // $ExpectType Observable<boolean>
+  const e = of(0, 1, 0).pipe(every(Boolean)); // $ExpectType Observable<boolean>
 })

src/internal/operators/every.ts

@@ -1,14 +1,13 @@
 /** @prettier */
 import { Observable } from '../Observable';
-import { OperatorFunction, TruthyTypesOf } from '../types';
+import { Falsy, OperatorFunction } from '../types';
 import { operate } from '../util/lift';
 import { OperatorSubscriber } from './OperatorSubscriber';
 
-export function every<T, S extends T>(
-  predicate: (value: T, index: number, source: Observable<T>) => value is S,
+export function every<T>(
+  predicate: BooleanConstructor,
   thisArg?: any
-): OperatorFunction<T, S>;
-export function every<T>(predicate: BooleanConstructor, thisArg?: any): OperatorFunction<T, TruthyTypesOf<T>>;
+): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>;
 export function every<T>(
   predicate: (value: T, index: number, source: Observable<T>) => boolean,
   thisArg?: any