TypeScript 5.x in 2025: Essential Features Every Developer Should Know

TypeScript 5.x represents a significant evolution of the language, introducing features that make code more expressive, safer, and easier to maintain. Let's explore the most impactful additions that should be in every developer's toolkit.

Decorators (Stage 3)

TypeScript 5.0 added support for the ECMAScript decorators proposal, enabling cleaner metaprogramming:

function logged(target: any, context: ClassMethodDecoratorContext) {
  const methodName = String(context.name);

  return function(this: any, ...args: any[]) {
    console.log(`Calling ${methodName} with:`, args);
    const result = target.call(this, ...args);
    console.log(`Result:`, result);
    return result;
  };
}

class Calculator {
  @logged
  add(a: number, b: number) {
    return a + b;
  }
}

const calc = new Calculator();
calc.add(2, 3);
// Logs: Calling add with: [2, 3]
// Logs: Result: 5

Use Cases

Dependency Injection:

class UserService {
  @inject(DatabaseService)
  private db!: DatabaseService;
}

Validation:

class User {
  @validate
  @length(3, 20)
  username!: string;
}

const Type Parameters

TypeScript 5.0 introduced const type parameters for more precise inference:

// Without const
function makeArray<T>(items: T[]) {
  return items;
}
const arr = makeArray(['a', 'b']); // string[]

// With const
function makeConstArray<const T>(items: T[]) {
  return items;
}
const constArr = makeConstArray(['a', 'b']); // readonly ["a", "b"]

Benefits:

• More specific literal types
• Better autocomplete
• Immutability by default

function createConfig<const T extends Record<string, unknown>>(config: T): T {
  return config;
}

const config = createConfig({
  apiUrl: 'https://api.example.com',
  timeout: 5000,
});

// Type is:
// {
//   readonly apiUrl: "https://api.example.com";
//   readonly timeout: 5000;
// }

Exhaustive Switch Cases

TypeScript 5.0 improved switch case exhaustiveness checking:

type Status = 'pending' | 'success' | 'error';

function handleStatus(status: Status) {
  switch (status) {
    case 'pending':
      return 'Loading...';
    case 'success':
      return 'Done!';
    case 'error':
      return 'Failed!';
    // If you add a new status type, TypeScript will error here
  }
}

Use satisfies never for runtime safety:

function handleStatus(status: Status): string {
  switch (status) {
    case 'pending':
      return 'Loading...';
    case 'success':
      return 'Done!';
    default:
      // This ensures all cases are handled
      const _exhaustive: never = status;
      throw new Error(`Unhandled status: ${status}`);
  }
}

satisfies Operator

Validate types without widening them:

type Color = { r: number; g: number; b: number } | string;

// Without satisfies - type is widened
const color1: Color = { r: 255, g: 0, b: 0 };
color1.r; // Error: Property 'r' doesn't exist on type 'Color'

// With satisfies - exact type preserved
const color2 = { r: 255, g: 0, b: 0 } satisfies Color;
color2.r; // ✓ Works! Type is { r: number; g: number; b: number }

Real-world example:

type Route = {
  path: string;
  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
  handler: (req: Request) => Response;
};

const routes = {
  getUser: {
    path: '/users/:id',
    method: 'GET',
    handler: (req) => new Response(),
  },
  createUser: {
    path: '/users',
    method: 'POST',
    handler: (req) => new Response(),
  },
} satisfies Record<string, Route>;

// Autocomplete works for route names
routes.getUser.path; // ✓
routes.getUser.method; // ✓ Type is 'GET', not string

Type-Only Imports and Exports

TypeScript 5.0 improved type-only imports:

// Import only the type, not the value
import type { User } from './types';
import { type Product, createProduct } from './api';

// Export type-only
export type { User };

Why it matters:

• Smaller bundles (types are erased)
• Clearer intent
• Better tree-shaking

Multi-Config Projects

extends arrays allow composing multiple configs:

