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

package/source/tuple-of.d.ts

@@ -1,6 +1,7 @@
 import type {If} from './if.d.ts';
 import type {IfNotAnyOrNever} from './internal/type.d.ts';
 import type {IsNegative} from './numeric.d.ts';
+import type {DigitCharacter} from './characters.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
@@ -30,7 +31,7 @@ type ZeroToFour = Range<0, 5>;
 //=> '0' | '1' | '2' | '3' | '4'
 
 type ThreeToEight = Range<3, 9>;
-//=> '5' | '3' | '4' | '6' | '7' | '8'
+//=> '3' | '4' | '5' | '6' | '7' | '8'
 ```
 
 Note: If the specified length is the non-literal `number` type, the result will not be a tuple but a regular array.
@@ -63,18 +64,51 @@ type EmptyTuple = TupleOf<-3, string>;
 //=> []
 ```
 
+Note: If the specified length has a decimal part, the decimal part will be ignored.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type DecimalLength = TupleOf<3.5, string>;
+//=> [string, string, string]
+```
+
 Note: If you need a readonly tuple, simply wrap this type with `Readonly`, for example, to create `readonly [number, number, number]` use `Readonly<TupleOf<3, number>>`.
 
 @category Array
 */
-export type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length,
-	_TupleOf<If<IsNegative<Length>, 0, Length>, Fill, []>,
-	Fill[], []>;
+export type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, {
+	ifNot: _TupleOf<If<IsNegative<Length>, 0, Length>, Fill>;
+	ifAny: Fill[];
+	ifNever: [];
+}>;
 
-type _TupleOf<L extends number, Fill, Accumulator extends UnknownArray> = number extends L
+type _TupleOf<Length extends number, Fill> = number extends Length
 	? Fill[]
-	: L extends Accumulator['length']
-		? Accumulator
-		: _TupleOf<L, Fill, [...Accumulator, Fill]>;
+	: BuildTupleDigitByDigit<`${Length}`, Fill>;
+
+type BuildTupleDigitByDigit<Length extends string, Fill, Accumulator extends UnknownArray = []> =
+	Length extends `${infer First extends DigitCharacter}${infer Rest}`
+		? BuildTupleDigitByDigit<Rest, Fill, [...RepeatTupleTenTimes<Accumulator>, ...DigitTupleOf<First, Fill>]>
+		: Accumulator;
+
+type RepeatTupleTenTimes<Tuple extends UnknownArray> = [
+	...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple,
+	...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple,
+];
+
+type DigitTupleOf<Digit extends DigitCharacter, Fill> = [
+	[],
+	[Fill],
+	[Fill, Fill],
+	[Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+	[Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill],
+][Digit];
 
 export {};

package/source/typed-array.d.ts

@@ -11,6 +11,7 @@ export type TypedArray =
 	| Uint16Array
 	| Int32Array
 	| Uint32Array
+	| Float16Array
 	| Float32Array
 	| Float64Array
 	| BigInt64Array

package/source/union-length.d.ts

@@ -0,0 +1,27 @@
+import type {UnionToTuple} from './union-to-tuple.d.ts';
+
+/**
+Returns the length of a union type.
+
+@example
+```
+import type {UnionLength} from 'type-fest';
+
+type T1 = UnionLength<'foo' | 'bar' | 'baz'>;
+//=> 3
+
+type T2 = UnionLength<[string, string, string] | {x: string; y: string; z: string}>;
+//=> 2
+
+type T3 = UnionLength<any>;
+//=> 1
+
+type T4 = UnionLength<never>;
+//=> 0
+```
+
+@category Type
+*/
+export type UnionLength<Union> = UnionToTuple<Union>['length'];
+
+export {};

package/source/union-to-intersection.d.ts

@@ -1,5 +1,5 @@
 /**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Convert a union type to an intersection type.
 
 Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
 

package/source/union-to-tuple.d.ts

@@ -1,6 +1,7 @@
 import type {ExcludeExactly} from './exclude-exactly.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {UnionMember} from './union-member.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Convert a union type into an unordered tuple type of its elements.
@@ -37,9 +38,12 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 
 @category Array
 */
-export type UnionToTuple<T, L = UnionMember<T>> =
-IsNever<T> extends false
-	? [...UnionToTuple<ExcludeExactly<T, L>>, L]
-	: [];
+export type UnionToTuple<Union> =
+	_UnionToTuple<Union> extends infer Result extends UnknownArray ? Result : never; // Nudges the compiler that `UnionToTuple` always yields an array.
+
+type _UnionToTuple<Union, Accumulator extends UnknownArray = [], Member = UnionMember<Union>> =
+	IsNever<Union> extends true
+		? Accumulator
+		: _UnionToTuple<ExcludeExactly<Union, Member>, [Member, ...Accumulator]>;
 
 export {};

package/source/unwrap-required.d.ts

@@ -0,0 +1,37 @@
+import type {MapsSetsOrArrays, NonRecursiveType} from './internal/type.d.ts';
+
+/**
+Revert the `Required` modifier on an object type.
+
+Use-case: Infer the underlying type `T` when only `Required<T>` is available or the original type may not be directly accessible.
+
+@example
+```
+import type {UnwrapRequired} from 'type-fest';
+
+type ContactFormData = Required<{
+	email: string;
+	message?: string;
+}>;
+
+type DraftContactFormData = UnwrapRequired<ContactFormData>;
+//=> {email: string; message?: string}
+```
+
+Note:
+	- If the provided type isn’t of the form `Required<T>`, `UnwrapRequired` simply returns the input type.
+	- `UnwrapRequired` doesn't work with arrays, if instantiated with arrays, it simply returns the input type.
+
+@category Object
+*/
+export type UnwrapRequired<RequiredObjectType> =
+	RequiredObjectType extends NonRecursiveType | MapsSetsOrArrays
+		? RequiredObjectType
+		: _UnwrapRequired<RequiredObjectType>;
+
+type _UnwrapRequired<RequiredObjectType> =
+	RequiredObjectType extends Required<infer ObjectType>
+		? ObjectType
+		: RequiredObjectType;
+
+export {};

package/source/words.d.ts

@@ -1,5 +1,6 @@
 import type {
 	ApplyDefaultOptions,
+	AsciiPunctuation,
 	IsNumeric,
 	WordSeparators,
 } from './internal/index.d.ts';
@@ -38,17 +39,34 @@ export type WordsOptions = {
 	```
 	*/
 	splitOnNumbers?: boolean;
