type-fest 2.19.0 → 3.1.0

package/source/set-optional.d.ts

@@ -28,8 +28,8 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 */
 export type SetOptional<BaseType, Keys extends keyof BaseType> =
 	Simplify<
-		// Pick just the keys that are readonly from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be mutable from the base type and make them mutable.
-		Partial<Pick<BaseType, Keys>>
+	// Pick just the keys that are readonly from the base type.
+	Except<BaseType, Keys> &
+	// Pick the keys that should be mutable from the base type and make them mutable.
+	Partial<Pick<BaseType, Keys>>
 	>;

package/source/set-required.d.ts

@@ -28,8 +28,8 @@ type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
 */
 export type SetRequired<BaseType, Keys extends keyof BaseType> =
 	Simplify<
-		// Pick just the keys that are optional from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be required from the base type and make them required.
-		Required<Pick<BaseType, Keys>>
+	// Pick just the keys that are optional from the base type.
+	Except<BaseType, Keys> &
+	// Pick the keys that should be required from the base type and make them required.
+	Required<Pick<BaseType, Keys>>
 	>;

package/source/simplify.d.ts

@@ -1,23 +1,3 @@
-/**
-@see Simplify
-*/
-export interface SimplifyOptions {
-	/**
-	Do the simplification recursively.
-
-	@default false
-	*/
-	deep?: boolean;
-}
-
-// Flatten a type without worrying about the result.
-type Flatten<
-	AnyType,
-	Options extends SimplifyOptions = {},
-> = Options['deep'] extends true
-	? {[KeyType in keyof AnyType]: Simplify<AnyType[KeyType], Options>}
-	: {[KeyType in keyof AnyType]: AnyType[KeyType]};
-
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
@@ -75,9 +55,4 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 
 @category Object
 */
-export type Simplify<
-	AnyType,
-	Options extends SimplifyOptions = {},
-> = Flatten<AnyType> extends AnyType
-	? Flatten<AnyType, Options>
-	: AnyType;
+export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};

package/source/split.d.ts

@@ -25,5 +25,5 @@ export type Split<
 > = S extends `${infer Head}${Delimiter}${infer Tail}`
 	? [Head, ...Split<Tail, Delimiter>]
 	: S extends Delimiter
-	? []
-	: [S];
+		? []
+		: [S];

package/source/spread.d.ts

@@ -7,8 +7,8 @@ type SpreadObject<FirstType extends object, SecondType extends object> = {
 		? FirstType[Key] | Required<SecondType>[Key]
 		: FirstType[Key];
 } & Pick<
-	SecondType,
-	RequiredKeysOf<SecondType> | Exclude<keyof SecondType, keyof FirstType>
+SecondType,
+RequiredKeysOf<SecondType> | Exclude<keyof SecondType, keyof FirstType>
 >;
 
 type TupleOrArray = readonly [...unknown[]];
@@ -76,8 +76,8 @@ baz(fooBar);
 @category Object
 */
 export type Spread<
-    FirstType extends Spreadable,
-    SecondType extends Spreadable,
+	FirstType extends Spreadable,
+	SecondType extends Spreadable,
 > = FirstType extends TupleOrArray
 	? SecondType extends TupleOrArray
 		? SpreadTupleOrArray<FirstType, SecondType>

package/source/stringified.d.ts

