Or/And: Fix documentation errors and add link to Xor (#1261)

Co-authored-by: Sindre Sorhus <[email protected]>
Co-authored-by: Som Shekhar Mukherjee <[email protected]>

Author: 3 people

readme.md

@@ -179,7 +179,7 @@ Click the type names for complete docs.
 - [`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 are 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.
 - [`AllExtend`](source/all-extend.d.ts) - Returns a boolean for whether every element in an array type extends another type.
 - [`NonEmptyTuple`](source/non-empty-tuple.d.ts) - Matches any non-empty tuple.

source/and.d.ts

@@ -46,6 +46,7 @@ type E = And<boolean, boolean>;
 ```
 
 Note: If either of the types is `never`, the result becomes `false`.
+
 @example
 ```
 import type {And} from 'type-fest';
@@ -73,6 +74,7 @@ type G = And<never, never>;
 ```
 
 @see {@link Or}
+@see {@link Xor}
 */
 export type And<A extends boolean, B extends boolean> = AllExtend<[A, B], true>;
 

source/or.d.ts

@@ -2,15 +2,15 @@ import type {If} from './if.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
-Returns a boolean for whether either of two given types are true.
+Returns a boolean for whether either of two given types is true.
 
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+Use-case: Constructing complex conditional types where at least one condition must be satisfied.
 
 @example
 ```
 import type {Or} from 'type-fest';
 
-type TT = Or<true, false>;
+type TT = Or<true, true>;
 //=> true
 
 type TF = Or<true, false>;
@@ -24,10 +24,11 @@ type FF = Or<false, false>;
 ```
 
 Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
-For example, `And<false, boolean>` expands to `And<false, true> | And<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+For example, `Or<false, boolean>` expands to `Or<false, true> | Or<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
 @example
 ```
-import type {And} from 'type-fest';
+import type {Or} from 'type-fest';
 
 type A = Or<false, boolean>;
 //=> boolean
@@ -74,6 +75,7 @@ type G = Or<never, never>;
 ```
 
 @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`

test-d/and.ts

@@ -1,25 +1,27 @@
 import {expectType} from 'tsd';
 import type {And} from '../source/and.d.ts';
 
+declare const boolean: boolean;
+
 expectType<And<true, true>>(true);
 expectType<And<true, false>>(false);
 expectType<And<false, true>>(false);
 expectType<And<false, false>>(false);
 
-expectType<And<true, boolean>>({} as boolean);
-expectType<And<boolean, true>>({} as boolean);
+expectType<And<true, boolean>>(boolean);
+expectType<And<boolean, true>>(boolean);
 expectType<And<false, boolean>>(false);
 expectType<And<boolean, false>>(false);
-expectType<And<boolean, boolean>>({} as boolean);
+expectType<And<boolean, boolean>>(boolean);
 
 // Boundary cases
-expectType<And<any, true>>({} as boolean);
-expectType<And<true, any>>({} as boolean);
+expectType<And<any, true>>(boolean);
+expectType<And<true, any>>(boolean);
 expectType<And<any, false>>(false);
 expectType<And<false, any>>(false);
-expectType<And<any, boolean>>({} as boolean);
-expectType<And<boolean, any>>({} as boolean);
-expectType<And<any, any>>({} as boolean);
+expectType<And<any, boolean>>(boolean);
+expectType<And<boolean, any>>(boolean);
+expectType<And<any, any>>(boolean);
 
 expectType<And<never, true>>(false);
 expectType<And<true, never>>(false);

test-d/or.ts

@@ -1,29 +1,32 @@
 import {expectType} from 'tsd';
 import type {Or} from '../source/or.d.ts';
 
+declare const boolean: boolean;
+
 expectType<Or<true, true>>(true);
 expectType<Or<true, false>>(true);
 expectType<Or<false, true>>(true);
 expectType<Or<false, false>>(false);
 
 expectType<Or<true, boolean>>(true);
 expectType<Or<boolean, true>>(true);
-expectType<Or<false, boolean>>({} as boolean);
-expectType<Or<boolean, false>>({} as boolean);
-expectType<Or<boolean, boolean>>({} as boolean);
+expectType<Or<false, boolean>>(boolean);
+expectType<Or<boolean, false>>(boolean);
+expectType<Or<boolean, boolean>>(boolean);
 
+// Boundary cases
 expectType<Or<true, any>>(true);
 expectType<Or<any, true>>(true);
-expectType<Or<false, any>>({} as boolean);
-expectType<Or<any, false>>({} as boolean);
-expectType<Or<boolean, any>>({} as boolean);
-expectType<Or<any, boolean>>({} as boolean);
-expectType<Or<any, any>>({} as boolean);
+expectType<Or<false, any>>(boolean);
+expectType<Or<any, false>>(boolean);
+expectType<Or<boolean, any>>(boolean);
+expectType<Or<any, boolean>>(boolean);
+expectType<Or<any, any>>(boolean);
 
 expectType<Or<true, never>>(true);
 expectType<Or<never, true>>(true);
 expectType<Or<false, never>>(false);
 expectType<Or<never, false>>(false);
-expectType<Or<boolean, never>>({} as boolean);
-expectType<Or<never, boolean>>({} as boolean);
+expectType<Or<boolean, never>>(boolean);
+expectType<Or<never, boolean>>(boolean);
 expectType<Or<never, never>>(false);