bun-assemblyscript 0.1.0

package/src/compiler.ts

@@ -0,0 +1,177 @@
+import { resolve, basename } from "path";
+import { tmpdir } from "os";
+
+export interface CompilerOptions {
+  optimizeLevel?: 0 | 1 | 2 | 3;
+  shrinkLevel?: 0 | 1 | 2;
+  runtime?: "minimal" | "stub" | "full" | "incremental";
+  sourceMap?: boolean;
+  debug?: boolean;
+}
+
+export interface CompilerResult {
+  success: boolean;
+  wasmBytes: Uint8Array | null;
+  sourceMapBytes: Uint8Array | null;
+  errors: string[];
+}
+
+/**
+ * Résout le chemin du binaire `asc.js` depuis node_modules.
+ * Lève une erreur claire si assemblyscript n'est pas installé.
+ */
+function resolveAscJs(cwd: string): string {
+  const candidates = [
+    resolve(cwd, "node_modules", "assemblyscript", "bin", "asc.js"),
+    resolve(cwd, "..", "node_modules", "assemblyscript", "bin", "asc.js"),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      if (Bun.file(candidate).size > 0) return candidate;
+    } catch {}
+  }
+
+  throw new Error(
+    [
+      "AssemblyScript compiler (asc) introuvable.",
+      "Installez-le avec :",
+      "  bun add -d assemblyscript",
+    ].join("\n")
+  );
+}
+
+/**
+ * Crée un fichier `.ts` temporaire qui est une copie exacte du fichier `.as`.
+ *
+ * Pont .as → .ts : asc v0.28 n'accepte que les extensions `.ts`.
+ * On copie le source dans un fichier temporaire `.ts`, on compile,
+ * puis on supprime le temporaire.
+ *
+ * @returns Chemin absolu vers le fichier temporaire `.ts`.
+ */
+async function createTsBridge(asFilePath: string): Promise<string> {
+  const source = await Bun.file(asFilePath).text();
+  const baseName = basename(asFilePath, ".as");
+  const tmpPath = resolve(tmpdir(), `asc_bridge_${baseName}_${Date.now()}.ts`);
+  await Bun.write(tmpPath, source);
+  return tmpPath;
+}
+
+/**
+ * Compile un fichier `.as` en bytes WASM.
+ *
+ * Stratégie :
+ *  1. Copier le `.as` en `.ts` temporaire (pont d'extension).
+ *  2. Invoquer `node asc.js` via Bun.spawn() — on utilise node car asc v0.28
+ *     appelle WebAssembly.instantiateStreaming() en interne, non supporté par Bun.
+ *  3. Lire le fichier WASM généré.
+ *  4. Nettoyer les fichiers temporaires.
+ *
+ * @param filename  Chemin absolu vers le fichier AssemblyScript source.
+ * @param options   Options de compilation.
+ */
+export async function compile(
+  filename: string,
+  options: CompilerOptions = {}
+): Promise<CompilerResult> {
+  const errors: string[] = [];
+
+  // 1. Résoudre asc.js
+  let ascJs: string;
+  try {
+    ascJs = resolveAscJs(process.cwd());
+  } catch (e) {
+    return {
+      success: false,
+      wasmBytes: null,
+      sourceMapBytes: null,
+      errors: [e instanceof Error ? e.message : String(e)],
+    };
+  }
+
+  // 2. Créer le pont .as → .ts
+  let tsBridgePath: string | null = null;
+  let outWasmPath: string | null = null;
+
+  try {
+    tsBridgePath = await createTsBridge(filename);
+    outWasmPath = tsBridgePath.replace(/\.ts$/, ".wasm");
+
+    // 3. Arguments CLI pour asc
+    const args = [
+      ascJs,
+      tsBridgePath,
+      "--outFile", outWasmPath,
+      "--optimizeLevel", String(options.optimizeLevel ?? 0),
+      "--runtime", options.runtime ?? "stub",
+    ];
+
+    if (options.shrinkLevel !== undefined) {
+      args.push("--shrinkLevel", String(options.shrinkLevel));
+    }
+    if (options.debug) args.push("--debug");
+    if (options.sourceMap) args.push("--sourceMap");
+
+    // 4. Lancer `node asc.js ...` — Node.js gère correctement WebAssembly.instantiateStreaming
+    const proc = Bun.spawn(["node", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      cwd: process.cwd(),
+    });
+
+    const [stderrText] = await Promise.all([
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+
+    const exitCode = proc.exitCode;
+
+    // Collecter les erreurs stderr
+    for (const line of stderrText.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length > 0) errors.push(trimmed);
+    }
+
+    if (exitCode !== 0) {
+      return { success: false, wasmBytes: null, sourceMapBytes: null, errors };
+    }
+
+    // 5. Lire le WASM généré
+    const wasmFile = Bun.file(outWasmPath);
+    const wasmBytes = new Uint8Array(await wasmFile.arrayBuffer());
+
+    let sourceMapBytes: Uint8Array | null = null;
+    if (options.sourceMap) {
+      const mapPath = outWasmPath + ".map";
+      if (await Bun.file(mapPath).exists()) {
+        sourceMapBytes = new Uint8Array(await Bun.file(mapPath).arrayBuffer());
+      }
+    }
+
+    if (wasmBytes.byteLength === 0) {
+      return {
+        success: false,
+        wasmBytes: null,
+        sourceMapBytes: null,
+        errors: [...errors, "Aucun output WASM produit par asc."],
+      };
+    }
+
+    return { success: true, wasmBytes, sourceMapBytes, errors };
+
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    errors.push(message);
+    return { success: false, wasmBytes: null, sourceMapBytes: null, errors };
+
+  } finally {
+    // 6. Nettoyer les fichiers temporaires dans tous les cas
+    const fs = await import("fs/promises");
+    for (const tmpFile of [tsBridgePath, outWasmPath, outWasmPath ? outWasmPath + ".map" : null]) {
+      if (tmpFile) {
+        try { await fs.unlink(tmpFile); } catch {}
+      }
+    }
+  }
+}

package/src/install/bunfig.ts

@@ -0,0 +1,45 @@
+import { join } from "path";
+import { existsSync } from "fs";
+
+/**
+ * Lit le bunfig.toml du projet hôte et injecte "bun-plugin-assemblyscript"
+ * dans le tableau preload s'il n'est pas déjà présent.
+ * 
+ * @param projectRoot Chemin racine du projet hôte
+ * @returns boolean indiquant si le fichier a été modifié
+ */
+export async function patchBunfig(projectRoot: string): Promise<boolean> {
+  const bunfigPath = join(projectRoot, "bunfig.toml");
+  let content = "";
+  let changed = false;
+
+  if (existsSync(bunfigPath)) {
+    content = await Bun.file(bunfigPath).text();
+    
+    // Si déjà présent, on ne fait rien pour ne pas dupliquer
+    if (!content.includes("bun-plugin-assemblyscript")) {
+      const preloadRegex = /preload\s*=\s*\[(.*?)\]/s;
+      const match = content.match(preloadRegex);
+      
+      if (match) {
+        const inner = match[1].trim();
+        const addition = inner.length > 0 ? `, "bun-plugin-assemblyscript"` : `"bun-plugin-assemblyscript"`;
+        content = content.replace(preloadRegex, `preload = [${inner}${addition}]`);
+        changed = true;
+      } else {
+        content += `\npreload = ["bun-plugin-assemblyscript"]\n`;
+        changed = true;
+      }
+    }
+  } else {
+    // Fichier absent : on créé une version vierge minimale
+    content = `preload = ["bun-plugin-assemblyscript"]\n`;
+    changed = true;
+  }
+
+  if (changed) {
+    await Bun.write(bunfigPath, content);
+  }
+  
+  return changed;
+}

package/src/install/index.ts

@@ -0,0 +1,142 @@
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+import { patchTsConfig } from "./tsconfig";
+import { patchBunfig } from "./bunfig";
+import { patchVsCode } from "./vscode";
+import { Glob } from "bun";
+
+async function run() {
+  // En mode postinstall NPM/Bun, INIT_CWD pointe vers le dossier du projet final installant le package
+  const hostRoot = process.env.INIT_CWD || process.cwd();
+  
+  // Anti-boucle : si on est dans le dépôt originel de dev, on limite certains comportements
+  const isSelf = hostRoot === process.cwd() && existsSync(join(hostRoot, "src", "compiler.ts"));
+
+  console.log("");
+  console.log("\x1b[36m┌──────────────────────────────────────────────┐\x1b[0m");
+  console.log("\x1b[36m│                                              │\x1b[0m");
+  console.log("\x1b[36m│    \x1b[1m🚀 Installation bun-assemblyscript\x1b[0;36m        │\x1b[0m");
+  console.log("\x1b[36m│                                              │\x1b[0m");
+
+  const results = {
+    ascParams: false,
+    bunfig: false,
+    globalDts: false,
+    tsconfig: false,
+    vscode: false,
+    example: false,
+  };
+
+  try {
+    // 1. Détecter assemblyscript
+    const pkgPath = join(hostRoot, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = await Bun.file(pkgPath).json();
+      const hasAsc =
+        (pkg.dependencies && pkg.dependencies.assemblyscript) ||
+        (pkg.devDependencies && pkg.devDependencies.assemblyscript);
+      if (hasAsc) {
+        results.ascParams = true;
+      } else {
+        console.log(
+          "\x1b[33m[!] Warning: 'assemblyscript' n'est pas installé dans votre projet.\x1b[0m"
+        );
+        console.log(
+          "\x1b[33m    => Lancez : bun add -d assemblyscript\x1b[0m\n"
+        );
+      }
+    }
+
+    // 2. bunfig.toml
+    await patchBunfig(hostRoot);
+    results.bunfig = true;
+
+    // 3. assemblyscript.d.ts (global)
+    const globalDest = join(hostRoot, "assemblyscript.d.ts");
+    if (!existsSync(globalDest) && !isSelf) {
+      // Résout depuis __dirname vers src/typegen/global.d.ts
+      const sourceGlobal = join(__dirname, "..", "typegen", "global.d.ts");
+      try {
+        const content = await Bun.file(sourceGlobal).text();
+        await Bun.write(globalDest, content);
+      } catch (e) {}
+    }
+    results.globalDts = true;
+
+    // 4. tsconfig.json
+    try {
+      await patchTsConfig(hostRoot);
+      results.tsconfig = true;
+    } catch (e) {}
+
+    // 5. VSCode Integration
+    try {
+      await patchVsCode(hostRoot, isSelf);
+      results.vscode = true;
+    } catch (e) {}
+
+    // 6. Créer example.as s'il n'y a pas de fichier .as dans le projet
+    let hasAsFile = false;
+    const asGlob = new Glob("**/*.as");
+    for (const file of asGlob.scanSync({ cwd: hostRoot })) {
+      if (!file.includes("node_modules") && !file.includes(".cache")) {
+        hasAsFile = true;
+        break;
+      }
+    }
+
+    let createdExample = false;
+    if (!hasAsFile && !isSelf) {
+      const wasmDir = join(hostRoot, "src", "wasm");
+      if (!existsSync(wasmDir)) {
+        mkdirSync(wasmDir, { recursive: true });
+      }
+
+      const asFile = join(wasmDir, "example.as");
+      const asCode = `// Exemple de fonction AssemblyScript
+export function add(a: i32, b: i32): i32 {
+  return a + b;
+}
+`;
+      await Bun.write(asFile, asCode);
+
+      const tsFile = join(wasmDir, "example.ts");
+      const tsCode = `import { add } from "./example.as";
+
+console.log("AssemblyScript add(10, 20) =", add(10, 20));
+`;
+      await Bun.write(tsFile, tsCode);
+
+      createdExample = true;
+    }
+    results.example = true;
+
+    // Formatter de résultat [✓] et [✗]
+    const check = (ok: boolean) => (ok ? "\x1b[32m✓\x1b[36m" : "\x1b[31m✗\x1b[36m");
+
+    console.log("\x1b[36m│  " + check(results.ascParams) + " Vérification dépendance AssemblyScript   │\x1b[0m");
+    console.log("\x1b[36m│  " + check(results.bunfig) + " Configuration automatique bunfig.toml    │\x1b[0m");
+    console.log("\x1b[36m│  " + check(results.globalDts) + " Copie de assemblyscript.d.ts global      │\x1b[0m");
+    console.log("\x1b[36m│  " + check(results.tsconfig) + " Configuration auto tsconfig.json         │\x1b[0m");
+    console.log("\x1b[36m│  " + check(results.vscode) + " Intégration VSCode (.vscode)               │\x1b[0m");
+    console.log("\x1b[36m│  " + check(results.example) + (createdExample ? " Fichier d'exemple généré                 " : " Projet contenant déjà des fichiers .as   ") + "│\x1b[0m");
+    console.log("\x1b[36m│                                              │\x1b[0m");
+    console.log("\x1b[36m└──────────────────────────────────────────────┘\x1b[0m\n");
+
+    if (createdExample) {
+      console.log(
+        "\x1b[1m\x1b[32mInstallation réussie !\x1b[0m Testez l'exemple avec la commande ci-dessous :\n"
+      );
+      console.log("  \x1b[36mbun run src/wasm/example.ts\x1b[0m\n");
+    } else {
+      console.log(
+        "\x1b[1m\x1b[32mInstallation réussie !\x1b[0m Votre projet est prêt.\n"
+      );
+    }
+  } catch (err) {
+    console.error("\x1b[31m[bun-as] Erreur pendant l'installation:\x1b[0m", err);
+    process.exit(1);
+  }
+}
+
+run().catch(() => process.exit(0));

package/src/install/tsconfig.ts

@@ -0,0 +1,61 @@
+import { join } from "path";
+
+/**
+ * Nettoie une chaîne JSON de ses commentaires (// et \/\* \*\/)
+ * afin de la rendre compatible avec JSON.parse().
+ */
+function stripJsonComments(jsonStr: string): string {
+  return jsonStr.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "");
+}
+
+/**
+ * Lit, nettoie et parse le \`tsconfig.json\` du projet hôte.
+ * Fusionne les options pour inclure les dépendances gérées par le plugin.
+ * Ne supprime pas les configurations existantes de l'utilisateur.
+ * 
+ * @param projectRoot Chemin vers la racine du projet hôte. (Par défaut \`process.cwd()\`)
+ */
+export async function patchTsConfig(projectRoot: string = process.cwd()): Promise<void> {
+  const tsconfigPath = join(projectRoot, "tsconfig.json");
+  let config: any = {};
+
+  try {
+    const rawContent = await Bun.file(tsconfigPath).text();
+    config = JSON.parse(stripJsonComments(rawContent));
+  } catch (err) {
+    // Si absent ou invalide, on génère une configuration par défaut minimale
+    config = {
+      compilerOptions: {
+        target: "ESNext",
+        moduleResolution: "bundler",
+      },
+    };
+  }
+
+  // S'assurer que les clés minimales existent
+  if (!config.compilerOptions) {
+    config.compilerOptions = {};
+  }
+  // S'assurer que le tableau include existe à la racine
+  if (!Array.isArray(config.include)) {
+    if (config.include) config.include = [config.include];
+    else config.include = [];
+  }
+
+  const includes: string[] = config.include;
+  let changed = false;
+
+  const requiredIncludes = ["assemblyscript.d.ts", "**/*.as.d.ts"];
+
+  for (const req of requiredIncludes) {
+    if (!includes.includes(req)) {
+      includes.push(req);
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    // Écriture du fichier modifié
+    await Bun.write(tsconfigPath, JSON.stringify(config, null, 2) + "\n");
+  }
+}

package/src/install/vscode.ts

@@ -0,0 +1,80 @@
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+
+export async function patchVsCode(hostRoot: string, isSelf: boolean) {
+  // Optionnel: on ne le fait pas si on est dans notre propre repo de dev, sauf si demandé.
+  // Mais c'est pratique de l'avoir même en dev. On va l'exécuter dans tous les cas.
+  
+  const vscodeDir = join(hostRoot, ".vscode");
+  if (!existsSync(vscodeDir)) {
+    mkdirSync(vscodeDir, { recursive: true });
+  }
+
+  // 6.1 settings.json
+  const settingsPath = join(vscodeDir, "settings.json");
+  let settings: any = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = await Bun.file(settingsPath).json();
+    } catch (e) {
+      // Ignorer si le JSON est invalide
+    }
+  }
+  if (!settings["files.associations"]) {
+    settings["files.associations"] = {};
+  }
+  settings["files.associations"]["*.as"] = "typescript";
+  await Bun.write(settingsPath, JSON.stringify(settings, null, 2));
+
+  // 6.2 as.code-snippets
+  const snippetsPath = join(vscodeDir, "as.code-snippets");
+  const snippets = {
+    "AssemblyScript Export": {
+      "prefix": "asexport",
+      "scope": "typescript",
+      "body": [
+        "export function ${1:name}(${2:a}: ${3:i32}): ${4:i32} {",
+        "  $0",
+        "}"
+      ],
+      "description": "Exported function for AssemblyScript"
+    },
+    "AssemblyScript Class": {
+      "prefix": "asclass",
+      "scope": "typescript",
+      "body": [
+        "export class ${1:Name} {",
+        "  constructor() {",
+        "    $0",
+        "  }",
+        "}"
+      ],
+      "description": "Exported class with constructor for AssemblyScript"
+    },
+    "AssemblyScript Import": {
+      "prefix": "asimport",
+      "scope": "typescript",
+      "body": [
+        "import { ${2:func} } from \"${1:./module.as}\";$0"
+      ],
+      "description": "Import pattern from an .as file"
+    }
+  };
+  await Bun.write(snippetsPath, JSON.stringify(snippets, null, 2));
+
+  // 6.3 extensions.json
+  const extensionsPath = join(vscodeDir, "extensions.json");
+  let extensions: any = {};
+  if (existsSync(extensionsPath)) {
+    try {
+      extensions = await Bun.file(extensionsPath).json();
+    } catch (e) {}
+  }
+  if (!extensions.recommendations) {
+    extensions.recommendations = [];
+  }
+  if (!extensions.recommendations.includes("saulecabrera.vscode-assemblyscript")) {
+    extensions.recommendations.push("saulecabrera.vscode-assemblyscript");
+  }
+  await Bun.write(extensionsPath, JSON.stringify(extensions, null, 2));
+}

