TypeScript et modules

Elide exécute les fichiers .ts, .mts, .cts et .tsx en supprimant leurs types ; il ne vérifie pas les types et ne lit pas tsconfig.json.

Syntaxe TypeScript

Syntaxe	État
Annotations de type, interfaces, `type`, génériques, `as`, `satisfies`, `!`	Supprimés
`import type`, `import { type X }`	Supprimés
`enum`, `const enum`	Compilés en objets
`namespace`	Compilé
Propriétés de paramètre du constructeur (`constructor(public x: number)`)	Compilées
`abstract`, champs `declare`, `override`, `accessor`	Pris en charge
`import fs = require("node:fs")`	Pris en charge
Décorateurs sur les classes et les méthodes	Décorateurs standard : chacun reçoit `(value, context)`
Décorateurs de style `experimentalDecorators`	Non pris en charge ; ils reçoivent les arguments standard
Décorateurs de paramètre (`constructor(@inject x)`)	`SyntaxError: … expected BindingIdentifier or BindingPattern`
Assertions de type `<string>value`	`Precompiler failed with 1 diagnostic(s): … [ERROR] Unexpected token` ; utilisez `value as string`
`export = value`	`SyntaxError: … Expected an operand but found export`
`paths` de `tsconfig.json`	Ignoré : `TypeError: Module not found: '@lib/math'`

Les imports peuvent nommer le fichier .ts, une extension .js ou aucune extension ; les trois se résolvent en math.ts :

import { add } from "./src/lib/math.ts";
import { add as add2 } from "./src/lib/math.js";
import { add as add3 } from "./src/lib/math";
console.log(add(1, 2), add2(2, 2), add3(3, 3));

3 4 6

JSX

Les fichiers .tsx utilisent le runtime JSX automatique et importent react/jsx-runtime. Installez React vous-même :

// app.tsx
import { renderToString } from "react-dom/server";

function Hello({ name }: { name: string }) {
  return <p>hello {name}</p>;
}

console.log(renderToString(<Hello name="elide" />));

elide install --ecosystems=npm   # react, react-dom in package.json
elide app.tsx

<p>hello <!-- -->elide</p>

Entrée	Résultat
`/** @jsxImportSource preact */` en tête d’un fichier `.tsx`	Importe `preact/jsx-runtime`
`jsxImportSource` dans `tsconfig.json`	Ignoré ; React est utilisé
`/** @jsx h */`	Ignoré ; des éléments React sont créés
JSX dans un fichier `.jsx`	`SyntaxError: … Expected an operand but found <` ; renommez le fichier en `.tsx`

Vérifier les types

Installez TypeScript et exécutez son compilateur via Elide :

{
  "scripts": { "typecheck": "tsc --noEmit" },
  "devDependencies": { "typescript": "^5.9.0", "@types/node": "^24.0.0" }
}

{
  "compilerOptions": {
    "module": "nodenext",
    "target": "esnext",
    "strict": true,
    "noEmit": true,
    "allowImportingTsExtensions": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "types": ["node"]
  }
}

elide install --ecosystems=npm
elide run typecheck              # or: elide run tsc

bad-types.ts(1,7): error TS2322: Type 'string' is not assignable to type 'number'.

tsc se termine avec 2 en cas d’erreurs de type. Passez les options du compilateur après -- : elide run tsc -- --version. Avec erasableSyntaxOnly, tsc refuse les enums, les namespaces et les propriétés de paramètre ; retirez cette option si vous les utilisez.

Types d’Elide

@elide-dev/types déclare les globales et les modules propres à Elide et inclut @types/node. Ajoutez-le comme dépendance de développement et nommez-le dans types :

{
  "type": "module",
  "scripts": { "typecheck": "tsc --noEmit" },
  "devDependencies": { "typescript": "^5.9.0", "@elide-dev/types": "nightly" }
}

{
  "compilerOptions": {
    "module": "nodenext",
    "target": "esnext",
    "strict": true,
    "noEmit": true,
    "allowImportingTsExtensions": true,
    "types": ["@elide-dev/types"]
  }
}

// main.ts
import { Database } from "elide:postgres";
import { readFileSync } from "node:fs";

const bytes: number = readFileSync("package.json").length;
console.log(`Elide ${Elide.version}: ${bytes} bytes`);
export const open = (url: string) => Database.connect(url);

elide install --ecosystems=npm
elide run typecheck
elide main.ts

Elide 1.6.0: 149 bytes

API	Déclarée
`Elide.version`, `debug`, `release`, `buildMode`	Oui
`Elide.targetArchitecture`	Typée `boolean` ; la valeur est une chaîne
`Elide.serve()`	Non : `Property 'serve' does not exist`
`elide:postgres`, `elide:mysql`	Oui
`elide:sqlite`, `elide:cel`, `elide:telemetry`	Non
`import … from "./script.py"`	Oui, en tant que `any`
Modules `node:*`	Oui, via `@types/node`

L’étiquette nightly suit les déclarations les plus récentes ; latest est plus ancienne.

Modules ES et CommonJS

Fichier	Système de modules
`.mjs`, `.mts`	Module ES
`.cjs`, `.cts`	CommonJS
`.ts`, `.tsx`	Module ES
`.js`	Module ES si le `package.json` le plus proche contient `"type": "module"`, sinon CommonJS

Un fichier .js contenant des instructions import sans "type": "module" échoue avec SyntaxError: … Expected an operand but found import ; ajoutez le champ ou renommez le fichier en .mjs.

Fonctionnalité	Comportement
`import lib, { a } from "./lib.cjs"`	`module.exports` est l’export par défaut, ses propriétés sont des exports nommés
`await import("./lib.cjs")`	Fonctionne
`require("./lib.mjs")`	`Error: require() of ES Module … not supported.` (`ERR_REQUIRE_ESM`) ; utilisez `await import()`
`createRequire(import.meta.url)`	Fonctionne
`import.meta.url`, `.filename`, `.dirname`	Fonctionnent
`import.meta.main`, `import.meta.resolve`	`undefined`
`__dirname` en CommonJS	Fonctionne
`__filename` dans le fichier CommonJS d’entrée	`"unknown"` ; utilisez `module.filename`. Les fichiers chargés par require reçoivent le vrai chemin.
`__dirname`, `require` dans les modules ES	Définis, contrairement à Node ; ne comptez pas dessus

JSON

Toutes ces formes chargent data.json :

import data from "./data.json" with { type: "json" };
import same from "./data.json";
const viaRequire = require("./data.json"); // CommonJS

`exports` et `imports` du paquet

Champ de `package.json`	`import`	`require()`
Sous-chemins `exports` (`"./feature": …`)	Fonctionne	Fonctionne
`exports` pour la racine du paquet, avec `main`	Fonctionne	Utilise `main`
`exports` pour la racine du paquet, sans `main`	Fonctionne	`Error: Cannot find module 'pkg'`
Conditions `import` et `default`	Fonctionnent	—
Une condition `require` placée avant `default`	Choisie à la place de `default`	—
Sous-chemin non exporté	`Package subpath is not defined by "exports" field` (sans `code`)	—
`imports` (`"#internal"`)	`TypeError: Packages imports do not define the specifier: '#internal'`	`Error: Cannot find module '#internal'`

Exemples

TypeScript sans build