Novas Funcionalidades do TypeScript 5.5 - Melhorias na Inferência e Performance

Visão Geral do TypeScript 5.5

O TypeScript 5.5 é uma atualização que melhora significativamente a experiência do desenvolvedor e a performance. Foram adicionadas várias funcionalidades práticas, incluindo melhorias na inferência de tipos, verificação de sintaxe de expressões regulares e aceleração do editor.

flowchart TB
    subgraph TS55["TypeScript 5.5 Principais Novas Funcionalidades"]
        subgraph TypeSystem["Melhorias no Sistema de Tipos"]
            TS1["Type Predicates Inferidos"]
            TS2["Refinamento de acesso por índice constante"]
            TS3["Melhoria no refinamento de tipos com typeof"]
        end

        subgraph Regex["Suporte a Expressões Regulares"]
            R1["Verificação de sintaxe de literais regex"]
            R2["Autocompletar nomes de grupos"]
            R3["Detecção de flags inválidas"]
        end

        subgraph Perf["Performance"]
            P1["Velocidade de resposta do editor 10-20% melhor"]
            P2["Redução no tempo de build"]
            P3["Redução no uso de memória"]
        end
    end

Type Predicates Inferidos

No TypeScript 5.5, agora é possível inferir automaticamente que uma função retorna um Type Predicate (predicado de tipo).

// TypeScript 5.4 e anteriores: Type Predicate explícito necessário
function isString(value: unknown): value is string {
  return typeof value === 'string';
}

// TypeScript 5.5: Inferência automática
function isString(value: unknown) {
  return typeof value === 'string';
}

// Exemplo de uso
const values: (string | number)[] = ['hello', 42, 'world'];

// No 5.5, o tipo é refinado automaticamente
const strings = values.filter(isString);
// Tipo de strings: string[]

// Uso com métodos de array
const mixedArray = [1, 'two', null, 3, undefined, 'four'];

const numbers = mixedArray.filter(
  (item): item is number => typeof item === 'number'
);

// No 5.5 isso também funciona (inferência automática)
const validItems = mixedArray.filter(item => item != null);
// Tipo de validItems: (string | number)[]

Exemplo Mais Complexo

interface User {
  id: string;
  name: string;
  email: string;
}

interface Admin extends User {
  role: 'admin';
  permissions: string[];
}

interface Guest {
  role: 'guest';
  sessionId: string;
}

type Person = User | Admin | Guest;

// Type Predicate inferido automaticamente
function isAdmin(person: Person) {
  return 'role' in person && person.role === 'admin';
}

function isUser(person: Person) {
  return 'email' in person;
}

const people: Person[] = [
  { id: '1', name: 'Alice', email: 'alice@example.com' },
  { id: '2', name: 'Bob', email: 'bob@example.com', role: 'admin', permissions: ['read', 'write'] },
  { role: 'guest', sessionId: 'abc123' },
];

// Tipo refinado automaticamente
const admins = people.filter(isAdmin);
// Tipo de admins: Admin[]

const users = people.filter(isUser);
// Tipo de users: (User | Admin)[]

Refinamento de Acesso por Índice Constante

// TypeScript 5.5: Melhoria no refinamento de tipos com índice constante

interface Config {
  database?: {
    host: string;
    port: number;
  };
  cache?: {
    enabled: boolean;
    ttl: number;
  };
}

function processConfig(config: Config) {
  // 5.4 e anteriores: Não refinado
  // 5.5: Refinado corretamente
  if (config['database'] !== undefined) {
    console.log(config['database'].host); // OK no 5.5
    console.log(config['database'].port); // OK no 5.5
  }

  // Exemplo com arrays
  const items: (string | undefined)[] = ['a', undefined, 'b'];

  if (items[0] !== undefined) {
    console.log(items[0].toUpperCase()); // OK no 5.5
  }
}

// Melhoria com tuplas
type Tuple = [string, number, boolean?];

function processTuple(tuple: Tuple) {
  if (tuple[2] !== undefined) {
    const flag: boolean = tuple[2]; // OK no 5.5
  }
}

Verificação de Sintaxe de Expressões Regulares

// TypeScript 5.5: Verificação de sintaxe de literais de expressão regular

// Erro: Sequência de escape inválida
const invalid1 = /\p/; // Error: Invalid escape sequence

