type-fest 4.39.1 → 4.40.1

package/index.d.ts

@@ -11,8 +11,11 @@ export type {DistributedPick} from './source/distributed-pick';
 export type {EmptyObject, IsEmptyObject} from './source/empty-object';
 export type {IfEmptyObject} from './source/if-empty-object';
 export type {NonEmptyObject} from './source/non-empty-object';
+export type {NonEmptyString} from './source/non-empty-string';
 export type {UnknownRecord} from './source/unknown-record';
 export type {UnknownArray} from './source/unknown-array';
+export type {UnknownSet} from './source/unknown-set';
+export type {UnknownMap} from './source/unknown-map';
 export type {Except} from './source/except';
 export type {TaggedUnion} from './source/tagged-union';
 export type {Writable} from './source/writable';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.39.1",
+	"version": "4.40.1",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -43,8 +43,8 @@
 	"devDependencies": {
 		"expect-type": "^1.1.0",
 		"npm-run-all2": "^7.0.1",
-		"tsd": "^0.31.2",
-		"typescript": "~5.8.2",
+		"tsd": "^0.32.0",
+		"typescript": "~5.8.3",
 		"xo": "^0.60.0"
 	},
 	"xo": {

package/readme.md

@@ -33,16 +33,6 @@
 			</a>
 			<br>
 			<br>
-			<a href="https://transloadit.com?utm_source=sindresorhus&utm_medium=referral&utm_campaign=sponsorship&utm_content=type-fest">
-				<picture>
-					<source width="350" media="(prefers-color-scheme: dark)" srcset="https://sindresorhus.com/assets/thanks/transloadit-logo-dark.svg">
-					<source width="350" media="(prefers-color-scheme: light)" srcset="https://sindresorhus.com/assets/thanks/transloadit-logo.svg">
-					<img width="350" src="https://sindresorhus.com/assets/thanks/transloadit-logo.svg" alt="Transloadit logo">
-				</picture>
-			</a>
-			<br>
-			<br>
-			<br>
 			<a href="https://logto.io/?ref=sindre">
 				<div>
 					<picture>
@@ -129,6 +119,8 @@ Click the type names for complete docs.
 - [`NonEmptyObject`](source/non-empty-object.d.ts) - Represents an object with at least 1 non-optional key.
 - [`UnknownRecord`](source/unknown-record.d.ts) - Represents an object with `unknown` value. You probably want this instead of `{}`.
 - [`UnknownArray`](source/unknown-array.d.ts) - Represents an array with `unknown` value.
+- [`UnknownMap`](source/unknown-map.d.ts) - Represents a map with `unknown` key and value.
+- [`UnknownSet`](source/unknown-set.d.ts) - Represents a set with `unknown` value.
 - [`Except`](source/except.d.ts) - Create a type from an object type without certain keys. This is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys).
 - [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
 - [`WritableDeep`](source/writable-deep.d.ts) - Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.
@@ -207,6 +199,7 @@ Click the type names for complete docs.
 - [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both true.
 - [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types are true.
 - [`NonEmptyTuple`](source/non-empty-tuple.d.ts) - Matches any non-empty tuple.
+- [`NonEmptyString`](source/non-empty-string.d.ts) - Matches any non-empty string.
 - [`FindGlobalType`](source/find-global-type.d.ts) - Tries to find the type of a global with the given name.
 - [`FindGlobalInstanceType`](source/find-global-type.d.ts) - Tries to find one or more types from their globally-defined constructors.
 

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

@@ -68,12 +68,11 @@ type _CamelCasedPropertiesDeep<
 		? CamelCasedPropertiesArrayDeep<Value, Options>
 		: Value extends Set<infer U>
 			? Set<_CamelCasedPropertiesDeep<U, Options>>
-			: {
-				[K in keyof Value as CamelCase<K, Options>]: _CamelCasedPropertiesDeep<
-				Value[K],
-				Options
-				>;
-			};
+			: Value extends object
+				? {
+					[K in keyof Value as CamelCase<K, Options>]: _CamelCasedPropertiesDeep<Value[K], Options>;
+				}
+				: Value;
 
 // This is a copy of DelimiterCasedPropertiesArrayDeep (see: delimiter-cased-properties-deep.d.ts).
 // These types should be kept in sync.

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

@@ -72,13 +72,13 @@ type _DelimiterCasedPropertiesDeep<
 	: Value extends UnknownArray
 		? DelimiterCasedPropertiesArrayDeep<Value, Delimiter, Options>
 		: Value extends Set<infer U>
-			? Set<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>> : {
-				[K in keyof Value as DelimiterCase<
-				K,
-				Delimiter,
-				Options
-				>]: _DelimiterCasedPropertiesDeep<Value[K], Delimiter, Options>;
-			};
+			? Set<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>>
+			: Value extends object
+				? {
+					[K in keyof Value as DelimiterCase<K, Delimiter, Options>]:
+					_DelimiterCasedPropertiesDeep<Value[K], Delimiter, Options>
+				}
+				: Value;
 
 // This is a copy of CamelCasedPropertiesArrayDeep (see: camel-cased-properties-deep.d.ts).
 // These types should be kept in sync.

package/source/is-float.d.ts

@@ -3,31 +3,41 @@ import type {Zero} from './numeric';
 /**
 Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
 
-It returns `false` for `Infinity`.
-
 Use-case:
 - If you want to make a conditional branch based on the result of whether a number is a float or not.
 
 @example
 ```
-type Float = IsFloat<1.5>;
+import type {IsFloat, PositiveInfinity} from "type-fest";
+
+type A = IsFloat<1.5>;
 //=> true
 
-type IntegerWithDecimal = IsInteger<1.0>;
-//=> false
+type B = IsFloat<-1.5>;
+//=> true
 
-type NegativeFloat = IsInteger<-1.5>;
+type C = IsFloat<1e-7>;
 //=> true
 
-type Infinity_ = IsInteger<Infinity>;
+type D = IsFloat<1.0>;
+//=> false
+
+type E = IsFloat<PositiveInfinity>;
+//=> false
+
+type F = IsFloat<1.23e+21>;
 //=> false
 ```
+
+@category Type Guard
+@category Numeric
 */
-export type IsFloat<T> =
-T extends number
-	? `${T}` extends `${infer _Sign extends '' | '-'}${number}.${infer Decimal extends number}`
-		? Decimal extends Zero
-			? false
-			: true
-		: false
+export type IsFloat<T> = T extends number
+	? `${T}` extends `${number}e${infer E extends '-' | '+'}${number}`
+		? E extends '-'
+			? true
+			: false
+		: `${T}` extends `${number}.${number}`
+			? true
+			: false
 	: false;

package/source/is-integer.d.ts

@@ -3,38 +3,48 @@ import type {IsFloat} from './is-float';
 import type {PositiveInfinity, NegativeInfinity} from './numeric';
 
 /**
-Returns a boolean for whether the given number is a integer, like `-5`, `1.0` or `100`.
-
-Like [`Number#IsInteger()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/IsInteger) but for types.
+Returns a boolean for whether the given number is an integer, like `-5`, `1.0`, or `100`.
 
 Use-case:
-- If you want to make a conditional branch based on the result of whether a number is a intrger or not.
+- If you want to make a conditional branch based on the result of whether a number is an integer or not.
 
 @example
 ```
-type Integer = IsInteger<1>;
-//=> true
+import type {IsInteger, PositiveInfinity} from "type-fest";
 
-type IntegerWithDecimal = IsInteger<1.0>;
+type A = IsInteger<1>;
 //=> true
 
-type NegativeInteger = IsInteger<-1>;
+type B = IsInteger<1.0>;
 //=> true
 
-type Float = IsInteger<1.5>;
-//=> false
+type C = IsInteger<-1>;
+//=> true
 
-// Supports non-decimal numbers
+type D = IsInteger<0b10>;
+//=> true
 
-type OctalInteger: IsInteger<0o10>;
+type E = IsInteger<0o10>;
 //=> true
 
-type BinaryInteger: IsInteger<0b10>;
+type F = IsInteger<0x10>;
 //=> true
 
-type HexadecimalInteger: IsInteger<0x10>;
+type G = IsInteger<1.23+21>;
 //=> true
+
+type H = IsInteger<1.5>;
+//=> false
+
+type I = IsInteger<PositiveInfinity>;
+//=> false
+
+type J = IsInteger<1e-7>;
+//=> false
 ```
+
+@category Type Guard
+@category Numeric
 */
 export type IsInteger<T> =
 T extends bigint

package/source/non-empty-string.d.ts

@@ -0,0 +1,28 @@
+/**
+Matches any non-empty string.
+
+This is useful when you need a string that is not empty, for example, as a function parameter.
+
+NOTE:
+- This returns `never` not just when instantiated with an empty string, but also when an empty string is a subtype of the instantiated type, like `string` or `Uppercase<string>`.
+
+@example
+```
+import type {NonEmptyString} from 'type-fest';
+
+declare function foo<T extends string>(string: NonEmptyString<T>): void;
+
+foo('a');
+//=> OK
+
+foo('');
+//=> Error: Argument of type '""' is not assignable to parameter of type 'never'.
+
+declare const someString: string
+foo(someString);
+//=> Error: Argument of type 'string' is not assignable to parameter of type 'never'.
+```
+
+@category String
+*/
+export type NonEmptyString<T extends string> = '' extends T ? never : T;

package/source/partial-deep.d.ts

@@ -1,4 +1,5 @@
 import type {ApplyDefaultOptions, BuiltIns} from './internal';
+import type {IsNever} from './is-never';
 
 /**
 @see {@link PartialDeep}
@@ -95,27 +96,29 @@ const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
 export type PartialDeep<T, Options extends PartialDeepOptions = {}> =
 	_PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
 
-type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown))
 	? T
-	: T extends Map<infer KeyType, infer ValueType>
-		? PartialMapDeep<KeyType, ValueType, Options>
-		: T extends Set<infer ItemType>
-			? PartialSetDeep<ItemType, Options>
-			: T extends ReadonlyMap<infer KeyType, infer ValueType>
-				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
-				: T extends ReadonlySet<infer ItemType>
-					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends object
-						? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-							? Options['recurseIntoArrays'] extends true
-								? ItemType[] extends T // Test for arrays (non-tuples) specifically
-									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-										? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
-										: Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
-									: PartialObjectDeep<T, Options> // Tuples behave properly
-								: T // If they don't opt into array testing, just use the original type
-							: PartialObjectDeep<T, Options>
-						: unknown;
+	: IsNever<keyof T> extends true // For functions with no properties
+		? T
+		: T extends Map<infer KeyType, infer ValueType>
+			? PartialMapDeep<KeyType, ValueType, Options>
+			: T extends Set<infer ItemType>
+				? PartialSetDeep<ItemType, Options>
+				: T extends ReadonlyMap<infer KeyType, infer ValueType>
+					? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+					: T extends ReadonlySet<infer ItemType>
+						? PartialReadonlySetDeep<ItemType, Options>
+						: T extends object
+							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+								? Options['recurseIntoArrays'] extends true
+									? ItemType[] extends T // Test for arrays (non-tuples) specifically
+										? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+											? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
+											: Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
+										: PartialObjectDeep<T, Options> // Tuples behave properly
+									: T // If they don't opt into array testing, just use the original type
+								: PartialObjectDeep<T, Options>
+							: unknown;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
@@ -140,6 +143,9 @@ type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = {
-	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
-};
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> =
+	(ObjectType extends (...arguments_: any) => unknown
+		? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType>
+		: {}) & ({
+		[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
+	});

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

@@ -54,6 +54,9 @@ type _PascalCasedPropertiesDeep<Value, Options extends Required<CamelCaseOptions
 	: Value extends Array<infer U>
 		? Array<_PascalCasedPropertiesDeep<U, Options>>
 		: Value extends Set<infer U>
-			? Set<_PascalCasedPropertiesDeep<U, Options>> : {
-				[K in keyof Value as PascalCase<K, Options>]: _PascalCasedPropertiesDeep<Value[K], Options>;
-			};
+			? Set<_PascalCasedPropertiesDeep<U, Options>>
+			: Value extends object
+				? {
+					[K in keyof Value as PascalCase<K, Options>]: _PascalCasedPropertiesDeep<Value[K], Options>;
+				}
+				: Value;

package/source/unknown-map.d.ts

@@ -0,0 +1,24 @@
+/**
+Represents a map with `unknown` key and value.
+
+Use case: You want a type that all maps can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownMap} from 'type-fest';
+
+type IsMap<T> = T extends UnknownMap ? true : false;
+
+type A = IsMap<Map<string, number>>;
+//=> true
+
+type B = IsMap<ReadonlyMap<number, string>>;
+//=> true
+
+type C = IsMap<string>;
+//=> false
+```
+
+@category Type
+*/
+export type UnknownMap = ReadonlyMap<unknown, unknown>;

package/source/unknown-set.d.ts

@@ -0,0 +1,24 @@
+/**
+Represents a set with `unknown` value.
+
+Use case: You want a type that all sets can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownSet} from 'type-fest';
+
+type IsSet<T> = T extends UnknownSet ? true : false;
+
+type A = IsSet<Set<string>>;
+//=> true
+
+type B = IsSet<ReadonlySet<number>>;
+//=> true
+
+type C = IsSet<string>;
+//=> false
+```
+
+@category Type
+*/
+export type UnknownSet = ReadonlySet<unknown>;