@depup/type-fest 5.4.4-depup.0

package/source/array-tail.d.ts

@@ -0,0 +1,70 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever, IsArrayReadonly} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Extract the type of an array or tuple minus the first element.
+
+@example
+```
+import type {ArrayTail} from 'type-fest';
+
+type A = ArrayTail<[1, 2, 3]>;
+//=> [2, 3]
+
+type B = ArrayTail<readonly [1, 2, 3]>;
+//=> readonly [2, 3]
+
+type C = ArrayTail<[1, 2, 3?, ...string[]]>;
+//=> [2, 3?, ...string[]]
+
+type D = ArrayTail<readonly [1]>;
+//=> readonly []
+
+type E = ArrayTail<[]>;
+//=> []
+
+type F = ArrayTail<string[]>;
+//=> string[]
+
+type G = ArrayTail<readonly [...string[], 1, 2]>;
+//=> readonly [...string[], 1, 2]
+```
+
+@example
+```
+import type {ArrayTail} from 'type-fest';
+
+type Curry<Func> = Func extends (...agruments_: infer Arguments) => infer Return
+	? Arguments extends readonly []
+		? Return
+		: (agrument: Arguments[0]) => Curry<(...agruments_: ArrayTail<Arguments>) => Return>
+	: never;
+
+declare function curry<Func extends Function>(fn: Func): Curry<Func>;
+
+declare function searchBooks(genre: string, minRating: number, available: boolean): string[];
+
+const availableTopSciFi = curry(searchBooks)('sci-fi')(4.5)(true);
+//=> string[]
+```
+
+@category Array
+*/
+export type ArrayTail<TArray extends UnknownArray> = IfNotAnyOrNever<TArray,
+	TArray extends UnknownArray // For distributing `TArray`
+		? _ArrayTail<TArray> extends infer Result
+			? If<IsArrayReadonly<TArray>, Readonly<Result>, Result>
+			: never // Should never happen
+		: never
+>;
+
+type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?, ...infer Tail]
+	? keyof TArray & `${number}` extends never
+		? TArray extends readonly []
+			? []
+			: TArray // Happens when `TArray` is a non-tuple array (e.g., `string[]`) or has a leading rest element (e.g., `[...string[], number]`)
+		: Tail
+	: [];
+
+export {};

package/source/array-values.d.ts

@@ -0,0 +1,24 @@
+/**
+Provides all values for a constant array or tuple.
+
+Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
+
+@example
+```
+import type {ArrayValues, ArrayIndices} from 'type-fest';
+
+const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+
+type WeekdayName = ArrayValues<typeof weekdays>;
+type Weekday = ArrayIndices<typeof weekdays>;
+
+const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+```
+
+@see {@link ArrayIndices}
+
+@category Array
+*/
+export type ArrayValues<T extends readonly unknown[]> = T[number];
+
+export {};

package/source/arrayable.d.ts

@@ -0,0 +1,31 @@
+/**
+Create a type that represents either the value or an array of the value.
+
+@see {@link 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 ${input} 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
+// TODO: Use `readonly T[]` when this issue is resolved: https://github.com/microsoft/TypeScript/issues/17002
+	| T[];
+
+export {};

package/source/async-return-type.d.ts

@@ -0,0 +1,28 @@
+type AsyncFunction = (...arguments_: any[]) => PromiseLike<unknown>;
+
+/**
+Unwrap the return type of a function that returns a `Promise`.
+
+There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
+
+@example
+```ts
+import type {AsyncReturnType} from 'type-fest';
+
+declare function asyncFunction(): Promise<{foo: string}>;
+
+// This type resolves to the unwrapped return type of `asyncFunction`.
+type Value = AsyncReturnType<typeof asyncFunction>;
+//=> {foo: string}
+
+declare function doSomething(value: Value): void;
+
+const value = await asyncFunction();
+doSomething(value);
+```
+
+@category Async
+*/
+export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
+
+export {};

package/source/asyncify.d.ts

@@ -0,0 +1,25 @@
+import type {SetReturnType} from './set-return-type.d.ts';
+
+/**
+Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
+
+Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
+
+@example
+```
+import type {Asyncify} from 'type-fest';
+
+// Synchronous function
+type Config = {featureFlags: Record<string, boolean>};
+
+declare function loadConfigSync(path: string): Config;
+
+type LoadConfigAsync = Asyncify<typeof loadConfigSync>;
+//=> (path: string) => Promise<Config>
+```
+
+@category Async
+*/
+export type Asyncify<Function_ extends (...arguments_: any[]) => any> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;
+
+export {};

package/source/basic.d.ts

@@ -0,0 +1,38 @@
+/**
+Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+export type Class<T, Arguments extends unknown[] = any[]> = {
+	prototype: Pick<T, keyof T>;
+	new(...arguments_: Arguments): T;
+};
+
+/**
+Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+export type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;
+
+/**
+Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/2/classes.html#abstract-classes-and-members).
+
+@category Class
+
+@privateRemarks
+We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)
+*/
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
+	prototype: Pick<T, keyof T>;
+}
+
+/**
+Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.
+
+@category Class
+*/
+export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new(...arguments_: Arguments) => T;
+
+export {};

