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!