Přechodová verze před zásadní změnou

Microsoft oznámil vydání TypeScript 6.0 Beta jako mezikrok mezi řadou 5.x a připravovanou verzí 7.0. Nejde o běžné „feature release“, ale o strategickou verzi, která:

• stabilizuje chování před velkou architektonickou změnou
• odstraňuje historické přežitky v konfiguraci
• mění výchozí nastavení směrem k modernímu JavaScriptu
• připravuje ekosystém na nový kompilátor psaný v jazyce Go

TypeScript 7.0 totiž nebude jen další verzí. Přinese kompletně nový kompilátor a jazykovou službu implementovanou v Go, s důrazem na výkon, paralelizaci a deterministické chování. Verze 6.0 je tedy poslední hlavní verze běžící na současném JavaScriptovém kompilátoru.

Instalace betaverze:

npm install -D typescript@betaCode language: CSS (css)

Beta je určena především pro testování, migraci větších projektů a ověření kompatibility knihoven.

Hlavní motiv verze 6.0

TypeScript 6.0 se soustředí na tři oblasti:

1. Determinismus a stabilita výstupů
2. Modernizaci výchozích konfigurací
3. Odstranění nebo deprecaci historických možností

1. Zlepšené odvozování typů u funkcí bez použití this

Jednou z mála skutečně jazykových změn je úprava způsobu, jakým TypeScript pracuje s kontextovou citlivostí funkcí.

Problém v předchozích verzích

TypeScript při inferenci generických parametrů někdy ignoroval funkce, které byly považovány za kontextově citlivé. To se týkalo zejména metod s implicitním this.

Příklad:

declare function callIt<T>(obj: {
    produce: (x: number) => T,
    consume: (y: T) => void,
}): void;Code language: PHP (php)

Toto fungovalo:

callIt({
    produce: (x: number) => x * 2,
    consume: y => y.toFixed(),
});Code language: CSS (css)

Ale následující zápis mohl selhat:

callIt({
    consume(y) {
        return y.toFixed();
    },
    produce(x: number) {
        return x * 2;
    },
});Code language: JavaScript (javascript)

Proč? Protože metody s implicitním this byly považovány za kontextově citlivé, a TypeScript je v některých případech vyřazoval z inferenčního procesu.

Co se mění v TypeScript 6.0

Nově TypeScript analyzuje, zda je this ve funkci skutečně použito.

Pokud:

• funkce má implicitní this
• ale this není v těle použito

pak se funkce nepovažuje za kontextově citlivou a může být plně zapojena do odvozování typů.

Výsledek:

• méně nečekaných chyb
• robustnější generická inference
• menší závislost na pořadí deklarací

Tato změna je kompatibilní zpětně, ale může v některých projektech změnit konkrétní inferovaný typ – typicky směrem k přesnějšímu výsledku.

2. Podpora subpath importů začínajících #/

TypeScript 6.0 rozšiřuje podporu moderní modulové rezoluce tak, aby odpovídala aktuálnímu chování Node.js.

Kontext

Node.js umožňuje definovat tzv. subpath imports pomocí pole imports v package.json. Tyto aliasy umožňují interně mapovat krátké cesty na konkrétní soubory v balíčku.

Dříve bylo běžné používat například:

{
  "imports": {
    "#root/*": "./dist/*"
  }
}Code language: JSON / JSON with Comments (json)

Nově Node podporuje i kratší variantu pomocí samotného #/.

Příklad konfigurace

{
  "name": "my-package",
  "type": "module",
  "imports": {
    "#": "./dist/index.js",
    "#/*": "./dist/*"
  }
}Code language: JSON / JSON with Comments (json)

Pak lze importovat:

import * as utils from "#/utils.js";Code language: JavaScript (javascript)

Co přidává TypeScript 6.0

TypeScript nyní podporuje tuto syntaxi při použití:

• --moduleResolution node20
• --moduleResolution nodenext
• --moduleResolution bundler

To znamená plnou kompatibilitu s moderním ESM chováním Node.js.

Důležité: tato podpora se týká pouze odpovídajících rezolučních strategií. Při použití zastaralých režimů (například classic) nebude fungovat – což je konzistentní s postupnou eliminací historických možností.

