type-fest 4.41.0 → 5.0.1

package/source/omit-deep.d.ts

@@ -1,12 +1,12 @@
-import type {ArraySplice} from './array-splice';
-import type {ExactKey, IsArrayReadonly, NonRecursiveType, SetArrayAccess, ToString} from './internal';
-import type {IsEqual} from './is-equal';
-import type {IsNever} from './is-never';
-import type {LiteralUnion} from './literal-union';
-import type {Paths} from './paths';
-import type {SimplifyDeep} from './simplify-deep';
-import type {UnionToTuple} from './union-to-tuple';
-import type {UnknownArray} from './unknown-array';
+import type {ArraySplice} from './array-splice.d.ts';
+import type {ExactKey, IsArrayReadonly, NonRecursiveType, SetArrayAccess, ToString} from './internal/index.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {LiteralUnion} from './literal-union.d.ts';
+import type {Paths} from './paths.d.ts';
+import type {SimplifyDeep} from './simplify-deep.d.ts';
+import type {UnionToTuple} from './union-to-tuple.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Omit properties from a deeply-nested object.
@@ -92,8 +92,8 @@ type AddressInfo = OmitDeep<Info1, 'address.1.foo'>;
 */
 export type OmitDeep<T, PathUnion extends LiteralUnion<Paths<T>, string>> =
 	SimplifyDeep<
-	OmitDeepHelper<T, UnionToTuple<PathUnion>>,
-	UnknownArray>;
+		OmitDeepHelper<T, UnionToTuple<PathUnion>>,
+		UnknownArray>;
 
 /**
 Internal helper for {@link OmitDeep}.

package/source/opaque.d.ts

@@ -1 +1 @@
-export * from './tagged';
+export type * from './tagged.d.ts';

package/source/optional-keys-of.d.ts

@@ -1,3 +1,5 @@
+import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
+
 /**
 Extract all optional keys from the given type.
 
@@ -31,9 +33,12 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-export type OptionalKeysOf<BaseType extends object> =
-	BaseType extends unknown // For distributing `BaseType`
-		? (keyof {
-			[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never
-		}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+export type OptionalKeysOf<Type extends object> =
+	Type extends unknown // For distributing `Type`
+		? (keyof {[Key in keyof Type as
+			IsOptionalKeyOf<Type, Key> extends false
+				? never
+				: Key
+			]: never
+		}) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
 		: never; // Should never happen

package/source/or.d.ts

@@ -1,4 +1,5 @@
-import type {IsEqual} from './is-equal';
+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.
@@ -9,17 +10,76 @@ Use-case: Constructing complex conditional types where multiple conditions must
 ```
 import type {Or} from 'type-fest';
 
-Or<true, false>;
+type TT = Or<true, false>;
 //=> true
 
-Or<false, false>;
+type TF = Or<true, false>;
+//=> true
+
+type FT = Or<false, true>;
+//=> true
+
+type FF = Or<false, 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`).
+@example
+```
+import type {And} from 'type-fest';
+
+type A = Or<false, boolean>;
+//=> boolean
+
+type B = Or<boolean, false>;
+//=> boolean
+
+type C = Or<true, boolean>;
+//=> true
+
+type D = Or<boolean, true>;
+//=> true
+
+type E = Or<boolean, boolean>;
+//=> boolean
+```
+
+Note: If `never` is passed as an argument, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type A = Or<true, never>;
+//=> true
+
+type B = Or<never, true>;
+//=> true
+
+type C = Or<false, never>;
+//=> false
+
+type D = Or<never, false>;
+//=> false
+
+type E = Or<boolean, never>;
+//=> boolean
+
+type F = Or<never, boolean>;
+//=> boolean
+
+type G = Or<never, never>;
 //=> false
 ```
 
 @see {@link And}
 */
