DelimiterCase: Pass Options generic to all related types (#1078)

Co-authored-by: Som Shekhar Mukherjee <[email protected]>
Co-authored-by: Sindre Sorhus <[email protected]>

Author: 3 people

source/delimiter-cased-properties-deep.d.ts

@@ -1,6 +1,7 @@
-import type {DelimiterCase} from './delimiter-case';
-import type {NonRecursiveType} from './internal';
+import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
+import type {ApplyDefaultOptions, NonRecursiveType} from './internal';
 import type {UnknownArray} from './unknown-array';
+import type {WordsOptions} from './words';
 
 /**
 Convert object properties to delimiter case recursively.
@@ -40,6 +41,16 @@ const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
 		},
 	],
 };
+
+const splitOnNumbers: DelimiterCasedPropertiesDeep<{line1: { line2: [{ line3: string }] }}, '-', {splitOnNumbers: true}> = {
+	'line-1': {
+		'line-2': [
+			{
+				'line-3': 'string',
+			},
+		],
+	},
+};
 ```
 
 @category Change case
@@ -49,34 +60,47 @@ const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
 export type DelimiterCasedPropertiesDeep<
 	Value,
 	Delimiter extends string,
+	Options extends WordsOptions = {},
+> = _DelimiterCasedPropertiesDeep<Value, Delimiter, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;
+
+type _DelimiterCasedPropertiesDeep<
+	Value,
+	Delimiter extends string,
+	Options extends Required<WordsOptions>,
 > = Value extends NonRecursiveType
 	? Value
 	: Value extends UnknownArray
-		? DelimiterCasedPropertiesArrayDeep<Value, Delimiter>
+		? DelimiterCasedPropertiesArrayDeep<Value, Delimiter, Options>
 		: Value extends Set<infer U>
-			? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
+			? Set<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>> : {
 				[K in keyof Value as DelimiterCase<
 				K,
-				Delimiter
-				>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
+				Delimiter,
+				Options
+				>]: _DelimiterCasedPropertiesDeep<Value[K], Delimiter, Options>;
 			};
 
 // This is a copy of CamelCasedPropertiesArrayDeep (see: camel-cased-properties-deep.d.ts).
 // These types should be kept in sync.
-type DelimiterCasedPropertiesArrayDeep<Value extends UnknownArray, Delimiter extends string> =
-	Value extends []
-		? []
-		// Tailing spread array
-		:	Value extends [infer U, ...infer V]
-			? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>]
-			: Value extends readonly [infer U, ...infer V]
-				? readonly [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>]
-				// Leading spread array
+type DelimiterCasedPropertiesArrayDeep<
+	Value extends UnknownArray,
+	Delimiter extends string,
+	Options extends Required<WordsOptions>,
+> = Value extends []
+	? []
+	// Trailing spread array
+	:	Value extends [infer U, ...infer V]
+		? [_DelimiterCasedPropertiesDeep<U, Delimiter, Options>, ..._DelimiterCasedPropertiesDeep<V, Delimiter, Options>]
+		: Value extends readonly [infer U, ...infer V]
+			? readonly [_DelimiterCasedPropertiesDeep<U, Delimiter, Options>, ..._DelimiterCasedPropertiesDeep<V, Delimiter, Options>]
+			// Leading spread array
+			: Value extends [...infer U, infer V]
+				? [..._DelimiterCasedPropertiesDeep<U, Delimiter, Options>, _DelimiterCasedPropertiesDeep<V, Delimiter, Options>]
 				: Value extends readonly [...infer U, infer V]
-					? [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>]
+					? readonly [..._DelimiterCasedPropertiesDeep<U, Delimiter, Options>, _DelimiterCasedPropertiesDeep<V, Delimiter, Options>]
 					// Array
 					: Value extends Array<infer U>
-						? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
+						? Array<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>>
 						: Value extends ReadonlyArray<infer U>
-							? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>>
+							? ReadonlyArray<_DelimiterCasedPropertiesDeep<U, Delimiter, Options>>
 							: never;

source/delimiter-cased-properties.d.ts

@@ -1,4 +1,6 @@
-import type {DelimiterCase} from './delimiter-case';
+import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
 
 /**
 Convert object properties to delimiter case but not recursively.
@@ -21,6 +23,10 @@ const result: DelimiterCasedProperties<User, '-'> = {
 	'user-id': 1,
 	'user-name': 'Tom',
 };
+
+const splitOnNumbers: DelimiterCasedProperties<{line1: string}, '-', {splitOnNumbers: true}> = {
+	'line-1': 'string',
+};
 ```
 
 @category Change case
@@ -30,8 +36,11 @@ const result: DelimiterCasedProperties<User, '-'> = {
 export type DelimiterCasedProperties<
 	Value,
 	Delimiter extends string,
+	Options extends WordsOptions = {},
 > = Value extends Function
 	? Value
 	: Value extends Array<infer U>
 		? Value
-		: {[K in keyof Value as DelimiterCase<K, Delimiter>]: Value[K]};
+		: {[K in keyof Value as
+			DelimiterCase<K, Delimiter, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>
+			]: Value[K]};

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

@@ -1,4 +1,7 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
 import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
 
 /**
 Convert object properties to kebab case recursively.
@@ -38,10 +41,23 @@ const result: KebabCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
+
+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> = DelimiterCasedPropertiesDeep<Value, '-'>;
+export type KebabCasedPropertiesDeep<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedPropertiesDeep<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

source/kebab-cased-properties.d.ts

@@ -1,4 +1,7 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
 import type {DelimiterCasedProperties} from './delimiter-cased-properties';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
 
 /**
 Convert object properties to kebab case but not recursively.
@@ -21,10 +24,17 @@ 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> = DelimiterCasedProperties<Value, '-'>;
+export type KebabCasedProperties<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedProperties<Value, '-', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

source/snake-case.d.ts

@@ -14,7 +14,8 @@ import type {SnakeCase} from 'type-fest';
 // Simple
 
 const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
-const someVariableNoSplitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p_network';
+const noSplitOnNumbers: SnakeCase<'p2pNetwork'> = 'p2p_network';
+const splitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: true}> = 'p_2_p_network';
 
 // Advanced
 

source/snake-cased-properties-deep.d.ts

@@ -1,4 +1,7 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
 import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
 
 /**
 Convert object properties to snake case recursively.
@@ -38,10 +41,23 @@ const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
+
+const splitOnNumbers: SnakeCasedPropertiesDeep<{line1: { line2: [{ line3: string }] }}, {splitOnNumbers: true}> = {
+	line_1: {
+		line_2: [
+			{
+				line_3: 'string',
+			},
+		],
+	},
+};
 ```
 
 @category Change case
 @category Template literal
 @category Object
 */
-export type SnakeCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '_'>;
+export type SnakeCasedPropertiesDeep<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedPropertiesDeep<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

source/snake-cased-properties.d.ts

@@ -1,4 +1,7 @@
+import type {DefaultDelimiterCaseOptions} from './delimiter-case';
 import type {DelimiterCasedProperties} from './delimiter-cased-properties';
+import type {ApplyDefaultOptions} from './internal';
+import type {WordsOptions} from './words';
 
 /**
 Convert object properties to snake case but not recursively.
@@ -21,10 +24,17 @@ const result: SnakeCasedProperties<User> = {
 	user_id: 1,
 	user_name: 'Tom',
 };
+
+const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
+	'line_1': 'string',
+};
 ```
 
 @category Change case
 @category Template literal
 @category Object
 */
-export type SnakeCasedProperties<Value> = DelimiterCasedProperties<Value, '_'>;
+export type SnakeCasedProperties<
+	Value,
+	Options extends WordsOptions = {},
+> = DelimiterCasedProperties<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;

test-d/delimiter-cased-properties-deep.ts

@@ -10,6 +10,9 @@ expectType<() => {a: string}>(fooBar);
 declare const bar: DelimiterCasedPropertiesDeep<Set<{fooBar: string}>, '-'>;
 expectType<Set<{'foo-bar': string}>>(bar);
 
+declare const withOptions: DelimiterCasedPropertiesDeep<Set<{helloWorld: {p2p: Array<{addressLine1: string}>}}>, '.', {splitOnNumbers: true}>;
+expectType<Set<{'hello.world': {'p.2.p': Array<{'address.line.1': string}>}}>>(withOptions);
+
 // Verify example
 type User = {
 	userId: number;

test-d/delimiter-cased-properties.ts

@@ -10,6 +10,9 @@ expectType<Array<{helloWorld: string}>>(bar);
 declare const fooBar: DelimiterCasedProperties<() => {a: string}, '-'>;
 expectType<() => {a: string}>(fooBar);
 
+declare const withOptions: DelimiterCasedProperties<{helloWorld1: {fooBar: string}}, '.', {splitOnNumbers: true}>;
+expectType<{'hello.world.1': {fooBar: string}}>(withOptions);
+
 // Verify example
 type User = {
 	userId: number;

test-d/kebab-cased-properties-deep.ts

@@ -1,11 +1,13 @@
 import {expectType} from 'tsd';
 import type {KebabCasedPropertiesDeep} from '../index';
 
-declare const foo: KebabCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
-expectType<{'hello-world': {'foo-bar': string}}>(foo);
+type FooBar = {helloWorld: {p2p: Array<{addressLine1: string}>}};
 
-declare const bar: KebabCasedPropertiesDeep<Set<{fooBar: string}>>;
-expectType<Set<{'foo-bar': string}>>(bar);
+declare const foo: KebabCasedPropertiesDeep<FooBar>;
+expectType<{'hello-world': {p2p: Array<{'address-line1': string}>}}>(foo);
+
+declare const bar: KebabCasedPropertiesDeep<FooBar, {splitOnNumbers: true}>;
+expectType<{'hello-world': {'p-2-p': Array<{'address-line-1': string}>}}>(bar);
 
 // Verify example
 type User = {

test-d/kebab-cased-properties.ts

@@ -1,8 +1,13 @@
 import {expectType} from 'tsd';
 import type {KebabCasedProperties} from '../index';
 
-declare const foo: KebabCasedProperties<{helloWorld: {fooBar: string}}>;
-expectType<{'hello-world': {fooBar: string}}>(foo);
+type Foobar = {helloWorld1: {fooBar: string}};
+
+declare const foo: KebabCasedProperties<Foobar>;
+expectType<{'hello-world1': {fooBar: string}}>(foo);
+
+declare const bar: KebabCasedProperties<Foobar, {splitOnNumbers: true}>;
+expectType<{'hello-world-1': {fooBar: string}}>(bar);
 
 // Verify example
 type User = {

test-d/snake-cased-properties-deep.ts

@@ -1,11 +1,13 @@
 import {expectType} from 'tsd';
 import type {SnakeCasedPropertiesDeep} from '../index';
 
-declare const foo: SnakeCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
-expectType<{hello_world: {foo_bar: string}}>(foo);
+type FooBar = {helloWorld: {p2p: Array<{addressLine1: string}>}};
 
-declare const bar: SnakeCasedPropertiesDeep<Set<{fooBar: string}>>;
-expectType<Set<{foo_bar: string}>>(bar);
+declare const foo: SnakeCasedPropertiesDeep<FooBar>;
+expectType<{hello_world: {p2p: Array<{address_line1: string}>}}>(foo);
+
+declare const bar: SnakeCasedPropertiesDeep<FooBar, {splitOnNumbers: true}>;
+expectType<{hello_world: {p_2_p: Array<{address_line_1: string}>}}>(bar);
 
 // Verify example
 type User = {

test-d/snake-cased-properties.ts

@@ -1,8 +1,13 @@
 import {expectType} from 'tsd';
 import type {SnakeCasedProperties} from '../index';
 
-declare const foo: SnakeCasedProperties<{helloWorld: {fooBar: string}}>;
-expectType<{hello_world: {fooBar: string}}>(foo);
+type Foobar = {helloWorld1: {fooBar: string}};
+
+declare const foo: SnakeCasedProperties<Foobar>;
+expectType<{hello_world1: {fooBar: string}}>(foo);
+
+declare const bar: SnakeCasedProperties<Foobar, {splitOnNumbers: true}>;
+expectType<{hello_world_1: {fooBar: string}}>(bar);
 
 // Verify example
 type User = {