package/src/instantiator.ts

@@ -0,0 +1,90 @@
+export interface ASExports {
+  [key: string]: (...args: number[]) => number | void;
+}
+
+export class AbortError extends Error {
+  constructor(
+    message: string,
+    public readonly file: string,
+    public readonly line: number,
+    public readonly column: number
+  ) {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
+/**
+ * Lit une String AssemblyScript depuis la mémoire linéaire.
+ *
+ * Format mémoire AS (runtime stub / minimal / full) :
+ *   ptr - 16 : ClassID  (4 octets)
+ *   ptr - 12 : reserved (4 octets)
+ *   ptr -  8 : rtSize   (4 octets)  ← taille du buffer en octets
+ *   ptr -  4 : length   (4 octets)  ← nombre de code units UTF-16
+ *   ptr      : données UTF-16       ← longueur = length * 2 octets
+ *
+ * Si ptr est 0 ou invalide, retourne la chaîne vide.
+ */
+function readASString(memory: WebAssembly.Memory, ptr: number): string {
+  if (ptr === 0) return "";
+
+  const buf = memory.buffer;
+  const dataView = new DataView(buf);
+
+  // Lire la longueur (code units UTF-16) stockée à ptr - 4
+  const byteLength = dataView.getInt32(ptr - 4, true); // en octets
+  const length = byteLength >>> 1;                     // en code-units
+
+  if (length <= 0 || ptr + byteLength > buf.byteLength) return "";
+
+  const u16 = new Uint16Array(buf, ptr, length);
+  return String.fromCharCode(...u16);
+}
+
+/**
+ * Instancie un module WASM AssemblyScript.
+ *
+ * Fournit les imports obligatoires :
+ *  - `env.memory`  : WebAssembly.Memory (initial 1 page = 64 Ko)
+ *  - `env.abort`   : handler qui lève une AbortError lisible
+ *
+ * @returns Un objet plat ne contenant que les exports de type `function`.
+ */
+export async function instantiate(wasmBytes: Uint8Array): Promise<ASExports> {
+  const memory = new WebAssembly.Memory({ initial: 1 });
+
+  const imports = {
+    env: {
+      memory,
+      abort(
+        msgPtr: number,
+        filePtr: number,
+        line: number,
+        col: number
+      ): void {
+        const message = readASString(memory, msgPtr);
+        const file = readASString(memory, filePtr);
+        throw new AbortError(
+          `AbortError: ${message || "(no message)"} — ${file || "(unknown file)"}:${line}:${col}`,
+          file,
+          line,
+          col
+        );
+      },
+    },
+  };
+
+  const { instance } = await WebAssembly.instantiate(wasmBytes, imports);
+  const rawExports = instance.exports as Record<string, unknown>;
+
+  // Ré-exporter nommément chaque fonction (objet plat, pas instance.exports)
+  const flatExports: ASExports = {};
+  for (const [key, value] of Object.entries(rawExports)) {
+    if (typeof value === "function") {
+      flatExports[key] = value as (...args: number[]) => number | void;
+    }
+  }
+
+  return flatExports;
+}