// Erro: Grupo não fechado
const invalid2 = /hello(/; // Error: Unterminated group

// Erro: Flag inválida
const invalid3 = /test/xyz; // Error: Unknown flag 'x', 'y', 'z'

// Erro: Referência anterior inválida
const invalid4 = /(\w+) \2/; // Error: Reference to non-existent group

// Expressões regulares corretas
const valid1 = /\d+/g;
const valid2 = /(?<name>\w+)/;
const valid3 = /hello world/i;

// Autocompletar para grupos de captura nomeados
const emailRegex = /(?<user>\w+)@(?<domain>\w+\.\w+)/;
const match = 'test@example.com'.match(emailRegex);

if (match?.groups) {
  console.log(match.groups.user);   // Autocomplete funciona
  console.log(match.groups.domain); // Autocomplete funciona
}

// Escape de propriedades Unicode
const unicodeRegex = /\p{Script=Hiragana}+/u;
const japaneseText = 'こんにちは'.match(unicodeRegex);

Detecção Automática de jsxImportSource

// TypeScript 5.5: Detecção automática da fonte de import JSX

// tsconfig.json
{
  "compilerOptions": {
    "jsx": "react-jsx",
    // Casos em que não é mais necessário especificar jsxImportSource explicitamente
  }
}

// Detecção automática a partir das dependencies no package.json
// - react → "react"
// - preact → "preact"
// - @emotion/react → "@emotion/react"

// Override manual também é possível
/** @jsxImportSource @emotion/react */
import { css } from '@emotion/react';

const style = css`
  color: blue;
`;

Melhorias de Performance

Detalhes das Otimizações

// 1. Melhoria no cache de tipos
// Redução de recálculo do mesmo tipo

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

// No 5.5 o cache de tipos recursivos foi melhorado,
// processando rapidamente mesmo objetos grandes

// 2. Avaliação preguiçosa de tipos condicionais
type ConditionalType<T> = T extends string
  ? { type: 'string'; value: string }
  : T extends number
  ? { type: 'number'; value: number }
  : never;

// Avaliação adiada até ser necessária

// 3. Otimização na resolução de imports
// Pula verificação de tipos para imports não utilizados

Modo isolatedDeclarations

// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true,
    "declaration": true
  }
}

// Neste modo, anotações de tipo explícitas são necessárias para exports

// OK: Tipo de retorno explícito
export function add(a: number, b: number): number {
  return a + b;
}

// Error: Tipo de retorno necessário
export function multiply(a: number, b: number) {
  return a * b;
}

// OK: Tipo explícito
export const config: { port: number; host: string } = {
  port: 3000,
  host: 'localhost',
};

// Error: Anotação de tipo necessária
export const settings = {
  debug: true,
};

Benefícios

Benefícios de isolatedDeclarations:

Suporte a Tipos para Novos Métodos de Set

// Definições de tipo para métodos de Set do ECMAScript 2025

const setA = new Set([1, 2, 3]);
const setB = new Set([2, 3, 4]);

// União
const union = setA.union(setB);
// Set { 1, 2, 3, 4 }

// Interseção
const intersection = setA.intersection(setB);
// Set { 2, 3 }

// Diferença
const difference = setA.difference(setB);
// Set { 1 }

// Diferença simétrica
const symmetricDifference = setA.symmetricDifference(setB);
// Set { 1, 4 }

// Verificação de subconjunto
const isSubset = setA.isSubsetOf(setB); // false
const isSuperset = setA.isSupersetOf(setB); // false
const isDisjoint = setA.isDisjointFrom(setB); // false

Como Atualizar

# Atualizar com npm
npm install -D typescript@5.5

# Atualizar com yarn
yarn add -D typescript@5.5

# Atualizar com pnpm
pnpm add -D typescript@5.5

Verificação de Breaking Changes

// 1. Impacto da inferência de Type Predicate
// Possibilidade de refinamento inesperado de tipos em código existente

// 2. Verificação de expressões regulares
// Expressões regulares inválidas que passavam antes agora geram erros

// Medida: Primeiro faça build com strict: false e verifique os warnings

Resumo

Links de Referência

• TypeScript 5.5 Release Notes
• TypeScript Handbook
• TypeScript GitHub
• TypeScript Playground