@ugo-studio/jspp 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -10,7 +10,8 @@
   },
   "files": [
     "dist",
-    "src/prelude"
+    "src/prelude",
+    "scripts"
   ],
   "scripts": {
     "postinstall": "bun run scripts/setup-compiler.ts",

package/scripts/precompile-headers.ts

@@ -0,0 +1,110 @@
+import fs from "fs/promises";
+import path from "path";
+
+const PRELUDE_DIR = path.resolve(process.cwd(), "src", "prelude");
+const PRECOMPILED_HEADER_BASE_DIR = path.resolve(process.cwd(), "prelude-build");
+
+const MODES = [
+    {
+        name: "debug",
+        flags: ["-O0"],
+    },
+    {
+        name: "release",
+        flags: ["-O3", "-DNDEBUG"],
+    },
+];
+
+if (process.platform === "win32") {
+    MODES[0].flags.push("-Wa,-mbig-obj");
+    MODES[1].flags.push("-Wa,-mbig-obj");
+}
+
+async function getLatestMtime(dirPath: string): 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);
+            if (nestedMtime > maxMtime) maxMtime = nestedMtime;
+        } else {
+            const stats = await fs.stat(fullPath);
+            if (stats.mtimeMs > maxMtime) maxMtime = stats.mtimeMs;
+        }
+    }
+    return maxMtime;
+}
+
+async function precompileHeaders() {
+    const force = process.argv.includes("--force");
+    try {
+        await fs.mkdir(PRECOMPILED_HEADER_BASE_DIR, { recursive: true });
+        const sourceMtime = await getLatestMtime(PRELUDE_DIR);
+
+        for (const mode of MODES) {
+            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");
+
+            if (!force) {
+                try {
+                    const gchStats = await fs.stat(gchPath);
+                    if (gchStats.mtimeMs >= sourceMtime) {
+                        console.log(`[${mode.name.toUpperCase()}] Headers are up-to-date. Skipping.`);
+                        continue;
+                    }
+                } catch (e) {
+                    // PCH doesn't exist, proceed to compile
+                }
+            }
+
+            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 compile = Bun.spawnSync({
+                cmd: [
+                    "g++",
+                    "-x",
+                    "c++-header",
+                    "-std=c++23",
+                    ...mode.flags,
+                    headerPath,
+                    "-o",
+                    gchPath,
+                    "-I",
+                    PRELUDE_DIR,
+                ],
+                stdout: "inherit",
+                stderr: "inherit",
+            });
+
+            if (compile.exitCode !== 0) {
+                console.error(
+                    `[${mode.name.toUpperCase()}] Failed to precompile headers.`,
+                );
+                process.exit(1);
+            }
+            console.log(`[${mode.name.toUpperCase()}] Success.`);
+        }
+    } catch (error: any) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+precompileHeaders();

package/scripts/setup-compiler.ts

@@ -0,0 +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();