feat: remove case transformation , startIndex and improve JsDoc examples

Author: benzaria

source/union-to-enum.d.ts

@@ -1,34 +1,8 @@
-import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {UnionToTuple} from './union-to-tuple.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
-import type {BuildTuple} from './internal/tuple.d.ts';
-import type {CamelCase} from './camel-case.d.ts';
 import type {Simplify} from './simplify.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
-/**
-{@link UnionToEnum} Options.
-*/
-type UnionToEnumOptions = {
-	/**
-	The starting **Index** of Numeric enums.
-
-	@default 1
-	*/
-	startIndex?: number;
-	/**
-	Whether to use **CamelCase** for property names.
-
-	@default false
-	*/
-	camelCase?: boolean;
-};
-
-type DefaultUnionToEnumOptions = {
-	startIndex: 1;
-	camelCase: false;
-};
-
 /**
 Converts a union or tuple of property keys (string, number, or symbol) into an **Enum**-like object.
 
@@ -37,37 +11,39 @@ The keys are preserved, and their values are either:
 - Their own literal values (by default)
 - Or numeric indices (`1`, `2`, ...) if `Numeric` is `true`
 
-By default, **Property** names are not **CamelCased** and **Numeric Enums** start from **Index `1`**. See {@link UnionToEnumOptions} to change this behaviour.
-
-This is useful for creating strongly typed enums from a union of literals.
+This is useful for creating strongly typed enums from a union/tuple of literals.
 
 @example-types
 ```
+import type {UnionToEnum} from 'type-fest';
+
 type E1 = UnionToEnum<'A' | 'B' | 'C'>;
 //=> { A: 'A'; B: 'B'; C: 'C' }
 
 type E2 = UnionToEnum<'X' | 'Y' | 'Z', true>;
 //=> { X: 1; Y: 2; Z: 3 }
 
-type E3 = UnionToEnum<['Play', 'Pause', 'Stop'], true, {startIndex: 3}>;
-//=> { Play: 3; Pause: 4; Stop: 5 }
+type E3 = UnionToEnum<['Play', 'Pause', 'Stop'], true>;
+//=> { Play: 1; Pause: 2; Stop: 3 }
 
-type E4 = UnionToEnum<['some_key', 'another_key'], false, {camelCase: true}>;
-//=> { someKey: 'some_key'; anotherKey: 'another_key' }
+type E4 = UnionToEnum<['some_key', 'another_key']>;
+//=> { 'some_key': 'some_key'; 'another_key': 'another_key' }
 
 type E5 = UnionToEnum<never>;
 //=> {}
 ```
 
 @example-function
 ```
+import type {UnionToEnum, CamelCasedProperties} from 'type-fest';
+
 const verb = ['write', 'read', 'delete'] as const;
 const resrc = ['file', 'folder', 'link'] as const;
 
 declare function createEnum<
 	const T extends readonly string[],
 	const U extends readonly string[],
->(x: T, y: U): UnionToEnum<`${T[number]}_${U[number]}`, false, {camelCase: true}>;
+>(x: T, y: U): CamelCasedProperties<UnionToEnum<`${T[number]}_${U[number]}`>>;
 
 const Template = createEnum(verb, resrc);
 //=> {
@@ -90,25 +66,21 @@ const Template = createEnum(verb, resrc);
 export type UnionToEnum<
 	Keys extends PropertyKey | readonly PropertyKey[],
 	Numeric extends boolean = false,
-	Options extends UnionToEnumOptions = {},
-> = ApplyDefaultOptions<UnionToEnumOptions, DefaultUnionToEnumOptions, Options> extends infer ResolvedOptions extends Required<UnionToEnumOptions>
-	? IsNever<Keys> extends true ? {}
-		: _UnionToEnum<[
-			...BuildTuple<ResolvedOptions['startIndex']>,
-			...[Keys] extends [UnknownArray] ? Keys : UnionToTuple<Keys>,
-		], Numeric, ResolvedOptions['camelCase']>
-	: never;
+> = IsNever<Keys> extends true ? {}
+	: _UnionToEnum<[never, // Shift the index by 1
+		...[Keys] extends [UnknownArray] ? Keys : UnionToTuple<Keys>,
+	], Numeric>;
 
+/**
+Core type for {@link UnionToEnum}.
+*/
 type _UnionToEnum<
 	Keys extends UnknownArray,
 	Numeric extends boolean,
