@cutticat/types

TypeScript type library.

Contents

• Overview
• Installation
• Quick start
• API
• Documentation
• Requirements

Overview

This library provides a set of useful TypeScript types for working with strings, objects, nullability, mutability, and HTTP. The types are optimized for strict TypeScript projects and provide compile-time type safety.

Installation

pnpm i @cutticat/types

Quick start

import type {
  ToCamelCase,
  ToSnakeCase,
  Join,
  NestedRecord,
  DeepReadonly,
  FullyUndefinable,
  PathParams,
} from "@cutticat/types"

// String transformations
type CamelCase = ToCamelCase<"hello-world"> // "helloWorld"
type SnakeCase = ToSnakeCase<"helloWorld">   // "hello_world"
type Csv = Join<["red", "green", "blue"]> // "red,green,blue"

// Working with objects
type Nested = NestedRecord<["user", "address"], { city: string }>
// { user: { address: { city: string } } }
type ReadonlyConfig = DeepReadonly<{ name: string; age: number }>
type OptionalConfig = FullyUndefinable<{ name: string; age: number }>

// HTTP path parameters
type Params = PathParams<"/users/:id/posts/:postId"> // { id: string; postId: string }

API

Strings

Case conversion:

• ToCamelCase<S> — converts to camelCase
• ToSnakeCase<S> — converts to snake_case
• ToPascalCase<S> — converts to PascalCase
• ToKebabCase<S> — converts to kebab-case

Prefixes and suffixes:

• RemovePrefix<T, Prefix> — removes a prefix
• RemoveSuffix<T, Suffix> — removes a suffix

Utilities:

• Join<Parts, Delimiter = ","> — joins a tuple of strings or numbers with a delimiter
• Split<S, Delimiter = ","> — splits a string into a tuple of parts
• ReplaceAll<S, From, To> — replaces all occurrences of a substring

Objects

• NestedRecord<Path, Value> — nested object whose keys follow a tuple path
• Property<T, Path> — value type at a path in an object
• PropertyPath — path of keys (Key[])
• PrefixKeys<T, Prefix> — adds a prefix to all keys
• KeysStartingWith<T, Prefix> — keys starting with a prefix
• Key — any valid object key (string | number | symbol)
• OwnKey — key type from Reflect.ownKeys(obj) (string | symbol)
• KeyToOwn<T> — converts Key to OwnKey (number → string)
• CleanOmit<T, K> — Omit without the string key artifact on objects with an index signature
• ExcludeFromProperties<T, E> / DeepExcludeFromProperties<T, E> — excludes values from properties
• IsPlainObject<T> — checks whether a value is a plain object

Nullability (nulls)

• DeepRequired<T> — all properties are required
• DeepPartial<T> — all properties are optional
• DeepNonNullable<T> — recursively removes null and undefined (mirror of DeepNullish<T>)
• DeepNonNullableRequired<T> — removes null/undefined and makes all properties required
• Nullish<T> / DeepNullish<T> — nullable properties (null | undefined)
• Undefinable<T> / DeepUndefinable<T> — properties allow undefined
• FullyUndefinable<T> / DeepFullyUndefinable<T> — all properties are optional and allow undefined
• IsOptional<T, K> — property K in T is declared optional
• HasUndefined<T> — undefined is part of the value type
• CopyOptionalAndUndefined<Source, Target, Keys?> — values from Target by key, copying optionality and undefined from Source

Mutability

• DeepReadonly<T, LocalExceptions?> — recursively makes all properties readonly
• DeepWritable<T, LocalExceptions?> — recursively removes readonly
• ReadonlyDate — Date without mutation methods
• Immutable, DeepReadonlyExceptions — exception mechanism for DeepReadonly/DeepWritable

HTTP

• HttpMethod — union of all HTTP methods
• HttpStatusCode — union of all HTTP status codes
• PathParams<Path> — extracts :param parameters from a path string

Maybe (optional values)

• MaybePromise<T> — value may be Promise<T> or synchronous T
• MaybeArray<T> — value may be an array T[] or a single T

Common

• UnionToIntersection<Union> — converts a union to an intersection
• Simplify<T> — simplifies object type display (useful after intersections and conditional types)

Predicates

• IsEqual<A, B> — true when the two types are identical
• IsNever<T> / IsAny<T> / IsUnknown<T> — true for those special types
• IsTuple<T> — true for a finite tuple, false for a general array
• Extends<A, B> — true if A is assignable to B (non-distributive)
• Not<T> — boolean negation
• If<Condition, Then, Else?> — picks Then or Else

Testing

Compile-time asserts for tsc --noEmit tests:

• Assert<T> — T must be true
• AssertAll<T> — every element of a tuple must be true
• AssertEqual<Actual, Expected> — types must be identical
• AssertNotEqual<Actual, Expected> — types must differ
• AssertExtends<Actual, Expected> — Actual must be assignable to Expected

Documentation

Detailed documentation:

• Project structure
• Scripts
• Style guide
• Contributing

Full API documentation is available in JSDoc comments. Use IDE autocomplete to browse it.

Requirements

• Node.js >= 22.18.0
• pnpm >= 10.17.0
• TypeScript >= 5.9.0