type-fest
Version:
A collection of essential TypeScript types
95 lines (79 loc) • 3.35 kB
TypeScript
import type {AsciiPunctuationCharacter} from './ascii-punctuation-character.d.ts';
import type {Or} from './or.d.ts';
import type {UnwrapBrandedPrimitive} from './unwrap-branded-primitive.d.ts';
import type {ApplyDefaultOptions} from './apply-default-options.d.ts';
import type {StartsWith} from './starts-with.d.ts';
import type {IsStringLiteral} from './is-string-literal.d.ts';
import type {Merge} from './merge.d.ts';
import type {_DefaultWordsOptions, _Words, WordsOptions} from './words.d.ts';
import type {KebabCase} from './kebab-case.d.ts'; // For `@link`
import type {SnakeCase} from './snake-case.d.ts'; // For `@link`
export type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {splitOnNumbers: false}>;
/**
Convert an array of words to delimiter case, lowercasing words while preserving the delimiter.
*/
type DelimiterCaseFromArray<
WordList extends string[],
Delimiter extends string,
OutputString extends string = '',
> = WordList extends [
infer FirstWord extends string,
...infer RemainingWords extends string[],
]
? DelimiterCaseFromArray<RemainingWords, Delimiter, OutputString extends '' ? Lowercase<FirstWord> : `${OutputString}${
// With `splitOnPunctuation: false`, a delimiter is not emitted next to punctuation, or the two double up. `OutputString` ends with the last character of the previous word, so testing it covers the word that ends in punctuation, and `FirstWord` covers the one that begins with it.
Or<StartsWith<FirstWord, AsciiPunctuationCharacter>, EndsWithPunctuation<OutputString>> extends true
? ''
: Delimiter
}${Lowercase<FirstWord>}`>
: OutputString;
/**
Whether the given string ends in punctuation.
*/
type EndsWithPunctuation<String_ extends string> = String_ extends `${string}${AsciiPunctuationCharacter}` ? true : false;
/**
Convert a string literal to a custom string delimiter casing.
This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
@see {@link KebabCase}
@see {@link SnakeCase}
@example
```
import type {DelimiterCase} from 'type-fest';
// Simple
const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
const someVariableWithPunctuation: DelimiterCase<'div.card::after', '#'> = 'div#card#after';
const someVariableNoSplitOnPunctuation: DelimiterCase<'div.card::after', '#', {splitOnPunctuation: false}> = 'div.card::after';
// Advanced
type OddlyCasedProperties<Value> = {
[Key in keyof Value as DelimiterCase<Key, '#'>]: Value[Key];
};
type SomeOptions = {
dryRun: boolean;
includeFile: string;
foo: number;
};
const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
'dry#run': true,
'include#file': 'bar.js',
foo: 123,
};
```
@category Change case
@category Template literal
*/
export type DelimiterCase<
Value,
Delimiter extends string,
Options extends WordsOptions = {},
> = Value extends string
? Delimiter extends unknown // For distributing `Delimiter`
? IsStringLiteral<Value> extends false
? Value
: DelimiterCaseFromArray<
_Words<UnwrapBrandedPrimitive<Value>, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>,
Delimiter extends object ? UnwrapBrandedPrimitive<Delimiter> : Delimiter
>
: never
: Value;
export {};