TypeScript und Module

Elide führt .ts-, .mts-, .cts- und .tsx-Dateien aus, indem es ihre Typen entfernt; es prüft keine Typen und liest keine tsconfig.json.

TypeScript-Syntax

Syntax	Status
Typannotationen, Interfaces, `type`, Generics, `as`, `satisfies`, `!`	Entfernt
`import type`, `import { type X }`	Entfernt
`enum`, `const enum`	Zu Objekten kompiliert
`namespace`	Kompiliert
Parameter-Properties im Konstruktor (`constructor(public x: number)`)	Kompiliert
`abstract`, `declare`-Felder, `override`, `accessor`	Unterstützt
`import fs = require("node:fs")`	Unterstützt
Decorators an Klassen und Methoden	Standard-Decorators: Jeder erhält `(value, context)`
Decorators im Stil von `experimentalDecorators`	Nicht unterstützt; sie erhalten die Standardargumente
Parameter-Decorators (`constructor(@inject x)`)	`SyntaxError: … expected BindingIdentifier or BindingPattern`
Typzusicherungen mit `<string>value`	`Precompiler failed with 1 diagnostic(s): … [ERROR] Unexpected token`; verwenden Sie `value as string`
`export = value`	`SyntaxError: … Expected an operand but found export`
`paths` in `tsconfig.json`	Ignoriert: `TypeError: Module not found: '@lib/math'`

Importe dürfen die .ts-Datei, eine .js-Endung oder keine Endung nennen; alle drei werden zu math.ts aufgelöst:

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

.tsx-Dateien verwenden die automatische JSX-Laufzeit und importieren react/jsx-runtime. Installieren Sie React selbst:

// 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>

Eingabe	Ergebnis
`/** @jsxImportSource preact */` am Anfang einer `.tsx`-Datei	Importiert `preact/jsx-runtime`
`jsxImportSource` in `tsconfig.json`	Ignoriert; React wird verwendet
`/** @jsx h */`	Ignoriert; es entstehen React-Elemente
JSX in einer `.jsx`-Datei	`SyntaxError: … Expected an operand but found <`; benennen Sie die Datei in `.tsx` um

Typen prüfen

Installieren Sie TypeScript und führen Sie seinen Compiler über Elide aus:

{
  "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'.

Bei Typfehlern endet tsc mit Exit-Code 2. Compiler-Optionen folgen nach --: elide run tsc -- --version. Mit erasableSyntaxOnly lehnt tsc Enums, Namespaces und Parameter-Properties ab; lassen Sie die Option weg, wenn Sie diese verwenden.

Elide-Typen

@elide-dev/types deklariert die eigenen Globals und Module von Elide und bindet @types/node ein. Fügen Sie das Paket als Entwicklungsabhängigkeit hinzu und nennen Sie es in 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	Deklariert
`Elide.version`, `debug`, `release`, `buildMode`	Ja
`Elide.targetArchitecture`	Als `boolean` typisiert; der Wert ist ein String
`Elide.serve()`	Nein: `Property 'serve' does not exist`
`elide:postgres`, `elide:mysql`	Ja
`elide:sqlite`, `elide:cel`, `elide:telemetry`	Nein
`import … from "./script.py"`	Ja, als `any`
`node:*`-Module	Ja, über `@types/node`

Das Tag nightly folgt den neuesten Deklarationen; latest ist älter.

ES-Module und CommonJS

Datei	Modulsystem
`.mjs`, `.mts`	ES-Modul
`.cjs`, `.cts`	CommonJS
`.ts`, `.tsx`	ES-Modul
`.js`	ES-Modul, wenn die nächstgelegene `package.json` `"type": "module"` enthält, sonst CommonJS

Eine .js-Datei mit import-Anweisungen und ohne "type": "module" scheitert mit SyntaxError: … Expected an operand but found import; ergänzen Sie das Feld oder benennen Sie die Datei in .mjs um.

Funktion	Verhalten
`import lib, { a } from "./lib.cjs"`	`module.exports` ist der Default-Export, seine Eigenschaften sind benannte Exporte
`await import("./lib.cjs")`	Funktioniert
`require("./lib.mjs")`	`Error: require() of ES Module … not supported.` (`ERR_REQUIRE_ESM`); verwenden Sie `await import()`
`createRequire(import.meta.url)`	Funktioniert
`import.meta.url`, `.filename`, `.dirname`	Funktionieren
`import.meta.main`, `import.meta.resolve`	`undefined`
`__dirname` in CommonJS	Funktioniert
`__filename` in der CommonJS-Einstiegsdatei	`"unknown"`; verwenden Sie `module.filename`. Per `require` geladene Dateien erhalten den echten Pfad.
`__dirname`, `require` in ES-Modulen	Anders als in Node definiert; verlassen Sie sich nicht darauf

JSON

Alle diese Varianten laden data.json:

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

Package-`exports` und -`imports`

Feld in `package.json`	`import`	`require()`
Subpfade in `exports` (`"./feature": …`)	Funktioniert	Funktioniert
`exports` für die Paketwurzel, mit `main`	Funktioniert	Verwendet `main`
`exports` für die Paketwurzel, ohne `main`	Funktioniert	`Error: Cannot find module 'pkg'`
Bedingungen `import` und `default`	Funktionieren	—
Eine `require`-Bedingung vor `default`	Wird statt `default` gewählt	—
Nicht exportierter Subpfad	`Package subpath is not defined by "exports" field` (ohne `code`)	—
`imports` (`"#internal"`)	`TypeError: Packages imports do not define the specifier: '#internal'`	`Error: Cannot find module '#internal'`

Beispiele

TypeScript ohne Build