import type {ApplyDefaultOptions} from './apply-default-options.d.ts'; import type {IfNotAnyOrNever} from './internal/type.d.ts'; import type {UnionToEnum} from './union-to-enum.d.ts'; // For `@link` import type {IsLiteral} from './is-literal.d.ts'; import type {Sum} from './sum.d.ts'; /** {@link TupleToEnum `TupleToEnum`} options. */ export type TupleToEnumOptions = { /** Use the index of each element as its value, instead of the element itself. @default false @example ``` import type {TupleToEnum} from 'type-fest'; type A = TupleToEnum<['play', 'pause']>; //=> {readonly play: 'play'; readonly pause: 'pause'} type B = TupleToEnum<['play', 'pause'], {numeric: true}>; //=> {readonly play: 0; readonly pause: 1} ``` */ numeric?: boolean; /** The value of the first element when `numeric` is `true`. Must be an integer. @default 0 @example ``` import type {TupleToEnum} from 'type-fest'; type A = TupleToEnum<['play', 'pause'], {numeric: true; startIndex: 1}>; //=> {readonly play: 1; readonly pause: 2} ``` */ startIndex?: number; }; type DefaultTupleToEnumOptions = { numeric: false; startIndex: 0; }; /** Create an enum-like object type from a tuple of property keys, where each key maps to itself, or to its index with the `numeric` option. Elements that are not literals, like `string` or `` `on${string}` ``, are ignored. Use-case: Type an object built from a list of values at runtime, like `Object.fromEntries(values.map((value, index) => [value, index]))`. Note: With `numeric`, a key that appears more than once gets a union of its indexes. In a generic function, use concrete option values before relying on the entry values. While any option is generic, TypeScript can read the result as if the default options were used. @example ``` import type {TupleToEnum} from 'type-fest'; const levels = ['debug', 'info', 'error'] as const; type Level = TupleToEnum; //=> {readonly debug: 'debug'; readonly info: 'info'; readonly error: 'error'} type LevelNumber = TupleToEnum; //=> {readonly debug: 0; readonly info: 1; readonly error: 2} ``` @see {@link UnionToEnum} @category Object */ export type TupleToEnum = IfNotAnyOrNever extends infer ResolvedOptions extends Required ? ResolvedOptions['numeric'] extends true // Inline, so that the result shows as an object instead of an internal alias. ? { readonly [Index in keyof Tuple as Index extends `${number}` ? IsLiteral extends true ? Tuple[Index] : never // Not a literal, like `string` or `` `on${string}` `` : never // Not an index ]: Index extends `${infer IndexNumber extends number}` // Inferred tuple indexes already have the correct value when the offset is zero. ? ResolvedOptions['startIndex'] extends 0 ? IndexNumber : Sum : never; // Not an index } : {readonly [Key in LiteralElements]: Key} : never // Should never happen : never; // Should never happen ifAny: {}; ifNever: {}; }>; // Filter per element, because a union like `string | 'foo'` collapses to `string` type LiteralElements = { [Index in keyof Tuple]: IsLiteral extends true ? Tuple[Index] : never; }[number]; export {};