type-fest 4.14.0 → 4.16.0

package/index.d.ts

@@ -9,6 +9,7 @@ export type {KeysOfUnion} from './source/keys-of-union';
 export type {DistributedOmit} from './source/distributed-omit';
 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 {UnknownRecord} from './source/unknown-record';
 export type {UnknownArray} from './source/unknown-array';
@@ -23,6 +24,7 @@ export type {RequireAtLeastOne} from './source/require-at-least-one';
 export type {RequireExactlyOne} from './source/require-exactly-one';
 export type {RequireAllOrNone} from './source/require-all-or-none';
 export type {RequireOneOrNone} from './source/require-one-or-none';
+export type {SingleKeyObject} from './source/single-key-object';
 export type {OmitIndexSignature} from './source/omit-index-signature';
 export type {PickIndexSignature} from './source/pick-index-signature';
 export type {PartialDeep, PartialDeepOptions} from './source/partial-deep';
@@ -96,6 +98,8 @@ export type {HasReadonlyKeys} from './source/has-readonly-keys';
 export type {WritableKeysOf} from './source/writable-keys-of';
 export type {HasWritableKeys} from './source/has-writable-keys';
 export type {Spread} from './source/spread';
+export type {IsInteger} from './source/is-integer';
+export type {IsFloat} from './source/is-float';
 export type {TupleToUnion} from './source/tuple-to-union';
 export type {IntRange} from './source/int-range';
 export type {IsEqual} from './source/is-equal';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.14.0",
