@ugo-studio/jspp 0.3.0 → 0.3.2

package/scripts/precompile-headers.ts

@@ -1,7 +1,82 @@
-import { spawnSync } from "child_process";
+import { spawn } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 
+const COLORS = {
+    reset: "\x1b[0m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+};
+
+export class Spinner {
+    private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    private interval: any = null;
+    private frameIndex = 0;
+    public text: string;
+
+    constructor(text: string) {
+        this.text = text;
+    }
+
+    start() {
+        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: string) {
+        this.text = text;
+        this.render();
+    }
+
+    stop(symbol: string = "", color: string = COLORS.reset) {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        this.clearLine();
+        process.stdout.write(
+            `${color}${symbol} ${COLORS.reset} ${this.text}\n`,
+        );
+        process.stdout.write("\x1b[?25h"); // Show cursor
+    }
+
+    succeed(text?: string) {
+        if (text) this.text = text;
+        this.stop("✔", COLORS.green);
+    }
+
+    fail(text?: string) {
+        if (text) this.text = text;
+        this.stop("✖", COLORS.red);
+    }
+
+    info(text?: string) {
+        if (text) this.text = text;
+        this.stop("ℹ", COLORS.cyan);
+    }
+
+    private render() {
+        this.clearLine();
+        const frame = this.frames[this.frameIndex];
+        process.stdout.write(
+            `${COLORS.cyan}${frame} ${COLORS.reset} ${this.text}`,
+        );
+    }
+
+    private clearLine() {
+        process.stdout.write("\r\x1b[K");
+    }
+}
+
 const PRELUDE_DIR = path.resolve(process.cwd(), "src", "prelude");
 const PRECOMPILED_HEADER_BASE_DIR = path.resolve(
     process.cwd(),
@@ -11,11 +86,24 @@ const PRECOMPILED_HEADER_BASE_DIR = path.resolve(
 const MODES = [
     {
         name: "debug",
-        flags: ["-O0"],
+        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",
     },
 ];
 
@@ -24,15 +112,19 @@ if (process.platform === "win32") {
     MODES[1].flags.push("-Wa,-mbig-obj");
 }
 
-async function getLatestMtime(dirPath: string): Promise<number> {
+async function getLatestMtime(
+    dirPath: string,
+    filter?: (name: string) => boolean,
+): Promise<number> {
     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);
+            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;
         }
@@ -40,53 +132,91 @@ async function getLatestMtime(dirPath: string): Promise<number> {
     return maxMtime;
 }
 
+async function findCppFiles(dir: string): Promise<string[]> {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map((entry) => {
+        const res = path.resolve(dir, entry.name);
+        if (entry.isDirectory()) {
+            return findCppFiles(res);
+        } else {
+            return res.endsWith(".cpp") ? [res] : [];
+        }
+    }));
+    return Array.prototype.concat(...files);
+}
+
+async function runCommand(cmd: string, args: string[]): Promise<boolean> {
+    // console.log(`${COLORS.dim}> ${cmd} ${args.join(" ")}${COLORS.reset}`);
+    return new Promise((resolve) => {
+        const proc = spawn(cmd, args, {
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        proc.on("close", (code) => resolve(code === 0));
+    });
+}
+
 async function precompileHeaders() {
     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 });
-        const sourceMtime = await getLatestMtime(PRELUDE_DIR);
+
+        const latestHeaderMtime = await getLatestMtime(
+            PRELUDE_DIR,
+            (name) => name.endsWith(".hpp") || name.endsWith(".h"),
+        );
 
         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, "index.hpp");
-            const gchPath = path.join(modeDir, "index.hpp.gch");
+            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...`);
+            if (!silent) spinner.start();
 
-            if (!force) {
+            await fs.mkdir(modeDir, { recursive: true });
+
+            let gchRebuilt = false;
+            let shouldBuildGch = force;
+
+            if (!shouldBuildGch) {
                 try {
                     const gchStats = await fs.stat(gchPath);
-                    if (gchStats.mtimeMs >= sourceMtime) {
-                        console.log(
-                            `[${mode.name.toUpperCase()}] Headers are up-to-date. Skipping.`,
-                        );
-                        continue;
+                    if (latestHeaderMtime > gchStats.mtimeMs) {
+                        shouldBuildGch = true;
                     }
                 } catch (e) {
-                    // PCH doesn't exist, proceed to compile
+                    shouldBuildGch = true;
                 }
             }
 
-            console.log(`\n[${mode.name.toUpperCase()}] Setting up...`);
-            await fs.mkdir(modeDir, { recursive: true });
-
-            // Copy index.hpp
-            await fs.copyFile(path.join(PRELUDE_DIR, "index.hpp"), headerPath);
-
-            // Remove existing gch if it exists
-            if (
-                await fs.stat(gchPath).then(
-                    () => true,
-                    () => false,
-                )
-            ) {
-                await fs.unlink(gchPath);
-            }
-
-            console.log(`[${mode.name.toUpperCase()}] Compiling header...`);
-            const tempGchPath = `${gchPath}.tmp`;
+            if (shouldBuildGch) {
+                if (silent) spinner.start();
+                spinner.update(`${modeLabel} Compiling header...`);
+                await fs.copyFile(
+                    path.join(PRELUDE_DIR, "jspp.hpp"),
+                    headerPath,
+                );
 
-            const compile = spawnSync(
-                "g++",
-                [
+                const tempGchPath = `${gchPath}.tmp`;
+                const success = await runCommand(mode.compiler, [
                     "-x",
                     "c++-header",
                     "-std=c++23",
@@ -95,31 +225,144 @@ async function precompileHeaders() {
                     "-o",
                     tempGchPath,
                     "-I",
+                    modeDir,
+                    "-I",
                     PRELUDE_DIR,
-                ],
-                {
-                    stdio: "inherit",
-                },
+                ]);
+
+                if (!success) {
+                    spinner.fail(`${modeLabel} Failed to precompile headers.`);
+                    process.exit(1);
+                }
+
+                await fs.rename(tempGchPath, gchPath);
+                gchRebuilt = true;
+                spinner.succeed(`${modeLabel} PCH Success.`);
+            } else {
+                if (!silent) {
+                    spinner.succeed(`${modeLabel} Headers are up-to-date.`);
+                }
+            }
+
+            // --- Incremental Compilation of .cpp files ---
+            const cppFiles = await findCppFiles(PRELUDE_DIR);
+            const objFiles: string[] = [];
+            let anyObjRebuilt = false;
+
+            // 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...`,
             );
+            if (!silent) libSpinner.start();
 
-            if (compile.status !== 0) {
+            for (let idx = 0; idx < cppFiles.length; idx++) {
+                const cppFile = cppFiles[idx];
+                const relativePath = path.relative(PRELUDE_DIR, cppFile);
+                const objFile = path.join(
+                    modeDir,
+                    relativePath.replace(/\.cpp$/, ".o"),
+                );
+                await fs.mkdir(path.dirname(objFile), { recursive: true });
+                objFiles.push(objFile);
+
+                let shouldCompile = force || gchRebuilt;
+                if (!shouldCompile) {
+                    try {
+                        const objStats = await fs.stat(objFile);
+                        const cppStats = await fs.stat(cppFile);
+                        if (
+                            cppStats.mtimeMs > objStats.mtimeMs ||
+                            gchMtime > objStats.mtimeMs
+                        ) {
+                            shouldCompile = true;
+                        }
+                    } catch (e) {
+                        shouldCompile = true;
+                    }
+                }
+
+                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(mode.compiler, [
+                        "-c",
+                        "-std=c++23",
+                        ...mode.flags,
+                        cppFile,
+                        "-o",
+                        objFile,
+                        "-I",
+                        modeDir,
+                        "-I",
+                        PRELUDE_DIR,
+                    ]);
+
+                    if (!success) {
+                        libSpinner.fail(
+                            `${modeLabel} Failed to compile ${relativePath}`,
+                        );
+                        process.exit(1);
+                    }
+                    anyObjRebuilt = true;
+                }
+            }
+
+            const libPath = path.join(modeDir, "libjspp.a");
+            let shouldArchive = anyObjRebuilt;
+            if (!shouldArchive) {
                 try {
-                    await fs.unlink(tempGchPath);
+                    await fs.access(libPath);
                 } catch (e) {
-                    // Ignore if temp file doesn't exist
+                    shouldArchive = true;
                 }
-                console.error(
-                    `[${mode.name.toUpperCase()}] Failed to precompile headers.`,
-                );
-                process.exit(1);
             }
 
-            // Atomically replace the old GCH with the new one
-            await fs.rename(tempGchPath, gchPath);
-            console.log(`[${mode.name.toUpperCase()}] Success.`);
+            if (shouldArchive) {
+                if (silent && !libSpinner["interval"]) libSpinner.start();
+                libSpinner.update(`${modeLabel} Updating runtime library...`);
+                const tempLibPath = `${libPath}.tmp`;
+
+                const success = await runCommand(mode.archiver, [
+                    "rcs",
+                    tempLibPath,
+                    ...objFiles,
+                ]);
+
+                if (!success) {
+                    libSpinner.fail(
+                        `${modeLabel} Failed to create static library.`,
+                    );
+                    process.exit(1);
+                }
+
+                await fs.rename(tempLibPath, libPath);
+                libSpinner.succeed(`${modeLabel} Runtime Library Success.`);
+            } else {
+                if (!silent) {
+                    libSpinner.succeed(
+                        `${modeLabel} Runtime library is up-to-date.`,
+                    );
+                } else {
+                    libSpinner.stop();
+                }
+            }
+        }
+        if (!jsppCliIsParent && !silent) {
+            console.log(
+                `\n${COLORS.bold}${COLORS.green}JSPP: Environment ready.${COLORS.reset}\n`,
+            );
         }
     } catch (error: any) {
-        console.error(`Error: ${error.message}`);
+        console.error(`${COLORS.red}Error: ${error.message}${COLORS.reset}`);
         process.exit(1);
     }
 }