-export type Or<A extends boolean, B extends boolean> = [A, B][number] extends false
-	? false
-	: true extends [IsEqual<A, true>, IsEqual<B, true>][number]
+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`
+
+export type _Or<A extends boolean, B extends boolean> = A extends true
+	? true
+	: B extends true
 		? true
-		: never;
+		: false;

package/source/override-properties.d.ts

@@ -1,4 +1,4 @@
-import type {Merge} from './merge';
+import type {Merge} from './merge.d.ts';
 
 /**
 Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.

package/source/package-json.d.ts

@@ -1,5 +1,5 @@
-import type {LiteralUnion} from './literal-union';
-import type {JsonObject, JsonValue} from './basic';
+import type {LiteralUnion} from './literal-union.d.ts';
+import type {JsonObject, JsonValue} from './json-value.d.ts';
 
 declare namespace PackageJson {
 	/**
@@ -211,7 +211,7 @@ declare namespace PackageJson {
 	/**
 	A mapping of conditions and the paths to which they resolve.
 	*/
-	type ExportConditions = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+	type ExportConditions = {
 		[condition: string]: Exports;
 	};
 
@@ -219,15 +219,15 @@ declare namespace PackageJson {
 	Entry points of a module, optionally with conditions and subpath exports.
 	*/
 	export type Exports =
-	| null
-	| string
-	| Array<string | ExportConditions>
-	| ExportConditions;
+		| null
+		| string
+		| Array<string | ExportConditions>
+		| ExportConditions;
 
 	/**
 	Import map entries of a module, optionally with conditions and subpath imports.
 	*/
-	export type Imports = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+	export type Imports = {
 		[key: `#${string}`]: Exports;
 	};
 