+	"version": "4.16.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -16,7 +16,6 @@
 		"node": ">=16"
 	},
 	"scripts": {
-		"test:set-parameter-type": "tsc --noEmit test-d/set-parameter-type",
 		"test:source-files-extension": "node script/test/source-files-extension.js",
 		"test:tsc": "tsc",
 		"test:tsd": "tsd",
@@ -40,11 +39,10 @@
 		"generics"
 	],
 	"devDependencies": {
-		"@sindresorhus/tsconfig": "~0.7.0",
 		"expect-type": "^0.15.0",
 		"npm-run-all2": "^6.1.2",
-		"tsd": "^0.28.1",
-		"typescript": "^5.2.2",
+		"tsd": "^0.31.0",
+		"typescript": "~5.4.3",
 		"xo": "^0.58.0"
 	},
 	"xo": {

package/readme.md

@@ -49,6 +49,22 @@
 			</a>
 			<br>
 			<br>
+			<br>
+			<a href="https://logto.io/?ref=sindre">
+				<div>
+					<picture>
+						<source width="200" media="(prefers-color-scheme: dark)" srcset="https://sindresorhus.com/assets/thanks/logto-logo-dark.svg?x">
+						<source width="200" media="(prefers-color-scheme: light)" srcset="https://sindresorhus.com/assets/thanks/logto-logo-light.svg?x">
+						<img width="200" src="https://sindresorhus.com/assets/thanks/logto-logo-light.svg?x" alt="Logto logo">
+					</picture>
+				</div>
+				<b>The better identity infrastructure for developers</b>
+				<div>
+					<sup>Logto is an open-source Auth0 alternative designed for every app.</sup>
+				</div>
+			</a>
+			<br>
+			<br>
 		</p>
 	</div>
 	<br>
@@ -110,7 +126,6 @@ Click the type names for complete docs.
 ### Utilities
 
 - [`EmptyObject`](source/empty-object.d.ts) - Represents a strictly empty plain object, the `{}` value.
-- [`IsEmptyObject`](source/empty-object.d.ts) - Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
 - [`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.
@@ -125,6 +140,7 @@ Click the type names for complete docs.
 - [`RequireExactlyOne`](source/require-exactly-one.d.ts) - Create a type that requires exactly a single key of the given keys and disallows more.
 - [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys.
 - [`RequireOneOrNone`](source/require-one-or-none.d.ts) - Create a type that requires exactly a single key of the given keys and disallows more, or none of the given keys.
+- [`SingleKeyObject`](source/single-key-object.d.ts) - Create a type that only accepts an object with a single key.
 - [`RequiredDeep`](source/required-deep.d.ts) - Create a deeply required version of another type. Use [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) if you only need one level deep.
 - [`PickDeep`](source/pick-deep.d.ts) - Pick properties from a deeply-nested object. Use [`Pick<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#picktype-keys) if you only need one level deep.
 - [`OmitDeep`](source/omit-deep.d.ts) - Omit properties from a deeply-nested object. Use [`Omit<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
@@ -220,6 +236,7 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`IsAny`](source/is-any.d.ts) - Returns a boolean for whether the given type is `any`. (Conditional version: [`IfAny`](source/if-any.d.ts).)
 - [`IsNever`](source/is-never.d.ts) - Returns a boolean for whether the given type is `never`. (Conditional version: [`IfNever`](source/if-never.d.ts).)
 - [`IsUnknown`](source/is-unknown.d.ts) - Returns a boolean for whether the given type is `unknown`. (Conditional version: [`IfUnknown`](source/if-unknown.d.ts).)
+- [`IsEmptyObject`](source/empty-object.d.ts) - Returns a boolean for whether the type is strictly equal to an empty plain object, the `{}` value. (Conditional version: [`IfEmptyObject`](source/if-empty-object.d.ts))
 
 ### JSON
 
@@ -268,6 +285,8 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`NegativeInteger`](source/numeric.d.ts) - A negative (`-∞ < x < 0`) `number` that is an integer.
 - [`NonNegativeInteger`](source/numeric.d.ts) - A non-negative (`0 <= x < ∞`) `number` that is an integer.
 - [`IsNegative`](source/numeric.d.ts) - Returns a boolean for whether the given number is a negative number.
+- [`IsFloat`](source/is-float.d.ts) - Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
+- [`IsInteger`](source/is-integer.d.ts) - Returns a boolean for whether the given number is a integer, like `-5`, `1.0` or `100`.
 - [`GreaterThan`](source/greater-than.d.ts) - Returns a boolean for whether a given number is greater than another number.
 - [`GreaterThanOrEqual`](source/greater-than-or-equal.d.ts) - Returns a boolean for whether a given number is greater than or equal to another number.
 - [`LessThan`](source/less-than.d.ts) - Returns a boolean for whether a given number is less than another number.

package/source/conditional-keys.d.ts

@@ -30,11 +30,10 @@ type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
 
 @category Object
 */
-export type ConditionalKeys<Base, Condition> = NonNullable<
-// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+export type ConditionalKeys<Base, Condition> =
 {
 	// Map through all the keys of the given base type.
-	[Key in keyof Base]:
+	[Key in keyof Base]-?:
 	// Pick only keys with types extending the given `Condition` type.
 	Base[Key] extends Condition
 	// Retain this key since the condition passes.
@@ -43,5 +42,4 @@ export type ConditionalKeys<Base, Condition> = NonNullable<
 		: never;
 
 	// Convert the produced object into a union type of the keys which passed the conditional test.
-}[keyof Base]
->;
+}[keyof Base];

package/source/if-empty-object.d.ts

@@ -0,0 +1,26 @@
+import type {IsEmptyObject} from './empty-object';
+
+/**
+An if-else-like type that resolves depending on whether the given type is `{}`.
+
+@see {@link IsEmptyObject}
+
+@example
+```
+import type {IfEmptyObject} from 'type-fest';
+
+type ShouldBeTrue = IfEmptyObject<{}>;
+//=> true
+
+type ShouldBeBar = IfEmptyObject<{key: any}, 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfEmptyObject<
+	T,
+	TypeIfEmptyObject = true,
+	TypeIfNotEmptyObject = false,
+> = IsEmptyObject<T> extends true ? TypeIfEmptyObject : TypeIfNotEmptyObject;

package/source/internal.d.ts

@@ -416,9 +416,11 @@ Multiple call signatures cannot currently be supported due to a TypeScript limit
 @see https://github.com/microsoft/TypeScript/issues/29732
 */
 export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =
-	T extends {(...arguments_: infer A): unknown; (...arguments_: any[]): unknown}
-		? unknown[] extends A
-			? false
+	T extends {(...arguments_: infer A): unknown; (...arguments_: infer B): unknown}
+		? B extends A
+			? A extends B
+				? false
+				: true
 			: true
 		: false;
 

package/source/is-float.d.ts

@@ -0,0 +1,33 @@
+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>;
+//=> true
+
+type IntegerWithDecimal = IsInteger<1.0>;
+//=> false
+
+type NegativeFloat = IsInteger<-1.5>;
+//=> true
+
+type Infinity_ = IsInteger<Infinity>;
+//=> false
+```
+*/
+export type IsFloat<T> =
+T extends number
+	? `${T}` extends `${infer _Sign extends '' | '-'}${number}.${infer Decimal extends number}`
+		? Decimal extends Zero
+			? false
+			: true
+		: false
+	: false;

package/source/is-integer.d.ts

@@ -0,0 +1,48 @@
+import type {Not} from './internal';
+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.
+
+Use-case:
+- If you want to make a conditional branch based on the result of whether a number is a intrger or not.
+
+@example
+```
+type Integer = IsInteger<1>;
+//=> true
+
+type IntegerWithDecimal = IsInteger<1.0>;
+//=> true
+
+type NegativeInteger = IsInteger<-1>;
+//=> true
+
+type Float = IsInteger<1.5>;
+//=> false
+
+// Supports non-decimal numbers
+
+type OctalInteger: IsInteger<0o10>;
+//=> true
+
+type BinaryInteger: IsInteger<0b10>;
+//=> true
+
+type HexadecimalInteger: IsInteger<0x10>;
+//=> true
+```
+*/
+export type IsInteger<T> =
+T extends bigint
+	? true
+	: T extends number
+		? number extends T
+			? false
+			: T extends PositiveInfinity | NegativeInfinity
+				? false
+				: Not<IsFloat<T>>
+		: false;

package/source/numeric.d.ts

@@ -1,3 +1,6 @@
+import type {IsFloat} from './is-float';
+import type {IsInteger} from './is-integer';
+
 export type Numeric = number | bigint;
 
 type Zero = 0 | 0n;
@@ -49,10 +52,35 @@ export type Finite<T extends number> = T extends PositiveInfinity | NegativeInfi
 
 /**
 A `number` that is an integer.
-You can't pass a `bigint` as they are already guaranteed to be integers.
 
 Use-case: Validating and documenting parameters.
 
+@example
+```
+type Integer = Integer<1>;
+//=> 1
+
+type IntegerWithDecimal = Integer<1.0>;
+//=> 1
+
+type NegativeInteger = Integer<-1>;
+//=> -1
+
+type Float = Integer<1.5>;
+//=> never
+
+// Supports non-decimal numbers
+
+type OctalInteger: Integer<0o10>;
+//=> 0o10
+
+type BinaryInteger: Integer<0b10>;
+//=> 0b10
+
+type HexadecimalInteger: Integer<0x10>;
+//=> 0x10
+```
+
 @example
 ```
 import type {Integer} from 'type-fest';
@@ -67,14 +95,18 @@ declare function setYear<T extends number>(length: Integer<T>): void;
 */
 // `${bigint}` is a type that matches a valid bigint literal without the `n` (ex. 1, 0b1, 0o1, 0x1)
 // Because T is a number and not a string we can effectively use this to filter out any numbers containing decimal points
-export type Integer<T extends number> = `${T}` extends `${bigint}` ? T : never;
+export type Integer<T> =
+	T extends unknown // To distributive type
+		? IsInteger<T> extends true ? T : never
+		: never; // Never happens
 
 /**
 A `number` that is not an integer.
-You can't pass a `bigint` as they are already guaranteed to be integers.
 
 Use-case: Validating and documenting parameters.
 
+It does not accept `Infinity`.
+
 @example
 ```
 import type {Float} from 'type-fest';
@@ -86,7 +118,10 @@ declare function setPercentage<T extends number>(length: Float<T>): void;
 
 @category Numeric
 */
-export type Float<T extends number> = T extends Integer<T> ? never : T;
+export type Float<T> =
+T extends unknown // To distributive type
+	? IsFloat<T> extends true ? T : never
+	: never; // Never happens
 
 /**
 A negative (`-∞ < x < 0`) `number` that is not an integer.

package/source/single-key-object.d.ts

@@ -0,0 +1,29 @@
+import type {IfEmptyObject} from './if-empty-object';
+import type {IsUnion} from './internal';
+
+/**
+Create a type that only accepts an object with a single key.
+
+@example
+```
+import type {SingleKeyObject} from 'type-fest';
+
+const someFunction = <T>(parameter: SingleKeyObject<T>) => {};
+
+someFunction({
+	value: true
+});
+
+someFunction({
+	value: true,
+	otherKey: true
+});
+// Error: Argument of type '{value: boolean; otherKey: boolean}' is not assignable to parameter of type 'never'.ts(2345)
+```
+
+@category Object
+*/
+export type SingleKeyObject<ObjectType> =
+	IsUnion<keyof ObjectType> extends true
+		? never
+		: IfEmptyObject<ObjectType, never, ObjectType>;