Dev Note

TypeScript’s Continued Dominance
TypeScript celebrated its 14th birthday in 2026, and the language shows no signs of slowing down. With over 90% of new Node.js projects and virtually all major React codebases using TypeScript, it has cemented its position as the default way to write JavaScript.
The TypeScript 5.x series has brought some genuinely transformative features. Let’s explore what matters most for developers building real applications today.
Photo by Ilya Pavlov on Unsplash
TypeScript 5.5: The Inferred Type Predicate Revolution
Perhaps the most celebrated quality-of-life improvement in recent TypeScript history was the introduction of inferred type predicates in TypeScript 5.5.
Before 5.5, you had to write verbose type guard functions:
// Before 5.5 — manual type predicate required
function isString(value: unknown): value is string {
  return typeof value === 'string';
}
const mixed: (string | number)[] = ['hello', 42, 'world', 7];
const strings = mixed.filter(isString);
// ✅ TypeScript knows strings is string[]
With 5.5+, TypeScript infers the predicate automatically:
// TypeScript 5.5+ — type predicate is inferred!
const mixed: (string | number | null | undefined)[] = ['hello', 42, null, 'world'];
const strings = mixed.filter(x => typeof x === 'string');
// ✅ TypeScript infers strings is string[] — no manual type guard needed!
const nonNull = mixed.filter(x => x != null);
// ✅ TypeScript infers nonNull is (string | number)[]
This small change eliminated thousands of boilerplate type guard functions across codebases worldwide.
Decorators: Finally Standardized (TC39 Stage 3)
After years of using the experimental experimentalDecorators flag, TypeScript 5.x supports the TC39 standard decorator proposal. The syntax is familiar but the semantics are cleaner:
// Modern standard decorators
function logged(target: ClassMethodDecoratorContext) {
  return function (this: unknown, ...args: unknown[]) {
    console.log(`Calling ${String(target.name)} with`, args);
    const result = (target as Function).apply(this, args);
    console.log(`${String(target.name)} returned`, result);
    return result;
  };
}
function memoize(target: ClassMethodDecoratorContext) {
  const cache = new Map();
  return function (this: unknown, ...args: unknown[]) {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = (target as Function).apply(this, args);
    cache.set(key, result);
    return result;
  };
}
class DataService {
  @logged
  @memoize
  async fetchUser(id: string): Promise<User> {
    return await db.users.findById(id);
  }
}
Standard decorators work without emitDecoratorMetadata and align with the JavaScript language spec.
The using Keyword: Explicit Resource Management
One of the most impactful additions to the TypeScript/JavaScript ecosystem is the Explicit Resource Management proposal, now available via the using keyword:
// Without using — manual cleanup required
async function processFile() {
  const file = await openFile('data.csv');
  try {
    const data = await file.read();
    return processData(data);
  } finally {
    await file.close(); // Easy to forget!
  }
}
// With using — cleanup is automatic and guaranteed
async function processFile() {
  await using file = openFile('data.csv');
  const data = await file.read();
  return processData(data);
} // file.close() called automatically here, even on error
For using to work, the resource must implement the [Symbol.dispose]() or [Symbol.asyncDispose]() method:
class DatabaseConnection implements AsyncDisposable {
  private connection: Connection;
  
  constructor(private url: string) {}
  
  async connect() {
    this.connection = await createConnection(this.url);
    return this;
  }
  
  async query<T>(sql: string, params: unknown[]): Promise<T[]> {
    return this.connection.execute(sql, params);
  }
  
