@ugo-studio/jspp 0.1.3 → 0.1.5

package/dist/cli.js

@@ -1,64 +1,138 @@
 #!/usr/bin/env bun
 import fs from "fs/promises";
 import path from "path";
+import pkg from "../package.json";
+import { parseArgs } from "./cli-utils/args";
+import { COLORS } from "./cli-utils/colors";
+import { getLatestMtime } from "./cli-utils/file-utils";
+import { Spinner } from "./cli-utils/spinner";
 import { Interpreter } from "./index";
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.length === 0) {
-        console.log("Usage: jspp <path-to-js-file>");
-        process.exit(1);
-    }
-    const jsFilePath = path.resolve(process.cwd(), args[0]);
+    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
     const jsFileName = path.basename(jsFilePath, ".js");
-    const outputDir = path.dirname(jsFilePath);
-    const cppFilePath = path.join(outputDir, `${jsFileName}.cpp`);
-    const exeFilePath = path.join(outputDir, `${jsFileName}.exe`);
+    const sourceDir = path.dirname(jsFilePath);
+    // Intermediate C++ file goes alongside the source JS file
+    const cppFilePath = path.join(sourceDir, `${jsFileName}.cpp`);
+    // Determine output executable path
+    let exeFilePath;
+    if (outputExePath) {
+        exeFilePath = outputExePath;
+    }
+    else {
+        const ext = process.platform === "win32" ? ".exe" : "";
+        exeFilePath = path.join(sourceDir, `${jsFileName}${ext}`);
+    }
+    // Mode Configuration
+    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", "-Wa,-mbig-obj"]
+        : ["-O0", "-Wa,-mbig-obj"];
+    const pchDir = path.resolve(process.cwd(), "prelude-build", mode);
+    const spinner = new Spinner("Initializing...");
     try {
+        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();
-        console.time(`Generated C++ code ${cppFilePath}...`);
         const { cppCode, preludePath } = interpreter.interpret(jsCode);
-        console.timeEnd(`Generated C++ code ${cppFilePath}...`);
-        await fs.mkdir(outputDir, { recursive: true });
+        // 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);
-        console.log(`Compiling ${cppFilePath}...`);
-        const compile = Bun.spawnSync({
+        spinner.succeed(`Generated ${COLORS.dim}${path.basename(cppFilePath)}${COLORS.reset}`);
+        // 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 = Bun.spawn({
+                cmd: ["bun", "run", "scripts/precompile-headers.ts"],
+                stdout: "pipe", // pipe to hide output unless error, or handle differently
+                stderr: "pipe",
+            });
+            const exitCode = await rebuild.exited;
+            if (exitCode !== 0) {
+                const stderr = await new Response(rebuild.stderr).text();
+                spinner.fail("Failed to rebuild precompiled headers");
+                console.error(stderr);
+                process.exit(1);
+            }
+            spinner.succeed("Precompiled headers updated");
+        }
+        else {
+            spinner.succeed("Precompiled headers up-to-date");
+        }
+        // 3. Compilation Phase
+        spinner.text = `Compiling binary...`;
+        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,
-                "-O3",
-                "-DNDEBUG",
-                // "-include",
-                // path.join(process.cwd(), "prelude-build", "index.hpp"),
             ],
-            stdout: "inherit",
-            stderr: "inherit",
+            stdout: "pipe",
+            stderr: "pipe",
         });
