Strongly-typed string functions for all!
😬 The problem
When you are working with literal strings, the string manipulation functions only work at the runtime level and the types don't follow those transformations. You end up losing type information and possibly having to cast the result.
const str = 'hello-world' as const;
const result = str.replace('-', ' '); // you should use: as 'hello world'
// ^? string🤓 The solution
This library aims to solve this problem by providing a set of common functions that work with literal strings at both type and runtime level.
import { replace } from 'string-ts';
const str = 'hello-world' as const;
const result = replace(str, '-', ' ');
// ^ 'hello world'📦 Installation
npm install string-ts📖 API
- Runtime counterparts of native type utilities
- Strongly-typed alternatives to native runtime utilities
- Strongly-typed alternatives to common loosely-typed functions
- Strongly-typed deep transformation of objects
- Type Utilities
- Runtime-only utilities
Runtime counterparts of native type utilities
capitalize
Capitalizes the first letter of a string. This is a runtime counterpart of Capitalize<T> from src/types.d.ts.
import { capitalize } from 'string-ts';
const str = 'hello world' as const;
const result = capitalize(str);
// ^ 'Hello world'Strongly-typed alternatives to native runtime utilities
toUpperCase
This function is a strongly-typed counterpart of String.prototype.toUpperCase.
import { toUpperCase } from 'string-ts';
const str = 'hello world' as const;
const result = toUpperCase(str);
// ^ 'HELLO WORLD'toLowerCase
This function is a strongly-typed counterpart of String.prototype.toLowerCase.
import { toLowerCase } from 'string-ts';
const str = 'HELLO WORLD' as const;
const result = toLowerCase(str);
// ^ 'hello world'trim
This function is a strongly-typed counterpart of String.prototype.trim.
import { trim } from 'string-ts';
const str = ' hello world ' as const;
const result = trim(str);
// ^ 'hello world'trimStart
This function is a strongly-typed counterpart of String.prototype.trimStart.
import { trimStart } from 'string-ts';
const str = ' hello world ' as const;
const result = trimStart(str);
// ^ 'hello world 'trimEnd
This function is a strongly-typed counterpart of String.prototype.trimEnd.
import { trimEnd } from 'string-ts';
const str = ' hello world ' as const;
const result = trimEnd(str);
// ^ ' hello world'join
This function is a strongly-typed counterpart of Array.prototype.join.
import { join } from 'string-ts';
const str = ['hello', 'world'] as ['hello', 'world'];
const result = join(str, ' ');
// ^ 'hello world'replace
This function is a strongly-typed counterpart of String.prototype.replace.
import { replace } from 'string-ts';
const str = 'hello-world-' as const;
const result = replace(str, '-', ' ');
// ^ 'hello world-'replaceAll
This function is a strongly-typed counterpart of String.prototype.replaceAll.
import { replaceAll } from 'string-ts';
const str = 'hello-world-' as const;
const result = replaceAll(str, '-', ' ');
// ^ 'hello world 'split
This function is a strongly-typed counterpart of String.prototype.split.
import { split } from 'string-ts';
const str = 'hello-world' as const;
const result = split(str, '-');
// ^ ['hello', 'world']Strongly-typed alternatives to common loosely-typed functions
words
This function identifies the words in a string and returns a tuple of words split by separators, differences in casing, numbers, and etc.
import { words } from 'string-ts';
const str = '-20someVery-weird String' as const;
const result = words(str);
// ^ ['20', 'some', 'Very', 'weird', 'String']toDelimiterCase
This function converts a string to a new case with a custom delimiter at both runtime and type levels.
import { toDelimiterCase } from 'string-ts';
const str = 'helloWorld' as const;
const result = toDelimiterCase(str, '.');
// ^ 'hello.World'toCamelCase
This function converts a string to camelCase at both runtime and type levels.
import { toCamelCase } from 'string-ts';
const str = 'hello-world' as const;
const result = toCamelCase(str);
// ^ 'helloWorld'toPascalCase
This function converts a string to PascalCase at both runtime and type levels.
import { toPascalCase } from 'string-ts';
const str = 'hello-world' as const;
const result = toPascalCase(str);
// ^ 'HelloWorld'toKebabCase
This function converts a string to kebab-case at both runtime and type levels.
import { toKebabCase } from 'string-ts';
const str = 'helloWorld' as const;
const result = toKebabCase(str);
// ^ 'hello-world'toSnakeCase
This function converts a string to snake_case at both runtime and type levels.
import { toSnakeCase } from 'string-ts';
const str = 'helloWorld' as const;
const result = toSnakeCase(str);
// ^ 'hello_world'toConstantCase
This function converts a string to CONSTANT_CASE at both runtime and type levels.
import { toConstantCase } from 'string-ts';
const str = 'helloWorld' as const;
const result = toConstantCase(str);
// ^ 'HELLO_WORLD'toTitleCase
This function converts a string to Title Case at both runtime and type levels.
import { toTitleCase } from 'string-ts';
const str = 'helloWorld' as const;
const result = toTitleCase(str);
// ^ 'Hello World'Strongly-typed deep transformation of objects
deepDelimiterKeys
This function recursively converts the keys of an object to a new case with a custom delimiter at both runtime and type levels.
import { deepDelimiterKeys } from 'string-ts';
const data = {
'hello-world': {
'foo-bar': 'baz',
},
} as const;
const result = deepDelimiterKeys(data, '.');
// ^ { 'hello.world': { 'foo.bar': 'baz' } }deepCamelKeys
This function recursively converts the keys of an object to camelCase at both runtime and type levels.
import { deepCamelKeys } from 'string-ts';
const data = {
'hello-world': {
'foo-bar': 'baz',
},
} as const;
const result = deepCamelKeys(data);
// ^ { helloWorld: { fooBar: 'baz' } }deepPascalKeys
This function recursively converts the keys of an object to PascalCase at both runtime and type levels.
import { deepPascalKeys } from 'string-ts';
const data = {
'hello-world': {
'foo-bar': 'baz',
},
} as const;
const result = deepPascalKeys(data);
// ^ { HelloWorld: { FooBar: 'baz' } }deepKebabKeys
This function recursively converts the keys of an object to kebab-case at both runtime and type levels.
import { deepKebabKeys } from 'string-ts';
const data = {
'helloWorld': {
'fooBar': 'baz',
},
} as const;
const result = deepKebabKeys(data);
// ^ { 'hello-world': { 'foo-bar': 'baz' } }deepSnakeKeys
This function recursively converts the keys of an object to snake_case at both runtime and type levels.
import { deepSnakeKeys } from 'string-ts';
const data = {
'helloWorld': {
'fooBar': 'baz',
},
} as const;
const result = deepSnakeKeys(data);
// ^ { 'hello_world': { 'foo_bar': 'baz' } }deepConstantKeys
This function recursively converts the keys of an object to CONSTANT_CASE at both runtime and type levels.
import { deepConstantKeys } from 'string-ts';
const data = {
'helloWorld': {
'fooBar': 'baz',
},
} as const;
const result = deepConstantKeys(data);
// ^ { 'HELLO_WORLD': { 'FOO_BAR': 'baz' } }Type Utilities
All the functions presented in this API have associated type counterparts.
import type * as St from 'string-ts';Native TS type utilities
Capitalize<'hello world'> // 'Hello world'
Lowercase<'HELLO WORLD'> // 'hello world'
Uppercase<'hello world'> // 'HELLO WORLD'General Type utilities from this library
St.Words<'hello-world'> // ['hello', 'world']
St.Join<['hello', 'world'], '-'> // 'hello-world'
St.Replace<'hello-world', 'l', '1'> // 'he1lo-world'
St.ReplaceAll<'hello-world', 'l', '1'> // 'he11o-wor1d'
St.Split<'hello-world', '-'> // ['hello', 'world']
St.TrimStart<' hello world '> // 'hello world '
St.TrimEnd<' hello world '> // ' hello world'
St.Trim<' hello world '> // 'hello world'Casing type utilities
St.CamelCase<'hello-world'> // 'helloWorld'
St.PascalCase<'hello-world'> // 'HelloWorld'
St.KebabCase<'helloWorld'> // 'hello-world'
St.SnakeCase<'helloWorld'> // 'hello_world'
St.ConstantCase<'helloWorld'> // 'HELLO_WORLD'
St.TitleCase<'helloWorld'> // 'Hello World'
St.DelimiterCase<'hello world', '.'> // 'hello.world'
St.DeepDelimiterKeys<{
'hello-world': { 'foo-bar': 'baz' }
}, '.'> // { 'hello.world': { 'foo.bar': 'baz' } }
St.DeepCamelKeys<{
'hello-world': { 'foo-bar': 'baz' }
}> // { helloWorld: { fooBar: 'baz' } }
St.DeepPascalKeys<{
'hello-world': { 'foo-bar': 'baz' }
}> // { HelloWorld: { FooBar: 'baz' } }
St.DeepKebabKeys<{
'helloWorld': { 'fooBar': 'baz' }
}> // { 'hello-world': { 'foo-bar': 'baz' } }
St.DeepSnakeKeys<{
'helloWorld': { 'fooBar': 'baz' }
}> // { 'hello_world': { 'foo_bar': 'baz' } }
St.DeepConstantKeys<{
'helloWorld': { 'fooBar': 'baz' }
}> // { 'HELLO_WORLD': { 'FOO_BAR': 'baz' } }Other exported type utilities
St.IsDigit<'a'> // false
St.IsDigit<'1'> // true
St.IsLetter<'a'> // true
St.IsLetter<'1'> // false
St.IsLower<'a'> // true
St.IsLower<'A'> // false
St.IsUpper<'a'> // false
St.IsUpper<'A'> // true
St.IsSeparator<' '> // true
St.IsSeparator<'-'> // true
St.IsSeparator<'a'> // false
St.IsSpecial<'a'> // false
St.IsSpecial<'!'> // true
St.IsSpecial<' '> // falseRuntime-only utilities
deepTransformKeys
This function recursively converts the keys of an object to a custom format, but only at runtime level.
import { deepTransformKeys, toUpperCase } from 'string-ts';
const data = { 'helloWorld': 'baz' } as const;
type MyType<T> = { [K in keyof T as Uppercase<K>]: T[K] }
const result = deepTransformKeys(data, toUpperCase) as MyType<typeof data>;
// ^ { 'HELLOWORLD': 'baz' }Disclaimer
This library doesn't support every internal character for the sake of keeping the maintainer's sanity.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent