Type Space

Welcome to Type Space, a suite of utility types for enhancing your TypeScript code. With @cuppachino/type-space, you can perform a wide range of type operations, including numeric calculations, string manipulation, tuple operations, and more.

Installation

Use your favorite package manager to install @cuppachino/type-space as a developer dependency.

@cuppachino/type-space

pnpm add -D @cuppachino/type-space

npm install --save-dev @cuppachino/type-space

Quick Reference

The source code is fully tsdoc'd, so you can use your IDE's intellisense to reference examples and descriptions at any time. Click any type for more documentation.

Base Types

• NumberLiteral: A stringified number literal.
• Stringifiable: An alias for string | number | bigint | boolean | null | undefined.
• UnknownArray: An alias for unknown[] | readonly unknown[], safer than any.
• UnknownRecord: An alias for Record<PropertyKey, unknown>, safer than any or {}.

Arithmetic Types

• Absolute: Coerces a number literal to a positive number of the same magnitude.
• Add: Return the sum of two number literals.
• Subtract: Return the difference between two number literals.

Numeric Types

• IntoNumber: Coerce a NumberLike type to a number
• IntoNumberLiteral: Coerce a NumberLike type to a NumberLiteral
• IsInteger: A boolean type that is true if a number literal is an integer.
• IsPositive: A boolean type that is true if a number literal is positive.
• IsNegative: A boolean type that is true if a number literal is negative.
• IsWhole: A boolean type that is true if a number literal is a whole number.
• NumberLike: Coerce either a number or a NumberLiteral into a union between the two.
• ParseNumberLiteral: Coerce a NumberLiteral type to a number

String Types

• Chars: Splits a string literal into a tuple of characters. Reads more clearly than Split in some cases.
• ReverseString: Reverse a string literal.
• Split: Splits a string literal into a tuple of characters, separated by the given delimiter.
• SplitAt: Split a string literal into a tuple of two strings, separated by the given index, non-inclusive.
• Stringify: Converts a type to a string literal type, if possible.
• StringIncludes: A boolean type that is true if a string literal includes a given substring (⊆).
• StringIncludesProper: A boolean type that is true if a string literal includes a given substring, and the substring is not the entire string (⊂).

Tuple Types

• CreateTuple: Generate a fixed-length tuple.
• Flat: Recursively flatten a tuple up to a given depth.
• IndexOf: Return a union of a tuple's indices.
• Indices: Generate a tuple of a tuple's indices.
• Join: Joins a tuple of strings into a single string, separated by a delimiter.
• Length: Extract the length property from an array or tuple.
• MergeAll: Merge all type members of a tuple into a single type.
• PartitionKeys: Extract a union of keys for each member in a tuple into a new tuple; order is preserved.
• PartitionValues: Create a tuple of value(s) for the given key(s) in each member of a tuple; order is preserved.
• PartitionPick: Maps picked properties from each member of a tuple into a new tuple; order is preserved.
• Reverse: Reverse the order of elements in a tuple type.

A la Array.prototype

sig

Action :: <Tuple> -> NewTuple

• Pop: Remove the last element from a tuple. Does not return the removed element.
• PopBy: Remove the last N elements from a tuple.
• Push: Adds one element type to the end of a tuple. Does not return the new length of the tuple.
• Shift: Remove the first element from a tuple type. Does not return the removed element.
• ShiftBy: Remove the first N elements from a tuple.
• Unshift: Adds one element type to the beginning of a tuple. Does not return the new length of the tuple.

Utility Types

• Assert: Assert that a type is assignable to another type; shorthand for T extends U ? T : never.
• Combine: Simplify a type by mapping over its properties.
• KeyOf: Extract all keys from every member of a union type, unlike keyof which only preserves shared members' keys.
• Mutable: Recursively removes the readonly modifier from all properties of a type.
• PartialSome: Return a new type that allows the specified keys to be undefined.
• PickAll: Extract properties from all members in a union, missing properties default to | undefined.
• RequireSome: Return a new type requiring the selected keys.
• Simplify: Simplify a type by mapping over its inferred properties - use when Combine cannot infer a deep type.
• Subset: TypeScript equivalent of ⊆.
• UnionLiteral: Create a union from a literal and primitive type without losing the literal type.
• UnionToIntersection: Create an intersection from all members of a union type.
• UnionToTuple: Convert a union to a tuple type. The order is not guaranteed.
• Zip: From a tuple of keys and a tuple of values, create a new record.

Extract

• ExtractRequired: Extract all non-optional properties from a type; exactOptionalPropertyTypes.
• ExtractOptional: Extract all optional properties from a type; exactOptionalPropertyTypes
• ExtractFunctions: Create a new type of all property functions and methods in a type.
• ExtractSetMembers: Create a union type of members in a Set.

Extends

| sig

Extends :: <T, R = T> -> boolean

• T is the type to check.
• R is the type returned when T extends the name of the generic.

• ExtendsFunction: Return a type if the given type extends a function or method.

---

I hope you have fun with these utilities. Thank you for using type-space!