Skip to content

README.md

Latest commit

 

History

History
111 lines (83 loc) · 4 KB

README.md

File metadata and controls

111 lines (83 loc) · 4 KB

TypeScript Advanced Type Utilities

A comprehensive collection of more than 150 high-performance TypeScript type utilities focused on type safety and developer experience.

Features

  • Zero Runtime Overhead - Pure type definitions
  • Type Safety - Advanced constraint utilities
  • Modular Design - Import only what you need
  • Rich Toolset - From basic to advanced type operations
  • IntelliSense Optimized - Great IDE support

Installation

npm install devtypes

Documentation

Read the full devtypes Documentation for detailed usage instructions, examples, and API references.

Quick Examples

Object Type Manipulation

import type { Merge } from 'devtypes/types/merge';
import type { RequireExactlyOne } from 'devtypes/types/constraint';

type UserBase = { id: number; name: string; email?: string };
type UserAuth = { email: string; password: string };

// Merge types (smart conflict resolution)
type User = Merge< UserBase, UserAuth >;
// { id: number; name: string; email: string; password: string }

// Require exactly one field
type LoginCredentials = RequireExactlyOne<
    { email?: string; phone?: string; username?: string; },
    'email' | 'phone' | 'username'
>;

Deep Utilities

import type { DeepPartial, DeepRequired } from 'devtypes/types/transform';

interface Config {
    server: {
        port: number;
        host: string;
        ssl?: {
            cert: string;
            key: string;
        };
    };
    database: {
        url: string;
        timeout?: number;
    };
}

// Make everything optional
type PartialConfig = DeepPartial< Config >;

// Make everything required
type FullConfig = DeepRequired< Config >;

Core Modules

Module Purpose
assert Assertion utilities for compile-time checks
class Class-specific utilities: methods, properties, constructors
condition Conditional type utilities (If and Equals)
constraint Property requirement constraints and validation
functional Functional type utilities: curry, compose, promisify
guard Type guard utilities for runtime type checking
list List-like structures (arrays, sets, maps, records, iterables)
merge (Deep) merging and intersection of types
object Object type manipulation and property utilities
primitive Primitive type utilities and literal handling
transform (Deep) transformations for objects, arrays, and nested structures
tuple Tuple-specific utilities and manipulations
union Union type utilities: exclusion, extraction, conversion
util Generic utility types: branding, boxing, casting, simplification

Performance Tips

Import from specific modules for best IDE performance:

// Good - direct import
import type { Brand } from 'devtypes/types/util';
import type { MethodNames } from 'devtypes/types/class';

// Avoid - star imports slow down IntelliSense
import type * as Types from 'devtypes';

Contributing

Contributions are welcome! Please feel free to submit a pull request.

License

Copyright 2025–2026 Paul Köhler (komed3).
Distributed under the MIT license.