@@ -7,7 +7,7 @@ Use-case: Changing interface values to strings in order to use them in a form mo
 ```
 import type {Stringified} from 'type-fest';
 
-type Car {
+type Car = {
 	model: string;
 	speed: number;
 }

package/source/tsconfig-json.d.ts

@@ -17,6 +17,8 @@ declare namespace TsConfigJson {
 			| 'ES2020'
 			| 'ES2022'
 			| 'ESNext'
+			| 'Node16'
+			| 'NodeNext'
 			| 'None'
 			// Lowercase alternatives
 			| 'commonjs'
@@ -28,6 +30,8 @@ declare namespace TsConfigJson {
 			| 'es2020'
 			| 'es2022'
 			| 'esnext'
+			| 'node16'
+			| 'nodenext'
 			| 'none';
 
 		export type NewLine =
@@ -181,13 +185,13 @@ declare namespace TsConfigJson {
 			| 'webworker.importscripts'
 			| 'webworker.iterable';
 
-		export interface Plugin {
+		export type Plugin = {
 			[key: string]: unknown;
 			/**
 			Plugin name.
 			*/
 			name?: string;
-		}
+		};
 
 		export type ImportsNotUsedAsValues =
 			| 'remove'
@@ -219,7 +223,7 @@ declare namespace TsConfigJson {
 
 	}
 
-	export interface CompilerOptions {
+	export type CompilerOptions = {
 		/**
 		The character set of the input files.
 
@@ -993,7 +997,7 @@ declare namespace TsConfigJson {
 		@default false
 		*/
 		explainFiles?: boolean;
-	}
+	};
 
 	namespace WatchOptions {
 		export type WatchFileKind =
@@ -1017,7 +1021,7 @@ declare namespace TsConfigJson {
 			| 'FixedChunkSize';
 	}
 
-	export interface WatchOptions {
+	export type WatchOptions = {
 
 		/**
 		Specify the strategy for watching individual files.
@@ -1058,14 +1062,14 @@ declare namespace TsConfigJson {
 		Specifies a list of files to exclude from watch
 		*/
 		excludeFiles?: string[];
-	}
+	};
 
 	/**
 	Auto type (.d.ts) acquisition options for this project.
 
 	Requires TypeScript version 2.1 or later.
 	*/
-	export interface TypeAcquisition {
+	export type TypeAcquisition = {
 		/**
 		Enable auto type acquisition.
 		*/
@@ -1080,9 +1084,9 @@ declare namespace TsConfigJson {
 		Specifies a list of type declarations to be excluded from auto type acquisition. For example, `['jquery', 'lodash']`.
 		*/
 		exclude?: string[];
-	}
+	};
 
-	export interface References {
+	export type References = {
 		/**
 		A normalized path on disk.
 		*/
@@ -1104,7 +1108,7 @@ declare namespace TsConfigJson {
 		True if it is intended that this reference form a circularity.
 		*/
 		circular?: boolean;
-	}
+	};
 }
 
 /**
@@ -1112,7 +1116,7 @@ Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs
 
 @category File
 */
-export interface TsConfigJson {
+export type TsConfigJson = {
 	/**
 	Instructs the TypeScript compiler how to compile `.ts` files.
 	*/
@@ -1169,4 +1173,4 @@ export interface TsConfigJson {
 	Requires TypeScript version 3.0 or later.
 	*/
 	references?: TsConfigJson.References[];
-}
+};

package/source/tuple-to-union.d.ts

@@ -0,0 +1,51 @@
+/**
+Convert a tuple into a union type of its elements.
+
+This can be useful when you have a fixed set of allowed values and want a type defining only the allowed values, but do not want to repeat yourself.
+
+@example
+```
+import type {TupleToUnion} from 'type-fest';
+
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = TupleToUnion<typeof destinations>;
+//=> 'a' | 'b' | 'c'
+
+function verifyDestination(destination: unknown): destination is Destination {
+	return destinations.includes(destination as any);
+}
+
+type RequestBody = {
+	deliverTo: Destination;
+};
+
+function verifyRequestBody(body: unknown): body is RequestBody {
+	const deliverTo = (body as any).deliverTo;
+	return typeof body === 'object' && body !== null && verifyDestination(deliverTo);
+}
+```
+
+Alternatively, you may use `typeof destinations[number]`. If `destinations` is a tuple, there is no difference. However if `destinations` is a string, the resulting type will the union of the characters in the string. Other types of `destinations` may result in a compile error. In comparison, TupleToUnion will return `never` if a tuple is not provided.
+
+@example
+```
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = typeof destinations[number];
+//=> 'a' | 'b' | 'c'
+
+const erroringType = new Set(['a', 'b', 'c']);
+
+type ErroringType = typeof erroringType[number];
+//=> Type 'Set<string>' has no matching index signature for type 'number'. ts(2537)
+
+const numberBool: { [n: number]: boolean } = { 1: true };
+
+type NumberBool = typeof numberBool[number];
+//=> boolean
+```
+
+@category Array
+*/
+export type TupleToUnion<ArrayType> = ArrayType extends readonly [infer Head, ...(infer Rest)] ? Head | TupleToUnion<Rest> : never;

package/source/union-to-intersection.d.ts

@@ -55,6 +55,6 @@ export type UnionToIntersection<Union> = (
 		: never
 		// Infer the `Intersection` type since TypeScript represents the positional
 		// arguments of unions of functions as an intersection of the union.
-	) extends ((mergedIntersection: infer Intersection) => void)
-		? Intersection
-		: never;
+) extends ((mergedIntersection: infer Intersection) => void)
+	? Intersection
+	: never;

package/source/writable.d.ts

@@ -33,8 +33,8 @@ type SomeWritable = Writable<Foo, 'b' | 'c'>;
 */
 export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
 	Simplify<
-		// Pick just the keys that are not writable from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
-		{-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
+	// Pick just the keys that are not writable from the base type.
+	Except<BaseType, Keys> &
+	// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
+	{-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
 	>;

package/source/mutable.d.ts

@@ -1,5 +0,0 @@
-import type {Writable} from './writable';
-
-/** @deprecated @see Writable */
-export type Mutable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
-	Writable<BaseType, Keys>;

package/source/promise-value.d.ts

@@ -1,29 +0,0 @@
-/**
-@deprecated Use the built-in [`Awaited` type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#the-awaited-type-and-promise-improvements) instead.
-
-Returns the type that is wrapped inside a `Promise` type.
-If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
-If the type is not a `Promise`, the type itself is returned.
-
-@example
-```
-import type {PromiseValue} from 'type-fest';
-
-type AsyncData = Promise<string>;
-let asyncData: AsyncData = Promise.resolve('ABC');
-
-type Data = PromiseValue<AsyncData>;
-let data: Data = await asyncData;
-
-// Here's an example that shows how this type reacts to non-Promise types.
-type SyncData = PromiseValue<string>;
-let syncData: SyncData = getSyncData();
-
-// Here's an example that shows how this type reacts to recursive Promise types.
-type RecursiveAsyncData = Promise<Promise<string>>;
-let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = await Promise.resolve(Promise.resolve('ABC'));
-```
-
-@category Async
-*/
-export type PromiseValue<PromiseType> = PromiseType extends PromiseLike<infer Value> ? PromiseValue<Value> : PromiseType;