@@ -242,19 +242,19 @@ declare namespace PackageJson {
 		A module ID with untranspiled code that is the primary entry point to the program.
 		*/
 		esnext?:
-		| string
-		| {
-			[moduleName: string]: string | undefined;
-			main?: string;
-			browser?: string;
-		};
+			| string
+			| {
+				[moduleName: string]: string | undefined;
+				main?: string;
+				browser?: string;
+			};
 
 		/**
 		A hint to JavaScript bundlers or component tools when packaging modules for client side use.
 		*/
 		browser?:
-		| string
-		| Partial<Record<string, string | false>>;
+			| string
+			| Partial<Record<string, string | false>>;
 
 		/**
 		Denote which files in your project are "pure" and therefore safe for Webpack to prune if unused.
@@ -426,8 +426,8 @@ declare namespace PackageJson {
 		The executable files that should be installed into the `PATH`.
 		*/
 		bin?:
-		| string
-		| Partial<Record<string, string>>;
+			| string
+			| Partial<Record<string, string>>;
 
 		/**
 		Filenames to put in place for the `man` program to find.
@@ -443,18 +443,18 @@ declare namespace PackageJson {
 		Location for the code repository.
 		*/
 		repository?:
-		| string
-		| {
-			type: string;
-			url: string;
+			| string
+			| {
+				type: string;
+				url: string;
 
-			/**
+				/**
 			Relative path to package.json if it is placed in non-root directory (for example if it is part of a monorepo).
 
 			[Read more.](https://github.com/npm/rfcs/blob/latest/implemented/0010-monorepo-subdirectory-declaration.md)
 			*/
-			directory?: string;
-		};
+				directory?: string;
+			};
 
 		/**
 		Script commands that are run at various times in the lifecycle of the package. The key is the lifecycle event, and the value is the command to run at that point.
@@ -517,50 +517,50 @@ declare namespace PackageJson {
 		Operating systems the module runs on.
 		*/
 		os?: Array<LiteralUnion<
-		| 'aix'
-		| 'darwin'
-		| 'freebsd'
-		| 'linux'
-		| 'openbsd'
-		| 'sunos'
-		| 'win32'
-		| '!aix'
-		| '!darwin'
-		| '!freebsd'
-		| '!linux'
-		| '!openbsd'
-		| '!sunos'
-		| '!win32',
-		string
+			| 'aix'
+			| 'darwin'
+			| 'freebsd'
+			| 'linux'
+			| 'openbsd'
+			| 'sunos'
+			| 'win32'
+			| '!aix'
+			| '!darwin'
+			| '!freebsd'
+			| '!linux'
+			| '!openbsd'
+			| '!sunos'
+			| '!win32',
+			string
 		>>;
 
 		/**
 		CPU architectures the module runs on.
 		*/
 		cpu?: Array<LiteralUnion<
-		| 'arm'
-		| 'arm64'
-		| 'ia32'
-		| 'mips'
-		| 'mipsel'
-		| 'ppc'
-		| 'ppc64'
-		| 's390'
-		| 's390x'
-		| 'x32'
-		| 'x64'
-		| '!arm'
-		| '!arm64'
-		| '!ia32'
-		| '!mips'
-		| '!mipsel'
-		| '!ppc'
-		| '!ppc64'
-		| '!s390'
-		| '!s390x'
-		| '!x32'
-		| '!x64',
-		string
+			| 'arm'
+			| 'arm64'
+			| 'ia32'
+			| 'mips'
+			| 'mipsel'
+			| 'ppc'
+			| 'ppc64'
+			| 's390'
+			| 's390x'
+			| 'x32'
+			| 'x64'
+			| '!arm'
+			| '!arm64'
+			| '!ia32'
+			| '!mips'
+			| '!mipsel'
+			| '!ppc'
+			| '!ppc64'
+			| '!s390'
+			| '!s390x'
+			| '!x32'
+			| '!x64',
+			string
 		>>;
 
 		/**
@@ -583,20 +583,20 @@ declare namespace PackageJson {
 		/**
 		Describes and notifies consumers of a package's monetary support information.
 
-		[Read more.](https://github.com/npm/rfcs/blob/latest/accepted/0017-add-funding-support.md)
+		[Read more.](https://github.com/npm/rfcs/blob/main/implemented/0017-add-funding-support.md)
 		*/
 		funding?: string | {
 			/**
 			The type of funding.
 			*/
 			type?: LiteralUnion<
-			| 'github'
-			| 'opencollective'
-			| 'patreon'
-			| 'individual'
-			| 'foundation'
-			| 'corporation',
-			string
+				| 'github'
+				| 'opencollective'
+				| 'patreon'
+				| 'individual'
+				| 'foundation'
+				| 'corporation',
+				string
 			>;
 
 			/**
@@ -667,10 +667,10 @@ Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-j
 @category File
 */
 export type PackageJson =
-JsonObject &
-PackageJson.NodeJsStandard &
-PackageJson.PackageJsonStandard &
-PackageJson.NonStandardEntryPoints &
-PackageJson.TypeScriptConfiguration &
-PackageJson.YarnConfiguration &
-PackageJson.JSPMConfiguration;
+	JsonObject &
+	PackageJson.NodeJsStandard &
+	PackageJson.PackageJsonStandard &
+	PackageJson.NonStandardEntryPoints &
+	PackageJson.TypeScriptConfiguration &
+	PackageJson.YarnConfiguration &
+	PackageJson.JSPMConfiguration;

package/source/partial-deep.d.ts

@@ -1,5 +1,5 @@
-import type {ApplyDefaultOptions, BuiltIns} from './internal';
-import type {IsNever} from './is-never';
+import type {ApplyDefaultOptions, BuiltIns} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 @see {@link PartialDeep}
@@ -18,10 +18,10 @@ export type PartialDeepOptions = {
 	- When set to `true`, elements of non-tuple arrays can be `undefined`.
 	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
 
-	@default true
+	@default false
 
 	@example
-	You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+	You can allow `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}` as the second type argument:
 
 	```
 	import type {PartialDeep} from 'type-fest';
@@ -30,10 +30,9 @@ export type PartialDeepOptions = {
 		languages: string[];
 	};
 
-	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
+	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}>;
 
-	partialSettings.languages = [undefined]; // Error
-	partialSettings.languages = []; // Ok
+	partialSettings.languages = [undefined]; // OK
 	```
 	*/
 	readonly allowUndefinedInNonTupleArrays?: boolean;
@@ -41,7 +40,7 @@ export type PartialDeepOptions = {
 
 type DefaultPartialDeepOptions = {
 	recurseIntoArrays: false;
-	allowUndefinedInNonTupleArrays: true;
+	allowUndefinedInNonTupleArrays: false;
 };
 
 /**
@@ -55,19 +54,19 @@ Use-cases:
 ```
 import type {PartialDeep} from 'type-fest';
 
-const settings: Settings = {
+let settings = {
 	textEditor: {
 		fontSize: 14,
 		fontColor: '#000000',
-		fontWeight: 400
+		fontWeight: 400,
 	},
 	autocomplete: false,
-	autosave: true
+	autosave: true,
 };
 
-const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
-	return {...settings, ...savedSettings};
-}
+const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
+	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
+);
 
 settings = applySavedSettings({textEditor: {fontWeight: 500}});
 ```
@@ -77,13 +76,15 @@ By default, this does not affect elements in array and tuple types. You can chan
 ```
 import type {PartialDeep} from 'type-fest';
 
-type Settings = {
-	languages: string[];
-}
+type Shape = {
+	dimensions: [number, number];
+};
 
-const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
-	languages: [undefined]
+const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
+	dimensions: [], // OK
 };
+
+partialShape.dimensions = [15]; // OK
 ```
 
 @see {@link PartialDeepOptions}
@@ -147,5 +148,5 @@ type PartialObjectDeep<ObjectType extends object, Options extends Required<Parti
 	(ObjectType extends (...arguments_: any) => unknown
 		? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType>
 		: {}) & ({
-		[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
-	});
+			[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
+		});

package/source/partial-on-undefined-deep.d.ts

@@ -1,6 +1,7 @@
-import type {IfUnknown} from './if-unknown';
-import type {ApplyDefaultOptions, BuiltIns, LiteralKeyOf} from './internal';
-import type {Merge} from './merge';
+import type {If} from './if.d.ts';
+import type {ApplyDefaultOptions, BuiltIns, LiteralKeyOf} from './internal/index.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {Merge} from './merge.d.ts';
 
 /**
 @see PartialOnUndefinedDeep
@@ -55,7 +56,7 @@ export type PartialOnUndefinedDeep<T, Options extends PartialOnUndefinedDeepOpti
 	_PartialOnUndefinedDeep<T, ApplyDefaultOptions<PartialOnUndefinedDeepOptions, DefaultPartialOnUndefinedDeepOptions, Options>>;
 
 type _PartialOnUndefinedDeep<T, Options extends Required<PartialOnUndefinedDeepOptions>> = T extends Record<any, any> | undefined
-	? {[KeyType in keyof T as undefined extends T[KeyType] ? IfUnknown<T[KeyType], never, KeyType> : never]?: PartialOnUndefinedDeepValue<T[KeyType], Options>} extends infer U // Make a partial type with all value types accepting undefined (and set them optional)
+	? {[KeyType in keyof T as undefined extends T[KeyType] ? If<IsUnknown<T[KeyType]>, never, KeyType> : never]?: PartialOnUndefinedDeepValue<T[KeyType], Options>} extends infer U // Make a partial type with all value types accepting undefined (and set them optional)
 		? Merge<{[KeyType in keyof T as KeyType extends LiteralKeyOf<U> ? never : KeyType]: PartialOnUndefinedDeepValue<T[KeyType], Options>}, U> // Join all remaining keys not treated in U
 		: never // Should not happen
 	: T;

package/source/pascal-case.d.ts

@@ -1,5 +1,5 @@
-import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case';
-import type {ApplyDefaultOptions} from './internal';
+import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
 
 /**
 Converts a string literal to pascal-case.
@@ -11,10 +11,11 @@ import type {PascalCase} from 'type-fest';
 // Simple
 
 const someVariable: PascalCase<'foo-bar'> = 'FooBar';
+const preserveConsecutiveUppercase: PascalCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'FooBARBaz';
 
 // Advanced
 
-type PascalCaseProps<T> = {
+type PascalCasedProperties<T> = {
 	[K in keyof T as PascalCase<K>]: T[K]
 };
 
@@ -22,12 +23,18 @@ interface RawOptions {
 	'dry-run': boolean;
 	'full_family_name': string;
 	foo: number;
-}
+	BAR: string;
+	QUZ_QUX: number;
+	'OTHER-FIELD': boolean;
+};
 
-const dbResult: CamelCasedProperties<ModelProps> = {
+const dbResult: PascalCasedProperties<RawOptions> = {
 	DryRun: true,
 	FullFamilyName: 'bar.js',
-	Foo: 123
+	Foo: 123,
+	Bar: 'foo',
+	QuzQux: 6,
+	OtherField: false,
 };
 ```
 

package/source/pascal-cased-properties-deep.d.ts

@@ -1,6 +1,6 @@
-import type {CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {PascalCase} from './pascal-case';
+import type {CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {PascalCase} from './pascal-case.d.ts';
 
 /**
 Convert object properties to pascal case recursively.
@@ -40,6 +40,14 @@ const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
+
+const preserveConsecutiveUppercase: PascalCasedPropertiesDeep<{fooBAR: {fooBARBiz: [{fooBARBaz: string}]}}, {preserveConsecutiveUppercase: true}> = {
+	FooBAR: {
+		FooBARBiz: [{
+			FooBARBaz: 'string',
+		}],
+	},
+};
 ```
 
 @category Change case

package/source/pascal-cased-properties.d.ts

@@ -1,6 +1,6 @@
-import type {CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {PascalCase} from './pascal-case';
+import type {CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {PascalCase} from './pascal-case.d.ts';
 
 /**
 Convert object properties to pascal case but not recursively.
@@ -23,6 +23,10 @@ const result: PascalCasedProperties<User> = {
 	UserId: 1,
 	UserName: 'Tom',
 };
+
+const preserveConsecutiveUppercase: PascalCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
+	FooBAR: 'string',
+};
 ```
 
 @category Change case