Utilities for manipulating and analyzing string types in TypeScript. These types allow you to trim, join, search, replace, capitalize, and analyze strings at the type level.

String Utilities

Utilities for manipulating and analyzing string types in TypeScript. These types allow you to trim, join, search, replace, capitalize, and analyze strings at the type level using template literal types.

Installation

npm i -D @halvaradop/ts-utility-types

Usage

import type { Trim, Capitalize, Join } from "@halvaradop/ts-utility-types"

import type * as Strings from "@halvaradop/ts-utility-types"


type Utilities = Strings.Absolute
AllEquals
AnyOf
AppendKeyValue
ArgsFunction
ArrayToUnion
Capitalize
Chunk
CompareArrayLength
ConstructTuple
DeepFilter
DeepGet
DeepKeys
DeepMerge
DeepMergeAll
DeepMutable
DeepNonNullable
DeepNonNullish
DeepNullable
DeepOmit
DeepPartial
DeepPick
DeepReadonly
DeepReplace
DeepRequired
DeepSet
DeepTruncate
DeepUnion
Discard
DropChar
EndsWith
Equals
ExcludePrivateKeys
Expect
Falsy
Filter
FilterNonNullish
FindAll
Flatten
FlattenProperties
Get
GetOptional
GetRequired
HasDuplicates
Includes
IndexOf
IndexOfString
Intersection
IsAny
IsArray
IsEven
IsFunction
IsNegative
IsNever
IsObject
IsOdd
IsPositive
Join
LastIndexOf
LengthOfString
LiteralUnion
MapTypes
Merge
MergeAll
Mutable
Not
Nullish
NumberRange
ObjectEntries
OmitByType
ParseUrlParams
PartialByKeys
PickByType
Prettify
Primitive
PrimitiveNullish
Properties
Replace
ReplaceKeys
RequiredByKeys
ReturnTypeOf
Reverse
Size
StartsWith
Take
ToPrimitive
ToUnion
Trim
TrimLeft
TrimRight
Trunc
Uniques
WhiteSpaces
Zip

Text Manipulation

`TrimLeft<Str, string>`

Removes whitespace from the start of a string type.

Argument	Type	Description
`Str`	`string`	The string to trim from the left.

import type { TrimLeft } from "@halvaradop/ts-utility-types"

type TrimmedLeft = TrimLeft<"  hello world  ">        
type TrimmedLeft = "hello world  "

type NoSpaces = TrimLeft<"hello world">
       
type NoSpaces = "hello world"

`TrimRight<Str, string>`

Removes whitespace from the end of a string type.

Argument	Type	Description
`Str`	`string`	The string to trim from the right.

import type { TrimRight } from "@halvaradop/ts-utility-types"

type TrimmedRight = TrimRight<"hello world  ">         
type TrimmedRight = "hello world"

type NoTrailing = TrimRight<"hello world">
        
type NoTrailing = "hello world"

`Trim<Str, string>`

Removes whitespace from both ends of a string type. Combines the functionality of TrimLeft and TrimRight.

Argument	Type	Description
`Str`	`string`	The string to trim.

Related: TrimLeft, TrimRight

import type { Trim } from "@halvaradop/ts-utility-types"

// Remove whitespace from both ends
type Trimmed = Trim<"  hello world  ">      
type Trimmed = "hello world"

// Already trimmed string
type AlreadyTrimmed = Trim<"no spaces">          
type AlreadyTrimmed = "no spaces"

// Only leading spaces
type LeadingSpaces = Trim<"  leading only">
         
type LeadingSpaces = "leading only"

Template Literal Types

String utilities leverage TypeScript's template literal types for compile-time string manipulation.

`Capitalize<Str, string, FirstWord, boolean = true>`

Capitalizes the first letter of a word and optionally lowercases the rest.

Argument	Type	Description
`Str`	`string`	The string to capitalize.
`FirstWord`	`boolean` (default `true`)	Whether to only capitalize the first word.

import type { Capitalize } from "@halvaradop/ts-utility-types"

type Capitalized = Capitalize<"hello world">        
type Capitalized = "Hello World"

type CapitalizeAll = Capitalize<"hello world", false>
         
type CapitalizeAll = "hello World"

`Join<Array, unknown[], Separator, number | string>`

Joins the values of a tuple into a string, using the given separator.

| Argument | Type | Description | | ----------- | ----------- | -------------------------------- | -------------------------------------- | | Array | unknown[] | The array to join into a string. | | Separator | number | string | The separator to use between elements. |

import type { Join } from "@halvaradop/ts-utility-types"

type JoinedDash = Join<["a", "p", "p", "l", "e"], "-">        
type JoinedDash = "a-p-p-l-e"

type JoinedSpace = Join<["Hello", "World"], " ">        
type JoinedSpace = "Hello World"

type JoinedNumber = Join<[1, 2, 3], "|">
         
type JoinedNumber = never

`StartsWith<Str, string, Match, string>`

Checks if a string type starts with the given value.

Argument	Type	Description
`Str`	`string`	The string to check.
`Match`	`string`	The substring to check for at start.

import type { StartsWith } from "@halvaradop/ts-utility-types"

type StartsWithAc = StartsWith<"abc", "ac">         
type StartsWithAc = false

type StartsWithAb = StartsWith<"abc", "ab">         
type StartsWithAb = true

type StartsWithHello = StartsWith<"hello world", "hello">
          
type StartsWithHello = true

`DropChar<Str, string, Match, string>`

Removes all occurrences of a character from a string type.

Argument	Type	Description
`Str`	`string`	The string to remove chars from.
`Match`	`string`	The character to remove.

import type { DropChar } from "@halvaradop/ts-utility-types"

type NoSpaces = DropChar<" b u t t e r f l y ! ", " ">       
type NoSpaces = "butterfly!"

type NoDashes = DropChar<"a-b-c-d", "-">
       
type NoDashes = "abcd"

`EndsWith<Str, string, Match, string>`

Checks if a string type ends with the given value.

Argument	Type	Description
`Str`	`string`	The string to check.
`Match`	`string`	The substring to check for at end.

import type { EndsWith } from "@halvaradop/ts-utility-types"

type EndsWithBc = EndsWith<"abc", "bc">        
type EndsWithBc = true

type EndsWithAc = EndsWith<"abc", "ac">        
type EndsWithAc = false

type EndsWithWorld = EndsWith<"hello world", "world">
         
type EndsWithWorld = true

`LengthOfString<Str, string>`

Returns the length of a string type as a numeric literal type.

Argument	Type	Description
`Str`	`string`	The string to get the length of.

import type { LengthOfString } from "@halvaradop/ts-utility-types"

type Length3 = LengthOfString<"foo">      
type Length3 = 3

type Length6 = LengthOfString<"foobar">      
type Length6 = 6

type EmptyLength = LengthOfString<"">
        
type EmptyLength = 0

`IndexOfString<Str, string, Match, string>`

Returns the index of the first occurrence of a character in the string. Returns -1 if not found.

Argument	Type	Description
`Str`	`string`	The string to search in.
`Match`	`string`	The character to search for.

import type { IndexOfString } from "@halvaradop/ts-utility-types"

type IndexO = IndexOfString<"foo", "o">      
type IndexO = 1

type NotFound = IndexOfString<"foo", "z">       
type NotFound = -1

type FirstA = IndexOfString<"banana", "a">
      
type FirstA = 1

String Utilities

On this page