  async [Symbol.asyncDispose]() {
    await this.connection.close();
    console.log('Database connection closed');
  }
}
async function getUserCount() {
  await using db = await new DatabaseConnection(DB_URL).connect();
  const [result] = await db.query<{ count: number }>(
    'SELECT COUNT(*) as count FROM users', 
    []
  );
  return result.count;
} // Connection automatically closed here
This pattern eliminates entire categories of resource leak bugs.
Template Literal Types: Advanced String Manipulation
TypeScript’s template literal types have grown into a powerful meta-programming tool:
// Route type generation
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
type ApiPath = '/users' | '/posts' | '/comments';
type ApiEndpoint = `${HTTPMethod} ${ApiPath}`;
// "GET /users" | "GET /posts" | "GET /comments" | "POST /users" | ...
// CSS property type safety
type CSSProperty = 'margin' | 'padding' | 'border';
type CSSDirection = 'top' | 'right' | 'bottom' | 'left';
type CSSDirectionalProperty = `${CSSProperty}-${CSSDirection}`;
// "margin-top" | "margin-right" | ... | "border-left"
// Event handler naming convention enforcement
type EventName = 'click' | 'focus' | 'blur' | 'change';
type HandlerName = `on${Capitalize<EventName>}`;
// "onClick" | "onFocus" | "onBlur" | "onChange"
function createEventHandlers<T extends EventName>(
  events: T[]
): Record<`on${Capitalize<T>}`, () => void> {
  // Type-safe event handler map
  return Object.fromEntries(
    events.map(e => [`on${e[0].toUpperCase()}${e.slice(1)}`, () => {}])
  ) as any;
}
satisfies Operator: Type-Safe Without Widening
The satisfies operator lets you validate a value matches a type without losing the inferred type:
type Colors = 'red' | 'green' | 'blue';
type RGB = [number, number, number];
type Hex = string;
type Palette = Record<Colors, RGB | Hex>;
// With 'as' — loses information, potential errors masked
const palette = {
  red: [255, 0, 0],
  green: '#00ff00',
  blue: [0, 0, 255],
} as Palette;
palette.red.toUpperCase(); // ❌ No error, but this will fail at runtime!
// With 'satisfies' — validates type AND preserves inference
const palette2 = {
  red: [255, 0, 0],
  green: '#00ff00', 
  blue: [0, 0, 255],
} satisfies Palette;
palette2.red.toUpperCase();   // ✅ Error caught! red is RGB, not string
palette2.green.toUpperCase(); // ✅ Works! green is string
palette2.red.map(x => x * 2); // ✅ Works! red is tuple, has .map()
Const Type Parameters: No More as const Everywhere
TypeScript 5.0 introduced const type parameters, making generic functions that preserve literal types much cleaner:
// Before — required 'as const' at every call site
function createRoute<T extends readonly string[]>(paths: T): T {
  return paths;
}
const routes = createRoute(['/', '/about', '/contact'] as const);
// ^^ Required 'as const' to preserve literal types
// TypeScript 5.0+ — use 'const' in generic constraint
function createRoute<const T extends readonly string[]>(paths: T): T {
  return paths;
}
const routes = createRoute(['/', '/about', '/contact']);
// ✅ TypeScript infers readonly ["/", "/about", "/contact"] without 'as const'
Project References and Build Performance in 2026
TypeScript’s project references feature has become essential for large monorepos:
// tsconfig.json in a monorepo root
{
  "files": [],
  "references": [
    { "path": "./packages/core" },
    { "path": "./packages/ui" },
    { "path": "./packages/api" },
    { "path": "./packages/app" }
  ]
}
With tsc --build, TypeScript only recompiles changed packages and their dependents. For a monorepo with 200+ packages, this can reduce incremental build times from minutes to seconds.
Combined with modern bundlers like Turbopack and esbuild, full TypeScript compilation is rarely on the critical path for development.
The Future: TypeScript and TC39
Microsoft’s TypeScript team maintains a careful relationship with TC39 (the JavaScript standards committee): TypeScript implements standard proposals, not the other way around.
Upcoming TC39 proposals TypeScript is watching:
Pattern Matching (match expression) — structural pattern matching for JavaScript
Records and Tuples — immutable, value-type compound data
Decimal — proper decimal arithmetic (no more 0.1 + 0.2 !== 0.3)
Type Annotations — native JS type syntax (TypeScript without the transpiler)
That last one is particularly significant: if type annotations land in JavaScript itself, TypeScript’s role evolves from transpiler to type-checker-only.
Practical Recommendations for 2026
Enable strict mode — "strict": true in tsconfig.json. No exceptions.
Use satisfies instead of type assertions wherever possible
Adopt using for any resource that needs cleanup
Remove experimentalDecorators — migrate to standard decorators
Set moduleResolution: "bundler" for modern projects using Vite/Webpack 5+
Enable verbatimModuleSyntax — ensures correct import/export types
Conclusion
TypeScript in 2026 is mature, fast, and remarkably expressive. The rough edges of early TypeScript — verbose type guards, decorator experiments, resource management footguns — have been addressed systematically.
For teams still on JavaScript: the migration cost has never been lower. Incremental adoption via allowJs and JSDoc types lets you get TypeScript’s benefits without rewriting everything at once.
The question in 2026 isn’t “should we use TypeScript?” It’s “how are we getting the most out of it?”
Resources:
TypeScript 5.5 Release Notes
TypeScript Playground
Type Challenges
Matt Pocock’s Total TypeScript

TypeScript 5.x in 2026: New Features That Changed How We Write JavaScript

댓글