type-fest 4.23.0 → 4.25.0

package/index.d.ts

@@ -36,6 +36,7 @@ export type {UndefinedOnPartialDeep} from './source/undefined-on-partial-deep';
 export type {ReadonlyDeep} from './source/readonly-deep';
 export type {LiteralUnion} from './source/literal-union';
 export type {Promisable} from './source/promisable';
+export type {Arrayable} from './source/arrayable';
 export type {Opaque, UnwrapOpaque, Tagged, GetTagMetadata, UnwrapTagged} from './source/opaque';
 export type {InvariantOf} from './source/invariant-of';
 export type {SetOptional} from './source/set-optional';
@@ -154,6 +155,7 @@ export type {Join} from './source/join';
 export type {Split} from './source/split';
 export type {Trim} from './source/trim';
 export type {Replace} from './source/replace';
+export type {StringRepeat} from './source/string-repeat';
 export type {Includes} from './source/includes';
 export type {Get} from './source/get';
 export type {LastArrayElement} from './source/last-array-element';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.23.0",
+	"version": "4.25.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/readme.md

@@ -269,9 +269,11 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`Split`](source/split.d.ts) - Represents an array of strings split using a given character or character set.
 - [`Replace`](source/replace.d.ts) - Represents a string with some or all matches replaced by a replacement.
 - [`StringSlice`](source/string-slice.d.ts) - Returns a string slice of a given range, just like `String#slice()`.
+- [`StringRepeat`](source/string-repeat.d.ts) - Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
 
 ### Array
 
+- [`Arrayable`](source/arrayable.d.ts) - Create a type that represents either the value or an array of the value.
 - [`Includes`](source/includes.d.ts) - Returns a boolean for whether the given array includes the given item.
 - [`Join`](source/join.d.ts) - Join an array of strings and/or numbers using the given string as a delimiter.
 - [`ArraySlice`](source/array-slice.d.ts) - Returns an array slice of a given range, just like `Array#slice()`.

package/source/arrayable.d.ts

@@ -0,0 +1,26 @@
+/**
+Create a type that represents either the value or an array of the value.
+
+@see Promisable
+
+@example
+```
+import type {Arrayable} from 'type-fest';
+
+function bundle(input: string, output: Arrayable<string>) {
+	const outputList = Array.isArray(output) ? output : [output];
+
+	// …
+
+	for (const output of outputList) {
+	  console.log(`write to: ${output}`);
+	}
+}
+
+bundle('src/index.js', 'dist/index.js');
+bundle('src/index.js', ['dist/index.cjs', 'dist/index.mjs']);
+```
+
+@category Array
+*/
+export type Arrayable<T> = T | readonly T[];

package/source/internal/numeric.d.ts

@@ -19,6 +19,33 @@ NumberAbsolute<NegativeInfinity>
 */
 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.
