@depup/type-fest 5.4.4-depup.0

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

@@ -0,0 +1,65 @@
+import type {_DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
+
+/**
+Convert object properties to kebab case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link KebabCase}
+@see {@link KebabCasedProperties}
+
+@example
+```
+import type {KebabCasedPropertiesDeep} from 'type-fest';
+
+type User = {
+	userId: number;
+	userName: string;
+};
+
+type UserWithFriends = {
+	userInfo: User;
+	userFriends: User[];
+};
+
+const result: KebabCasedPropertiesDeep<UserWithFriends> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom',
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': 'Jerry',
+		},
+		{
+			'user-id': 3,
+			'user-name': 'Spike',
+		},
+	],
+};
+
+const splitOnNumbers: KebabCasedPropertiesDeep<{line1: {line2: [{line3: string}]}}, {splitOnNumbers: true}> = {
+	'line-1': {
+		'line-2': [
+			{
+				'line-3': 'string',
+			},
+		],
+	},
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedPropertiesDeep<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedPropertiesDeep<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

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

@@ -0,0 +1,42 @@
+import type {_DefaultDelimiterCaseOptions} from './delimiter-case.d.ts';
+import type {DelimiterCasedProperties} from './delimiter-cased-properties.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
+
+/**
+Convert object properties to kebab case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see {@link KebabCase}
+@see {@link KebabCasedPropertiesDeep}
+
+@example
+```
+import type {KebabCasedProperties} from 'type-fest';
+
+type User = {
+	userId: number;
+	userName: string;
+};
+
+const result: KebabCasedProperties<User> = {
+	'user-id': 1,
+	'user-name': 'Tom',
+};
+
+const splitOnNumbers: KebabCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
+	'line-1': 'string',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type KebabCasedProperties<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedProperties<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+
+export {};

package/source/key-as-string.d.ts

@@ -0,0 +1,27 @@
+/**
+Get keys of the given type as strings.
+
+Number keys are converted to strings.
+
+Use-cases:
+- Get string keys from a type which may have number keys.
+- Makes it possible to index using strings retrieved from template types.
+
+@example
+```
+import type {KeyAsString} from 'type-fest';
+
+type Foo = {
+	1: number;
+	stringKey: string;
+};
+
+type StringKeysOfFoo = KeyAsString<Foo>;
+//=> 'stringKey' | '1'
+```
+
+@category Object
+*/
+export type KeyAsString<BaseType> = `${Extract<keyof BaseType, string | number>}`;
+
+export {};

package/source/keys-of-union.d.ts

@@ -0,0 +1,44 @@
+import type {UnionToIntersection} from './union-to-intersection.d.ts';
+
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+export type KeysOfUnion<ObjectType> =
+  // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+  keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+
+export {};

package/source/last-array-element.d.ts

@@ -0,0 +1,36 @@
+/**
+Extract the type of the last element of an array.
+
+Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
+
+@example
+```
+import type {LastArrayElement} from 'type-fest';
+
+declare function lastOf<const V extends readonly any[]>(array: V): LastArrayElement<V>;
+
+const last1 = lastOf(['foo', 'bar']);
+//=> 'bar'
+
+const last2 = lastOf([true, false, 'baz', 10]);
+//=> 10
+```
+
+@category Array
+@category Template literal
+*/
+export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> =
+	// If the last element of an array is a spread element, the `LastArrayElement` result should be `'the type of the element before the spread element' | 'the type of the spread element'`.
+	Elements extends readonly []
+		? ElementBeforeTailingSpreadElement
+		: Elements extends readonly [...infer U, infer V]
+			? V
+			: Elements extends readonly [infer U, ...infer V]
+				// If we return `V[number] | U` directly, it would be wrong for `[[string, boolean, object, ...number[]]`.
+				// So we need to recurse type `V` and carry over the type of the element before the spread element.
+				? LastArrayElement<V, U>
+				: Elements extends ReadonlyArray<infer U>
+					? U | ElementBeforeTailingSpreadElement
+					: never;
+
+export {};

package/source/less-than-or-equal.d.ts

@@ -0,0 +1,24 @@
+import type {GreaterThan} from './greater-than.d.ts';
+
+/**
+ Returns a boolean for whether a given number is less than or equal to another number.
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+type A = LessThanOrEqual<1, -5>;
+//=> false
+
+type B = LessThanOrEqual<1, 1>;
+//=> true
+
+type C = LessThanOrEqual<1, 5>;
+//=> true
+```
+*/
+export type LessThanOrEqual<A extends number, B extends number> = number extends A | B
+	? never
+	: GreaterThan<A, B> extends true ? false : true;
+
+export {};

package/source/less-than.d.ts

@@ -0,0 +1,28 @@
+import type {GreaterThanOrEqual} from './greater-than-or-equal.d.ts';
+
+/**
+Returns a boolean for whether a given number is less than another number.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+type A = LessThan<1, -5>;
+//=> false
+
+type B = LessThan<1, 1>;
+//=> false
+
+type C = LessThan<1, 5>;
+//=> true
+```
+*/
+export type LessThan<A extends number, B extends number> = number extends A | B
+	? never
+	: GreaterThanOrEqual<A, B> extends infer Result
+		? Result extends true
+			? false
+			: true
+		: never; // Should never happen
+
+export {};

package/source/literal-to-primitive-deep.d.ts

@@ -0,0 +1,71 @@
+import type {LiteralToPrimitive} from './literal-to-primitive.d.ts';
+import type {OmitIndexSignature} from './omit-index-signature.d.ts';
+
+/**
+Like `LiteralToPrimitive` except it converts literal types inside an object or array deeply.
+
+For example, given a constant object, it returns a new object type with the same keys but with all the values converted to primitives.
+
+@see {@link LiteralToPrimitive}
+
+Use-case: Deal with data that is imported from a JSON file.
+
+@example
+```
+import type {LiteralToPrimitiveDeep} from 'type-fest';
+
+const config = {
+	appName: 'MyApp',
+	version: '1.0.0',
+	maxRetries: 3,
+	enableLogging: true,
+	apiUrl: 'https://api.myapp.com/v1',
+} as const;
+
+declare function updateConfig(newConfig: typeof config): void;
+
+updateConfig({
+	// @ts-expect-error
+	appName: 'MyUpdatedApp',
+	// Error: Type '"MyUpdatedApp"' is not assignable to type '"MyApp"'.
+
+	// @ts-expect-error
+	version: '2.0.0',
+	// Error: Type '"2.0.0"' is not assignable to type '"1.0.0"'.
+
+	// @ts-expect-error
+	maxRetries: 1,
+	// Error: Type '1' is not assignable to type '3'.
+
+	// @ts-expect-error
+	enableLogging: false,
+	// Error: Type 'false' is not assignable to type 'true'.
+
+	// @ts-expect-error
+	apiUrl: 'https://api.myapp.com/v2',
+	// Error: Type '"https://api.myapp.com/v2"' is not assignable to type '"https://api.myapp.com/v1"'.
+});
+
+declare function updateConfigFixed(newConfig: LiteralToPrimitiveDeep<typeof config>): void;
+
+updateConfigFixed({
+	appName: 'MyUpdatedApp',
+	version: '2.0.0',
+	maxRetries: 1,
+	enableLogging: false,
+	apiUrl: 'https://api.myapp.com/v2',
+});
+```
+
+@category Type
+@category Object
+*/
+export type LiteralToPrimitiveDeep<T> = T extends object
+	? T extends Array<infer U>
+		? Array<LiteralToPrimitiveDeep<U>>
+		: {
+			[K in keyof OmitIndexSignature<T>]: LiteralToPrimitiveDeep<T[K]>;
+		}
+	: LiteralToPrimitive<T>;
+
+export {};

package/source/literal-to-primitive.d.ts

@@ -0,0 +1,38 @@
+/**
+Given a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) return the {@link Primitive | primitive type} it belongs to, or `never` if it's not a primitive.
+
+Use-case: Working with generic types that may be literal types.
+
+@example
+```
+import type {LiteralToPrimitive} from 'type-fest';
+
+// No overloads needed to get the correct return type
+function plus<T extends number | bigint | string>(x: T, y: T): LiteralToPrimitive<T> {
+	return x + (y as any);
+}
+
+plus('a', 'b'); // string
+plus(1, 2); // number
+plus(1n, 2n); // bigint
+```
+
+@category Type
+*/
+export type LiteralToPrimitive<T> = T extends number
+	? number
+	: T extends bigint
+		? bigint
+		: T extends string
+			? string
+			: T extends boolean
+				? boolean
+				: T extends symbol
+					? symbol
+					: T extends null
+						? null
+						: T extends undefined
+							? undefined
+							: never;
+
+export {};

package/source/literal-union.d.ts

@@ -0,0 +1,39 @@
+import type {Primitive} from './primitive.d.ts';
+
+export type _LiteralStringUnion<T> = LiteralUnion<T, string>;
+
+/**
+Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const petWithoutAutocomplete: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const petWithAutoComplete: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+export type LiteralUnion<
+	LiteralType,
+	BaseType extends Primitive,
+> = LiteralType | (BaseType & Record<never, never>);
+
+export {};