package/source/camel-case.d.ts

@@ -0,0 +1,92 @@
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {Words, WordsOptions} from './words.d.ts';
+
+/**
+CamelCase options.
+
+@see {@link CamelCase}
+*/
+export type CamelCaseOptions = WordsOptions & {
+	/**
+	Whether to preserved consecutive uppercase letter.
+
+	@default false
+	*/
+	preserveConsecutiveUppercase?: boolean;
+};
+
+export type _DefaultCamelCaseOptions = {
+	splitOnNumbers: true;
+	preserveConsecutiveUppercase: false;
+};
+
+/**
+Convert an array of words to camel-case.
+*/
+type CamelCaseFromArray<
+	Words extends string[],
+	Options extends Required<CamelCaseOptions>,
+	OutputString extends string = '',
+> = Words extends [
+	infer FirstWord extends string,
+	...infer RemainingWords extends string[],
+]
+	? Options['preserveConsecutiveUppercase'] extends true
+		? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}`
+		: `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}`
+	: OutputString;
+
+/**
+Convert a string literal to camel-case.
+
+This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+
+By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
+
+@example
+```
+import type {CamelCase} from 'type-fest';
+
+// Simple
+
+const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+const preserveConsecutiveUppercase: CamelCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'fooBARBaz';
+
+// Advanced
+
+type CamelCasedProperties<T> = {
+	[K in keyof T as CamelCase<K>]: T[K]
+};
+
+type RawOptions = {
+	'dry-run': boolean;
+	'full_family_name': string;
+	foo: number;
+	BAR: string;
+	QUZ_QUX: number;
+	'OTHER-FIELD': boolean;
+};
+
+const dbResult: CamelCasedProperties<RawOptions> = {
+	dryRun: true,
+	fullFamilyName: 'bar.js',
+	foo: 123,
+	bar: 'foo',
+	quzQux: 6,
+	otherField: false,
+};
+```
+
+@category Change case
+@category Template literal
+*/
+export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extends string
+	? string extends Type
+		? Type
+		: Uncapitalize<CamelCaseFromArray<
+			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type, Options>,
+			ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>
+		>>
+	: Type;
+
+export {};

package/source/camel-cased-properties-deep.d.ts

@@ -0,0 +1,99 @@
+import type {CamelCase, CamelCaseOptions, _DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions, NonRecursiveType} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Convert object properties to camel case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link CamelCasedProperties}
+@see {@link CamelCase}
+
+@example
+```
+import type {CamelCasedPropertiesDeep} from 'type-fest';
+
+type User = {
+	UserId: number;
+	UserName: string;
+};
+
+type UserWithFriends = {
+	UserInfo: User;
+	UserFriends: User[];
+};
+
+const result: CamelCasedPropertiesDeep<UserWithFriends> = {
+	userInfo: {
+		userId: 1,
+		userName: 'Tom',
+	},
+	userFriends: [
+		{
+			userId: 2,
+			userName: 'Jerry',
+		},
+		{
+			userId: 3,
+			userName: 'Spike',
+		},
+	],
+};
+
+const preserveConsecutiveUppercase: CamelCasedPropertiesDeep<{fooBAR: {fooBARBiz: [{fooBARBaz: string}]}}, {preserveConsecutiveUppercase: true}> = {
+	fooBAR: {
+		fooBARBiz: [{
+			fooBARBaz: 'string',
+		}],
+	},
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type CamelCasedPropertiesDeep<
+	Value,
+	Options extends CamelCaseOptions = {},
+> = _CamelCasedPropertiesDeep<Value, ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>>;
+
+type _CamelCasedPropertiesDeep<
+	Value,
+	Options extends Required<CamelCaseOptions>,
+> = Value extends NonRecursiveType
+	? Value
+	: Value extends UnknownArray
+		? CamelCasedPropertiesArrayDeep<Value, Options>
+		: Value extends Set<infer U>
+			? Set<_CamelCasedPropertiesDeep<U, Options>>
+			: Value extends object
+				? {
+					[K in keyof Value as CamelCase<K, Options>]: _CamelCasedPropertiesDeep<Value[K], Options>;
+				}
+				: Value;
+
+// This is a copy of DelimiterCasedPropertiesArrayDeep (see: delimiter-cased-properties-deep.d.ts).
+// These types should be kept in sync.
+type CamelCasedPropertiesArrayDeep<
+	Value extends UnknownArray,
+	Options extends Required<CamelCaseOptions>,
+> = Value extends []
+	? []
+	// Trailing spread array
+	: Value extends [infer U, ...infer V]
+		? [_CamelCasedPropertiesDeep<U, Options>, ..._CamelCasedPropertiesDeep<V, Options>]
+		: Value extends readonly [infer U, ...infer V]
+			? readonly [_CamelCasedPropertiesDeep<U, Options>, ..._CamelCasedPropertiesDeep<V, Options>]
+			: // Leading spread array
+			Value extends readonly [...infer U, infer V]
+				? [..._CamelCasedPropertiesDeep<U, Options>, _CamelCasedPropertiesDeep<V, Options>]
+				: // Array
+				Value extends Array<infer U>
+					? Array<_CamelCasedPropertiesDeep<U, Options>>
+					: Value extends ReadonlyArray<infer U>
+						? ReadonlyArray<_CamelCasedPropertiesDeep<U, Options>>
+						: never;
+
+export {};

package/source/camel-cased-properties.d.ts

@@ -0,0 +1,45 @@
+import type {CamelCase, CamelCaseOptions, _DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+
+/**
+Convert object properties to camel case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link CamelCasedPropertiesDeep}
+@see {@link CamelCase}
+
+@example
+```
+import type {CamelCasedProperties} from 'type-fest';
+
+type User = {
+	UserId: number;
+	UserName: string;
+};
+
+const result: CamelCasedProperties<User> = {
+	userId: 1,
+	userName: 'Tom',
+};
+
+const preserveConsecutiveUppercase: CamelCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
+	fooBAR: 'string',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type CamelCasedProperties<Value, Options extends CamelCaseOptions = {}> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
+		? Value
+		: {
+			[K in keyof Value as
+			CamelCase<K, ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>>
+			]: Value[K];
+		};
+
+export {};

package/source/characters.d.ts

@@ -0,0 +1,67 @@
+/**
+Matches any uppercase letter in the basic Latin alphabet (A-Z).
+
+@example
+```
+import type {UppercaseLetter} from 'type-fest';
+
+const a: UppercaseLetter = 'A'; // Valid
+// @ts-expect-error
+const b: UppercaseLetter = 'a'; // Invalid
+// @ts-expect-error
+const c: UppercaseLetter = 'AB'; // Invalid
+```
+
+@category Type
+*/
+export type UppercaseLetter = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+
+/**
+Matches any lowercase letter in the basic Latin alphabet (a-z).
+
+@example
+```
+import type {LowercaseLetter} from 'type-fest';
+
+const a: LowercaseLetter = 'a'; // Valid
+// @ts-expect-error
+const b: LowercaseLetter = 'A'; // Invalid
+```
+
+@category Type
+*/
+export type LowercaseLetter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+
+/**
+Matches any digit as a string ('0'-'9').
+
+@example
+```
+import type {DigitCharacter} from 'type-fest';
+
+const a: DigitCharacter = '0'; // Valid
+// @ts-expect-error
+const b: DigitCharacter = 0; // Invalid
+```
+
+@category Type
+*/
+export type DigitCharacter = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+
+/**
+Matches any lowercase letter (a-z), uppercase letter (A-Z), or digit ('0'-'9') in the basic Latin alphabet.
+
+@example
+```
+import type {Alphanumeric} from 'type-fest';
+
+const a: Alphanumeric = 'A'; // Valid
+// @ts-expect-error
+const b: Alphanumeric = '#'; // Invalid
+```
+
+@category Type
+*/
+export type Alphanumeric = LowercaseLetter | UppercaseLetter | DigitCharacter;
+
+export {};

package/source/conditional-except.d.ts

@@ -0,0 +1,47 @@
+import type {Except} from './except.d.ts';
+import type {ConditionalKeys} from './conditional-keys.d.ts';
+
+/**
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import type {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	constructor(public name: string, public successes: number, public failures: bigint) {}
+
+	run() {
+		// do something
+	}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import type {ConditionalExcept} from 'type-fest';
+
+type Example = {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+};
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+
+@category Object
+*/
+export type ConditionalExcept<Base, Condition> = Except<
+	Base,
+	ConditionalKeys<Base, Condition>
+>;
+
+export {};

package/source/conditional-keys.d.ts

@@ -0,0 +1,63 @@
+import type {ExtendsStrict} from './extends-strict.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {TupleToObject} from './tuple-to-object.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type Example = {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+};
+
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
+
+Note: To extract optional keys, make sure your `Condition` is a union of `undefined` (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringKeysAndUndefined = ConditionalKeys<{a?: string}, string | undefined>;
+//=> 'a'
+
+type NoMatchingKeys = ConditionalKeys<{a?: string}, string>;
+//=> never
+```
+
+You can also extract array indices whose value match the specified condition, as shown below:
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringValueIndices = ConditionalKeys<[string, number, string], string>;
+//=> '0' | '2'
+
+type NumberValueIndices = ConditionalKeys<[string, number?, string?], number | undefined>;
+//=> '1'
+```
+
+@category Object
+*/
+export type ConditionalKeys<Base, Condition> = (Base extends UnknownArray ? TupleToObject<Base> : Base) extends infer _Base // Remove non-numeric keys from arrays
+	? IfNotAnyOrNever<_Base, _ConditionalKeys<_Base, Condition>, keyof _Base>
+	: never;
+
+type _ConditionalKeys<Base, Condition> = keyof {
+	[
+	Key in (keyof Base & {}) as // `& {}` prevents homomorphism
+	ExtendsStrict<Base[Key], Condition> extends true ? Key : never
+	]: never
+};
+
+export {};