Add OrAll type

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 {OrMultiple} from './source/or-multiple.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

@@ -183,6 +183,7 @@ Click the type names for complete docs.
 - [`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.
+- [`OrMultiple`](source/or-multiple.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-multiple.d.ts

@@ -0,0 +1,63 @@
+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 {OrMultiple} from 'type-fest';
+
+type FFT = OrMultiple<[false, false, true]>;
+//=> true
+
+type FFF = OrMultiple<[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, `OrMultiple<[false, boolean]>` expands to `OrMultiple<[false, true]> | OrMultiple<[false, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+```
+import type {OrMultiple} from 'type-fest';
+
+type A = OrMultiple<[false, boolean]>;
+//=> boolean
+
+type B = OrMultiple<[true, boolean]>;
+//=> true
+```
+
+Note: If `never` is passed as an element, it is treated as `false` and the result is computed accordingly.
+```
+import type {OrMultiple} from 'type-fest';
+
+type A = OrMultiple<[never, never, true]>;
+//=> true
+
+type B = OrMultiple<[never, never, false]>;
+//=> false
+
+type C = OrMultiple<[never, never, never]>;
+//=> false
+
+type D = OrMultiple<[never, never, boolean]>;
+//=> boolean
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+```
+import type {OrMultiple} from 'type-fest';
+
+type A = OrMultiple<[false, any]>;
+//=> boolean
+
+type B = OrMultiple<[true, any]>;
+//=> true
+```
+*/
+export type OrMultiple<T extends readonly boolean[]> = SomeExtend<T, true>;
+
+export {};

test-d/or-multiple.ts

@@ -0,0 +1,30 @@
+import {expectType} from 'tsd';
+import type {OrMultiple} from '../source/or-multiple.d.ts';
+
+declare const boolean: boolean;
+
+// Basic boolean combinations
+expectType<OrMultiple<[true, false]>>(true);
+expectType<OrMultiple<[false, true]>>(true);
+expectType<OrMultiple<[true, true]>>(true);
+expectType<OrMultiple<[false, false]>>(false);
+
+// Multiple elements in a tuple
+expectType<OrMultiple<[false, false, false, true]>>(true);
+expectType<OrMultiple<[false, false, false, false]>>(false);
+
+// `boolean` element
+expectType<OrMultiple<[false, false, boolean]>>(boolean);
+expectType<OrMultiple<[false, boolean, true]>>(true);
+expectType<OrMultiple<[boolean, boolean, boolean]>>(boolean);
+
+// Boundary cases
+expectType<OrMultiple<[]>>(false);
+
+expectType<OrMultiple<[any, any, false]>>(boolean);
+expectType<OrMultiple<[any, any, true]>>(true);
+expectType<OrMultiple<[any, any, any]>>(boolean);
+
+expectType<OrMultiple<[never, never, false]>>(false);
+expectType<OrMultiple<[never, never, true]>>(true);
+expectType<OrMultiple<[never, never, never]>>(false);