@ugo-studio/jspp 0.2.0 → 0.2.2

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { spawn } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 import pkg from "../package.json";
@@ -7,6 +8,7 @@ import { COLORS } from "./cli-utils/colors";
 import { getLatestMtime } from "./cli-utils/file-utils";
 import { Spinner } from "./cli-utils/spinner";
 import { Interpreter } from "./index";
+const pkgDir = path.dirname(__dirname);
 async function main() {
     const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
     const jsFileName = path.basename(jsFilePath, ".js");
@@ -26,13 +28,11 @@ async function main() {
     const mode = isRelease ? "release" : "debug";
     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"];
+    const flags = isRelease ? ["-O3", "-DNDEBUG"] : ["-O0"];
     if (process.platform === "win32") {
         flags.push("-Wa,-mbig-obj");
     }
-    const pchDir = path.resolve(process.cwd(), "prelude-build", mode);
+    const pchDir = path.resolve(pkgDir, "prelude-build", mode);
     const spinner = new Spinner("Initializing...");
     try {
         spinner.start();
@@ -44,7 +44,7 @@ async function main() {
         const { cppCode, preludePath } = interpreter.interpret(jsCode);
         // 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);
+        await fs.writeFile(cppFilePath, cppCode);
         spinner.succeed(`Generated cpp`);
         // 2. Precompiled Header Check
         spinner.text = "Checking precompiled headers...";
@@ -64,14 +64,22 @@ async function main() {
         if (shouldRebuild) {
             spinner.update("Rebuilding precompiled headers (this may take a while)...");
             // Use spawn (async) instead of spawnSync to keep spinner alive
-            const rebuild = Bun.spawn({
-                cmd: ["bun", "run", "scripts/precompile-headers.ts"],
-                stdout: "pipe", // pipe to hide output unless error, or handle differently
-                stderr: "pipe",
+            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));
             });
-            const exitCode = await rebuild.exited;
             if (exitCode !== 0) {
-                const stderr = await new Response(rebuild.stderr).text();
+                const stderr = Buffer.concat(stderrChunks).toString();
                 spinner.fail("Failed to rebuild precompiled headers");
                 console.error(stderr);
                 process.exit(1);
@@ -86,25 +94,28 @@ async function main() {
         spinner.start();
         // Ensure output directory exists
         await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
-        const compile = Bun.spawn({
-            cmd: [
-                "g++",
-                "-std=c++23",
-                ...flags,
-                cppFilePath,
-                "-o",
-                exeFilePath,
-                "-I",
-                pchDir,
-                "-I",
-                preludePath,
-            ],
-            stdout: "pipe",
-            stderr: "pipe",
+        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));
+        }
+        const compileExitCode = await new Promise((resolve) => {
+            compile.on("close", (code) => resolve(code ?? 1));
         });
-        const compileExitCode = await compile.exited;
         if (compileExitCode !== 0) {
-            const stderr = await new Response(compile.stderr).text();
+            const stderr = Buffer.concat(compileStderrChunks).toString();
             spinner.fail(`Compilation failed`);
             console.error(stderr);
             process.exit(1);
@@ -121,12 +132,12 @@ async function main() {
         }
         // 4. Execution Phase
         console.log(`\n${COLORS.cyan}--- Running Output ---${COLORS.reset}`);
-        const run = Bun.spawn({
-            cmd: [exeFilePath, ...scriptArgs],
-            stdout: "inherit",
-            stderr: "inherit",
+        const run = spawn(exeFilePath, scriptArgs, {
+            stdio: "inherit",
+        });
+        const runExitCode = await new Promise((resolve) => {
+            run.on("close", (code) => resolve(code ?? 1));
         });
-        const runExitCode = await run.exited;
         console.log(`${COLORS.cyan}----------------------${COLORS.reset}\n`);
         if (runExitCode !== 0) {
             console.error(`${COLORS.red}Execution failed with exit code ${runExitCode}${COLORS.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",

package/scripts/precompile-headers.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 
@@ -76,9 +77,9 @@ async function precompileHeaders() {
             }
 
             console.log(`[${mode.name.toUpperCase()}] Compiling header...`);
-            const compile = Bun.spawnSync({
-                cmd: [
-                    "g++",
+            const compile = spawnSync(
+                "g++",
+                [
                     "-x",
                     "c++-header",
                     "-std=c++23",
@@ -89,11 +90,12 @@ async function precompileHeaders() {
                     "-I",
                     PRELUDE_DIR,
                 ],
-                stdout: "inherit",
-                stderr: "inherit",
-            });
+                {
+                    stdio: "inherit",
+                }
+            );
 
-            if (compile.exitCode !== 0) {
+            if (compile.status !== 0) {
                 console.error(
                     `[${mode.name.toUpperCase()}] Failed to precompile headers.`,
                 );

package/src/prelude/index.hpp

@@ -7,13 +7,8 @@
 #include "values/shape.hpp"
 #include "values/symbol.hpp"
 #include "values/non_values.hpp"
-// #include "any_value.hpp"
-// #include "values/object.hpp"
-// #include "values/array.hpp"
-// #include "values/function.hpp"
 #include "values/iterator.hpp"
 #include "values/async_iterator.hpp"
-// #include "values/promise.hpp"
 #include "values/string.hpp"
 
 #include "any_value.hpp"