package/scripts/setup-compiler.ts

@@ -1,63 +1,63 @@
-import { spawnSync } from "child_process";
-import { platform } from "os";
-
-const COLORS = {
-    reset: "\x1b[0m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    red: "\x1b[31m",
-    cyan: "\x1b[36m",
-    bold: "\x1b[1m",
-};
-
-function checkGpp(): boolean {
-    try {
-        const result = spawnSync("g++", ["--version"], { encoding: "utf8" });
-        return result.status === 0;
-    } catch (e) {
-        return false;
-    }
-}
-
-function setup() {
-    console.log(`${COLORS.bold}${COLORS.cyan}JSPP: Checking for C++ compiler...${COLORS.reset}`);
-
-    if (checkGpp()) {
-        console.log(`${COLORS.green}✔ g++ found.${COLORS.reset}`);
-        return;
-    }
-
-    console.log(`${COLORS.yellow}⚠ g++ (GCC) not found in PATH. JSPP requires a C++23 compatible compiler.${COLORS.reset}`);
-
-    const os = platform();
-
-    if (os === "win32") {
-        console.log(`\n${COLORS.bold}To install GCC on Windows:${COLORS.reset}`);
-        console.log(`1. Install MinGW-w64 via MSYS2: ${COLORS.cyan}https://www.msys2.org/${COLORS.reset}`);
-        console.log(`2. Or use winget: ${COLORS.cyan}winget install MSYS2.MSYS2${COLORS.reset}`);
-        console.log(`   Then run: ${COLORS.bold}pacman -S mingw-w64-x86_64-gcc${COLORS.reset}`);
-    } else if (os === "linux") {
-        console.log(`\n${COLORS.bold}To install GCC on Linux (Ubuntu/Debian):${COLORS.reset}`);
-        console.log(`${COLORS.cyan}sudo apt update && sudo apt install g++-14 -y${COLORS.reset}`);
-        console.log(`\nAttempting to install now (may require password)...`);
-        
-        // Try to install automatically on Linux if apt is found
-        try {
-            const install = spawnSync("sudo", ["apt-get", "install", "-y", "g++-14"], { stdio: "inherit" });
-            if (install.status === 0) {
-                console.log(`${COLORS.green}✔ g++-14 installed successfully.${COLORS.reset}`);
-                // Try to set up symlink if needed or just inform user
-                return;
-            }
-        } catch (e) {
-            console.error(`${COLORS.red}Automatic installation failed. Please install manually.${COLORS.reset}`);
-        }
-    } else if (os === "darwin") {
-        console.log(`\n${COLORS.bold}To install GCC on macOS:${COLORS.reset}`);
-        console.log(`${COLORS.cyan}brew install gcc${COLORS.reset}`);
-    }
-
-    console.log(`\n${COLORS.bold}After installation, please ensure 'g++' is in your PATH and restart your terminal.${COLORS.reset}\n`);
-}
-
-setup();
+import { spawnSync } from "child_process";
+import { platform } from "os";
+
+const COLORS = {
+    reset: "\x1b[0m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+    bold: "\x1b[1m",
+};
+
+function checkGpp(): boolean {
+    try {
+        const result = spawnSync("g++", ["--version"], { encoding: "utf8" });
+        return result.status === 0;
+    } catch (e) {
+        return false;
+    }
+}
+
+function setup() {
+    console.log(`${COLORS.bold}${COLORS.cyan}JSPP: Checking for C++ compiler...${COLORS.reset}`);
+
+    if (checkGpp()) {
+        console.log(`${COLORS.green}✔ g++ found.${COLORS.reset}`);
+        return;
+    }
+
+    console.log(`${COLORS.yellow}⚠ g++ (GCC) not found in PATH. JSPP requires a C++23 compatible compiler.${COLORS.reset}`);
+
+    const os = platform();
+
+    if (os === "win32") {
+        console.log(`\n${COLORS.bold}To install GCC on Windows:${COLORS.reset}`);
+        console.log(`1. Install MinGW-w64 via MSYS2: ${COLORS.cyan}https://www.msys2.org/${COLORS.reset}`);
+        console.log(`2. Or use winget: ${COLORS.cyan}winget install MSYS2.MSYS2${COLORS.reset}`);
+        console.log(`   Then run: ${COLORS.bold}pacman -S mingw-w64-x86_64-gcc${COLORS.reset}`);
+    } else if (os === "linux") {
+        console.log(`\n${COLORS.bold}To install GCC on Linux (Ubuntu/Debian):${COLORS.reset}`);
+        console.log(`${COLORS.cyan}sudo apt update && sudo apt install g++-14 -y${COLORS.reset}`);
+        console.log(`\nAttempting to install now (may require password)...`);
+        
+        // Try to install automatically on Linux if apt is found
+        try {
+            const install = spawnSync("sudo", ["apt-get", "install", "-y", "g++-14"], { stdio: "inherit" });
+            if (install.status === 0) {
+                console.log(`${COLORS.green}✔ g++-14 installed successfully.${COLORS.reset}`);
+                // Try to set up symlink if needed or just inform user
+                return;
+            }
+        } catch (e) {
+            console.error(`${COLORS.red}Automatic installation failed. Please install manually.${COLORS.reset}`);
+        }
+    } else if (os === "darwin") {
+        console.log(`\n${COLORS.bold}To install GCC on macOS:${COLORS.reset}`);
+        console.log(`${COLORS.cyan}brew install gcc${COLORS.reset}`);
+    }
+
+    console.log(`\n${COLORS.bold}After installation, please ensure 'g++' is in your PATH and restart your terminal.${COLORS.reset}\n`);
+}
+
+setup();

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();