Add OrAll type (#1378)

Co-authored-by: Som Shekhar Mukherjee <iamssmkhrj@gmail.com>

Author: salisbury-espinosa

index.d.ts

@@ -156,6 +156,7 @@ export type {IfNull} from './source/if-null.d.ts';
 export type {IsUndefined} from './source/is-undefined.d.ts';
 export type {And} from './source/and.d.ts';
 export type {Or} from './source/or.d.ts';
+export type {OrAll} from './source/or-all.d.ts';
 export type {Xor} from './source/xor.d.ts';
 export type {AllExtend, AllExtendOptions} from './source/all-extend.d.ts';
 export type {SomeExtend, SomeExtendOptions} from './source/some-extend.d.ts';

readme.md

@@ -180,9 +180,10 @@ Click the type names for complete docs.
 - [`AllUnionFields`](source/all-union-fields.d.ts) - Create a type with all fields from a union of object types.
 - [`DistributedOmit`](source/distributed-omit.d.ts) - Omits keys from a type, distributing the operation over a union.
 - [`DistributedPick`](source/distributed-pick.d.ts) - Picks keys from a type, distributing the operation over a union.
-- [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both true.
-- [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types is true.
-- [`Xor`](source/xor.d.ts) - Returns a boolean for whether only one of two given types is true.
+- [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both `true`.
+- [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types is `true`.
+- [`Xor`](source/xor.d.ts) - Returns a boolean for whether only one of two given types is `true`.
+- [`OrAll`](source/or-all.d.ts) - Returns a boolean for whether any of the given elements is `true`.
 - [`AllExtend`](source/all-extend.d.ts) - Returns a boolean for whether every element in an array type extends another type.
 - [`SomeExtend`](source/some-extend.d.ts) - Returns a boolean for whether some element in an array type extends another type.
 - [`NonEmptyTuple`](source/non-empty-tuple.d.ts) - Matches any non-empty tuple.

source/or-all.d.ts

@@ -0,0 +1,72 @@
+import type {SomeExtend} from './some-extend.d.ts';
+
+/**
+Returns a boolean for whether any of the given elements is `true`.
+
+Use-cases:
+- Check if at least one condition in a list of booleans is met.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type FFT = OrAll<[false, false, true]>;
+//=> true
+
+type FFF = OrAll<[false, false, false]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `OrAll<[false, boolean]>` expands to `OrAll<[false, true]> | OrAll<[false, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, boolean]>;
+//=> boolean
+
+type B = OrAll<[true, boolean]>;
+//=> true
+```
+
+Note: If `never` is passed as an element, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[never, never, true]>;
+//=> true
+
+type B = OrAll<[never, never, false]>;
+//=> false
+
+type C = OrAll<[never, never, never]>;
+//=> false
+
+type D = OrAll<[never, never, boolean]>;
+//=> boolean
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, any]>;
+//=> boolean
+
+type B = OrAll<[true, any]>;
+//=> true
+```
+
+Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in an empty tuple. See [Wikipedia: Clause (logic) > Empty clauses](https://en.wikipedia.org/wiki/Clause_(logic)#Empty_clauses:~:text=The%20truth%20evaluation%20of%20an%20empty%20disjunctive%20clause%20is%20always%20false.).
+
+@see {@link Or}
+*/
+export type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
+
+export {};

source/or.d.ts

@@ -1,5 +1,4 @@
-import type {If} from './if.d.ts';
-import type {IsNever} from './is-never.d.ts';
+import type {OrAll} from './or-all.d.ts';
 
 /**
 Returns a boolean for whether either of two given types is true.
@@ -74,16 +73,10 @@ type G = Or<never, never>;
 //=> false
 ```
 
+@see {@link OrAll}
 @see {@link And}
 @see {@link Xor}
 */
-export type Or<A extends boolean, B extends boolean> =
-	_Or<If<IsNever<A>, false, A>, If<IsNever<B>, false, B>>; // `never` is treated as `false`
-
-export type _Or<A extends boolean, B extends boolean> = A extends true
-	? true
-	: B extends true
-		? true
-		: false;
+export type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
 
 export {};

test-d/or-all.ts

@@ -0,0 +1,62 @@
+import {expectType} from 'tsd';
+import type {OrAll} from '../source/or-all.d.ts';
+
+declare const boolean: boolean;
+
+// Basic boolean combinations
+expectType<OrAll<[true, false]>>(true);
+expectType<OrAll<[false, true]>>(true);
+expectType<OrAll<[true, true]>>(true);
+expectType<OrAll<[false, false]>>(false);
+
+// Multiple elements in a tuple
+expectType<OrAll<[false, false, false, true]>>(true);
+expectType<OrAll<[false, false, false, false]>>(false);
+
+// `boolean` element
+expectType<OrAll<[false, false, boolean]>>(boolean);
+expectType<OrAll<[false, boolean, true]>>(true);
+expectType<OrAll<[boolean, boolean, boolean]>>(boolean);
+
+// Unions
+expectType<OrAll<[false, false, true] | [false, false, false]>>(boolean); // `true` | `false`
+expectType<OrAll<[false, true, false] | [true]>>(true); // `true` | `true`
+expectType<OrAll<[false] | [false, false, false]>>(false); // `false` | `false`
+expectType<OrAll<[true, false] | [false, boolean]>>(boolean); // `true` | `boolean`
+expectType<OrAll<[false, false] | [false, false, boolean]>>(boolean); // `false` | `boolean`
+expectType<OrAll<[boolean, false, false] | [boolean]>>(boolean); // `boolean` | `boolean`
+
+// Tuples with rest element
+expectType<OrAll<[false, ...Array<false>]>>(false);
+expectType<OrAll<[...Array<false>, true]>>(true);
+expectType<OrAll<[false, ...Array<false>, boolean]>>(boolean);
+
+// Non-tuple arrays
+expectType<OrAll<Array<true>>>(true);
+expectType<OrAll<Array<false>>>(false);
+expectType<OrAll<boolean[]>>(boolean);
+
+// Readonly arrays
+expectType<OrAll<readonly [true, false, true]>>(true);
+expectType<OrAll<readonly [false, false, false]>>(false);
+expectType<OrAll<readonly [false, false, boolean]>>(boolean);
+expectType<OrAll<ReadonlyArray<true>>>(true);
+expectType<OrAll<ReadonlyArray<false>>>(false);
+expectType<OrAll<readonly boolean[]>>(boolean);
+
+// Boundary cases
+expectType<OrAll<[]>>(false);
+
+expectType<OrAll<[any, any, false]>>(boolean);
+expectType<OrAll<[any, any, true]>>(true);
+expectType<OrAll<[any, any, any]>>(boolean);
+
+expectType<OrAll<[never, never, false]>>(false);
+expectType<OrAll<[never, never, true]>>(true);
+expectType<OrAll<[never, never, never]>>(false);
+
+// Errors with non-boolean or optional elements
+// @ts-expect-error
+type Error1 = OrAll<[1, 0]>;
+// @ts-expect-error
+type Error2 = OrAll<[true, false?]>;