type-fest 2.18.1 → 2.19.0

package/index.d.ts

@@ -23,6 +23,7 @@ export {Opaque, UnwrapOpaque} from './source/opaque';
 export {InvariantOf} from './source/invariant-of';
 export {SetOptional} from './source/set-optional';
 export {SetRequired} from './source/set-required';
+export {SetNonNullable} from './source/set-non-nullable';
 export {ValueOf} from './source/value-of';
 export {PromiseValue} from './source/promise-value';
 export {AsyncReturnType} from './source/async-return-type';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "2.18.1",
+	"version": "2.19.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/readme.md

@@ -142,6 +142,7 @@ Click the type names for complete docs.
 - [`InvariantOf`](source/invariant-of.d.ts) - Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
 - [`SetOptional`](source/set-optional.d.ts) - Create a type that makes the given keys optional.
 - [`SetRequired`](source/set-required.d.ts) - Create a type that makes the given keys required.
+- [`SetNonNullable`](source/set-non-nullable.d.ts) - Create a type that makes the given keys non-nullable.
 - [`ValueOf`](source/value-of.d.ts) - Create a union of the given object's values, and optionally specify which keys to get the values from.
 - [`ConditionalKeys`](source/conditional-keys.d.ts) - Extract keys from a shape where values extend the given `Condition` type.
 - [`ConditionalPick`](source/conditional-pick.d.ts) - Like `Pick` except it selects properties from a shape where the values extend the given `Condition` type.

package/source/exact.d.ts

@@ -1,6 +1,29 @@
-import type {Primitive} from './primitive';
 import type {KeysOfUnion} from './internal';
 
+/**
+Extract the element of an array that also works for array union.
+
+Returns `never` if T is not an array.
+
+It creates a type-safe way to access the element type of `unknown` type.
+*/
+type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+
+/**
+Extract the object field type if T is an object and K is a key of T, return `never` otherwise.
+
+It creates a type-safe way to access the member type of `unknown` type.
+*/
+type ObjectValue<T, K> = K extends keyof T ? T[K] : never;
+
+/**
+Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.
+- Generate a list of keys that exists in `InputType` but not in `ParameterType`.
+- Mark these excess keys as `never`.
+*/
+type ExactObject<ParameterType, InputType> = {[Key in keyof ParameterType]: Exact<ParameterType[Key], ObjectValue<InputType, Key>>}
+	& Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+
 /**
 Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared.
 
@@ -41,11 +64,10 @@ onlyAcceptNameImproved(invalidInput); // Compilation error
 
 @category Utilities
 */
-export type Exact<ParameterType, InputType extends ParameterType> = ParameterType extends Primitive
-	? ParameterType
-	/*
-	Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.
-	- Generate a list of keys that exists in `InputType` but not in `ParameterType`.
-	- Mark these excess keys as `never`.
-	*/
-	: {[Key in keyof ParameterType]: Exact<ParameterType[Key], InputType[Key]>} & Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+export type Exact<ParameterType, InputType> =
+	// Convert union of array to array of union: A[] & B[] => (A & B)[]
+	ParameterType extends unknown[] ? Array<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+	// In TypeScript, Array is a subtype of ReadonlyArray, so always test Array before ReadonlyArray.
+	: ParameterType extends readonly unknown[] ? ReadonlyArray<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+	: ParameterType extends object ? ExactObject<ParameterType, InputType>
+	: ParameterType;

package/source/package-json.d.ts

@@ -223,15 +223,17 @@ declare namespace PackageJson {
 		string
 	>;
 
+	type ExportConditions = {[condition in ExportCondition]: Exports};
+
 	/**
 	Entry points of a module, optionally with conditions and subpath exports.
 	*/
 	export type Exports =
 	| null
 	| string
-	| string[]
-	| {[key in ExportCondition]: Exports}
-	| {[key: string]: Exports}; // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+	| Array<string | ExportConditions>
+	| ExportConditions
+	| {[path: string]: Exports}; // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
 
 	/**
 	Import map entries of a module, optionally with conditions.

package/source/set-non-nullable.d.ts

@@ -0,0 +1,35 @@
+import type {Except} from './except';
+import type {Simplify} from './simplify';
+
+/**
+Create a type that makes the given keys non-nullable. The remaining keys are kept as is.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are non-nullable.
+
+@example
+```
+import type {SetNonNullable} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string | undefined;
+	c?: boolean | null;
+}
+
+type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
+// type SomeNonNullable = {
+// 	a: number;
+// 	b: string; // Can no longer be undefined.
+// 	c?: boolean; // Can no longer be null, but is still optional.
+// }
+```
+
+@category Object
+*/
+export type SetNonNullable<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 non-nullable from the base type and make them non-nullable.
+		{[Key in Keys]: NonNullable<BaseType[Key]>}
+	>;