+
+Supports floating-point as a string.
+
+@example
+```
+type A = IsNumberLike<'1'>;
+//=> true
+
+type B = IsNumberLike<'-1.1'>;
+//=> true
+
+type C = IsNumberLike<1>;
+//=> true
+
+type D = IsNumberLike<'a'>;
+//=> false
+*/
+export type IsNumberLike<N> =
+	N extends number ? true
+		:	N extends `${number}`
+			? true
+			: N extends `${number}.${number}`
+				? true
+				: false;
+
 /**
 Returns the minimum number in the given union of numbers.
 

package/source/merge-deep.d.ts

@@ -322,7 +322,7 @@ export type MergeDeepOptions = {
 
 	Note: Top-level arrays and tuples are always spread.
 
-	@default 'spread'
+	@default 'replace'
 	*/
 	arrayMergeMode?: ArrayMergeMode;
 

package/source/omit-deep.d.ts

@@ -37,6 +37,25 @@ type UsefulInfo = OmitDeep<Info, 'userInfo.uselessInfo'>;
 // 	userInfo: {
 // 		name: string;
 // 	};
+// };
+
+// Supports removing multiple paths
+type Info1 = {
+	userInfo: {
+		name: string;
+		uselessField: string;
+		uselessInfo: {
+			foo: string;
+		};
+	};
+};
+
+type UsefulInfo1 = OmitDeep<Info1, 'userInfo.uselessInfo' | 'userInfo.uselessField'>;
+// type UsefulInfo1 = {
+// 	userInfo: {
+// 		name: string;
+// 	};
+// };
 
 // Supports array
 type A = OmitDeep<[1, 'foo', 2], 1>;

package/source/paths.d.ts

@@ -1,7 +1,6 @@
-import type {StaticPartOfArray, VariablePartOfArray, NonRecursiveType, ToString} from './internal';
+import type {StaticPartOfArray, VariablePartOfArray, NonRecursiveType, ToString, IsNumberLike} from './internal';
 import type {EmptyObject} from './empty-object';
 import type {IsAny} from './is-any';
-import type {IsNever} from './is-never';
 import type {UnknownArray} from './unknown-array';
 import type {Subtract} from './subtract';
 import type {GreaterThan} from './greater-than';
@@ -18,6 +17,44 @@ export type PathsOptions = {
 	@default 10
 	*/
 	maxRecursionDepth?: number;
+
+	/**
+	Use bracket notation for array indices and numeric object keys.
+
+	@default false
+
+	@example
+	```
+	type ArrayExample = {
+		array: ['foo'];
+	};
+
+	type A = Paths<ArrayExample, {bracketNotation: false}>;
+	//=> 'array' | 'array.0'
+
+	type B = Paths<ArrayExample, {bracketNotation: true}>;
+	//=> 'array' | 'array[0]'
+	```
+
+	@example
+	```
+	type NumberKeyExample = {
+		1: ['foo'];
+	};
+
+	type A = Paths<NumberKeyExample, {bracketNotation: false}>;
+	//=> 1 | '1' | '1.0'
+
+	type B = Paths<NumberKeyExample, {bracketNotation: true}>;
+	//=> '[1]' | '[1][0]'
+	```
+	*/
+	bracketNotation?: boolean;
+};
+
+type DefaultPathsOptions = {
+	maxRecursionDepth: 10;
+	bracketNotation: false;
 };
 
 /**
@@ -61,7 +98,14 @@ open('listB.1'); // TypeError. Because listB only has one element.
 @category Object
 @category Array
 */
-export type Paths<T, Options extends PathsOptions = {}> =
+export type Paths<T, Options extends PathsOptions = {}> = _Paths<T, {
+	// Set default maxRecursionDepth to 10
+	maxRecursionDepth: Options['maxRecursionDepth'] extends number ? Options['maxRecursionDepth'] : DefaultPathsOptions['maxRecursionDepth'];
+	// Set default bracketNotation to false
+	bracketNotation: Options['bracketNotation'] extends boolean ? Options['bracketNotation'] : DefaultPathsOptions['bracketNotation'];
+}>;
+
+type _Paths<T, Options extends Required<PathsOptions>> =
 	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
 		? never
 		: IsAny<T> extends true
@@ -76,25 +120,50 @@ export type Paths<T, Options extends PathsOptions = {}> =
 					? InternalPaths<T, Options>
 					: never;
 
-type InternalPaths<T, Options extends PathsOptions = {}> =
-	(Options['maxRecursionDepth'] extends number ? Options['maxRecursionDepth'] : 10) extends infer MaxDepth extends number
+type InternalPaths<T, Options extends Required<PathsOptions>> =
+	Options['maxRecursionDepth'] extends infer MaxDepth extends number
 		? Required<T> extends infer T
 			? T extends EmptyObject | readonly []
 				? never
 				: {
 					[Key in keyof T]:
 					Key extends string | number // Limit `Key` to string or number.
-						// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-						?
-						| Key
-						| ToString<Key>
-						| (
-							GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
-								? IsNever<Paths<T[Key], {maxRecursionDepth: Subtract<MaxDepth, 1>}>> extends false
-									? `${Key}.${Paths<T[Key], {maxRecursionDepth: Subtract<MaxDepth, 1>}>}`
-									: never
+						? (
+							Options['bracketNotation'] extends true
+								? IsNumberLike<Key> extends true
+									? `[${Key}]`
+									: (Key | ToString<Key>)
 								: never
-						)
+								|
+								Options['bracketNotation'] extends false
+								// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
+									? (Key | ToString<Key>)
+									: never
+						) extends infer TranformedKey extends string | number ?
+						// 1. If style is 'a[0].b' and 'Key' is a numberlike value like 3 or '3', transform 'Key' to `[${Key}]`, else to `${Key}` | Key
+						// 2. If style is 'a.0.b', transform 'Key' to `${Key}` | Key
+							| TranformedKey
+							| (
+								// Recursively generate paths for the current key
+								GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
+									? _Paths<T[Key], {bracketNotation: Options['bracketNotation']; maxRecursionDepth: Subtract<MaxDepth, 1>}> extends infer SubPath
+										? SubPath extends string | number
+											? (
+												Options['bracketNotation'] extends true
+													? SubPath extends `[${any}]` | `[${any}]${string}`
+														? `${TranformedKey}${SubPath}` // If next node is number key like `[3]`, no need to add `.` before it.
+														: `${TranformedKey}.${SubPath}`
+													: never
+											) | (
+												Options['bracketNotation'] extends false
+													? `${TranformedKey}.${SubPath}`
+													: never
+											)
+											: never
+										: never
+									: never
+							)
+							: never
 						: never
 				}[keyof T & (T extends UnknownArray ? number : unknown)]
 			: never

package/source/string-repeat.d.ts

@@ -0,0 +1,43 @@
+import type {IsNegative} from './numeric';
+import type {Subtract} from './subtract';
+
+/**
+Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
+
+@example
+```
+import {StringRepeat} from 'type-fest';
+
+declare function stringRepeat<
+	Input extends string,
+	Count extends number
+>(input: Input, count: Count): StringRepeat<Input, Count>;
+
+// The return type is the exact string literal, not just `string`.
+
+stringRepeat('foo', 2);
+//=> 'foofoo'
+
+stringRepeat('=', 3);
+//=> '==='
+```
+
+@category String
+@category Template literal
+*/
+export type StringRepeat<
+	Input extends string,
+	Count extends number,
+> = number extends Count
+	? Input extends ''
+		? ''
+		: string
+	: IsNegative<Count> extends true
+		? never
+		: Count extends 0
+			? ''
+			: string extends Input
+				? string
+				: StringRepeat<Input, Subtract<Count, 1>> extends infer R extends string
+					? `${Input}${R}`
+					: never;