{
  "extends": [
    "@tsconfig/node18/tsconfig.json",
    "@tsconfig/strictest/tsconfig.json",
    "./tsconfig.base.json"
  ],
  "compilerOptions": {
    "outDir": "./dist"
  }
}

Benefits:

• Reusable configuration
• Easier monorepo setup
• Better defaults sharing

Performance Improvements

TypeScript 5.x includes major performance wins:

1. Faster Type Checking

// This is now much faster in TS 5.x
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

2. Optimized Recursive Types

// Complex recursive types are faster
type JSON = string | number | boolean | null | JSON[] | { [key: string]: JSON };

3. Better Inference

// Smarter inference reduces explicit annotations
const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
];

// TypeScript correctly infers:
// { id: number; name: string }[]

Practical Migration Tips

1. Enable Strict Mode Gradually

{
  "compilerOptions": {
    "strict": false,
    "noImplicitAny": true,        // Start here
    "strictNullChecks": true,      // Then this
    "strictFunctionTypes": true,   // Then this
    // ... enable others incrementally
  }
}

2. Use @ts-expect-error for Known Issues

// @ts-expect-error - Known issue, fix in next sprint
const result = legacyFunction();

3. Leverage New Features Incrementally

// Before
const config: Config = {
  apiUrl: 'https://api.example.com',
};

// After - use satisfies for better types
const config = {
  apiUrl: 'https://api.example.com',
} satisfies Config;

Advanced Patterns

1. Branded Types

type UserId = string & { __brand: 'UserId' };
type ProductId = string & { __brand: 'ProductId' };

function getUser(id: UserId) { /* ... */ }

const userId = 'user_123' as UserId;
const productId = 'prod_456' as ProductId;

getUser(userId);      // ✓
getUser(productId);   // ✗ Type error!

2. Template Literal Types

type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type Endpoint = '/users' | '/products';
type Route = `${HTTPMethod} ${Endpoint}`;

// Route is:
// | 'GET /users' | 'POST /users' | 'PUT /users' | 'DELETE /users'
// | 'GET /products' | 'POST /products' | ...

3. Conditional Types with Inference

type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type A = UnwrapPromise<Promise<string>>;  // string
type B = UnwrapPromise<number>;           // number

Tooling Recommendations

1. Type Coverage

npm install -D type-coverage
npx type-coverage --detail

Aim for >90% type coverage in new code.

2. ts-reset

Improve default type definitions:

npm install -D @total-typescript/ts-reset

// tsconfig.json
{
  "include": ["./node_modules/@total-typescript/ts-reset"]
}

3. Type Challenges

Practice with type-challenges:

npm install -D @type-challenges/utils

Common Pitfalls

1. Over-Engineering Types

// ❌ Too complex
type DeepReadonly<T> = T extends object
  ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
  : T;

// ✅ Use simpler approaches when possible
type Config = Readonly<{
  api: Readonly<{ url: string; key: string }>;
}>;

2. Ignoring unknown vs any

// ❌ Avoid any
function parseJSON(json: string): any {
  return JSON.parse(json);
}

// ✅ Use unknown + type guards
function parseJSON(json: string): unknown {
  return JSON.parse(json);
}

const data = parseJSON('{"name": "Alice"}');
if (typeof data === 'object' && data !== null && 'name' in data) {
  console.log(data.name); // Type-safe!
}

3. Not Using Utility Types

// ❌ Manual type transformation
type UserUpdate = {
  id?: number;
  name?: string;
  email?: string;
};

// ✅ Use built-in utilities
type User = { id: number; name: string; email: string };
type UserUpdate = Partial<User>;

Conclusion

TypeScript 5.x brings powerful features that make the language more expressive and maintainable. By adopting decorators, const type parameters, and the satisfies operator, you can write safer, more self-documenting code.

The key is to adopt these features incrementally, understanding when they add value versus when simpler approaches suffice. TypeScript should enable better code, not complicate it.

Start with one or two features today, and gradually integrate them into your workflow. Your future self (and your team) will thank you.