type-fest 4.39.1 → 4.40.0

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.0",
 	"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/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/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>;