Align behavior of [Camel|Pascal|Kebab|Snake]-Cased types with lodash

source/camel-case.d.ts

@@ -1,5 +1,5 @@
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
-import type {Words, WordsOptions} from './words.d.ts';
+import type {_DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
 
 /**
 CamelCase options.
@@ -15,8 +15,7 @@ export type CamelCaseOptions = WordsOptions & {
 	preserveConsecutiveUppercase?: boolean;
 };
 
-export type _DefaultCamelCaseOptions = {
-	splitOnNumbers: true;
+export type _DefaultCamelCaseOptions = _DefaultWordsOptions & {
 	preserveConsecutiveUppercase: false;
 };
 
@@ -49,8 +48,14 @@ import type {CamelCase} from 'type-fest';
 
 // Simple
 
-const someVariable: CamelCase<'foo-bar'> = 'fooBar';
-const preserveConsecutiveUppercase: CamelCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'fooBARBaz';
+type CamelCase1 = CamelCase<'foo-bar'>;
+//=> 'fooBar'
+
+type CamelCase2 = CamelCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}>;
+//=> 'fooBARBaz'
+
+type CamelCase3 = CamelCase<'foo-bar:BAZ', {splitOnPunctuation: true}>;
+//=> 'fooBarBaz'
 
 // Advanced
 

source/kebab-case.d.ts

@@ -12,12 +12,16 @@ This can be useful when, for example, converting a camel-cased object property t
 import type {KebabCase} from 'type-fest';
 
 // Simple
+type KebabCase1 = KebabCase<'fooBar'>;
+//=> 'foo-bar'
 
-const someVariable: KebabCase<'fooBar'> = 'foo-bar';
-const someVariableNoSplitOnNumbers: KebabCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p-network';
+type KebabCase2 = KebabCase<'p2pNetwork', {splitOnNumbers: false}>;
+//=> 'p2p-network'
 
-// Advanced
+type KebabCase3 = KebabCase<'div.card::after', {splitOnPunctuation: true}>;
+//=> 'div-card-after'
 
+// Advanced
 type KebabCasedProperties<T> = {
 	[K in keyof T as KebabCase<K>]: T[K]
 };

source/pascal-case.d.ts

@@ -10,8 +10,14 @@ import type {PascalCase} from 'type-fest';
 
 // Simple
 
-const someVariable: PascalCase<'foo-bar'> = 'FooBar';
-const preserveConsecutiveUppercase: PascalCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'FooBARBaz';
+type PascalCase1 = PascalCase<'foo-bar'>;
+//=> 'FooBar'
+
+type PascalCase2 = PascalCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}>;
+//=> 'FooBARBaz'
+
+type PascalCase3 = PascalCase<'foo-bar>>baz', {splitOnPunctuation: true}>;
+//=> 'FooBarBaz'
 
 // Advanced
 

source/snake-case.d.ts

@@ -12,10 +12,14 @@ This can be useful when, for example, converting a camel-cased object property t
 import type {SnakeCase} from 'type-fest';
 
 // Simple
+type SnakeCase1 = SnakeCase<'fooBar'>;
+//=> 'foo_bar'
 
-const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
-const noSplitOnNumbers: SnakeCase<'p2pNetwork'> = 'p2p_network';
-const splitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: true}> = 'p_2_p_network';
+type SnakeCase2 = SnakeCase<'p2pNetwork', {splitOnNumbers: false}>;
+//=> 'p2p_network'
+
+type SnakeCase3 = SnakeCase<'div.card::after', {splitOnPunctuation: true}>;
+//=> 'div_card_after'
 
 // Advanced
 

source/words.d.ts

@@ -1,5 +1,6 @@
 import type {
 	ApplyDefaultOptions,
+	AsciiPunctuation,
 	IsNumeric,
 	WordSeparators,
 } from './internal/index.d.ts';
@@ -38,55 +39,83 @@ export type WordsOptions = {
 	```
 	*/
 	splitOnNumbers?: boolean;
+	/**
+	Split on {@link AsciiPunctuation | punctuation characters} (e.g., `#`, `&`, `*`, `:`, `?`, `@`, `~`).
+
+	@example
+	```
+	import type {Words} from 'type-fest';
+
+	type Example1 = Words<'hello:world', {splitOnPunctuation: true}>;
+	//=> ['hello', 'world']
+
+	type Example2 = Words<'hello:world', {splitOnPunctuation: false}>;
+	//=> ['hello', ':world']
+	```
+	*/
+	splitOnPunctuation?: boolean;
 };
 
 export type _DefaultWordsOptions = {
 	splitOnNumbers: true;
+	splitOnPunctuation: false;
 };
 
 /**
 Split a string (almost) like Lodash's `_.words()` function.
 
 - Split on each word that begins with a capital letter.
 - Split on each {@link WordSeparators}.
+- Split on each {@link AsciiPunctuation} (if {@link WordsOptions.splitOnPunctuation} is enabled).
 - Split on numeric sequence.
 
 @example
 ```
 import type {Words} from 'type-fest';
 
-type Words0 = Words<'helloWorld'>;
+type Words1 = Words<'helloWorld'>;
 //=> ['hello', 'World']
 
-type Words1 = Words<'helloWORLD'>;
+type Words2 = Words<'helloWORLD'>;
 //=> ['hello', 'WORLD']
 
-type Words2 = Words<'hello-world'>;
+type Words3 = Words<'hello-world'>;
 //=> ['hello', 'world']
 
-type Words3 = Words<'--hello the_world'>;
+type Words4 = Words<'--hello the_world'>;
 //=> ['hello', 'the', 'world']
 
-type Words4 = Words<'lifeIs42'>;
+type Words5 = Words<'lifeIs42'>;
 //=> ['life', 'Is', '42']
 
-type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
+type Words6 = Words<'p2pNetwork', {splitOnNumbers: false}>;
 //=> ['p2p', 'Network']
+
+type Words7 = Words<'hello:world'>;
+//=> ['hello', ':world']
+
+type Words8 = Words<'hello:world', {splitOnPunctuation: true}>;
+//=> ['hello', 'world']
 ```
 
 @category Change case
 @category Template literal
 */