3. Kombinace --moduleResolution bundler s --module commonjs

V předchozích verzích bylo --moduleResolution bundler možné použít pouze s:

• --module esnext
• --module preserve

To bylo omezující pro projekty, které:

• používají bundler,
• ale stále emitují CommonJS výstup.

TypeScript 6.0 toto omezení odstraňuje a umožňuje kombinaci:

{
  "compilerOptions": {
    "module": "commonjs",
    "moduleResolution": "bundler"
  }
}Code language: JSON / JSON with Comments (json)

Tato změna:

• zjednodušuje migraci starších projektů
• umožňuje modernější rezoluci bez nutnosti kompletního přechodu na ESM
• reflektuje realitu mnoha build pipeline

4. --stableTypeOrdering: Deterministické řazení typů

Jedna z nejdůležitějších změn z pohledu přípravy na TypeScript 7.0.

Problém: Nestabilní pořadí typů

TypeScript interně přiřazuje typům ID podle pořadí, v jakém jsou vytvářeny během kompilace. To může vést k tomu, že:

• unijní typy změní pořadí literálů
• .d.ts soubory se změní
• diff v repozitáři ukáže změnu, i když se logika nezměnila

Příklad:

export function foo(condition: boolean) {
    return condition ? 100 : 500;
}Code language: JavaScript (javascript)

Vygenerované deklarace:

export declare function foo(condition: boolean): 100 | 500;Code language: PHP (php)

Po přidání jiné deklarace nad foo se může změnit pořadí:

export declare function foo(condition: boolean): 500 | 100;Code language: PHP (php)

Funkčně identické, ale z hlediska diffu problematické.

Nový flag

--stableTypeOrdering

Tento flag:

• zavádí deterministické řazení typů
• přibližuje chování budoucímu TypeScript 7.0
• eliminuje náhodné změny pořadí unijních typů

Nevýhoda:

• může zpomalit typovou kontrolu až o cca 25 %
• je primárně určen pro testování migrace

Doporučení týmu: vyzkoušet v CI, zejména u knihoven generujících .d.ts.

5. Sloučení dom, dom.iterable a dom.asynciterable

Jednou z konfiguračních změn je sjednocení DOM knihoven.

Stav před TypeScript 6.0

Pokud chtěl projekt používat iterovatelné DOM kolekce (například NodeListOf, HTMLCollection atd.) s podporou for...of, bylo nutné explicitně přidat knihovnu:

{
  "compilerOptions": {
    "lib": ["dom", "dom.iterable"]
  }
}Code language: JSON / JSON with Comments (json)

Pro asynchronní iteraci bylo nutné přidat i:

"dom.asynciterable"Code language: JSON / JSON with Comments (json)

To bylo historické rozdělení kvůli kompatibilitě s různými cílovými prostředími.

Co se mění

TypeScript 6.0 nyní:

• zahrnuje obsah dom.iterable
• zahrnuje obsah dom.asynciterable

přímo do lib.dom.

To znamená, že dnes už stačí:

{
  "compilerOptions": {
    "lib": ["dom"]
  }
}Code language: JSON / JSON with Comments (json)

A následující kód bude fungovat bez další konfigurace:

for (const element of document.querySelectorAll("div")) {
    console.log(element.textContent);
}Code language: JavaScript (javascript)

Tato změna reflektuje fakt, že moderní prohlížeče již tato API běžně podporují.

6. Nové výchozí hodnoty v tsconfig.json

TypeScript 6.0 výrazně mění defaultní nastavení kompilátoru, pokud není explicitně uvedeno jinak.

Cílem je:

• podporovat moderní JavaScript
• zapnout bezpečnější chování
• minimalizovat historické kompromisy

6.1 strict: true jako výchozí hodnota

Dosud bylo nutné explicitně zapnout přísný režim:

{
  "compilerOptions": {
    "strict": true
  }
}Code language: JSON / JSON with Comments (json)

Nově je strict zapnutý implicitně.

To zahrnuje například:

• strictNullChecks
• strictFunctionTypes
• strictBindCallApply
• noImplicitAny
• další bezpečnostní kontroly

Pro starší projekty to může znamenat nové chyby při upgradu.

