@ugo-studio/jspp 0.3.0 → 0.3.2

package/dist/cli/wasm.js

@@ -0,0 +1,70 @@
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { Spinner } from "./spinner.js";
+export async function setupEmsdk(pkgDir, spinner) {
+    spinner.text = "Checking Emscripten SDK...";
+    spinner.start();
+    // Ensure emsdk is set up
+    const setupEmsdk = spawn("bun", ["run", "scripts/setup-emsdk.ts"], {
+        cwd: pkgDir,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const setupExitCode = await new Promise((resolve) => {
+        setupEmsdk.on("close", (code) => resolve(code ?? 1));
+    });
+    if (setupExitCode !== 0) {
+        spinner.fail("Emscripten SDK setup failed");
+        process.exit(1);
+    }
+    spinner.stop();
+}
+export async function postProcessWasm(exeFilePath, wasmExports) {
+    const outputDir = path.dirname(exeFilePath);
+    const outputBaseName = path.basename(exeFilePath, ".js");
+    // Generate .d.ts
+    let dtsContent = "";
+    for (const exp of wasmExports) {
+        const params = exp.params.map((p) => `${p.name}: ${p.type}`)
+            .join(", ");
+        dtsContent +=
+            `export declare function wasm_export_${exp.jsName}(${params}): ${exp.returnType};\n`;
+    }
+    dtsContent += `export declare const Module: Promise<any>;\n`;
+    dtsContent += `export declare const load: () => typeof Module;\n`;
+    dtsContent +=
+        `declare const jsppModule: (options?: any) => Promise<any>;\n`;
+    dtsContent += `export default jsppModule;\n`;
+    const dtsPath = path.join(outputDir, `${outputBaseName}.d.ts`);
+    await fs.writeFile(dtsPath, dtsContent);
+    // Append exports to .js glue code
+    let jsGlue = await fs.readFile(exeFilePath, "utf-8");
+    // Emscripten with -sEXPORT_ES6=1 adds this at the end
+    const defaultExportStr = "export default jsppModule;";
+    if (jsGlue.trim().endsWith(defaultExportStr)) {
+        jsGlue = jsGlue.trim().substring(0, jsGlue.trim().length - defaultExportStr.length);
+    }
+    jsGlue += `\n\n// JSPP Named Exports\n`;
+    jsGlue += `let _notLoaded = true;\n`;
+    jsGlue += `let _resolve = () => {};\n`;
+    jsGlue += `let _reject = () => {};\n`;
+    jsGlue += `let _instance;\n`;
+    jsGlue +=
+        `const _getinstance=()=>{if(!_instance)throw new Error("Module not loaded");return _instance}\n`;
+    jsGlue +=
+        `export const Module = new Promise((res,rej)=>{_resolve=res;_reject=rej});\n`;
+    jsGlue += `export const load = async () => {\n`;
+    jsGlue += ` if (_notLoaded) {\n`;
+    jsGlue += `  _notLoaded = false;\n`;
+    jsGlue +=
+        `  jsppModule().then(m=>{_instance=m;_resolve(m)}).catch(e=>{_notLoaded=true;_reject(e)});\n`;
+    jsGlue += ` }\n`;
+    jsGlue += ` return Module;\n`;
+    jsGlue += `};\n`;
+    for (const exp of wasmExports) {
+        jsGlue +=
+            `export const wasm_export_${exp.jsName} = (...args) => _getinstance()._wasm_export_${exp.jsName}(...args);\n`;
+    }
+    jsGlue += `export default jsppModule;\n`;
+    await fs.writeFile(exeFilePath, jsGlue);
+}

package/dist/index.js

@@ -1,19 +1,30 @@
 import path from "path";
-import { TypeAnalyzer } from "./analysis/typeAnalyzer.js";
-import { CodeGenerator } from "./core/codegen/index.js";
-import { Parser } from "./core/parser.js";
+import { TypeAnalyzer } from "./interpreter/analysis/typeAnalyzer.js";
+import { CodeGenerator } from "./interpreter/core/codegen/index.js";
+import { Parser } from "./interpreter/core/parser.js";
 export class Interpreter {
     parser = new Parser();
     analyzer = new TypeAnalyzer();
     generator = new CodeGenerator();
-    interpret(code, fileName) {
+    interpret(code, fileName, target = "native") {
         const ast = this.parser.parse(code, fileName);
         this.analyzer.analyze(ast);
         const isTypescript = fileName
             ? path.extname(fileName) === ".ts"
             : false;
-        const cppCode = this.generator.generate(ast, this.analyzer, isTypescript);
+        const cppCode = this.generator.generate(ast, this.analyzer, isTypescript, target === "wasm");
         const preludePath = path.resolve(import.meta.dirname, "..", "src", "prelude");
-        return { cppCode, preludePath };
+        return {
+            cppCode,
+            preludePath,
+            wasmExports: this.generator.wasmExports.map((e) => ({
+                jsName: e.jsName,
+                params: e.params.map((p) => ({
+                    name: p.name.getText(),
+                    type: this.analyzer.inferNodeReturnType(p),
+                })),
+                returnType: "number", // Currently always number as wrappers use double
+            })),
+        };
     }
 }

package/dist/{analysis → interpreter/analysis}/scope.js

@@ -7,6 +7,41 @@ export const RESERVED_KEYWORDS = new Set([
     "co_return",
     "co_await",
 ]);
+export const RESERVED_VAR_NAMES = new Set([
+    "arguments",
+    "class",
+    "const",
+    "let",
+    "var",
+    "enum",
+    "false",
+    "true",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "catch",
+    "typeof",
+    "void",
+]);
 export const BUILTIN_OBJECTS = new Set([
     { name: "undefined", isConst: true },
     { name: "null", isConst: true },
@@ -25,6 +60,7 @@ export const BUILTIN_OBJECTS = new Set([
     { name: "clearInterval", isConst: false },
     { name: "Array", isConst: false },
     { name: "Object", isConst: false },
+    { name: "Boolean", isConst: false },
     { name: "Math", isConst: false },
 ]);
 // Represents a single scope (e.g., a function body or a block statement)
@@ -57,7 +93,6 @@ export class Scope {
 export class ScopeManager {
     currentScope;
     allScopes = []; // Array to store all created scopes
-    reservedKeywords = new Set(RESERVED_KEYWORDS);
     constructor() {
         const rootScope = new Scope(null, null); // The global scope
         this.currentScope = rootScope;
@@ -86,7 +121,7 @@ export class ScopeManager {
     // Defines a variable in the current scope.
     define(name, type) {
         // if (name === "named" || name === "letVal") console.log("Defining", name, "in scope. isBuiltin:", type.isBuiltin, " type:", type.type);
-        if (this.reservedKeywords.has(name) && !type.isBuiltin) {
+        if (RESERVED_KEYWORDS.has(name) && !type.isBuiltin) {
             if (type.declaration) {
                 throw new CompilerError(`Unexpected reserved word "${name}"`, type.declaration, "SyntaxError");
             }
@@ -96,7 +131,7 @@ export class ScopeManager {
     }
     // Defines a `var` variable (hoisted to function or global scope).
     defineVar(name, type) {
-        if (this.reservedKeywords.has(name) && !type.isBuiltin) {
+        if (RESERVED_KEYWORDS.has(name) && !type.isBuiltin) {
             if (type.declaration) {
                 throw new CompilerError(`Unexpected reserved word "${name}"`, type.declaration, "SyntaxError");
             }