sindresorhus/type-fest

Features

• TypeScript Type Definitions - Offers a vast collection of TypeScript type definitions for complex structural transformations.
• Types - Provides deep and shallow object transformation types for merging and omitting properties.
• Advanced Type Validation - Implements strict type checks for JSON compatibility, mutual exclusivity, and deep immutability.
• String Case Transformers - Provides utility types for converting string literals and object keys between camelCase, kebab-case, snake_case, and PascalCase.
• String Literal Obfuscation - Provides utilities for trimming, splitting, slicing, or removing prefixes and suffixes from string literal types.
• TypeScript Utility Libraries - Acts as a comprehensive library of reusable utility types for TypeScript transformations.
• Generic Constraint Validation - Implements strict generic constraints to ensure type safety for structures like JSON-compatible objects.
• Numeric Type Utilities - Provides a set of types for type-level arithmetic and numeric range validation.
• JSON Type Compatibility - Ensures values match JSON-compatible structures and converts types to be assignable to JSON values.
• Literal Value Extraction - Retrieves all literal values from a constant array or tuple to enforce type-safe index access.
• Object Type Transformations - Removes properties from a type based on a specified condition.
• Type-Level Array Modifications - Enables creating new array types by adding, removing, or replacing elements at specific index ranges.
• Conditional Types - Implements type-level decision systems that resolve types based on evaluated conditions.
• Distributive - Provides advanced distributive conditional types to process union members individually.
• Array and Tuple Utilities - Ships a collection of utility types for slicing arrays and extracting tuple element types.
• String Case Transformation Types - Transforms top-level object keys to camel case at the type level.
• String Literal Processing - Provides comprehensive string literal processing for casing and pattern-based modifications.
• String Literal Type Manipulations - Implements type-level utilities for trimming, splitting, slicing, and removing prefixes or suffixes from string literal types.
• Template Literal Types - Leverages template literal types for compile-time string transformation and validation.
• Tuple and Array Type Transformations - Provides utilities for reversing tuples, converting them to unions, and extracting element types at the type level.
• Type-Level Arithmetic - Implements type-level arithmetic for calculating numeric ranges and absolute values.
• Type-Level Array Slicing - Extracts a subset of elements from a tuple or array type using start and end indices.
• Type-Level Length Extraction - Extracts the length of an array as a numeric literal or general number type.
• Type-Level Membership Verification - Determines if a specific type exists within a tuple or array for conditional type logic.
• Type-Level Tuple Reversal - Reverses the order of elements in a tuple, handling both fixed-length and optional elements.
• Type Validation - Provides general utilities for determining if a type is a literal, union, tuple, or possesses specific properties.
• Union Type Transformations - Creates a single object type containing every possible key found across a union of object types.
• Variadic Element Extraction - Provides a utility for retrieving the type of the variadic element from a tuple array.
• Immutability Enforcement Utilities - Provides utilities to create deeply read-only or deeply mutable versions of objects and collections.
• Mapped Type Transformations - Provides comprehensive mapped type transformations for iterating over object keys and modifying type structures.
• Recursive Type Processing - Ships recursive type processing for deep operations on nested object hierarchies.
• String Manipulation Types - Implements type-level casing transformations for string literals and object keys.
• Element Type Extraction - Provides a utility for retrieving the type of elements within an array or tuple.
• Variadic Tuple Manipulation - Provides utilities for variadic tuple manipulation, including slicing and reversing elements at the type level.
• Readonly Property Detection - Determines if a type contains any readonly fields to conditionally change API behavior.
• Type Hint Simplifications - Flattens complex intersecting types into a single object representation to improve IDE readability and hints.
• Writable Property Detection - Checks if a type contains any writable properties to conditionally enable API behaviors.
• Async Return Type Extraction - Unwraps the resolved value from a function that returns a promise at the type level.
• Asynchronous Type Management - Provides utilities for wrapping values in promises, unwrapping return types, and creating async versions of function types.
• Asynchronous Type Utilities - Provides utilities for wrapping values in promises and unwrapping the return types of asynchronous functions.
• Configuration Schema Extensions - Provides type schemas and extensions for standard configuration files like package.json.
• Numeric Type Logic - Generates precise numeric unions and ranges for constrained value sets.
• Mutual Exclusivity Utilities - Implements union mutual exclusivity by adding optional never types to union members.
• Exact Object Type Constraints - Rejects arguments containing properties not explicitly declared in the target type.
• Any Type Restrictions - Provides a utility to detect and flag the use of the any type to enforce stricter type safety.
• Index Range Constraints - Restricts array index values to only those that actually exist in a constant array or tuple.
• Primitive Type Utilities - Provides utility types for matching primitives, classes, constructors, and specific character sets.
• Standard Configuration Type Schemas - Includes a set of predefined type schemas for standard files like package.json and tsconfig.json.
• String Character Set Constraints - Restricts strings to specific subsets of the Latin alphabet, including uppercase, lowercase, digits, and alphanumeric characters.
• Element Type Validators - Determines if every element within an array type extends a specific target type.
• Structural Type Validations - Checks if a value matches a specific class, constructor, or abstract class structure at the type level.
• Object Field Optionality - Determines if a type contains optional properties to allow conditional logic based on field presence.
• Rigorous Type Set Operations - Ensures exact type matching by providing rigorous versions of Extract, Exclude, and Extends.
• Type Simplification - Flattens complex nested type definitions into a cleaner representation for better editor readability.
• Strict Empty Object Constraints - Restricts a value to be a strictly empty plain object, preventing arrays, primitives, or properties.
• Required Field Enforcement - Determines if a given type contains any required properties to change API behavior.
• Configuration Extensions - Provides utilities to extend base type definitions for configuration files like package.json.
• Intersection Flattening - Simplifies complex intersecting types into single object representations to improve editor hints.
• Type Utilities - Collection of essential and advanced type definitions.

Star history