@ugo-studio/jspp 0.3.0 → 0.3.2

package/LICENSE

@@ -1,25 +1,25 @@
-# License
-
-JSPP is licensed under the [MIT License](#mit-license).
-
-## MIT License
-
-Copyright (c) 2025 Emmanuel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+# License
+
+JSPP is licensed under the [MIT License](#mit-license).
+
+## MIT License
+
+Copyright (c) 2025 Emmanuel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -11,7 +11,11 @@ The primary goal of this project is to achieve a near-perfect translation of Jav
 
 JavaScript is flexible and dynamic; C++ is performant and type-safe. JSPP aims to offer the best of both worlds. By transpiling JS/TS to C++, we can potentially run JavaScript logic in environments where C++ is native, with significant performance gains and opportunities for low-level interoperability.
 
-This project serves as a deep dive into compiler design, language semantics, and the expressive power of modern C++. The current implementation translates an entire JavaScript/TypeScript file into a single C++ `main` function, cleverly using `std::shared_ptr<std::any>` (and custom wrappers) to replicate JavaScript's dynamic typing, garbage-collection-like memory management, and complex features like closures.
+This project serves as a deep dive into compiler design, language semantics, and the expressive power of modern C++. The architecture is designed for performance, utilizing:
+- **Fast Runtime Library:** Core JavaScript logic is implemented in a static C++ library (`libjspp.a`), precompiled for speed.
+- **Precompiled Headers (PCH):** Common headers are precompiled to drastically reduce the front-end parsing time of the C++ compiler.
+- **NaN-Boxing:** An efficient 64-bit value representation (NaN-boxing) is used to replicate JavaScript's dynamic typing with minimal overhead.
+- **Modern C++23:** Leverages the latest language features, including coroutines for `async/await` and generators.
 
 ## Features
 
@@ -67,8 +71,10 @@ To contribute to JSPP or run its test suite, follow these steps:
 ### Prerequisites
 
 - **Bun:** This project uses [Bun](https://bun.sh/) for package management, script execution, and testing.
-- **C++ Compiler:** A compiler with support for C++23 is required. This project is tested with `g++`.
-  - `g++` (MinGW on Windows, or available via build-essentials on Linux)
+- **C++ Compiler:** A compiler with support for C++23 is required (e.g., `g++` 13+ or `clang` 17+).
+  - **Windows:** [MSYS2](https://www.msys2.org/) with `mingw-w64-x86_64-gcc` is recommended.
+  - **Linux:** `g++-14` or equivalent.
+  - **macOS:** `brew install gcc`.
 
 ### Setup
 
@@ -76,10 +82,11 @@ To contribute to JSPP or run its test suite, follow these steps:
     ```sh
     git clone https://github.com/ugo-studio/jspp.git
     ```
-2.  Install dependencies:
+2.  Install dependencies and build the runtime:
     ```sh
     bun install
     ```
+    *Note: The `postinstall` script will automatically check for your C++ compiler and precompile the runtime headers and library.*
 
 ## Usage
 
@@ -99,11 +106,9 @@ jspp my-code/test.ts
 
 The transpiled C++ file and executable will be generated in the same directory as the input file and cleaned up after execution (unless `--keep-cpp` is used).
 
-You can also run the test suite:
+### Timing and Reports
 
-```sh
-bun test
-```
+In debug mode (default), JSPP provides a compilation time report using GCC's `-ftime-report`. This helps track the performance of the transpilation and compilation phases.
 
 ## Roadmap
 
@@ -115,7 +120,7 @@ This project is ambitious, and there is a long and exciting road ahead. Here is
 
 This phase focuses on building a solid foundation that correctly models JavaScript's core runtime behavior.
 
-- [x] Dynamic Variables & Primitives
+- [x] Dynamic Variables & Primitives (NaN-boxing)
 - [x] Function Declarations & Arrow Functions
 - [x] Correct Hoisting for Variables and Functions
 - [x] Closures & Lexical Scoping
@@ -139,16 +144,19 @@ This phase broadens the range of supported JavaScript syntax and features.
 
 This phase focuses on building out the standard library and enabling modular code.
 
-- [ ] **JS Standard Library:** Implementation of common built-in objects. (Currently supports: `Math`, `Symbol`, `Error`, `String`, `Array`, `Object`, `Timer`). **Pending:** `Date`, `Temporal`, `Map`, `Set`, `JSON`, etc.
-- [x] **Asynchronous Operations:** Event loop, `Promise`, `async/await`, and timers (`setTimeout`).
+- [x] **JS Standard Library:** Core implementation of `Math`, `Symbol`, `Error`, `String`, `Array`, `Object`, `Timer`.
+- [ ] **Expanded Library:** `Date`, `Temporal`, `Map`, `Set`, `JSON`, `RegExp`.
+- [x] **Asynchronous Operations:** Event loop, `Promise`, `async/await`.
 - [ ] **Module System:** Support for `import` and `export` to transpile multi-file projects.
 
 ### **Phase 4: Optimization & Advanced Features**
 
 With a feature-complete transpiler, the focus will shift to performance and advanced capabilities.
 
+- [x] **Architecture Optimization:** Static library runtime and Precompiled Headers.
 - [ ] **Performance Benchmarking:** Create a suite to compare transpiled C++ performance against V8.
-- [ ] **C++ Interoperability:** Define a clear API for calling C++ functions from the transpiled JavaScript and vice-versa.
+- [ ] **Linker Optimization:** Support for `LLD` or `Mold` linkers.
+- [ ] **C++ Interoperability:** Define a clear API for calling C++ functions from JavaScript.
 
 ## Contributing
 

package/dist/cli/args.js

@@ -7,6 +7,7 @@ export function parseArgs(rawArgs) {
     let keepCpp = false;
     let outputExePath = null;
     let scriptArgs = [];
+    let target = "native";
     for (let i = 0; i < rawArgs.length; i++) {
         const arg = rawArgs[i];
         if (!arg)
@@ -21,6 +22,26 @@ export function parseArgs(rawArgs) {
         else if (arg === "--keep-cpp") {
             keepCpp = true;
         }
+        else if (arg === "-t" || arg === "--target") {
+            if (i + 1 < rawArgs.length) {
+                const targetValue = rawArgs[i + 1]?.toLowerCase();
+                if (targetValue === "wasm") {
+                    target = "wasm";
+                }
+                else if (targetValue === "native") {
+                    target = "native";
+                }
+                else {
+                    console.error(`${COLORS.red}Error: Invalid target '${targetValue}'. Supported targets: native, wasm.${COLORS.reset}`);
+                    process.exit(1);
+                }
+                i++;
+            }
+            else {
+                console.error(`${COLORS.red}Error: --target requires a value (native or wasm).${COLORS.reset}`);
+                process.exit(1);
+            }
+        }
         else if (arg === "-o" || arg === "--output") {
             if (i + 1 < rawArgs.length) {
                 outputExePath = rawArgs[i + 1] ?? null;
@@ -55,5 +76,6 @@ export function parseArgs(rawArgs) {
             ? path.resolve(process.cwd(), outputExePath)
             : null,
         scriptArgs,
+        target,
     };
 }

package/dist/cli/compiler.js

@@ -0,0 +1,53 @@
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { COLORS } from "./colors.js";
+import { Spinner } from "./spinner.js";
+import { msToHumanReadable } from "./utils.js";
+export async function compileCpp(cppFilePath, exeFilePath, pchDir, preludePath, isWasm, flags, emsdkEnv, spinner) {
+    spinner.text = `Compiling binary...`;
+    spinner.start();
+    // Ensure output directory exists
+    await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
+    const runtimeLibPath = path.join(pchDir, "libjspp.a");
+    const compiler = isWasm ? "em++" : "g++";
+    const compileArgs = [
+        "-std=c++23",
+        ...flags,
+        "-include",
+        "jspp.hpp",
+        cppFilePath,
+        runtimeLibPath,
+        "-o",
+        exeFilePath,
+        "-I",
+        pchDir,
+        "-I",
+        preludePath,
+    ];
+    if (!isWasm) {
+        compileArgs.splice(1, 0, "-Winvalid-pch");
+    }
+    const compileStartTime = performance.now();
+    const compile = spawn(compiler, compileArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: emsdkEnv,
+        shell: process.platform === "win32",
+    });
+    const compileStderrChunks = [];
+    if (compile.stderr) {
+        compile.stderr.on("data", (chunk) => compileStderrChunks.push(chunk));
+    }
+    const compileExitCode = await new Promise((resolve) => {
+        compile.on("close", (code) => resolve(code ?? 1));
+    });
+    if (compileExitCode !== 0) {
+        const stderr = Buffer.concat(compileStderrChunks).toString();
+        spinner.fail(`Compilation failed`);
+        console.error(stderr);
+        process.exit(1);
+    }
+    const compileEndTime = performance.now();
+    const compileTime = msToHumanReadable(compileEndTime - compileStartTime);
+    spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset} ${COLORS.dim}[${compileTime}]${COLORS.reset}`);
+}

package/dist/cli/index.js

@@ -1,128 +1,75 @@
 #!/usr/bin/env node
-import { spawn } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 import pkg from "../../package.json" with { type: "json" };
-import { CompilerError } from "../core/error.js";
-import { Interpreter } from "../index.js";
+import { CompilerError } from "../interpreter/core/error.js";
 import { parseArgs } from "./args.js";
 import { COLORS } from "./colors.js";
-import { getLatestMtime } from "./file-utils.js";
+import { compileCpp } from "./compiler.js";
+import { checkAndRebuildPCH } from "./pch.js";
+import { runOutput } from "./runner.js";
 import { Spinner } from "./spinner.js";
+import { transpile } from "./transpiler.js";
+import { postProcessWasm, setupEmsdk } from "./wasm.js";
 const pkgDir = path.dirname(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 main() {
-    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
+    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs, target, } = parseArgs(process.argv.slice(2));
+    const isWasm = target === "wasm";
     const ext = path.extname(jsFilePath);
     const jsFileName = path.basename(jsFilePath, ext);
     const sourceDir = path.dirname(jsFilePath);
-    // Intermediate C++ file goes alongside the source JS file
-    const cppFilePath = path.join(sourceDir, `${jsFileName}.cpp`);
+    // Intermediate C++ file goes alongside the source JS file if `--output` is not set
+    let cppFilePath = path.join(sourceDir, `${jsFileName}.cpp`);
     // Determine output executable path
     let exeFilePath;
     if (outputExePath) {
         exeFilePath = outputExePath;
+        cppFilePath = path.join(path.dirname(outputExePath), `${jsFileName}.cpp`);
     }
     else {
-        const ext = process.platform === "win32" ? ".exe" : "";
-        exeFilePath = path.join(sourceDir, `${jsFileName}${ext}`);
+        if (isWasm) {
+            exeFilePath = path.join(sourceDir, `${jsFileName}.js`);
+        }
+        else {
+            const ext = process.platform === "win32" ? ".exe" : "";
+            exeFilePath = path.join(sourceDir, `${jsFileName}${ext}`);
+        }
     }
     // Mode Configuration
-    const mode = isRelease ? "release" : "debug";
+    const mode = isWasm ? "wasm" : (isRelease ? "release" : "debug");
+    const modeNote = isRelease
+        ? `${COLORS.dim}(optimized)${COLORS.reset}`
+        : `${COLORS.dim}(debug)${COLORS.reset}\n${COLORS.dim}NOTE: Use "--release" for an optimized build for production${COLORS.reset}`;
     console.log(`${COLORS.bold}JSPP Compiler${COLORS.reset} ${COLORS.dim}v${pkg.version}${COLORS.reset}`);
-    console.log(`Mode: ${isRelease ? COLORS.green : COLORS.yellow}${mode.toUpperCase()}${COLORS.reset}\n`);
-    const flags = isRelease ? ["-O3", "-DNDEBUG"] : ["-O0"];
-    if (process.platform === "win32") {
+    console.log(`Target: ${isWasm ? COLORS.cyan : COLORS.green}${target.toUpperCase()}${COLORS.reset} | Mode: ${isRelease ? COLORS.green : COLORS.yellow}${mode.toUpperCase()}${COLORS.reset} ${modeNote}\n`);
+    const flags = isRelease ? ["-O3", "-DNDEBUG"] : ["-Og"];
+    if (isWasm) {
+        flags.push("-sASYNCIFY", "-sALLOW_MEMORY_GROWTH=1", "-sWASM=1", "-sEXPORT_ES6=1", "-sMODULARIZE=1", "-sEXPORT_NAME=jsppModule");
+    }
+    else if (process.platform === "win32") {
         flags.push("-Wa,-mbig-obj");
     }
     const pchDir = path.resolve(pkgDir, "prelude-build", mode);
     const spinner = new Spinner("Initializing...");
     try {
+        if (isWasm) {
+            await setupEmsdk(pkgDir, spinner);
+        }
         spinner.start();
-        // 1. Interpreter Phase
-        spinner.update(`Reading ${path.basename(jsFilePath)}...`);
-        const jsCode = await fs.readFile(jsFilePath, "utf-8");
-        spinner.update("Transpiling to C++...");
-        const interpreter = new Interpreter();
-        const { cppCode, preludePath } = interpreter.interpret(jsCode, jsFilePath);
-        // Ensure directory for cpp file exists (should exist as it's source dir, but for safety if we change logic)
-        await fs.mkdir(path.dirname(cppFilePath), { recursive: true });
-        await fs.writeFile(cppFilePath, cppCode);
-        spinner.succeed(`Generated cpp`);
+        // 1. Transpilation Phase
+        const { preludePath, wasmExports } = await transpile(jsFilePath, cppFilePath, target, spinner);
         // 2. Precompiled Header Check
-        spinner.text = "Checking precompiled headers...";
-        spinner.start();
-        const pchFile = path.join(pchDir, "index.hpp.gch");
-        let shouldRebuild = false;
-        try {
-            const pchStats = await fs.stat(pchFile);
-            const sourceMtime = await getLatestMtime(preludePath);
-            if (sourceMtime > pchStats.mtimeMs) {
-                shouldRebuild = true;
-            }
-        }
-        catch (e) {
-            shouldRebuild = true;
-        }
-        if (shouldRebuild) {
-            spinner.update("Rebuilding precompiled headers (this may take a while)...");
-            // Use spawn (async) instead of spawnSync to keep spinner alive
-            const rebuild = spawn("bun", [
-                "run",
-                "scripts/precompile-headers.ts",
-            ], {
-                cwd: pkgDir,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            const stderrChunks = [];
-            if (rebuild.stderr) {
-                rebuild.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-            }
-            const exitCode = await new Promise((resolve) => {
-                rebuild.on("close", (code) => resolve(code ?? 1));
-            });
-            if (exitCode !== 0) {
-                const stderr = Buffer.concat(stderrChunks).toString();
-                spinner.fail("Failed to rebuild precompiled headers");
-                console.error(stderr);
-                process.exit(1);
-            }
-            spinner.succeed("Precompiled headers updated");
-        }
-        else {
-            spinner.succeed("Precompiled headers");
-        }
+        await checkAndRebuildPCH(pkgDir, pchDir, mode, preludePath, emsdkEnv, spinner);
         // 3. Compilation Phase
-        spinner.text = `Compiling binary...`;
-        spinner.start();
-        // Ensure output directory exists
-        await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
-        const compile = spawn("g++", [
-            "-std=c++23",
-            ...flags,
-            cppFilePath,
-            "-o",
-            exeFilePath,
-            "-I",
-            pchDir,
-            "-I",
-            preludePath,
-        ], {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const compileStderrChunks = [];
-        if (compile.stderr) {
-            compile.stderr.on("data", (chunk) => compileStderrChunks.push(chunk));
+        await compileCpp(cppFilePath, exeFilePath, pchDir, preludePath, isWasm, flags, emsdkEnv, spinner);
+        // 3.5 Post-processing for Wasm (Exports)
+        if (isWasm) {
+            await postProcessWasm(exeFilePath, wasmExports);
         }
-        const compileExitCode = await new Promise((resolve) => {
-            compile.on("close", (code) => resolve(code ?? 1));
-        });
-        if (compileExitCode !== 0) {
-            const stderr = Buffer.concat(compileStderrChunks).toString();
-            spinner.fail(`Compilation failed`);
-            console.error(stderr);
-            process.exit(1);
-        }
-        spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset}`);
         // Clean up C++ file if not requested to keep
         if (!keepCpp) {
             try {
@@ -133,18 +80,7 @@ async function main() {
             }
         }
         // 4. Execution Phase
-        console.log(`\n${COLORS.cyan}--- Running Output ---${COLORS.reset}`);
-        const run = spawn(exeFilePath, scriptArgs, {
-            stdio: "inherit",
-        });
-        const runExitCode = await new Promise((resolve) => {
-            run.on("close", (code) => resolve(code ?? 1));
-        });
-        console.log(`${COLORS.cyan}----------------------${COLORS.reset}\n`);
-        if (runExitCode !== 0) {
-            console.error(`${COLORS.red}Execution failed with exit code ${runExitCode}${COLORS.reset}`);
-            process.exit(1);
-        }
+        await runOutput(exeFilePath, scriptArgs, isWasm);
     }
     catch (error) {
         if (error instanceof CompilerError) {

package/dist/cli/pch.js

@@ -0,0 +1,71 @@
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { COLORS } from "./colors.js";
+import { Spinner } from "./spinner.js";
+import { getLatestMtime, msToHumanReadable } from "./utils.js";
+export async function checkAndRebuildPCH(pkgDir, pchDir, mode, preludePath, emsdkEnv, spinner) {
+    spinner.text = "Checking precompiled headers...";
+    spinner.start();
+    const pchFile = path.join(pchDir, "jspp.hpp.gch");
+    const runtimeLibPath = path.join(pchDir, "libjspp.a");
+    let shouldRebuildPCH = false;
+    try {
+        const pchStats = await fs.stat(pchFile);
+        const libStats = await fs.stat(runtimeLibPath);
+        // 1. Check if any header is newer than the PCH
+        const latestHeaderMtime = await getLatestMtime(preludePath, (name) => name.endsWith(".hpp") || name.endsWith(".h"));
+        // 2. Check if any CPP file is newer than the library
+        const latestCppMtime = await getLatestMtime(preludePath, (name) => name.endsWith(".cpp"));
+        if (latestHeaderMtime > pchStats.mtimeMs ||
+            latestCppMtime > libStats.mtimeMs ||
+            pchStats.mtimeMs > libStats.mtimeMs) {
+            shouldRebuildPCH = true;
+        }
+    }
+    catch (e) {
+        shouldRebuildPCH = true;
+    }
+    if (shouldRebuildPCH) {
+        spinner.update("Rebuilding precompiled headers (this may take a while)...");
+        const pchStartTime = performance.now();
+        const rebuild = spawn("bun", [
+            "run",
+            "scripts/precompile-headers.ts",
+            "--jspp-cli-is-parent",
+            "--mode",
+            mode,
+        ], {
+            cwd: pkgDir,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: emsdkEnv,
+        });
+        if (rebuild.stdout) {
+            rebuild.stdout.on("data", (chunk) => {
+                spinner.pause();
+                process.stdout.write(chunk);
+            });
+        }
+        const stderrChunks = [];
+        if (rebuild.stderr) {
+            rebuild.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        }
+        const exitCode = await new Promise((resolve) => {
+            rebuild.on("close", (code) => {
+                spinner.resume();
+                resolve(code ?? 1);
+            });
+        });
+        if (exitCode !== 0) {
+            const stderr = Buffer.concat(stderrChunks).toString();
+            spinner.fail("Failed to rebuild precompiled headers");
+            console.error(stderr);
+            process.exit(1);
+        }
+        const pchTime = msToHumanReadable(performance.now() - pchStartTime);
+        spinner.succeed(`Precompiled headers updated ${COLORS.dim}[${pchTime}]${COLORS.reset}`);
+    }
+    else {
+        spinner.stop();
+    }
+}

package/dist/cli/runner.js

@@ -0,0 +1,23 @@
+import { spawn } from "child_process";
+import path from "path";
+import { COLORS } from "./colors.js";
+export async function runOutput(exeFilePath, scriptArgs, isWasm) {
+    if (isWasm) {
+        console.log(`\n${COLORS.cyan}Compilation finished. To run the output, use node or a browser:${COLORS.reset}`);
+        console.log(`${COLORS.bold}    node ${path.basename(exeFilePath)}${COLORS.reset}\n`);
+    }
+    else {
+        console.log(`\n${COLORS.cyan}--- Running Output ---${COLORS.reset}`);
+        const run = spawn(exeFilePath, scriptArgs, {
+            stdio: "inherit",
+        });
+        const runExitCode = await new Promise((resolve) => {
+            run.on("close", (code) => resolve(code ?? 1));
+        });
+        console.log(`${COLORS.cyan}----------------------${COLORS.reset}\n`);
+        if (runExitCode !== 0) {
+            console.error(`${COLORS.red}Execution failed with exit code ${runExitCode}${COLORS.reset}`);
+            process.exit(1);
+        }
+    }
+}

package/dist/cli/spinner.js

@@ -1,32 +1,42 @@
 import { COLORS } from "./colors.js";
 export class Spinner {
     frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    interval = null;
+    interval = null; // Note: You may need NodeJS.Timeout depending on your environment
     frameIndex = 0;
     text;
     constructor(text) {
         this.text = text;
     }
     start() {
+        if (this.interval)
+            return; // Prevent multiple intervals
         process.stdout.write("\x1b[?25l"); // Hide cursor
         this.frameIndex = 0;
         this.render();
-        this.interval = setInterval(() => {
-            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
-            this.render();
-        }, 80);
-    }
-    update(text) {
-        this.text = text;
-        this.render();
+        this.startInterval();
     }
-    stop(symbol = "", color = COLORS.reset) {
+    pause() {
         if (this.interval) {
             clearInterval(this.interval);
             this.interval = null;
         }
+    }
+    resume() {
+        if (this.interval)
+            return; // Already running
+        process.stdout.write("\x1b[?25l"); // Ensure cursor stays hidden
+        this.startInterval();
+    }
+    update(text) {
+        this.text = text;
+        this.render();
+    }
+    stop(symbol, color = COLORS.reset) {
+        this.pause(); // Reuse pause logic to clear the interval
         this.clearLine();
-        process.stdout.write(`${color}${symbol} ${COLORS.reset} ${this.text}\n`);
+        if (symbol) {
+            process.stdout.write(`${color}${symbol} ${COLORS.reset} ${this.text}\n`);
+        }
         process.stdout.write("\x1b[?25h"); // Show cursor
     }
     succeed(text) {
@@ -44,6 +54,12 @@ export class Spinner {
             this.text = text;
         this.stop("ℹ", COLORS.cyan);
     }
+    startInterval() {
+        this.interval = setInterval(() => {
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+            this.render();
+        }, 80);
+    }
     render() {
         this.clearLine();
         const frame = this.frames[this.frameIndex];

package/dist/cli/transpiler.js

@@ -0,0 +1,20 @@
+import fs from "fs/promises";
+import path from "path";
+import { Interpreter } from "../index.js";
+import { COLORS } from "./colors.js";
+import { Spinner } from "./spinner.js";
+import { msToHumanReadable } from "./utils.js";
+export async function transpile(jsFilePath, cppFilePath, target, spinner) {
+    spinner.update(`Reading ${path.basename(jsFilePath)}...`);
+    const jsCode = await fs.readFile(jsFilePath, "utf-8");
+    spinner.update("Transpiling to C++...");
+    const transpileStartTime = performance.now();
+    const interpreter = new Interpreter();
+    const { cppCode, preludePath, wasmExports } = interpreter.interpret(jsCode, jsFilePath, target);
+    const transpileTime = msToHumanReadable(performance.now() - transpileStartTime);
+    // Ensure directory for cpp file exists
+    await fs.mkdir(path.dirname(cppFilePath), { recursive: true });
+    await fs.writeFile(cppFilePath, cppCode);
+    spinner.succeed(`Generated cpp ${COLORS.dim}[${transpileTime}]${COLORS.reset}`);
+    return { preludePath, wasmExports };
+}

package/dist/cli/utils.js

@@ -0,0 +1,59 @@
+import fs from "fs/promises";
+import path from "path";
+export async function getLatestMtime(dirPath, filter) {
+    let maxMtime = 0;
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            const nestedMtime = await getLatestMtime(fullPath, filter);
+            if (nestedMtime > maxMtime)
+                maxMtime = nestedMtime;
+        }
+        else {
+            if (filter && !filter(entry.name))
+                continue;
+            const stats = await fs.stat(fullPath);
+            if (stats.mtimeMs > maxMtime)
+                maxMtime = stats.mtimeMs;
+        }
+    }
+    return maxMtime;
+}
+/**
+ * Converts milliseconds to a single-unit, human-readable decimal format.
+ * @param ms - The time in milliseconds
+ * @returns A formatted string (e.g., "2.52s", "1.5h")
+ */
+export function msToHumanReadable(ms) {
+    if (ms < 0) {
+        throw new Error("Time cannot be negative");
+    }
+    if (ms === 0) {
+        return "0ms";
+    }
+    const MS_PER_SECOND = 1000;
+    const MS_PER_MINUTE = 60 * MS_PER_SECOND;
+    const MS_PER_HOUR = 60 * MS_PER_MINUTE;
+    const MS_PER_DAY = 24 * MS_PER_HOUR;
+    // Helper to safely truncate to 2 decimal places without rounding up
+    const formatValue = (val) => {
+        // toFixed(3) resolves float math errors, slice(0,-1) enforces truncation (e.g. 2.528 -> 2.52)
+        let str = val.toFixed(3).slice(0, -1);
+        // Remove trailing zeroes and lingering decimal points (e.g., "2.00" -> "2")
+        return str.replace(/0+$/, "").replace(/\.$/, "");
+    };
+    if (ms >= MS_PER_DAY) {
+        return formatValue(ms / MS_PER_DAY) + "d";
+    }
+    if (ms >= MS_PER_HOUR) {
+        return formatValue(ms / MS_PER_HOUR) + "h";
+    }
+    if (ms >= MS_PER_MINUTE) {
+        return formatValue(ms / MS_PER_MINUTE) + "m";
+    }
+    if (ms >= MS_PER_SECOND) {
+        return formatValue(ms / MS_PER_SECOND) + "s";
+    }
+    return formatValue(ms) + "ms";
+}