type-fest 4.13.0 → 4.14.0

package/index.d.ts

@@ -7,6 +7,7 @@ export * from './source/observable-like';
 // Utilities
 export type {KeysOfUnion} from './source/keys-of-union';
 export type {DistributedOmit} from './source/distributed-omit';
+export type {DistributedPick} from './source/distributed-pick';
 export type {EmptyObject, IsEmptyObject} from './source/empty-object';
 export type {NonEmptyObject} from './source/non-empty-object';
 export type {UnknownRecord} from './source/unknown-record';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.13.0",
+	"version": "4.14.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -16,7 +16,12 @@
 		"node": ">=16"
 	},
 	"scripts": {
-		"test": "xo && tsd && tsc && node script/test/source-files-extension.js"
+		"test:set-parameter-type": "tsc --noEmit test-d/set-parameter-type",
+		"test:source-files-extension": "node script/test/source-files-extension.js",
+		"test:tsc": "tsc",
+		"test:tsd": "tsd",
+		"test:xo": "xo",
+		"test": "run-p test:*"
 	},
 	"files": [
 		"index.d.ts",
@@ -37,9 +42,10 @@
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "~0.7.0",
 		"expect-type": "^0.15.0",
+		"npm-run-all2": "^6.1.2",
 		"tsd": "^0.28.1",
 		"typescript": "^5.2.2",
-		"xo": "^0.56.0"
+		"xo": "^0.58.0"
 	},
 	"xo": {
 		"rules": {
@@ -49,7 +55,14 @@
 			"import/extensions": "off",
 			"@typescript-eslint/no-redeclare": "off",
 			"@typescript-eslint/no-confusing-void-expression": "off",
-			"@typescript-eslint/no-unsafe-argument": "off"
+			"@typescript-eslint/no-unsafe-argument": "off",
+			"object-curly-newline": [
+				"error",
+				{
+					"multiline": true,
+					"consistent": true
+				}
+			]
 		}
 	},
 	"tsd": {

package/readme.md

@@ -183,6 +183,7 @@ Click the type names for complete docs.
 - [`Paths`](source/paths.d.ts) - Generate a union of all possible paths to properties in the given object.
 - [`SharedUnionFieldsDeep`](source/shared-union-fields-deep.d.ts) - Create a type with shared fields from a union of object types, deeply traversing nested structures.
 - [`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.
 
 ### Type Guard
 

package/source/asyncify.d.ts

@@ -29,4 +29,4 @@ const getFooAsync: AsyncifiedFooGetter = (someArg) => {
 
 @category Async
 */
-export type Asyncify<Fn extends (...arguments_: any[]) => any> = SetReturnType<Fn, Promise<Awaited<ReturnType<Fn>>>>;
+export type Asyncify<Function_ extends (...arguments_: any[]) => any> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;

package/source/distributed-pick.d.ts

@@ -0,0 +1,85 @@
+import type {KeysOfUnion} from './keys-of-union';
+
+/**
+Pick keys from a type, distributing the operation over a union.
+
+TypeScript's `Pick` doesn't distribute over unions, leading to the erasure of unique properties from union members when picking keys. This creates a type that only retains properties common to all union members, making it impossible to access member-specific properties after the Pick. Essentially, using `Pick` on a union type merges the types into a less specific one, hindering type narrowing and property access based on discriminants. This type solves that.
+
+Example:
+
+```
+type A = {
+	discriminant: 'A';
+	foo: {
+		bar: string;
+	};
+};
+
+type B = {
+	discriminant: 'B';
+	foo: {
+		baz: string;
+	};
+};
+
+type Union = A | B;
+
+type PickedUnion = Pick<Union, 'discriminant' | 'foo'>;
+//=> {discriminant: 'A' | 'B', foo: {bar: string} | {baz: string}}
+
+const pickedUnion: PickedUnion = createPickedUnion();
+
+if (pickedUnion.discriminant === 'A') {
+	// We would like to narrow `pickedUnion`'s type
+	// to `A` here, but we can't because `Pick`
+	// doesn't distribute over unions.
+
+	pickedUnion.foo.bar;
+	//=> Error: Property 'bar' does not exist on type '{bar: string} | {baz: string}'.
+}
+```
+
+@example
+```
+type A = {
+	discriminant: 'A';
+	foo: {
+		bar: string;
+	};
+	extraneous: boolean;
+};
+
+type B = {
+	discriminant: 'B';
+	foo: {
+		baz: string;
+	};
+	extraneous: boolean;
+};
+
+// Notice that `foo.bar` exists in `A` but not in `B`.
+
+type Union = A | B;
+
+type PickedUnion = DistributedPick<Union, 'discriminant' | 'foo'>;
+
+const pickedUnion: PickedUnion = createPickedUnion();
+
+if (pickedUnion.discriminant === 'A') {
+	pickedUnion.foo.bar;
+ 	//=> OK
+
+	pickedUnion.extraneous;
+	//=> Error: Property `extraneous` does not exist on type `Pick<A, 'discriminant' | 'foo'>`.
+
+	pickedUnion.foo.baz;
+	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`.
+}
+```
+
+@category Object
+*/
+export type DistributedPick<ObjectType, KeyType extends KeysOfUnion<ObjectType>> =
+	ObjectType extends unknown
+		? Pick<ObjectType, Extract<KeyType, keyof ObjectType>>
+		: never;

package/source/internal.d.ts

@@ -98,7 +98,7 @@ export type BuiltIns = Primitive | void | Date | RegExp;
 /**
 Matches non-recursive types.
 */
-export type NonRecursiveType = BuiltIns | Function | (new (...args: any[]) => unknown);
+export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
 
 /**
 Returns a boolean for whether the given type is a plain key-value object.

package/source/readonly-deep.d.ts

@@ -38,7 +38,7 @@ Note that types containing overloaded functions are not made deeply readonly due
 */
 export type ReadonlyDeep<T> = T extends BuiltIns
 	? T
-	: T extends new (...args: any[]) => unknown
+	: T extends new (...arguments_: any[]) => unknown
 		? T // Skip class constructors
 		: T extends (...arguments_: any[]) => unknown
 			? {} extends ReadonlyObjectDeep<T>

package/source/set-parameter-type.d.ts

@@ -1,5 +1,5 @@
 import type {IsUnknown} from './is-unknown';
-import type {StaticPartOfArray} from './internal';
+import type {StaticPartOfArray, VariablePartOfArray} from './internal';
 import type {UnknownArray} from './unknown-array';
 
 /**
@@ -32,7 +32,10 @@ type MergeObjectToArray<TArray extends UnknownArray, TObject, TArrayCopy extends
 		? number extends TObject['length']
 			? TObject
 			: {
-				[K in keyof TArray]: K extends keyof TObject ? TObject[K] : TArray[K]
+				[K in keyof TArray]:
+				number extends K
+					? VariablePartOfArray<TArray>[number]
+					: K extends keyof TObject ? TObject[K] : TArray[K]
 			}
 		: TObject extends object
 			// If `TObject` is a object witch key is number like `{0: string, 1: number}`
@@ -101,14 +104,14 @@ type HandleLog2 = SetParameterType<HandleMessage, {2: string}>;
 
 @category Function
 */
-export type SetParameterType<Fn extends (...arguments_: any[]) => unknown, P extends Record<number, unknown>> =
+export type SetParameterType<Function_ extends (...arguments_: any[]) => unknown, P extends Record<number, unknown>> =
 	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
-	Fn extends (this: infer ThisArg, ...arguments_: infer Arguments) => unknown
+	Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => unknown
 		? (
 			// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
 			// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
-			IsUnknown<ThisArg> extends true
-				? (...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Fn>
-				: (this: ThisArg, ...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Fn>
+			IsUnknown<ThisArgument> extends true
+				? (...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Function_>
+				: (this: ThisArgument, ...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Function_>
 		)
-		: Fn;	// This part should be unreachable
+		: Function_;	// This part should be unreachable

package/source/set-return-type.d.ts

@@ -17,13 +17,13 @@ type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | u
 
 @category Function
 */
-export type SetReturnType<Fn extends (...arguments_: any[]) => any, TypeToReturn> =
+export type SetReturnType<Function_ extends (...arguments_: any[]) => any, TypeToReturn> =
 	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
-	Fn extends (this: infer ThisArg, ...arguments_: infer Arguments) => any ? (
+	Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => any ? (
 		// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
 		// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
-		IsUnknown<ThisArg> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArg, ...arguments_: Arguments) => TypeToReturn
+		IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn
 	) : (
 		// This part should be unreachable, but we make it meaningful just in case…
-		(...arguments_: Parameters<Fn>) => TypeToReturn
+		(...arguments_: Parameters<Function_>) => TypeToReturn
 	);

package/source/tsconfig-json.d.ts

@@ -68,6 +68,7 @@ declare namespace TsConfigJson {
 			| 'es2022'
 			| 'esnext';
 
+		// eslint-disable-next-line unicorn/prevent-abbreviations
 		export type Lib =
 			| 'ES5'
 			| 'ES6'