-        if (compile.exitCode !== 0) {
-            console.error(`Compilation failed for ${cppFilePath}`);
+        const compileExitCode = await compile.exited;
+        if (compileExitCode !== 0) {
+            const stderr = await new Response(compile.stderr).text();
+            spinner.fail(`Compilation failed`);
+            console.error(stderr);
             process.exit(1);
         }
-        console.log(`Running ${exeFilePath}...`);
-        console.log("\x1b[32m\n------start------\x1b[0m");
-        const run = Bun.spawnSync({
-            cmd: [exeFilePath],
+        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 {
+                await fs.unlink(cppFilePath);
+            }
+            catch (e) {
+                // Ignore error if file cannot be deleted
+            }
+        }
+        // 4. Execution Phase
+        console.log(`\n${COLORS.cyan}--- Running Output ---${COLORS.reset}`);
+        const run = Bun.spawn({
+            cmd: [exeFilePath, ...scriptArgs],
             stdout: "inherit",
             stderr: "inherit",
         });
-        console.log("\x1b[32m\n------end--------\x1b[0m");
-        if (run.exitCode !== 0) {
-            console.error(`Execution failed for ${exeFilePath}`);
+        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}`);
             process.exit(1);
         }
-        console.log(`Successfully ran ${exeFilePath}`);
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
+        spinner.fail("An unexpected error occurred");
+        console.error(error);
         process.exit(1);
     }
 }

package/dist/core/codegen/class-handlers.js

@@ -0,0 +1,131 @@
+import ts from "typescript";
+import { CodeGenerator } from "./";
+import { visitObjectPropertyName } from "./expression-handlers";
+export function visitClassDeclaration(node, context) {
+    const className = node.name.getText();
+    // Check extends
+    let extendsExpr = null;
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            if (clause.token === ts.SyntaxKind.ExtendsKeyword &&
+                clause.types.length > 0) {
+                extendsExpr = clause.types[0].expression;
+            }
+        }
+    }
+    let parentName = "";
+    if (extendsExpr) {
+        parentName = this.visit(extendsExpr, context);
+        if (ts.isIdentifier(extendsExpr)) {
+            const scope = this.getScopeForNode(extendsExpr);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(extendsExpr.getText(), scope);
+            if (typeInfo) {
+                parentName = this.getDerefCode(parentName, this.getJsVarName(extendsExpr), context, typeInfo);
+            }
+        }
+    }
+    const classContext = {
+        ...context,
+        superClassVar: parentName,
+    };
+    // 1. Constructor
+    const constructor = node.members.find(ts.isConstructorDeclaration);
+    let constructorLambda = "";
+    if (constructor) {
+        constructorLambda = this.generateLambda(constructor, {
+            ...classContext,
+            isInsideFunction: true,
+            lambdaName: className,
+        }, { isClass: true });
+    }
+    else {
+        // Default constructor
+        if (parentName) {
+            constructorLambda =
+                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
+                 auto __parent = ${parentName};
+                 __parent.call(${this.globalThisVar}, args, "super");
+                 return jspp::Constants::UNDEFINED;
+             }, "${className}")`;
+        }
+        else {
+            constructorLambda =
+                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
+                 return jspp::Constants::UNDEFINED;
+             }, "${className}")`;
+        }
+    }
+    let code = `${this.indent()}*${className} = ${constructorLambda};\n`;
+    // Set prototype of class (static inheritance) and prototype object (instance inheritance)
+    if (parentName) {
+        code +=
+            `${this.indent()}(*${className}).set_prototype(${parentName});\n`;
+        code +=
+            `${this.indent()}(*${className}).get_own_property("prototype").set_prototype(${parentName}.get_own_property("prototype"));\n`;
+    }
+    else {
+        code +=
+            `${this.indent()}(*${className}).get_own_property("prototype").set_prototype(::Object.get_own_property("prototype"));\n`;
+    }
+    // Members
+    for (const member of node.members) {
+        if (ts.isMethodDeclaration(member)) {
+            const methodName = visitObjectPropertyName.call(this, member.name, {
+                ...context,
+                isObjectLiteralExpression: true, // Reuse this flag to handle computed properties
+            });
+            const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+            const methodLambda = this.generateLambda(member, {
+                ...classContext,
+                isInsideFunction: true,
+            });
+            if (isStatic) {
+                code +=
+                    `${this.indent()}(*${className}).set_own_property(${methodName}, ${methodLambda});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}(*${className}).get_own_property("prototype").set_own_property(${methodName}, ${methodLambda});\n`;
+            }
+        }
+        else if (ts.isGetAccessor(member)) {
+            const methodName = visitObjectPropertyName.call(this, member.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+            const lambda = this.generateLambda(member, {
+                ...classContext,
+                isInsideFunction: true,
+            });
+            if (isStatic) {
+                code +=
+                    `${this.indent()}(*${className}).define_getter(${methodName}, ${lambda});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}(*${className}).get_own_property("prototype").define_getter(${methodName}, ${lambda});\n`;
+            }
+        }
+        else if (ts.isSetAccessor(member)) {
+            const methodName = visitObjectPropertyName.call(this, member.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+            const lambda = this.generateLambda(member, {
+                ...classContext,
+                isInsideFunction: true,
+            });
+            if (isStatic) {
+                code +=
+                    `${this.indent()}(*${className}).define_setter(${methodName}, ${lambda});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}(*${className}).get_own_property("prototype").define_setter(${methodName}, ${lambda});\n`;
+            }
+        }
+    }
+    return code;
+}