@ugo-studio/jspp 0.3.1 → 0.3.3

package/dist/{core → interpreter/core}/codegen/statement-handlers.js

@@ -52,6 +52,21 @@ export function visitSourceFile(node, context) {
         // Mark before further visits
         this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Check for @export comment
+        let exported = false;
+        if (this.isWasm) {
+            const fullText = sourceFile.text;
+            const commentRanges = ts.getLeadingCommentRanges(fullText, stmt.pos);
+            if (commentRanges) {
+                for (const range of commentRanges) {
+                    const comment = fullText.substring(range.pos, range.end);
+                    if (comment.includes("@export")) {
+                        exported = true;
+                        break;
+                    }
+                }
+            }
+        }
         // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
         const argumentKeywordIsUsed = this.isVariableUsedWithoutDeclaration("arguments", stmt.body);
@@ -72,9 +87,18 @@ export function visitSourceFile(node, context) {
             noTypeSignature: true,
         });
         // Generate native lambda
-        if (this.isDeclarationCalledAsFunction(stmt, node)) {
+        if (this.isDeclarationCalledAsFunction(stmt, node) || exported) {
             const nativeLambda = this.generateNativeLambda(lambdaComps);
             code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+            if (exported) {
+                this.wasmExports.push({
+                    jsName: funcName,
+                    nativeName,
+                    params: Array.from(stmt.parameters),
+                });
+                code +=
+                    `${this.indent()}__wasm_export_ptr_${funcName} = ${nativeName};\n`;
+            }
         }
         // Generate AnyValue wrapped lamda
         if (this.isDeclarationUsedAsValue(stmt, node) ||
@@ -799,6 +823,20 @@ export function visitReturnStatement(node, context) {
                 !typeInfo.isBuiltin) {
                 finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
+            const exprReturnType = this.typeAnalyzer.inferNodeReturnType(expr);
+            if (exprReturnType === "number" &&
+                context.isInsideNativeLambda &&
+                context.isInsideFunction) {
+                const funcDecl = this
+                    .findEnclosingFunctionDeclarationFromReturnStatement(expr);
+                if (funcDecl) {
+                    const funcReturnType = this.typeAnalyzer
+                        .inferFunctionReturnType(funcDecl);
+                    if (funcReturnType === "number") {
+                        finalExpr = `${finalExpr}.as_double()`;
+                    }
+                }
+            }
         }
         return `${this.indent()}${returnCmd} ${finalExpr};\n`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -14,14 +14,16 @@
     "scripts"
   ],
   "scripts": {
-    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/precompile-headers.ts",
+    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts && bun run scripts/precompile-headers.ts --mode debug",
     "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
-    "precompile": "bun run scripts/precompile-headers.ts",
     "test": "bun test",
     "build": "tsc",
     "prepack": "bun run build",
-    "publish:npm": "npm publish --access=public"
+    "publish:npm": "npm publish --access=public",
+    "script:setup-compiler": "bun run scripts/setup-compiler.ts",
+    "script:setup-emsdk": "bun run scripts/setup-emsdk.ts",
+    "script:precompile-headers": "bun run scripts/precompile-headers.ts"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/scripts/precompile-headers.ts

@@ -1,4 +1,4 @@
-import { spawn, spawnSync } from "child_process";
+import { spawn } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 
@@ -87,10 +87,23 @@ const MODES = [
     {
         name: "debug",
         flags: ["-Og"],
+        linkerFlags: [],
+        compiler: "g++",
+        archiver: "ar",
     },
     {
         name: "release",
         flags: ["-O3", "-DNDEBUG"],
+        linkerFlags: [],
+        compiler: "g++",
+        archiver: "ar",
+    },
+    {
+        name: "wasm",
+        flags: ["-O3", "-DNDEBUG"],
+        linkerFlags: ["-sASYNCIFY", "-sALLOW_MEMORY_GROWTH=1"],
+        compiler: "em++",
+        archiver: "emar",
     },
 ];
 
@@ -99,6 +112,14 @@ if (process.platform === "win32") {
     MODES[1].flags.push("-Wa,-mbig-obj");
 }
 
+const pkgDir = path.dirname(import.meta.dirname);
+const emsdkEnv = {
+    ...process.env,
+    PATH: `${path.join(pkgDir, ".emsdk")}${path.delimiter}${
+        path.join(pkgDir, ".emsdk", "upstream", "emscripten")
+    }${path.delimiter}${process.env.PATH}`,
+};
+
 async function getLatestMtime(
     dirPath: string,
     filter?: (name: string) => boolean,
@@ -134,17 +155,31 @@ async function findCppFiles(dir: string): Promise<string[]> {
 
 async function runCommand(cmd: string, args: string[]): Promise<boolean> {
     return new Promise((resolve) => {
-        const proc = spawn(cmd, args, { stdio: "ignore" });
+        const proc = spawn(cmd, args, {
+            stdio: "inherit",
+            shell: process.platform === "win32",
+            env: emsdkEnv,
+        });
         proc.on("close", (code) => resolve(code === 0));
     });
 }
 
 async function precompileHeaders() {
-    console.log(
-        `${COLORS.bold}${COLORS.cyan}JSPP: Precompiling headers and runtime...${COLORS.reset}\n`,
-    );
-
     const force = process.argv.includes("--force");
+    const jsppCliIsParent = process.argv.includes("--jspp-cli-is-parent");
+    const silent = process.argv.includes("--silent");
+
+    const modeArgIdx = process.argv.indexOf("--mode");
+    const targetMode = modeArgIdx !== -1
+        ? process.argv[modeArgIdx + 1]
+        : undefined;
+
+    if (!jsppCliIsParent && !silent) {
+        console.log(
+            `${COLORS.bold}${COLORS.cyan}JSPP: Precompiling headers and runtime...${COLORS.reset}\n`,
+        );
+    }
+
     try {
         await fs.mkdir(PRECOMPILED_HEADER_BASE_DIR, { recursive: true });
 
@@ -154,13 +189,15 @@ async function precompileHeaders() {
         );
 
         for (const mode of MODES) {
+            if (targetMode && mode.name !== targetMode) continue;
+
             const modeDir = path.join(PRECOMPILED_HEADER_BASE_DIR, mode.name);
             const headerPath = path.join(modeDir, "jspp.hpp");
             const gchPath = path.join(modeDir, "jspp.hpp.gch");
 
             const modeLabel = `[${mode.name.toUpperCase()}]`;
             const spinner = new Spinner(`${modeLabel} Checking headers...`);
-            spinner.start();
+            if (!silent) spinner.start();
 
             await fs.mkdir(modeDir, { recursive: true });
 
@@ -179,6 +216,7 @@ async function precompileHeaders() {
             }
 
             if (shouldBuildGch) {
+                if (silent) spinner.start();
                 spinner.update(`${modeLabel} Compiling header...`);
                 await fs.copyFile(
                     path.join(PRELUDE_DIR, "jspp.hpp"),
@@ -186,7 +224,7 @@ async function precompileHeaders() {
                 );
 
                 const tempGchPath = `${gchPath}.tmp`;
-                const success = await runCommand("g++", [
+                const success = await runCommand(mode.compiler, [
                     "-x",
                     "c++-header",
                     "-std=c++23",
@@ -209,7 +247,9 @@ async function precompileHeaders() {
                 gchRebuilt = true;
                 spinner.succeed(`${modeLabel} PCH Success.`);
             } else {
-                spinner.succeed(`${modeLabel} Headers are up-to-date.`);
+                if (!silent) {
+                    spinner.succeed(`${modeLabel} Headers are up-to-date.`);
+                }
             }
 
             // --- Incremental Compilation of .cpp files ---
@@ -217,12 +257,16 @@ async function precompileHeaders() {
             const objFiles: string[] = [];
             let anyObjRebuilt = false;
 
-            const gchMtime = (await fs.stat(gchPath)).mtimeMs;
+            // We need gchPath to exist for next check, if it doesn't we probably have a problem or it's a first run
+            let gchMtime = 0;
+            try {
+                gchMtime = (await fs.stat(gchPath)).mtimeMs;
+            } catch (e) {}
 
             const libSpinner = new Spinner(
                 `${modeLabel} Checking runtime library...`,
             );
-            libSpinner.start();
+            if (!silent) libSpinner.start();
 
             for (let idx = 0; idx < cppFiles.length; idx++) {
                 const cppFile = cppFiles[idx];
@@ -251,12 +295,13 @@ async function precompileHeaders() {
                 }
 
                 if (shouldCompile) {
+                    if (silent && !libSpinner["interval"]) libSpinner.start();
                     libSpinner.update(
                         `${modeLabel} Compiling ${relativePath} ${COLORS.dim}[${
                             idx + 1
                         }/${cppFiles.length}]${COLORS.reset}`,
                     );
-                    const success = await runCommand("g++", [
+                    const success = await runCommand(mode.compiler, [
                         "-c",
                         "-std=c++23",
                         ...mode.flags,
@@ -290,10 +335,11 @@ async function precompileHeaders() {
             }
 
             if (shouldArchive) {
+                if (silent && !libSpinner["interval"]) libSpinner.start();
                 libSpinner.update(`${modeLabel} Updating runtime library...`);
                 const tempLibPath = `${libPath}.tmp`;
 
-                const success = await runCommand("ar", [
+                const success = await runCommand(mode.archiver, [
                     "rcs",
                     tempLibPath,
                     ...objFiles,
@@ -309,14 +355,20 @@ async function precompileHeaders() {
                 await fs.rename(tempLibPath, libPath);
                 libSpinner.succeed(`${modeLabel} Runtime Library Success.`);
             } else {
-                libSpinner.succeed(
-                    `${modeLabel} Runtime library is up-to-date.`,
-                );
+                if (!silent) {
+                    libSpinner.succeed(
+                        `${modeLabel} Runtime library is up-to-date.`,
+                    );
+                } else {
+                    libSpinner.stop();
+                }
             }
         }
-        console.log(
-            `\n${COLORS.bold}${COLORS.green}JSPP: Environment ready.${COLORS.reset}\n`,
-        );
+        if (!jsppCliIsParent && !silent) {
+            console.log(
+                `\n${COLORS.bold}${COLORS.green}JSPP: Environment ready.${COLORS.reset}\n`,
+            );
+        }
     } catch (error: any) {
         console.error(`${COLORS.red}Error: ${error.message}${COLORS.reset}`);
         process.exit(1);

package/scripts/setup-emsdk.ts

@@ -0,0 +1,114 @@
+import { spawnSync } from "child_process";
+import fs from "fs";
+import { platform } from "os";
+import path from "path";
+
+const COLORS = {
+    reset: "\x1b[0m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+    bold: "\x1b[1m",
+};
+
+const EMSDK_DIR = path.resolve(process.cwd(), ".emsdk");
+const isWin = platform() === "win32";
+const emsdkCmd = isWin ? "emsdk.bat" : "./emsdk";
+
+function checkEmcc(): boolean {
+    try {
+        const result = spawnSync("emcc", ["--version"], { encoding: "utf8" });
+        return result.status === 0;
+    } catch (e) {
+        return false;
+    }
+}
+
+function runCommand(
+    cmd: string,
+    args: string[],
+    cwd: string = process.cwd(),
+): boolean {
+    console.log(`${COLORS.cyan}> ${cmd} ${args.join(" ")}${COLORS.reset}`);
+    const result = spawnSync(cmd, args, {
+        cwd,
+        stdio: "inherit",
+        shell: isWin,
+    });
+    return result.status === 0;
+}
+
+async function setup() {
+    console.log(
+        `${COLORS.bold}${COLORS.cyan}JSPP: Setting up Emscripten SDK for Wasm support...${COLORS.reset}`,
+    );
+
+    if (checkEmcc()) {
+        console.log(
+            `${COLORS.green}✔ Emscripten (emcc) found in PATH.${COLORS.reset}`,
+        );
+        return;
+    }
+
+    if (fs.existsSync(path.join(EMSDK_DIR, emsdkCmd))) {
+        console.log(
+            `${COLORS.yellow}ℹ Local EMSDK found in .emsdk directory.${COLORS.reset}`,
+        );
+    } else {
+        console.log(
+            `${COLORS.yellow}ℹ EMSDK not found. Cloning from GitHub...${COLORS.reset}`,
+        );
+        if (
+            !runCommand("git", [
+                "clone",
+                "https://github.com/emscripten-core/emsdk.git",
+                ".emsdk",
+            ])
+        ) {
+            console.error(
+                `${COLORS.red}Error: Failed to clone EMSDK repository. Make sure 'git' is installed.${COLORS.reset}`,
+            );
+            return;
+        }
+    }
+
+    console.log(
+        `${COLORS.cyan}Installing latest Emscripten SDK...${COLORS.reset}`,
+    );
+    if (!runCommand(emsdkCmd, ["install", "latest"], EMSDK_DIR)) {
+        console.error(
+            `${COLORS.red}Error: Failed to install Emscripten SDK.${COLORS.reset}`,
+        );
+        return;
+    }
+
+    console.log(
+        `${COLORS.cyan}Activating latest Emscripten SDK...${COLORS.reset}`,
+    );
+    if (
+        !runCommand(emsdkCmd, ["activate", "latest", "--permanent"], EMSDK_DIR)
+    ) {
+        console.error(
+            `${COLORS.red}Error: Failed to activate Emscripten SDK.${COLORS.reset}`,
+        );
+        return;
+    }
+
+    console.log(
+        `\n${COLORS.green}✔ Emscripten SDK setup complete.${COLORS.reset}`,
+    );
+    console.log(
+        `${COLORS.yellow}Note: To use emcc in your current terminal, you may need to run:${COLORS.reset}`,
+    );
+    if (isWin) {
+        console.log(`${COLORS.bold}    .emsdk\\emsdk_env.bat${COLORS.reset}`);
+    } else {
+        console.log(
+            `${COLORS.bold}    source .emsdk/emsdk_env.sh${COLORS.reset}`,
+        );
+    }
+    console.log("");
+}
+
+setup();