type-fest 5.4.4 → 5.6.0

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

@@ -1,19 +1,7 @@
+import type {ExcludeExactly} from './exclude-exactly.d.ts';
 import type {IsNever} from './is-never.d.ts';
-import type {UnionToIntersection} from './union-to-intersection.d.ts';
-
-/**
-Returns the last element of a union type.
-
-@example
-```
-type Last = LastOfUnion<1 | 2 | 3>;
-//=> 3
-```
-*/
-type LastOfUnion<T> =
-UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
-	? R
-	: never;
+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.
@@ -50,9 +38,12 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 
 @category Array
 */
-export type UnionToTuple<T, L = LastOfUnion<T>> =
-IsNever<T> extends false
-	? [...UnionToTuple<Exclude<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/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

@@ -37,11 +37,7 @@ writableFoo.b[0] = 'new value'; // Will still fail as the value of property "b"
 writableFoo.b = ['something']; // Will work as the "b" property itself is no longer readonly.
 
 type SomeWritable = Writable<Foo, 'b' | 'c'>;
-// type SomeWritable = {
-// 	readonly a: number;
-// 	b: readonly string[]; // It's now writable. The type of the property remains unaffected.
-// 	c: boolean; // It's now writable.
-// }
+//=> {readonly a: number; b: readonly string[]; c: boolean}
 
 // Also supports array
 const readonlyArray: readonly number[] = [1, 2, 3];
@@ -54,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>
+					// 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]}
+				>;
 
 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.