type-fest 4.30.0 → 4.30.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.30.0",
+	"version": "4.30.2",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -64,6 +64,10 @@
 					"multiline": true,
 					"consistent": true
 				}
+			],
+			"import/consistent-type-specifier-style": [
+				"error",
+				"prefer-top-level"
 			]
 		}
 	},

package/readme.md

@@ -194,7 +194,6 @@ Click the type names for complete docs.
 - [`TaggedUnion`](source/tagged-union.d.ts) - Create a union of types that share a common discriminant property.
 - [`IntRange`](source/int-range.d.ts) - Generate a union of numbers (includes the start and excludes the end).
 - [`IntClosedRange`](source/int-closed-range.d.ts) - Generate a union of numbers (includes the start and the end).
-- [`IntRange`](source/int-range.d.ts) - Generate a union of numbers.
 - [`ArrayIndices`](source/array-indices.d.ts) - Provides valid indices for a constant array or tuple.
 - [`ArrayValues`](source/array-values.d.ts) - Provides all values for a constant array or tuple.
 - [`ArraySplice`](source/array-splice.d.ts) - Creates a new array type by adding or removing elements at a specified index range in the original array.

package/source/arrayable.d.ts

@@ -13,7 +13,7 @@ function bundle(input: string, output: Arrayable<string>) {
 	// …
 
 	for (const output of outputList) {
-	  console.log(`write to: ${output}`);
+		console.log(`write to: ${output}`);
 	}
 }
 
@@ -23,4 +23,7 @@ bundle('src/index.js', ['dist/index.cjs', 'dist/index.mjs']);
 
 @category Array
 */
-export type Arrayable<T> = T | readonly T[];
+export type Arrayable<T> =
+T
+// TODO: Use `readonly T[]` when this issue is resolved: https://github.com/microsoft/TypeScript/issues/17002
+| T[];

package/source/set-optional.d.ts

@@ -27,9 +27,11 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 @category Object
 */
 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>>
-	>;
+	BaseType extends unknown // To distribute `BaseType` when it's a union type.
+		? 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<Except<BaseType, Exclude<keyof BaseType, Keys>>>
+		>
+		: never;

package/source/set-readonly.d.ts

@@ -33,6 +33,6 @@ export type SetReadonly<BaseType, Keys extends keyof BaseType> =
 	BaseType extends unknown
 		? Simplify<
 		Except<BaseType, Keys> &
-		Readonly<Pick<BaseType, Keys>>
+		Readonly<Except<BaseType, Exclude<keyof BaseType, Keys>>>
 		>
 		: never;

package/source/set-required.d.ts

@@ -35,6 +35,6 @@ export type SetRequired<BaseType, Keys extends keyof BaseType> =
 		// 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>>
+		Required<Except<BaseType, Exclude<keyof BaseType, Keys>>>
 		>
 		: never;

package/source/shared-union-fields.d.ts

@@ -1,5 +1,6 @@
 import type {NonRecursiveType, IsUnion} from './internal';
 import type {IsNever} from './is-never';
+import type {Simplify} from './simplify';
 import type {UnknownArray} from './unknown-array';
 
 /**
@@ -63,21 +64,12 @@ function displayPetInfo(petInfo: SharedUnionFields<Cat | Dog>) {
 @category Union
 */
 export type SharedUnionFields<Union> =
-// If `Union` is not a union type, return `Union` directly.
-IsUnion<Union> extends false
-	? Union
-	// `Union extends` will convert `Union`
-	// to a [distributive conditionaltype](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	// But this is not what we want, so we need to wrap `Union` with `[]` to prevent it.
-	: [Union] extends [NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray]
-		? Union
-		: [Union] extends [object]
-			// `keyof Union` can extract the same key in union type, if there is no same key, return never.
-			? keyof Union extends infer Keys
-				? IsNever<Keys> extends false
-					? {
-						[Key in keyof Union]: Union[Key]
-					}
-					: {}
-				: Union
-			: Union;
+Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+		?
+		| SkippedMembers
+		| (IsNever<RelevantMembers> extends true
+			? never
+			: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
+		: never
+	: never;

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

@@ -18,6 +18,8 @@ UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
 /**
 Convert a union type into an unordered tuple type of its elements.
 
+"Unordered" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.
+
 This can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.
 
 @example