ts-essentials/ts-essentials

Features

• Utility Type Definitions - TypeScript-ts-tool offers reusable type helpers and utility definitions to simplify complex type manipulations.
• Type-Level Programming Utilities - Provides a comprehensive toolkit for complex type-level programming to ensure stronger type safety and reduce boilerplate.
• Type Transformations - TypeScript-ts-tool performs complex type-level programming and transformations to ensure stronger type safety through reusable utility types.
• Readonly Property Declarations - TypeScript-ts-tool marks specified properties of a type as read-only to prevent reassignment.
• Type-Level Optionality Modifiers - TypeScript-ts-tool marks specified keys as optional while keeping all other properties required.
• Property Modifier Transformers - TypeScript-ts-tool changes specific properties of a type to be required, optional, read-only, or writable without affecting other properties.
• Required Property Marking - TypeScript-ts-tool transforms a type by selecting specific keys to be mandatory while leaving others optional.
• Deep Immutability Enforcements - TypeScript-ts-tool recursively applies a readonly modifier to all properties of an object to prevent nested reassignment.
• TypeScript Utility Libraries - Provides a comprehensive collection of advanced utility types for recursive modifications and structural validations.
• Deep Property Modifiers - TypeScript-ts-tool recursively applies modifiers like optionality, read-only status, or nullability to all nested properties within an object structure.
• Exact Type Equality Verification - Returns a type only when two provided types are identical, otherwise returns an impossible state.
• Generic Type Constraints - TypeScript-ts-tool ensures a value is a function with specific argument and return types.
• Type Constraint Validation - Checks if a type matches criteria such as being a tuple, a non-empty object, or a specific shape.
• JSON Type Compatibility - Provides a set of strict type definitions that ensure compatibility with JSON serialization requirements.
• JSON Array Validation - Restricts a type to elements that are valid JSON types to ensure the value conforms to a JSON array.
• JSON Object Validation - Restricts keys to strings and values to JSON-compatible types to ensure a valid JSON object structure.
• JSON Value Validation - Ensures a variable matches any valid JSON type, including strings, numbers, booleans, and objects.
• Exhaustiveness Checks - Ensures all possible cases of a discriminated union are handled by throwing errors on unexpected paths.
• JSON Primitive Definition - Restricts a value to basic JSON types such as strings, numbers, booleans, and null.
• JSON Structure Definition - Provides specific type definitions for JSON primitives, objects, arrays, and general values.
• Custom Type Guards - TypeScript-ts-tool constrains functions to follow type predicate patterns to narrow the first argument for type guards.
• Type Modifier Utilities - TypeScript-ts-tool modifies object keys or values by changing case, toggling optionality, or flattening types for better readability.
• Recursive Object Type Transformers - Provides tools for recursively applying property modifiers like optionality and read-only status to nested structures.
• Property Mutability Modifiers - TypeScript-ts-tool sets or unsets the readonly modifier for specific keys or deeply nested properties.
• Array and Tuple Utilities - TypeScript-ts-tool extracts elements from the head or tail of a tuple and enforces non-empty array constraints.
• Runtime Type Validation - Verifies that a runtime value matches a specific expected type to ensure behavioral correctness.
• Type Guard Utilities - Offers utilities for narrowing types using predicates and structural checks to improve static analysis accuracy.
• Type Member Extraction - Provides utilities to isolate specific parts of a type by picking keys based on value types or identifying object paths.
• Union Key Extraction - Creates a union type consisting of every property key found across all members of a union type.
• Union Member Filtering - Provides utility types to extract or exclude specific members from union types using conditional logic.
• Union to Intersection Converters - Transforms union types into intersection types to facilitate complex function signatures.
• Type Identity Validation - Checks if a type matches a specific primitive, is a union, is a tuple, or is identical to another shape.
• Case Completeness Verification - Verifies that all possible options in a conditional block are handled to prevent missing case errors.
• JSON Schema Validation - Defines strict type constraints to ensure data structures conform to JSON specifications for arrays, objects, and primitives.
• Recursive Mapped Types - Implements recursive mapped types to apply modifiers like optionality or read-only across nested object hierarchies.
• Runtime Type Assertions - Ships a library of runtime assertions that throw detailed errors when data does not match declared TypeScript types.
• Writable Key Extraction - Identifies all properties of an object type that can be reassigned by returning a union of keys.
• Type Constraint Enforcements - TypeScript-ts-tool creates a type that requires exactly one specific key from a set to be present while leaving others optional.
• Underlying Value Extraction - Resolves the core data type by returning element types for arrays, return types for functions, or property values for objects.
• Structural Type Manipulation Tools - Provides a toolkit for altering property mutability, casing, and optionality across nested object structures.
• Readonly Property Detection - Creates a union type containing only the names of properties explicitly marked as read-only.
• Optional Key Extractions - Identifies all optional properties within an object type and creates a union of those keys.
• Nested Optionality Marking - TypeScript-ts-tool converts specific nested properties defined by a path to optional.
• Recursive Optionality Marking - TypeScript-ts-tool marks all nested properties of an object as optional to facilitate deep merging or partial updates.
• Object Key Path Extractors - Generates a union type representing all possible navigation paths through nested objects and arrays.
• Existence-Validated Property Strippers - Provides a safe way to remove properties from a type by ensuring the keys exist before stripping.
• Async Return Type Extraction - TypeScript-ts-tool removes the Promise wrapper from a type to return the underlying value for synchronous and asynchronous definitions.
• Class Type Definitions - TypeScript-ts-tool creates a type for a class constructor that returns a specific type to allow functions to accept classes.
• Mutual Exclusivity Utilities - TypeScript-ts-tool prevents a value from matching more than one specified type simultaneously.
• Cardinality Constraints - TypeScript-ts-tool creates types that require at least one or at most one key from a specific set of properties.
• Opaque Type Definitions - TypeScript-ts-tool defines a unique type based on a primitive to prevent accidental assignment between identical base types.
• Minimum Length Constraints - TypeScript-ts-tool ensures an array contains at least one item or defines a type as a single value or array.
• Any Type Restrictions - Provides mechanisms to identify and restrict the use of the any type to enforce stricter type safety.
• Property Presence Constraints - TypeScript-ts-tool requires a type to have at least one or at most one of a specified set of properties.
• Object Merging - TypeScript-ts-tool combines two object types where properties from the second object override the first.
• Case Conversion - TypeScript-ts-tool converts object property names from other casing conventions to camelCase recursively.
• Mutable Partial Type Generators - TypeScript-ts-tool recursively transforms all properties of a type to be optional and writable for incremental object construction.
• Read-Only Modifier Removers - Allows for the removal of the read-only modifier from specific properties to enable assignment.
• Primitive Type Checkers - Provides utilities for identifying if a value is a primitive type such as string, number, or boolean.
• Primitive Value Matching - Matches any primitive value to ensure a variable contains a basic data type rather than an object.
• Property Key Filterings - Extracts a union of property names based on whether their values are assignable to a target type.
• Property Modifier Extractions - Derives union types of keys based on whether they are marked as optional, read-only, or required.
• String Case Transformation Types - Provides type-level transformations to convert string literal types and object keys into camel case.
• Tuple Element Constraints - TypeScript-ts-tool ensures a collection of values conforms to a tuple structure where each element matches a specific constraint.
• Sequence Tail Extractions - TypeScript-ts-tool returns a type containing all elements of a sequence except for the first item.
• Tuple Type Validation - Returns the original type if it is a tuple and returns never otherwise.
• Type Guard Metadata Extractions - Matches predicate functions and identifies return types to facilitate narrowing via type guards.
• Type Predicate Analysis - Identifies function signatures and extracts narrowed types derived from type predicates.
• Union Type Detection Filters - Provides a mechanism to exclude union types by returning the never type when a union is encountered.
• Unknown Type Handling - Provides strategies for manipulating values and conditional logic when types are unknown at compile time.
• Guaranteed Non-Empty Arrays - TypeScript-ts-tool ensures an array contains at least one element of a specific type to prevent processing empty lists.
• Structural Type Validations - Includes utilities for validating structural identity and exact type equality for primitives, unions, and tuples.
• Object Path Type Resolutions - Generates union types of string paths to resolve value types at specific nested locations within objects.
• Nested Property Path Resolution - Resolves the types of values located at specific deep paths within objects, arrays, or tuples.
• Nested Requirement Enforcement - TypeScript-ts-tool sets specific properties at deep paths within a type as required.
• Deep Property Picking - TypeScript-ts-tool selects a nested set of properties based on a filter while validating they exist in the source type.
• Nested Property Removal - TypeScript-ts-tool excludes specific properties from a structure based on a filter map, including deep nesting.
• Required Object Definitions - TypeScript-ts-tool creates a required object type with specified keys and values to ensure all properties are present.
• Nullable Type Removals - TypeScript-ts-tool strips null and undefined from all properties and nested children while preserving optional markers.
• Recursive Casing Transformations - TypeScript-ts-tool recursively transforms all property names of an object type into camel case.
• Array Type Matching - Identifies both standard and read-only array types to ensure safety during generic constraints.
• Recursive Requirement Enforcement - TypeScript-ts-tool transforms all properties and nested children into required fields to ensure all necessary data is present.
• Type Intersection and Merging - TypeScript-ts-tool combines a sequence of object types into a single merged type while preserving modifiers and signatures.
• Intersection Flattening - Simplifies complex nested type intersections into a flat object to improve editor tooltip readability.
• Type-Safe Dictionary Definitions - TypeScript-ts-tool creates an object type with specified key and value types to ensure type-safe index access.
• Input Normalization Types - TypeScript-ts-tool accepts either a single value or a readonly array of values to provide a flexible interface.
• Async-Compatible Return Types - TypeScript-ts-tool creates a type that accepts either a direct value or a promise for interfaces and abstract classes.
• Detection - Identifies whether a given type is the bottom type by returning a boolean.
• Element Type Extraction - Derives the type of individual elements within an array or tuple for precise type-level manipulation.
• First Element Extractions - Retrieves the type of the first element of a tuple or array to define variables based on the initial entry.
• Object Property Type Extractors - Extracts the specific type of a value located at a nested path within an object structure.
• Variadic Tuple Manipulation - Provides type-level operations for variadic tuples, including element extraction and minimum length enforcement.
• Type-Based Property Filterings - Extracts all properties from a type whose values match a specified value or union of values.
• Deep Property Picking - TypeScript-ts-tool selects specific properties from a type based on a filter, including deeply nested keys.
• Never-Based Property Exclusions - TypeScript-ts-tool removes properties from a type whose values are never to enable assignment across discriminated unions.
• Required Key Extractions - Creates a union type containing only the properties of an object that are marked as required.
• Key Presence Enforcement - TypeScript-ts-tool mandates that at least one key from a specified set be present while leaving other properties optional.

Star history