Pokud je potřeba zachovat staré chování:

{
  "compilerOptions": {
    "strict": false
  }
}Code language: JSON / JSON with Comments (json)

6.2 module: esnext jako výchozí

Moderní JavaScript ekosystém se posunul směrem k ESM.

TypeScript proto mění výchozí hodnotu module na:

"module": "esnext"Code language: JavaScript (javascript)

To znamená:

• generování import/export
• lepší kompatibilitu s bundlery
• moderní výstup jako standard

6.3 target na nejnovější ECMAScript

Výchozí target se nyní nastavuje na aktuální nejnovější standard (např. ES2025).

Dříve byl výchozí target konzervativnější.

Dopad:

• méně downlevel transformací
• rychlejší kompilace
• menší výstupní kód

Pro legacy prostředí je nutné explicitně nastavit:

{
  "compilerOptions": {
    "target": "es2017"
  }
}Code language: JSON / JSON with Comments (json)

nebo jinou požadovanou verzi.

6.4 noUncheckedSideEffectImports: true

Nově zapnuto implicitně.

Tento flag pomáhá zachytit importy, které:

• nemají žádný export
• existují jen kvůli side-effectům
• nebo jsou překlepem

Například:

mport "./does-not-exist";Code language: JavaScript (javascript)

Nově může generovat chybu, pokud modul není nalezen.

Cílem je eliminovat tiché chyby v importech.

6.5 libReplacement: false

Tento méně známý flag ovlivňuje způsob, jakým TypeScript nahrazuje knihovny.

Nově je výchozí hodnota nastavena na false, což:

• zjednodušuje chování
• snižuje komplexitu editorových scénářů
• zlepšuje výkon

7. Ukončené podpory a odstraněné možnosti

TypeScript 6.0 je výrazně „úklidová“ verze. Velká část změn se týká odstranění historických možností, které dnes již nedávají smysl v moderním JavaScript ekosystému.

Většinu ukončených podpor lze dočasně potlačit pomocí:

{
  "compilerOptions": {
    "ignoreDeprecations": "6.0"
  }
}Code language: JSON / JSON with Comments (json)

Toto ale slouží pouze jako přechodné řešení. V TypeScript 7.0 budou tyto možnosti definitivně odstraněny.

7.1 target: es5 je u konce

Historicky bylo běžné cílit na ES5 kvůli podpoře starých prohlížečů.

{
  "compilerOptions": {
    "target": "es5"
  }
}Code language: JSON / JSON with Comments (json)

TypeScript 6.0 tuto možnost ukončuje.

Důvody:

• většina prostředí dnes podporuje minimálně ES2015
• downlevel transformace jsou složité a zpomalují kompilaci
• ES5 cílení dnes obvykle řeší bundler nebo jiný transpiler

Doporučení: používat moderní target a případné další transformace řešit v build pipeline.

7.2 --downlevelIteration je u konce

Tento flag měl smysl především při cílení na ES5:

{
  "compilerOptions": {
    "downlevelIteration": true
  }
}Code language: JSON / JSON with Comments (json)

S ukončením ES5 cílení ztrácí význam.

7.3 Konec hodnot module

Následující hodnoty budou odstraněny:

• amd
• umd
• system

Tyto modulové systémy jsou dnes považovány za historické.

Moderní alternativy:

• esnext
• node16
• node20
• nodenext
• commonjs (v přechodových scénářích)

7.4 --moduleResolution classic je odstraněn

Starý klasický modulový resolver byl zdrojem nejasností a neodpovídal chování Node.js ani bundlerů.

Pokud máte:

{
  "compilerOptions": {
    "moduleResolution": "classic"
  }
}Code language: JSON / JSON with Comments (json)

Je nutné přejít na:

"moduleResolution": "nodenext"Code language: JavaScript (javascript)

nebo

"moduleResolution": "bundler"Code language: JavaScript (javascript)

v závislosti na projektu.

7.5 --baseUrl jako lookup root je odstraněn

baseUrl byl používán pro aliasování importů:

{
  "compilerOptions": {
    "baseUrl": "./src"
  }
}Code language: JSON / JSON with Comments (json)

Problém:

