bun-assemblyscript 0.1.0

package/src/plugin.ts

@@ -0,0 +1,189 @@
+import type { BunPlugin } from "bun";
+import { compile, type CompilerOptions } from "./compiler";
+import { instantiate } from "./instantiator";
+import { parseASExports, type ASExport } from "./typegen/parser";
+import { generateDts } from "./typegen/generator";
+import { join } from "path";
+import { existsSync } from "fs";
+
+export interface PluginOptions {
+  compilerOverrides?: CompilerOptions;
+}
+
+function isBuildMode(build: { config?: { target?: string } }): boolean {
+  return (
+    build.config !== undefined &&
+    typeof build.config.target === "string" &&
+    build.config.target.length > 0 &&
+    process.env.NODE_ENV === "production"
+  );
+}
+
+function isComplexType(t: string): boolean {
+  const trim = t.trim();
+  return trim === "string" || trim === "String" || trim.includes("Array") || trim.includes("Map");
+}
+
+function hasComplexExports(exports: ASExport[]): boolean {
+  for (const exp of exports) {
+    if (exp.kind === "class") return true;
+    if (exp.type && isComplexType(exp.type)) return true;
+    if (exp.params && exp.params.some((p) => isComplexType(p.type))) return true;
+    if (exp.returnType && isComplexType(exp.returnType)) return true;
+    if (exp.methods && hasComplexExports(exp.methods)) return true;
+  }
+  return false;
+}
+
+function generateInlineModule(exportNames: string[], wasmBase64: string): string {
+  const lines: string[] = [
+    `// Auto-generated by bun-plugin-assemblyscript (inline)`,
+    `const __b64 = ${JSON.stringify(wasmBase64)};`,
+    `const __bin = Uint8Array.from(atob(__b64), (c) => c.charCodeAt(0));`,
+    `const __memory = new WebAssembly.Memory({ initial: 1 });`,
+    `function __readStr(mem, ptr) {`,
+    `  if (ptr === 0) return "";`,
+    `  const dv = new DataView(mem.buffer);`,
+    `  const len = dv.getInt32(ptr - 4, true) >>> 1;`,
+    `  if (len <= 0) return "";`,
+    `  return String.fromCharCode(...new Uint16Array(mem.buffer, ptr, len));`,
+    `}`,
+    `const __imports = {`,
+    `  env: {`,
+    `    memory: __memory,`,
+    `    abort(msg, file, line, col) {`,
+    `      const m = __readStr(__memory, msg);`,
+    `      const f = __readStr(__memory, file);`,
+    `      throw new Error(\`AbortError: \${m || "(no)"} — \${f}:\${line}:\${col}\`);`,
+    `    }`,
+    `  }`,
+    `};`,
+    `const { instance: __inst } = await WebAssembly.instantiate(__bin, __imports);`,
+  ];
+  for (const name of exportNames) {
+    lines.push(`export const ${name} = __inst.exports.${name};`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+function generateFileModule(exportNames: string[], wasmUrl: string): string {
+  const lines: string[] = [
+    `// Auto-generated by bun-plugin-assemblyscript (file)`,
+    `const __url = ${JSON.stringify(wasmUrl)};`,
+    `const __res = await fetch(__url);`,
+    `const __bin = new Uint8Array(await __res.arrayBuffer());`,
+    `const __memory = new WebAssembly.Memory({ initial: 1 });`,
+    `function __readStr(mem, ptr) {`,
+    `  if (ptr === 0) return "";`,
+    `  const dv = new DataView(mem.buffer);`,
+    `  const len = dv.getInt32(ptr - 4, true) >>> 1;`,
+    `  if (len <= 0) return "";`,
+    `  return String.fromCharCode(...new Uint16Array(mem.buffer, ptr, len));`,
+    `}`,
+    `const __imports = {`,
+    `  env: {`,
+    `    memory: __memory,`,
+    `    abort(msg, file, line, col) {`,
+    `      const m = __readStr(__memory, msg);`,
+    `      const f = __readStr(__memory, file);`,
+    `      throw new Error(\`AbortError: \${m || "(no)"} — \${f}:\${line}:\${col}\`);`,
+    `    }`,
+    `  }`,
+    `};`,
+    `const { instance: __inst } = await WebAssembly.instantiate(__bin, __imports);`,
+  ];
+  for (const name of exportNames) {
+    lines.push(`export const ${name} = __inst.exports.${name};`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+export function assemblyScriptPlugin(options: PluginOptions = {}): BunPlugin {
+  return {
+    name: "bun-plugin-assemblyscript",
+    async setup(build) {
+      let embedMode = "auto";
+      try {
+        if (existsSync("bunfig.toml")) {
+          const config = await Bun.file("bunfig.toml").text();
+          const match = config.match(/embedMode\s*=\s*(?:"|')([^"']+)(?:"|')/);
+          if (match) embedMode = match[1];
+        }
+      } catch (e) {}
+
+      // Build context
+      const isProd = isBuildMode(build) || process.env.NODE_ENV === "production" || build.config?.minify;
+
+      build.onLoad({ filter: /\.as$/ }, async (args) => {
+        let parsedExports: ASExport[] = [];
+        let hasComplex = false;
+        try {
+          const source = await Bun.file(args.path).text();
+          parsedExports = parseASExports(source);
+          await generateDts(parsedExports, args.path);
+          hasComplex = hasComplexExports(parsedExports);
+        } catch (e) {
+          console.warn("[bun-assemblyscript] Génération de types échouée :", e);
+        }
+
+        const compilerOptions: CompilerOptions = {
+          optimizeLevel: isProd ? 3 : 0,
+          shrinkLevel: isProd ? 2 : 0,
+          runtime: hasComplex ? "incremental" : "stub",
+          sourceMap: !isProd,
+          debug: !isProd,
+          ...options.compilerOverrides,
+        };
+
+        const result = await compile(args.path, compilerOptions);
+
+        if (!result.success || !result.wasmBytes) {
+          return {
+            contents: "",
+            errors: result.errors.map((text) => ({ text })),
+          };
+        }
+
+        // Ecrire le sourcemap dans le cache à côté du .wasm si non prod
+        if (!isProd && result.sourceMapBytes) {
+          const cacheDir = join(process.cwd(), ".cache", "bun-as", require("path").basename(args.path));
+          const currentHash = require("crypto").createHash("sha256").update(await Bun.file(args.path).text()).digest("hex");
+          const mapPath = join(cacheDir, currentHash + ".wasm.map");
+          try {
+            await require("fs/promises").mkdir(cacheDir, { recursive: true });
+            await Bun.write(mapPath, result.sourceMapBytes);
+          } catch (e) {}
+        }
+
+        // Stratégie d'embedding
+        let finalMode = embedMode;
+        if (finalMode === "auto") {
+          finalMode = result.wasmBytes.length < 100000 ? "inline" : "file";
+        }
+
+        const exportsMap = await instantiate(result.wasmBytes);
+        const exportNames = Object.keys(exportsMap).filter(
+          (k) => k !== "__data_end" && k !== "__heap_base"
+        );
+
+        if (finalMode === "inline") {
+          const b64 = Buffer.from(result.wasmBytes).toString("base64");
+          return { contents: generateInlineModule(exportNames, b64), loader: "js" };
+        } else {
+          // File mode
+          const outdir = build.config?.outdir || "./dist";
+          const fileName = "module-" + Bun.hash(result.wasmBytes) + ".wasm";
+          const outPath = join(process.cwd(), outdir, fileName);
+          
+          try {
+            await require("fs/promises").mkdir(join(process.cwd(), outdir), { recursive: true });
+            await Bun.write(outPath, result.wasmBytes);
+          } catch(e) {}
+
+          const wasmUrl = "./" + fileName;
+          return { contents: generateFileModule(exportNames, wasmUrl), loader: "js" };
+        }
+      });
+    },
+  };
+}

package/src/typegen/generator.ts

@@ -0,0 +1,62 @@
+import { mapType } from "./typemap";
+import { type ASExport } from "./parser";
+
+/**
+ * Génère le contenu d'un fichier .d.ts à partir d'un tableau d'exports AS.
+ * Si le contenu (hash) n'a pas changé, on n'écrase pas le fichier.
+ *
+ * @param exports     Liste des exports parsés
+ * @param sourcePath  Chemin absolu vers le fichier `.as` d'origine
+ */
+export async function generateDts(
+  exports: ASExport[],
+  sourcePath: string
+): Promise<void> {
+  const lines: string[] = [
+    "// auto-generated by bun-plugin-assemblyscript — do not edit",
+    "",
+  ];
+
+  for (const exp of exports) {
+    if (exp.kind === "const") {
+      lines.push(`export const ${exp.name}: ${mapType(exp.type!)};`);
+    } else if (exp.kind === "function") {
+      const params = exp
+        .params!.map((p) => `${p.name}: ${mapType(p.type)}`)
+        .join(", ");
+      lines.push(
+        `export function ${exp.name}(${params}): ${mapType(exp.returnType!)};`
+      );
+    } else if (exp.kind === "class") {
+      lines.push(`export class ${exp.name} {`);
+      if (exp.methods) {
+        for (const m of exp.methods) {
+          const params = m
+            .params!.map((p) => `${p.name}: ${mapType(p.type)}`)
+            .join(", ");
+          lines.push(
+            `  ${m.name}(${params}): ${mapType(m.returnType!)};`
+          );
+        }
+      }
+      lines.push(`}`);
+    }
+  }
+
+  const dtsContent = lines.join("\n") + "\n";
+  const dtsPath = sourcePath + ".d.ts";
+  const newHash = Bun.hash(dtsContent);
+
+  try {
+    const existingContent = await Bun.file(dtsPath).text();
+    const oldHash = Bun.hash(existingContent);
+    if (newHash === oldHash) {
+      // Pas de modification structurelle de la signature, on ne fait rien
+      return;
+    }
+  } catch (err) {
+    // Fichier inexistant, on procède à l'écriture
+  }
+
+  await Bun.write(dtsPath, dtsContent);
+}

package/src/typegen/global.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Types globaux AssemblyScript (primitives)
+ * Cela permet à l'éditeur de reconnaître i32, f64, etc. dans les fichiers .as
+ * sans entrer en conflit avec les types TypeScript standards (String, Array).
+ */
+declare type i8 = number;
+declare type i16 = number;
+declare type i32 = number;
+declare type i64 = bigint;
+declare type isize = number;
+declare type u8 = number;
+declare type u16 = number;
+declare type u32 = number;
+declare type u64 = bigint;
+declare type usize = number;
+declare type f32 = number;
+declare type f64 = number;
+declare type bool = boolean;
+declare type v128 = never;
+declare type anyref = any;
+declare type externref = any;
+
+declare module "*.as" {
+  const exports: Record<string, unknown>;
+  export default exports;
+}

package/src/typegen/parser.ts

@@ -0,0 +1,118 @@
+export type ASExportKind = "function" | "const" | "class";
+
+export interface ASParam {
+  name: string;
+  type: string;
+}
+
+export interface ASExport {
+  name: string;
+  kind: ASExportKind;
+  params?: ASParam[];
+  returnType?: string;
+  type?: string;     // For constants
+  methods?: ASExport[]; // For class methods
+}
+
+function extractClassBody(text: string, startIndex: number): string {
+  let depth = 0;
+  let inClass = false;
+  let bodyStart = -1;
+  const length = text.length;
+
+  for (let i = startIndex; i < length; i++) {
+    const char = text[i];
+    if (char === "{") {
+      if (depth === 0) {
+        inClass = true;
+        bodyStart = i + 1;
+      }
+      depth++;
+    } else if (char === "}") {
+      depth--;
+      if (depth === 0 && inClass) {
+        return text.substring(bodyStart, i);
+      }
+    }
+  }
+  return "";
+}
+
+/**
+ * Parse un fichier source AssemblyScript (.as) et extrait les signatures publiques.
+ * Gère "export function", "export const" et "export class".
+ */
+export function parseASExports(source: string): ASExport[] {
+  // Nettoyer les commentaires ( /* ... */ et // ... )
+  const text = source.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "");
+  const exports: ASExport[] = [];
+
+  // Parsing des fonctions (hors des classes)
+  const fnRegex = /export\s+function\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*:\s*([^;{]+)/g;
+  let match;
+  while ((match = fnRegex.exec(text)) !== null) {
+    const name = match[1];
+    const paramsStr = match[2];
+    const returnType = match[3].trim();
+
+    const params: ASParam[] = paramsStr
+      .split(",")
+      .filter((p) => p.trim())
+      .map((p) => {
+        const parts = p.split(":");
+        return {
+          name: parts[0].trim(),
+          type: parts.length > 1 ? parts[1].trim() : "unknown",
+        };
+      });
+
+    exports.push({ kind: "function", name, params, returnType });
+  }
+
+  // Parsing des constantes (export const)
+  const constRegex = /export\s+const\s+([a-zA-Z0-9_]+)\s*:\s*([^=;]+)/g;
+  while ((match = constRegex.exec(text)) !== null) {
+    exports.push({ kind: "const", name: match[1], type: match[2].trim() });
+  }
+
+  // Parsing des classes (export class)
+  const classRegex = /export\s+class\s+([a-zA-Z0-9_]+)/g;
+  while ((match = classRegex.exec(text)) !== null) {
+    const className = match[1];
+    const body = extractClassBody(text, match.index);
+
+    const methods: ASExport[] = [];
+    // Méthodes publiques de classe
+    const methodRegex = /(?:public\s+)?([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*:\s*([^;{]+)/g;
+    let mMatch;
+    while ((mMatch = methodRegex.exec(body)) !== null) {
+      const mName = mMatch[1];
+      if (mName === "constructor") continue;
+
+      const mParamsStr = mMatch[2];
+      const mReturnType = mMatch[3].trim();
+
+      const mParams: ASParam[] = mParamsStr
+        .split(",")
+        .filter((p) => p.trim())
+        .map((p) => {
+          const parts = p.split(":");
+          return {
+            name: parts[0].trim(),
+            type: parts.length > 1 ? parts[1].trim() : "unknown",
+          };
+        });
+
+      methods.push({
+        kind: "function",
+        name: mName,
+        params: mParams,
+        returnType: mReturnType,
+      });
+    }
+
+    exports.push({ kind: "class", name: className, methods });
+  }
+
+  return exports;
+}

package/src/typegen/typemap.ts

@@ -0,0 +1,51 @@
+/**
+ * Mappe un type AssemblyScript vers un type de définition TypeScript (.d.ts).
+ */
+export function mapType(asType: string): string {
+  const t = asType.trim();
+
+  // Primitives exactes
+  switch (t) {
+    case "i8":
+    case "i16":
+    case "i32":
+    case "i64":
+    case "u8":
+    case "u16":
+    case "u32":
+    case "u64":
+    case "f32":
+    case "f64":
+    case "isize":
+    case "usize":
+      return "number";
+
+    case "bool":
+      return "boolean";
+
+    case "string":
+    case "String":
+      return "string";
+
+    case "void":
+      return "void";
+  }
+
+  // Match des tableaux
+  const arrayMatch = t.match(/^(?:Static)?Array<(.+)>$/);
+  if (arrayMatch) {
+    return `${mapType(arrayMatch[1])}[]`;
+  }
+
+  // Match des Maps
+  const mapMatch = t.match(/^Map<(.+?)\s*,\s*(.+)>$/);
+  if (mapMatch) {
+    return `Map<${mapType(mapMatch[1])}, ${mapType(mapMatch[2])}>`;
+  }
+
+  // Fallback si type inconnu
+  console.warn(
+    `[bun-assemblyscript] Warning : Type AssemblyScript non reconnu '${t}'. Fallback sur 'unknown'.`
+  );
+  return "unknown";
+}

package/src/watcher/index.ts

@@ -0,0 +1,117 @@
+import { Glob } from "bun";
+import { watch } from "fs";
+import { join, basename } from "path";
+import { compile } from "../compiler";
+import { get, set, computeHash, invalidate } from "../cache";
+import { parseASExports } from "../typegen/parser";
+import { generateDts } from "../typegen/generator";
+import { logSuccess, logError, logStart } from "./logger";
+
+// Conserve les watchers et les hashes en mémoire vive
+const hashes = new Map<string, string>();
+const watchers = new Map<string, any>();
+
+async function processFile(filePath: string, isInitial: boolean, isProd = false) {
+  try {
+    const text = await Bun.file(filePath).text();
+    const hash = await computeHash(text);
+
+    // Skip si strictement rien n'a changé en mémoire
+    if (hashes.get(filePath) === hash) {
+      if (isInitial) {
+        // En initialisation, vérifier si le cache disque existe vraiment
+        const cached = await get(filePath, hash);
+        if (cached) return;
+      } else {
+        return; 
+      }
+    }
+
+    hashes.set(filePath, hash);
+    const startTime = performance.now();
+
+    // Check le cache persistant sur disque
+    const cached = await get(filePath, hash);
+    if (cached) {
+      if (!isInitial) {
+        logSuccess(basename(filePath), Math.round(performance.now() - startTime) + " (cached)");
+      }
+      return;
+    }
+
+    // Compilation complète par asc
+    const result = await compile(filePath, {
+      optimizeLevel: isProd ? 3 : 0,
+      runtime: isProd ? "minimal" : "stub",
+    });
+
+    if (!result.success || !result.wasmBytes) {
+      logError(basename(filePath), result.errors);
+      return;
+    }
+
+    // Régénération automatique des définitions TypeScript
+    const parsed = parseASExports(text);
+    await generateDts(parsed, filePath);
+    const dtsContent = await Bun.file(filePath + ".d.ts").text();
+
+    // Enregistrer dans le cache disque
+    await set(filePath, hash, result.wasmBytes, dtsContent);
+
+    logSuccess(basename(filePath), Math.round(performance.now() - startTime));
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      // Fichier potentiellement supprimé
+      await invalidate(filePath);
+      hashes.delete(filePath);
+    } else {
+      logError(basename(filePath), [err instanceof Error ? err.message : String(err)]);
+    }
+  }
+}
+
+/**
+ * Lance le daemon de surveillance.
+ */
+export async function startWatcher() {
+  const glob = new Glob("**/*.as");
+  const files: string[] = [];
+
+  // Scan initial récursif avec Glob (ignore node_modules et caches)
+  for (const file of glob.scanSync(".")) {
+    if (file.includes("node_modules") || file.includes(".cache")) continue;
+    const absPath = join(process.cwd(), file);
+    files.push(absPath);
+  }
+
+  logStart(files.length);
+
+  for (const file of files) {
+    await processFile(file, true);
+
+    const watcher = watch(file, async (event) => {
+      if (event === "change" || event === "rename") {
+        await processFile(file, false);
+      }
+    });
+    watchers.set(file, watcher);
+  }
+}
+
+/**
+ * Compile tout le projet `as` en mode production (optimisation max).
+ */
+export async function startBuild() {
+  const glob = new Glob("**/*.as");
+  const files: string[] = [];
+
+  for (const file of glob.scanSync(".")) {
+    if (file.includes("node_modules") || file.includes(".cache")) continue;
+    const absPath = join(process.cwd(), file);
+    files.push(absPath);
+  }
+
+  for (const file of files) {
+    await processFile(file, true, true);
+  }
+}

package/src/watcher/logger.ts

@@ -0,0 +1,26 @@
+/**
+ * Utilitaire de log léger en console sans aucune dépendance,
+ * s'appuyant uniquement sur les séquences d'échappement ANSI natives.
+ */
+
+export function logSuccess(file: string, ms: number | string) {
+  // \x1b[32m -> Vert, \x1b[0m -> Reset
+  console.log(`\x1b[32m[bun-as] ✓ ${file} compiled in ${ms}ms\x1b[0m`);
+}
+
+export function logError(file: string, errors: string[]) {
+  // \x1b[31m -> Rouge
+  console.error(`\x1b[31m[bun-as] ✗ Error in ${file}\x1b[0m`);
+  for (const error of errors) {
+    console.error(`\x1b[31m  ${error}\x1b[0m`);
+  }
+}
+
+export function logStart(count: number) {
+  // \x1b[36m -> Cyan
+  console.log(
+    `\x1b[36m[bun-as] Watching ${count} AssemblyScript file${
+      count > 1 ? "s" : ""
+    }...\x1b[0m`
+  );
+}

package/test/fixtures/math.as

@@ -0,0 +1,14 @@
+/// <reference path="../../assemblyscript.d.ts" />
+
+
+export function add(a: i32, b: i32): i32 {
+  return (a + b) as i32;
+}
+
+export function multiply(a: i32, b: i32): i32 {
+  return (a * b) as i32;
+}
+
+export function subtract(a: i32, b: i32): i32 {
+  return (a - b) as i32;
+}

package/test/fixtures/math.as.d.ts

@@ -0,0 +1,5 @@
+// auto-generated by bun-plugin-assemblyscript — do not edit
+
+export function add(a: number, b: number): number;
+export function multiply(a: number, b: number): number;
+export function subtract(a: number, b: number): number;

package/test/math.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "bun:test";
+import { add, multiply, subtract } from "./fixtures/math.as";
+
+describe("AssemblyScript Math Functions", () => {
+  it("should add two numbers correctly", () => {
+    expect(add(2, 3)).toBe(5);
+    expect(add(-1, 1)).toBe(0);
+    expect(add(0, 0)).toBe(0);
+  });
+
+  it("should multiply two numbers correctly", () => {
+    expect(multiply(2, 3)).toBe(6);
+    expect(multiply(-2, 3)).toBe(-6);
+    expect(multiply(0, 5)).toBe(0);
+  });
+
+  it("should subtract two numbers correctly", () => {
+    expect(subtract(5, 3)).toBe(2);
+    expect(subtract(3, 5)).toBe(-2);
+    expect(subtract(0, 0)).toBe(0);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": [
+      "ESNext"
+    ],
+    "types": [
+      "bun-types"
+    ],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist"
+  },
+  "include": [
+    "*.ts",
+    "src/**/*.ts",
+    "test/**/*.ts",
+    "assemblyscript.d.ts",
+    "**/*.as.d.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}