-export type Words<Sentence extends string, Options extends WordsOptions = {}> =
-	WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>>;
+export type Words<
+	Sentence extends string,
+	Options extends WordsOptions = {},
+> = WordsImplementation<
+	Sentence,
+	ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>
+>;
 
 type WordsImplementation<
 	Sentence extends string,
 	Options extends Required<WordsOptions>,
 	LastCharacter extends string = '',
 	CurrentWord extends string = '',
 > = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}`
-	? FirstCharacter extends WordSeparators
+	? FirstCharacter extends WordSeparators | (Options['splitOnPunctuation'] extends true ? AsciiPunctuation : never)
 		// Skip word separator
 		? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>]
 		: LastCharacter extends ''

test-d/camel-case.ts

@@ -87,3 +87,13 @@ expectType<'a1BText'>('' as CamelCase<'a1b_text'>);
 
 expectType<'p2pNetwork'>('' as CamelCase<'p2pNetwork', {splitOnNumbers: false}>);
 expectType<'p2PNetwork'>('' as CamelCase<'p2pNetwork', {splitOnNumbers: true}>);
+
+// Punctuation
+expectType<CamelCase<'onDialog:close'>>('onDialog:close');
+expectType<CamelCase<'foo-bar>>baz'>>('fooBar>>baz');
+expectType<CamelCase<'foo-bar::01'>>('fooBar::01');
+
+expectType<CamelCase<'onDialog:close', {splitOnPunctuation: true}>>('onDialogClose');
+expectType<CamelCase<'foo-bar>>baz', {splitOnPunctuation: true}>>('fooBarBaz');
+expectType<CamelCase<'fooBAR:biz', {splitOnPunctuation: true; preserveConsecutiveUppercase: true}>>('fooBARBiz');
+expectType<CamelCase<'foo-bar::01', {splitOnPunctuation: true}>>('fooBar01');

test-d/kebab-case.ts

@@ -79,20 +79,21 @@ expectType<'fo-o2bar'>(kebabFromNumberInTheMiddleNoSplitOnNumbersEdgeCase2);
 const kebabFromNumberInTheMiddleNoSplitOnNumbersEdgeCase3: KebabCase<'FOO22Bar'> = 'foo22-bar';
 expectType<'foo22-bar'>(kebabFromNumberInTheMiddleNoSplitOnNumbersEdgeCase3);
 
-declare const withPunctuation: KebabCase<'onDialog:close'>;
-expectType<'on-dialog:close'>(withPunctuation);
+// Punctuation
+expectType<KebabCase<'onDialog:close'>>('on-dialog:close');
+expectType<KebabCase<'foo-bar>>baz'>>('foo-bar>>baz');
+expectType<KebabCase<'card::after'>>('card::after');
+expectType<KebabCase<'div.card::after'>>('div.card::after');
 
-declare const withPunctuation2: KebabCase<'foo-bar>>baz'>;
-expectType<'foo-bar>>baz'>(withPunctuation2);
+expectType<KebabCase<'onDialog:close', {splitOnPunctuation: true}>>('on-dialog-close');
+expectType<KebabCase<'foo-bar>>baz', {splitOnPunctuation: true}>>('foo-bar-baz');
+expectType<KebabCase<'card::after', {splitOnPunctuation: true}>>('card-after');
+expectType<KebabCase<'div.card::after', {splitOnPunctuation: true}>>('div-card-after');
 
-declare const withPunctuation3: KebabCase<'card::after'>;
-expectType<'card::after'>(withPunctuation3);
+// Punctuation with number
+expectType<KebabCase<'foo-bar::01'>>('foo-bar::01');
+expectType<KebabCase<'foo-bar::01', {splitOnNumbers: true}>>('foo-bar::-01');
 
-declare const withPunctuation4: KebabCase<'div.card::after'>;
-expectType<'div.card::after'>(withPunctuation4);
+expectType<KebabCase<'foo-bar::01', {splitOnPunctuation: true; splitOnNumbers: false}>>('foo-bar-01');
+expectType<KebabCase<'foo-bar::01', {splitOnNumbers: true; splitOnPunctuation: true}>>('foo-bar-01');
 
-declare const withPunctuationAndNumber: KebabCase<'foo-bar::01'>;
-expectType<'foo-bar::01'>(withPunctuationAndNumber);
-
-declare const withPunctuationAndNumber2: KebabCase<'foo-bar::01', {splitOnNumbers: true}>;
-expectType<'foo-bar::-01'>(withPunctuationAndNumber2);

test-d/pascal-case.ts

@@ -22,3 +22,14 @@ expectType<PascalCase<'foo\tBAR-Biz_BUZZ'>>('FooBarBizBuzz');
 
 expectType<PascalCase<string, {preserveConsecutiveUppercase: true}>>({} as Capitalize<string>);
 expectType<PascalCase<string>>({} as Capitalize<string>);
+
+// Punctuation
+expectType<PascalCase<'onDialog:close'>>('OnDialog:close');
+expectType<PascalCase<'foo-bar>>baz'>>('FooBar>>baz');
+expectType<PascalCase<'foo-bar::01'>>('FooBar::01');
+
+expectType<PascalCase<'onDialog:close', {splitOnPunctuation: true}>>('OnDialogClose');
+expectType<PascalCase<'foo-bar>>baz', {splitOnPunctuation: true}>>('FooBarBaz');
+expectType<PascalCase<'fooBAR:biz', {splitOnPunctuation: true; preserveConsecutiveUppercase: true}>>('FooBARBiz');
+expectType<PascalCase<'foo-bar::01', {splitOnPunctuation: true}>>('FooBar01');
+

test-d/snake-case.ts

@@ -82,20 +82,23 @@ expectType<'fo_o2bar'>(snakeFromNumberInTheMiddleNoSplitOnNumbersEdgeCase2);
 const snakeFromNumberInTheMiddleNoSplitOnNumbersEdgeCase3: SnakeCase<'FOO22Bar'> = 'foo22_bar';
 expectType<'foo22_bar'>(snakeFromNumberInTheMiddleNoSplitOnNumbersEdgeCase3);
 
-declare const withPunctuation: SnakeCase<'onDialog:close'>;
-expectType<'on_dialog:close'>(withPunctuation);
+// Punctuation
+expectType<SnakeCase<'onDialog:close'>>('on_dialog:close');
+expectType<SnakeCase<'foo-bar>>baz'>>('foo_bar>>baz');
+expectType<SnakeCase<'card::after'>>('card::after');
+expectType<SnakeCase<'div.card::after'>>('div.card::after');
+expectType<SnakeCase<'foo-bar::01'>>('foo_bar::01');
+
+expectType<SnakeCase<'onDialog:close', {splitOnPunctuation: true}>>('on_dialog_close');
+expectType<SnakeCase<'foo-bar>>baz', {splitOnPunctuation: true}>>('foo_bar_baz');
+expectType<SnakeCase<'card::after', {splitOnPunctuation: true}>>('card_after');
+expectType<SnakeCase<'div.card::after', {splitOnPunctuation: true}>>('div_card_after');
+expectType<SnakeCase<'foo-bar::01', {splitOnPunctuation: true}>>('foo_bar_01');
+
+// Punctuation with number
+expectType<SnakeCase<'foo-bar::01'>>('foo_bar::01');
+expectType<SnakeCase<'foo-bar::01', {splitOnNumbers: true}>>('foo_bar::_01');
+
+expectType<SnakeCase<'foo-bar::01', {splitOnPunctuation: true; splitOnNumbers: false}>>('foo_bar_01');
+expectType<SnakeCase<'foo-bar::01', {splitOnNumbers: true; splitOnPunctuation: true}>>('foo_bar_01');
 
-declare const withPunctuation2: SnakeCase<'foo-bar>>baz'>;
-expectType<'foo_bar>>baz'>(withPunctuation2);
-
-declare const withPunctuation3: SnakeCase<'card::after'>;
-expectType<'card::after'>(withPunctuation3);
-
-declare const withPunctuation4: SnakeCase<'div.card::after'>;
-expectType<'div.card::after'>(withPunctuation4);
-
-declare const withPunctuationAndNumber: SnakeCase<'foo-bar::01'>;
-expectType<'foo_bar::01'>(withPunctuationAndNumber);
-
-declare const withPunctuationAndNumber2: SnakeCase<'foo-bar::01', {splitOnNumbers: true}>;
-expectType<'foo_bar::_01'>(withPunctuationAndNumber2);

test-d/words.ts

@@ -93,3 +93,18 @@ expectType<Words<'01item01'>>(['01', 'item', '01']);
 expectType<Words<'10item10'>>(['10', 'item', '10']);
 expectType<Words<'010item010'>>(['010', 'item', '010']);
 expectType<Words<'item0_item_1 item -2'>>(['item', '0', 'item', '1', 'item', '2']);
+
+// SplitOnPunctuation
+expectType<Words<':'>>([':']);
+expectType<Words<'::'>>([':', ':']);
+expectType<Words<'hello::'>>(['hello', ':', ':']);
+expectType<Words<'hello:world'>>(['hello', ':world']);
+expectType<Words<'hello::world'>>(['hello', ':', ':world']);
+expectType<Words<'hello-braveNew:world'>>(['hello', 'brave', 'New', ':world']);
+
+expectType<Words<':', {splitOnPunctuation: true}>>([]);
+expectType<Words<'::', {splitOnPunctuation: true}>>([]);
+expectType<Words<'hello::', {splitOnPunctuation: true}>>(['hello']);
+expectType<Words<'hello:world', {splitOnPunctuation: true}>>(['hello', 'world']);
+expectType<Words<'hello::world', {splitOnPunctuation: true}>>(['hello', 'world']);
+expectType<Words<'hello-braveNew:world', {splitOnPunctuation: true}>>(['hello', 'brave', 'New', 'world']);