@depup/type-fest 5.5.0-depup.0 → 5.9.0-depup.0

package/source/greater-than.d.ts

@@ -1,8 +1,9 @@
-import type {NumberAbsolute, PositiveNumericStringGt} from './internal/index.d.ts';
+import type {PositiveNumericStringGt} from './internal/index.d.ts';
 import type {IsEqual} from './is-equal.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {And} from './and.d.ts';
 import type {Or} from './or.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns a boolean for whether a given number is greater than another number.
@@ -82,7 +83,7 @@ export type GreaterThan<A extends number, B extends number> =
 											? true
 											: [false, false] extends R
 												? PositiveNumericStringGt<`${A}`, `${B}`>
-												: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
+												: PositiveNumericStringGt<`${Absolute<B>}`, `${Absolute<A>}`>
 									: never
 					: never
 			: never // Should never happen

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

@@ -1,7 +1,7 @@
 import type {OptionalKeysOf} from './optional-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any optional fields.
+Returns a boolean for whether the given type has any optional fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of optional fields.
 

package/source/has-readonly-keys.d.ts

@@ -1,7 +1,7 @@
 import type {ReadonlyKeysOf} from './readonly-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any readonly fields.
+Returns a boolean for whether the given type has any readonly fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of readonly fields.
 

package/source/has-required-keys.d.ts

@@ -1,7 +1,7 @@
 import type {RequiredKeysOf} from './required-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any required fields.
+Returns a boolean for whether the given type has any required fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of required fields.
 

package/source/has-writable-keys.d.ts

@@ -1,7 +1,7 @@
 import type {WritableKeysOf} from './writable-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any writable fields.
+Returns a boolean for whether the given type has any writable fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of writable fields.
 

package/source/int-closed-range.d.ts

@@ -2,9 +2,7 @@ import type {IntRange} from './int-range.d.ts';
 import type {Sum} from './sum.d.ts';
 
 /**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (inclusive) parameter.
+Generate a union of numbers between a specified start and end (both inclusive), with an optional step.
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntClosedRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8 | 10`.
 

package/source/int-range.d.ts

@@ -2,9 +2,7 @@ import type {TupleOf} from './tuple-of.d.ts';
 import type {Subtract} from './subtract.d.ts';
 
 /**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (exclusive) parameter.
+Generate a union of numbers between a specified start (inclusive) and end (exclusive), with an optional step.
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8`.
 
@@ -56,9 +54,9 @@ type PrivateIntRange<
 	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
 	List extends unknown[] = TupleOf<Start, never>,
 	EndLengthTuple extends unknown[] = TupleOf<End>,
-> = Gap extends 0 ?
+> = Gap extends 0
 	// Handle the case that without `Step`
-	List['length'] extends End // The result of "List[length] === End"
+	? List['length'] extends End // The result of "List[length] === End"
 		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
 		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
 	// Handle the case that with `Step`

package/source/internal/array.d.ts

@@ -29,8 +29,8 @@ type B = StaticPartOfArray<A>;
 */
 export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> =
 	T extends unknown
-		? number extends T['length'] ?
-			T extends readonly [infer U, ...infer V]
+		? number extends T['length']
+			? T extends readonly [infer U, ...infer V]
 				? StaticPartOfArray<V, [...Result, U]>
 				: Result
 			: T
@@ -69,11 +69,11 @@ type NormalResult = SetArrayAccess<ReadonlyStringArray, false>;
 ```
 */
 export type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
-T extends readonly [...infer U] ?
-	IsReadonly extends true
-		? readonly [...U]
-		: [...U]
-	: T;
+	T extends readonly [...infer U]
+		? IsReadonly extends true
+			? readonly [...U]
+			: [...U]
+		: T;
 
 /**
 Returns whether the given array `T` is readonly.
@@ -111,7 +111,7 @@ type B = CollapseRestElement<[string?, string?, ...number[]]>;
 //=> [string | undefined, string | undefined, number]
 ```
 */