-	CamelCase_ extends boolean,
 > = Simplify<{readonly [
 	K in keyof Keys as K extends `${number}`
 		? Keys[K] extends PropertyKey
-			? CamelCase_ extends true
-				? CamelCase<Keys[K]>
-				: Keys[K]
+			? Keys[K]
 			: never
 		: never
 	]: Numeric extends true

test-d/union-to-enum.ts

@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {UnionToEnum} from '../index.d.ts';
+import type {CamelCasedProperties, UnionToEnum} from '../index.d.ts';
 
 // Union input
 expectType<UnionToEnum<'b' | 'a' | 'd' | 'c'>>({b: 'b', a: 'a', d: 'd', c: 'c'} as const);
@@ -15,17 +15,11 @@ expectType<UnionToEnum<'Only', true>>({Only: 1} as const);
 
 // Tuple with numeric keys
 expectType<UnionToEnum<[1, 2, 3]>>({1: 1, 2: 2, 3: 3} as const);
-expectType<UnionToEnum<[1, 2, 3], true, {startIndex: 10}>>({1: 10, 2: 11, 3: 12} as const);
+expectType<UnionToEnum<[1, 2, 3], true>>({1: 1, 2: 2, 3: 3} as const);
 
 // Mixed keys
 expectType<UnionToEnum<['a', 1, 'b']>>({a: 'a', 1: 1, b: 'b'} as const);
-expectType<UnionToEnum<['a', 1, 'b'], true, {startIndex: 0}>>({a: 0, 1: 1, b: 2} as const);
-
-// Literal const arrays
-const buttons = ['Play', 'Pause', 'Stop'] as const;
-
-expectType<UnionToEnum<typeof buttons>>({Play: 'Play', Pause: 'Pause', Stop: 'Stop'} as const);
-expectType<UnionToEnum<typeof buttons, true, {startIndex: 0}>>({Play: 0, Pause: 1, Stop: 2} as const);
+expectType<UnionToEnum<['a', 1, 'b'], true>>({a: 1, 1: 2, b: 3} as const);
 
 // Symbol keys
 declare const sym1: unique symbol;
@@ -51,27 +45,28 @@ expectType<UnionToEnum<number[]>>({} as const);
 expectType<UnionToEnum<symbol[]>>({} as const);
 
 // `never` / `any`
-expectType<UnionToEnum<never>>({} as const);
-expectType<UnionToEnum<any>>({} as const);
+expectType<UnionToEnum<never>>({});
+expectType<UnionToEnum<any>>({});
+
+// Literal const arrays
+const buttons = ['Play', 'Pause', 'Stop'] as const;
+
+expectType<UnionToEnum<typeof buttons>>({Play: 'Play', Pause: 'Pause', Stop: 'Stop'} as const);
+expectType<UnionToEnum<typeof buttons, true>>({Play: 1, Pause: 2, Stop: 3} as const);
 
-// CamelCase
 const level = ['DEBUG', 'INFO', 'ERROR', 'WARNING'] as const;
-expectType<UnionToEnum<typeof buttons, false, {camelCase: true}>>({
-	play: 'Play',
-	pause: 'Pause',
-	stop: 'Stop',
-} as const);
-expectType<UnionToEnum<typeof level, false, {camelCase: true}>>({
-	debug: 'DEBUG',
-	info: 'INFO',
-	error: 'ERROR',
-	warning: 'WARNING',
+
+expectType<UnionToEnum<typeof level>>({
+	DEBUG: 'DEBUG',
+	INFO: 'INFO',
+	ERROR: 'ERROR',
+	WARNING: 'WARNING',
 } as const);
-expectType<UnionToEnum<typeof level, true, {camelCase: true}>>({
-	debug: 1,
-	info: 2,
-	error: 3,
-	warning: 4,
+expectType<UnionToEnum<typeof level, true>>({
+	DEBUG: 1,
+	INFO: 2,
+	ERROR: 3,
+	WARNING: 4,
 } as const);
 
 // Dynamic Enum
@@ -81,7 +76,7 @@ const resrc = ['file', 'folder', 'link'] as const;
 declare function createEnum<
 	const T extends readonly string[],
 	const U extends readonly string[],
->(x: T, y: U): UnionToEnum<`${T[number]}_${U[number]}`, false, {camelCase: true}>;
+>(x: T, y: U): CamelCasedProperties<UnionToEnum<`${T[number]}_${U[number]}`>>;
 
 const Template = createEnum(verb, resrc);