• neodpovídá standardnímu Node chování
• vede k neočekávaným kolizím
• komplikuje přechod mezi nástroji

7.6 --esModuleInterop false a --allowSyntheticDefaultImports false již nejsou podporovány

TypeScript umožňoval vypnout interoperabilitu mezi CommonJS a ESM.

Například:

{
  "compilerOptions": {
    "esModuleInterop": false
  }
}Code language: JSON / JSON with Comments (json)

V TypeScript 6.0 již nelze tyto volby nastavit na false.

Interop chování je nyní standardem.

Důvod:

• většina ekosystému s ním počítá
• bez něj vznikají neintuitivní import chyby
• zjednodušení konfigurace

7.7 --alwaysStrict false odstraněn

TypeScript nyní vždy generuje strict mode JavaScript.

Staré nastavení:

{
  "compilerOptions": {
    "alwaysStrict": false
  }
}Code language: JSON / JSON with Comments (json)

Již není podporováno.

To může mít dopad například na:

• použití rezervovaných slov
• implicitní globální proměnné

7.8 outFile odstraněn

Možnost generovat jeden výstupní soubor byla odstraněna:

{
  "compilerOptions": {
    "outFile": "bundle.js"
  }
}Code language: JSON / JSON with Comments (json)

TypeScript se profiluje jako transpiler, nikoliv bundler.

Pro spojování souborů je nutné použít:

• esbuild
• Rollup
• Webpack
• Vite
• jiný bundler

7.9 Namespace syntax pomocí module je odstraněn

Starší syntax:

module MyNamespace {
    export const x = 1;
}Code language: JavaScript (javascript)

Nový syntax:

namespace MyNamespace {
    export const x = 1;
}Code language: JavaScript (javascript)

7.10 Import assertions je odstraněn

Starší syntax:

import data from "./file.json" asserts { type: "json" };Code language: JavaScript (javascript)

Nový syntax:

import data from "./file.json" with { type: "json" };Code language: JavaScript (javascript)

7.11 /// <reference no-default-lib="true"/> již není podporováno

Tato direktiva je odstraněna.

Správné řešení je nyní explicitní konfigurace lib v tsconfig.json.

8. Změna chování CLI při kombinaci tsconfig.json a explicitních souborů

Dříve bylo možné spustit:

tsc foo.tsCode language: CSS (css)

i když existoval tsconfig.json.

TypeScript 6.0 nyní v takovém případě hlásí chybu.

Pokud chcete ignorovat konfiguraci, je nutné použít:

tsc --ignoreConfig foo.tsCode language: CSS (css)

Cílem je odstranit nejasnosti, kdy bylo obtížné určit, zda je projekt kompilován podle konfigurace nebo podle explicitně zadaných souborů.

9. Příprava na TypeScript 7.0 (Go kompilátor)

Nejzásadnější změna se netýká syntaxe, ale architektury.

TypeScript 7.0:

• bude napsán v Go
• přinese výrazně vyšší výkon
• umožní paralelní typovou kontrolu
• zavede deterministické řazení typů jako standard
• odstraní všechny možnosti s ukončenou podporou z verze 6.0

Doporučení:

1. Vyřešit všechna deprecation warning.
2. Vyzkoušet --stableTypeOrdering.
3. Explicitně nastavit konfiguraci tam, kde projekt spoléhá na staré výchozí hodnoty.
4. Otestovat knihovny generující .d.ts soubory.

Závěr

TypeScript 6.0 Beta nepřináší nové jazykové konstrukce, ale představuje klíčovou strategickou verzi.

Hlavní přínosy:

• zlepšená inference u funkcí bez this
• podpora moderních subpath importů
• nový režim deterministického řazení typů
• modernizované výchozí nastavení kompilátoru
• rozsáhlý úklid historických možností
• příprava na přepsání kompilátoru do Go

Pro běžné projekty může být upgrade relativně bezbolestný, pokud již používají moderní konfiguraci. Starší projekty však mohou zaznamenat větší množství varování a chyb.

TypeScript 6.0 je méně o nových funkcích a více o stabilizaci a přípravě na budoucnost.

Původní zpráva: https://devblogs.microsoft.com/typescript/announcing-typescript-6-0-beta/