-export type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+export type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {ifNot: _CollapseRestElement<TArray>}>;
 
 type _CollapseRestElement<
 	TArray extends UnknownArray,

package/source/internal/keys.d.ts

@@ -87,14 +87,14 @@ type Key4 = ExactKey<Object, 1>;
 @category Object
 */
 export type ExactKey<T extends object, Key extends PropertyKey> =
-Key extends keyof T
-	? Key
-	: ToString<Key> extends keyof T
-		? ToString<Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof T
-				? NumberKey
-				: never
-			: never;
+	Key extends keyof T
+		? Key
+		: ToString<Key> extends keyof T
+			? ToString<Key>
+			: Key extends `${infer NumberKey extends number}`
+				? NumberKey extends keyof T
+					? NumberKey
+					: never
+				: never;
 
 export {};

package/source/internal/numeric.d.ts

@@ -1,26 +1,8 @@
 import type {IsNever} from '../is-never.d.ts';
 import type {Finite, NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
-import type {StringToNumber} from './string.d.ts';
 import type {IfNotAnyOrNever, IsAnyOrNever} from './type.d.ts';
 
-/**
-Returns the absolute value of a given value.
-
-@example
-```
-type A = NumberAbsolute<-1>;
-//=> 1
-
-type B = NumberAbsolute<1>;
-//=> 1
-
-type C = NumberAbsolute<NegativeInfinity>;
-//=> PositiveInfinity
-```
-*/
-export type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
-
 /**
 Check whether the given type is a number or a number string.
 
@@ -44,11 +26,13 @@ type E = IsNumberLike<'a'>;
 //=> false
 */
 export type IsNumberLike<N> =
-	IfNotAnyOrNever<N,
-		N extends number | `${number}`
+	IfNotAnyOrNever<N, {
+		ifNot: N extends number | `${number}`
 			? true
-			: false,
-		boolean, false>;
+			: false;
+		ifAny: boolean;
+		ifNever: false;
+	}>;
 
 /**
 Returns the minimum number in the given union of numbers.
@@ -142,10 +126,18 @@ type D = ReverseSign<PositiveInfinity>;
 */
 export type ReverseSign<N extends number> =
 	// Handle edge cases
-	N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity :
-	// Handle negative numbers
-	`${N}` extends `-${infer P extends number}` ? P
-		// Handle positive numbers
-		: `-${N}` extends `${infer R extends number}` ? R : never;
+	N extends 0
+		? 0
+		: N extends PositiveInfinity
+			? NegativeInfinity
+			: N extends NegativeInfinity
+				? PositiveInfinity
+				// Handle negative numbers
+				: `${N}` extends `-${infer P extends number}`
+					? P
+					// Handle positive numbers
+					: `-${N}` extends `${infer R extends number}`
+						? R
+						: never;
 
 export {};

package/source/internal/object.d.ts

@@ -3,13 +3,14 @@ import type {IsEqual} from '../is-equal.d.ts';
 import type {KeysOfUnion} from '../keys-of-union.d.ts';
 import type {RequiredKeysOf} from '../required-keys-of.d.ts';
 import type {Merge} from '../merge.d.ts';
-import type {OptionalKeysOf} from '../optional-keys-of.d.ts';
 import type {IsAny} from '../is-any.d.ts';
 import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
+import type {StringToNumber} from '../string-to-number.d.ts';
+import type {Primitive} from '../primitive.d.ts';
 import type {FilterDefinedKeys, FilterOptionalKeys} from './keys.d.ts';
-import type {MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
-import type {StringToNumber, ToString} from './string.d.ts';
+import type {IfNotAnyOrNever, MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
+import type {ToString} from './string.d.ts';
 
 /**
 Create an object type with the given key `<Key>` and value `<Value>`.
@@ -223,14 +224,23 @@ export type ApplyDefaultOptions<
 	Options extends object,
 	Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,
 	SpecifiedOptions extends Options,
+> =
+	_ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+		? Result
+		: never;
+
+type _ApplyDefaultOptions<
+	Options,
+	Defaults,
+	SpecifiedOptions,
 > =
 	If<IsAny<SpecifiedOptions>, Defaults,
 		If<IsNever<SpecifiedOptions>, Defaults,
-			Simplify<Merge<Defaults, {
+			Merge<Defaults, {
 				[Key in keyof SpecifiedOptions
-				as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key
+				as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key
 				]: SpecifiedOptions[Key]
-			}> & Required<Options>>>>; // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+			}>>>;
 
 /**
 Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
@@ -265,6 +275,34 @@ export type CollapseLiterals<T> = {} extends T
 		? U
 		: T;
 
+/**
+Returns the base type of a branded type.
+
+@example
+```
+type Brand = {readonly __brand: unique symbol};
+
+type A = UnwrapBrand<string & Brand>;
+//=> string
+
+type B = UnwrapBrand<number & Brand>;
+//=> number
+
+type C = UnwrapBrand<PropertyKey & Brand>;
+//=> PropertyKey
+
+type D = UnwrapBrand<(1 | 200n | 'foo' | 'bar') & Brand>;
+//=> 1 | 200n | 'foo' | 'bar'
+```
+*/
+export type UnwrapBrand<T> = IfNotAnyOrNever<T, {ifNot: _UnwrapBrand<T, Primitive>}>;
+
+type _UnwrapBrand<T, Base> = T extends Primitive
+	? T extends infer U & Pick<T, Exclude<keyof T, KeysOfUnion<Base>>>
+		? U
+		: T
+	: T;
+
 /**
 Normalize keys by including string and number representations wherever applicable.
 

package/source/internal/string.d.ts

@@ -1,6 +1,6 @@
 import type {TupleOf} from '../tuple-of.d.ts';
-import type {NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
 import type {Trim} from '../trim.d.ts';
+import type {StringLength} from '../string-length.d.ts';
 import type {Whitespace} from './characters.d.ts';
 
 /**
@@ -10,42 +10,6 @@ Note: This type is not the return type of the `.toString()` function.
 */
 export type ToString<T> = T extends string | number ? `${T}` : never;
 
-/**
-Converts a numeric string to a number.
-
-@example
-```
-type PositiveInt = StringToNumber<'1234'>;
-//=> 1234
-
-type NegativeInt = StringToNumber<'-1234'>;
-//=> -1234
-
-type PositiveFloat = StringToNumber<'1234.56'>;
-//=> 1234.56
-
-type NegativeFloat = StringToNumber<'-1234.56'>;
-//=> -1234.56
-
-type PositiveInfinity = StringToNumber<'Infinity'>;
-//=> Infinity
-
-type NegativeInfinity = StringToNumber<'-Infinity'>;
-//=> -Infinity
-```
-
-@category String
-@category Numeric
-@category Template literal
-*/
-export type StringToNumber<S extends string> = S extends `${infer N extends number}`
-	? N
-	: S extends 'Infinity'
-		? PositiveInfinity
-		: S extends '-Infinity'
-			? NegativeInfinity
-			: never;
-
 /**
 Returns a boolean for whether the given string `S` starts with the given string `SearchString`.
 
@@ -73,45 +37,6 @@ export type StartsWith<S extends string, SearchString extends string> = string e
 		? true
 		: false;
 
-/**
-Returns an array of the characters of the string.
-
-@example
-```
-type A = StringToArray<'abcde'>;
-//=> ['a', 'b', 'c', 'd', 'e']
-
-type B = StringToArray<string>;
-//=> never
-```
-
-@category String
-*/
-export type StringToArray<S extends string, Result extends string[] = []> = string extends S
-	? never
-	: S extends `${infer F}${infer R}`
-		? StringToArray<R, [...Result, F]>
-		: Result;
-
-/**
-Returns the length of the given string.
-
-@example
-```
-type A = StringLength<'abcde'>;
-//=> 5
-
-type B = StringLength<string>;
-//=> never
-```
-
-@category String
-@category Template literal
-*/
-export type StringLength<S extends string> = string extends S
-	? never
-	: StringToArray<S>['length'];
-
 /**
 Returns a boolean for whether a string is whitespace.
 */

package/source/internal/tuple.d.ts

@@ -46,8 +46,8 @@ type B = TupleMax<[1, 2, 5, 3, 99, -1]>;
 ```
 */
 export type TupleMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number]
-	? never :
-	A extends [infer F extends number, ...infer R extends number[]]
+	? never
+	: A extends [infer F extends number, ...infer R extends number[]]
 		? GreaterThan<F, Result> extends true
 			? TupleMax<R, F>
 			: TupleMax<R, Result>

package/source/internal/type.d.ts

@@ -1,9 +1,7 @@
-import type {If} from '../if.d.ts';
 import type {IsAny} from '../is-any.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
-import type {UnionToIntersection} from '../union-to-intersection.d.ts';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
@@ -91,16 +89,16 @@ An if-else-like type that resolves depending on whether the given type is `any`
 
 @example
 ```
-// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
-type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+// When `T` is neither `any` nor `never` (like `string`) => Returns `IfNot` branch
+type A = IfNotAnyOrNever<string, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'VALID'
 
 // When `T` is `any` => Returns `IfAny` branch
-type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+type B = IfNotAnyOrNever<any, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'IS_ANY'
 
 // When `T` is `never` => Returns `IfNever` branch
-type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+type C = IfNotAnyOrNever<never, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'IS_NEVER'
 ```
 
@@ -113,7 +111,7 @@ import type {StringRepeat} from 'type-fest';
 type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
 
 // The following implementation is not tail recursive
-type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, {ifNot: S extends ` ${infer R}` ? TrimLeft<R> : S}>;
 
 // Hence, instantiations with long strings will fail
 // @ts-expect-error
@@ -122,7 +120,7 @@ type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
 // Error: Type instantiation is excessively deep and possibly infinite.
 
 // To fix this, move the recursion into a helper type
-type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, {ifNot: _TrimLeftOptimised<S>}>;
 
 type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
 
@@ -130,8 +128,16 @@ type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
 //=> ''
 ```
 */
-export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
-	If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+export type IfNotAnyOrNever<T, Cases extends {ifNot: unknown; ifAny?: unknown; ifNever?: unknown}> =
+	IsAny<T> extends true
+		? 'ifAny' extends keyof Cases
+			? Cases['ifAny']
+			: any
+		: IsNever<T> extends true
+			? 'ifNever' extends keyof Cases
+				? Cases['ifNever']
+				: never
+			: Cases['ifNot'];
 
 /**
 Returns a boolean for whether the given type is `any` or `never`.

package/source/is-boolean-literal.d.ts

@@ -0,0 +1,39 @@
+import type {CollapseLiterals, UnwrapBrand} from './internal/object.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+
+/**
+Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+@example
+```
+import type {IsBooleanLiteral} from 'type-fest';
+
+type A = IsBooleanLiteral<true>;
+//=> true
+
+type B = IsBooleanLiteral<false>;
+//=> true
+
+type C = IsBooleanLiteral<boolean>;
+//=> false
+
+type D = IsBooleanLiteral<true | false>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsBooleanLiteral<T> = IfNotAnyOrNever<T, {
+	ifNot: _IsBooleanLiteral<CollapseLiterals<UnwrapBrand<T>>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+type _IsBooleanLiteral<T> = boolean extends T
+	? false
+	: T extends boolean
+		? true
+		: false;
+
+export {};

package/source/is-integer.d.ts

@@ -47,14 +47,14 @@ type J = IsInteger<1e-7>;
 @category Numeric
 */
 export type IsInteger<T> =
-T extends bigint
-	? true
-	: T extends number
-		? number extends T
-			? false
-			: T extends PositiveInfinity | NegativeInfinity
+	T extends bigint
+		? true
+		: T extends number
+			? number extends T
 				? false
-				: Not<IsFloat<T>>
-		: false;
+				: T extends PositiveInfinity | NegativeInfinity
+					? false
+					: Not<IsFloat<T>>
+			: false;
 
 export {};