+	/**
+	Split on {@link AsciiPunctuation | punctuation characters} (e.g., `#`, `&`, `*`, `:`, `?`, `@`, `~`).
+
+	@example
+	```
+	import type {Words} from 'type-fest';
+
+	type Example1 = Words<'hello:world', {splitOnPunctuation: true}>;
+	//=> ['hello', 'world']
+
+	type Example2 = Words<'hello:world', {splitOnPunctuation: false}>;
+	//=> ['hello', ':world']
+	```
+	*/
+	splitOnPunctuation?: boolean;
 };
 
 export type _DefaultWordsOptions = {
 	splitOnNumbers: true;
+	splitOnPunctuation: false;
 };
 
 /**
-Split a string (almost) like Lodash's `_.words()` function.
+Split a string similar to Lodash's `_.words()` function.
 
 - Split on each word that begins with a capital letter.
 - Split on each {@link WordSeparators}.
+- Split on each {@link AsciiPunctuation} (if {@link WordsOptions.splitOnPunctuation} is enabled).
 - Split on numeric sequence.
 
 @example
@@ -72,13 +90,21 @@ type Words4 = Words<'lifeIs42'>;
 
 type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
 //=> ['p2p', 'Network']
+
+type Words6 = Words<'hello:world', {splitOnPunctuation: true}>;
+//=> ['hello', 'world']
+
+type Words7 = Words<'hello:world', {splitOnPunctuation: false}>;
+//=> ['hello', ':world']
+
+type Words8 = Words<'hello::world', {splitOnPunctuation: true}>;
+//=> ['hello', 'world']
 ```
 
 @category Change case
 @category Template literal
 */
-export type Words<Sentence extends string, Options extends WordsOptions = {}> =
-	WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>>;
+export type Words<Sentence extends string, Options extends WordsOptions = {}> = WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>>;
 
 type WordsImplementation<
 	Sentence extends string,
@@ -86,7 +112,7 @@ type WordsImplementation<
 	LastCharacter extends string = '',
 	CurrentWord extends string = '',
 > = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}`
-	? FirstCharacter extends WordSeparators
+	? FirstCharacter extends WordSeparators | (Options['splitOnPunctuation'] extends true ? AsciiPunctuation : never)
 		// Skip word separator
 		? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>]
 		: LastCharacter extends ''

package/source/writable.d.ts

@@ -50,19 +50,19 @@ writableArray.push(4); // Will work as the array itself is now writable.
 @category Object
 */
 export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
-BaseType extends ReadonlyMap<infer KeyType, infer ValueType>
-	? Map<KeyType, ValueType>
-	: BaseType extends ReadonlySet<infer ItemType>
-		? Set<ItemType>
-		: BaseType extends readonly unknown[]
-			// Handle array
-			? WritableArray<BaseType>
-			// Handle object
-			: Simplify<
-			// Pick just the keys that are not writable from the base type.
-				Except<BaseType, Keys> &
-			// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
-				{-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
-			>;
+	BaseType extends ReadonlyMap<infer KeyType, infer ValueType>
+		? Map<KeyType, ValueType>
+		: BaseType extends ReadonlySet<infer ItemType>
+			? Set<ItemType>
+			: BaseType extends readonly unknown[]
+				// Handle array
+				? WritableArray<BaseType>
+				// Handle object
+				: Simplify<
+					// Pick just the keys that are not writable from the base type.
+					Except<BaseType, Keys>
+					// Make the specified keys writable.
+					& {-readonly [KeyType in keyof BaseType as KeyType extends Keys ? KeyType : never]: BaseType[KeyType]}
+				>;
 
 export {};

package/source/xor.d.ts

@@ -3,7 +3,7 @@ import type {And} from './and.d.ts';
 import type {Or} from './or.d.ts';
 
 /**
-Returns a boolean for whether only one of two given types is true.
+Returns a boolean for whether only one of two given types is `true`.
 
 Use-case: Constructing complex conditional types where one single condition must be satisfied.