@ugo-studio/jspp 0.3.0 → 0.3.2

package/src/prelude/values/symbol.hpp

@@ -1,101 +1,101 @@
-#pragma once
-
-#include "types.hpp"
-#include <atomic>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <optional>
-
-namespace jspp
-{
-    // Forward declaration of AnyValue
-    class AnyValue;
-
-    struct JsSymbol : HeapObject
-    {
-        std::string description;
-        std::string key; // Internal unique key used for AnyValue property maps
-
-        JsType get_heap_type() const override { return JsType::Symbol; }
-
-        // --- Registries ---
-
-        // 1. Global Symbol Registry (for Symbol.for/keyFor)
-        static std::unordered_map<std::string, JsSymbol*> &registry()
-        {
-            static std::unordered_map<std::string, JsSymbol*> reg;
-            return reg;
-        }
-
-        // 2. All Internal Keys Registry (for robust Object.keys filtering)
-        static std::unordered_set<std::string> &internal_keys_registry()
-        {
-            static std::unordered_set<std::string> keys;
-            return keys;
-        }
-
-        static bool is_internal_key(const std::string &k)
-        {
-            return internal_keys_registry().count(k) > 0;
-        }
-
-        // --- Constructors ---
-
-        // Standard Constructor (creates unique symbol)
-        JsSymbol(const std::string &desc) : description(desc)
-        {
-            static std::atomic<uint64_t> id_counter{0};
-            // Ensure unique internal key for property storage
-            key = "__Sym" + std::to_string(id_counter++) + "_" + desc;
-
-            // Register this key as a valid symbol key
-            internal_keys_registry().insert(key);
-        }
-
-        // Constructor for Well-Known Symbols (fixed keys)
-        JsSymbol(const std::string &desc, const std::string &fixed_key)
-            : description(desc), key(fixed_key)
-        {
-            // Register this key as a valid symbol key
-            internal_keys_registry().insert(key);
-        }
-
-        // --- Global Registry API ---
-
-        // Implements Symbol.for(key)
-        static JsSymbol* for_global(const std::string &registryKey)
-        {
-            auto &reg = registry();
-            auto it = reg.find(registryKey);
-            if (it != reg.end())
-            {
-                return it->second;
-            }
-
-            // Create new symbol with description = registryKey
-            auto newSym = new JsSymbol(registryKey);
-            newSym->ref(); // Keep it alive in registry
-            reg[registryKey] = newSym;
-            return newSym;
-        }
-
-        // Implements Symbol.keyFor(sym)
-        static std::optional<std::string> key_for(const JsSymbol *sym)
-        {
-            auto &reg = registry();
-            for (const auto &pair : reg)
-            {
-                if (pair.second == sym)
-                {
-                    return pair.first;
-                }
-            }
-            return std::nullopt;
-        }
-
-        // --- Methods ---
-        std::string to_std_string() const;
-        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
-    };
-}
+#pragma once
+
+#include "types.hpp"
+#include <atomic>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <optional>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    struct JsSymbol : HeapObject
+    {
+        std::string description;
+        std::string key; // Internal unique key used for AnyValue property maps
+
+        JsType get_heap_type() const override { return JsType::Symbol; }
+
+        // --- Registries ---
+
+        // 1. Global Symbol Registry (for Symbol.for/keyFor)
+        static std::unordered_map<std::string, JsSymbol*> &registry()
+        {
+            static std::unordered_map<std::string, JsSymbol*> reg;
+            return reg;
+        }
+
+        // 2. All Internal Keys Registry (for robust Object.keys filtering)
+        static std::unordered_set<std::string> &internal_keys_registry()
+        {
+            static std::unordered_set<std::string> keys;
+            return keys;
+        }
+
+        static bool is_internal_key(const std::string &k)
+        {
+            return internal_keys_registry().count(k) > 0;
+        }
+
+        // --- Constructors ---
+
+        // Standard Constructor (creates unique symbol)
+        JsSymbol(const std::string &desc) : description(desc)
+        {
+            static std::atomic<uint64_t> id_counter{0};
+            // Ensure unique internal key for property storage
+            key = "__Sym" + std::to_string(id_counter++) + "_" + desc;
+
+            // Register this key as a valid symbol key
+            internal_keys_registry().insert(key);
+        }
+
+        // Constructor for Well-Known Symbols (fixed keys)
+        JsSymbol(const std::string &desc, const std::string &fixed_key)
+            : description(desc), key(fixed_key)
+        {
+            // Register this key as a valid symbol key
+            internal_keys_registry().insert(key);
+        }
+
+        // --- Global Registry API ---
+
+        // Implements Symbol.for(key)
+        static JsSymbol* for_global(const std::string &registryKey)
+        {
+            auto &reg = registry();
+            auto it = reg.find(registryKey);
+            if (it != reg.end())
+            {
+                return it->second;
+            }
+
+            // Create new symbol with description = registryKey
+            auto newSym = new JsSymbol(registryKey);
+            newSym->ref(); // Keep it alive in registry
+            reg[registryKey] = newSym;
+            return newSym;
+        }
+
+        // Implements Symbol.keyFor(sym)
+        static std::optional<std::string> key_for(const JsSymbol *sym)
+        {
+            auto &reg = registry();
+            for (const auto &pair : reg)
+            {
+                if (pair.second == sym)
+                {
+                    return pair.first;
+                }
+            }
+            return std::nullopt;
+        }
+
+        // --- Methods ---
+        std::string to_std_string() const;
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+    };
+}

package/dist/cli/file-utils.js

@@ -1,20 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-export async function getLatestMtime(dirPath) {
-    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;
-}

package/dist/cli-utils/args.js

@@ -1,59 +0,0 @@
-import path from "path";
-import pkg from "../../package.json" with { type: "json" };
-import { COLORS } from "./colors.js";
-export function parseArgs(rawArgs) {
-    let jsFilePathArg = null;
-    let isRelease = false;
-    let keepCpp = false;
-    let outputExePath = null;
-    let scriptArgs = [];
-    for (let i = 0; i < rawArgs.length; i++) {
-        const arg = rawArgs[i];
-        if (!arg)
-            continue;
-        if (arg === "--") {
-            scriptArgs = rawArgs.slice(i + 1);
-            break;
-        }
-        if (arg === "--release") {
-            isRelease = true;
-        }
-        else if (arg === "--keep-cpp") {
-            keepCpp = true;
-        }
-        else if (arg === "-o" || arg === "--output") {
-            if (i + 1 < rawArgs.length) {
-                outputExePath = rawArgs[i + 1] ?? null;
-                i++;
-            }
-            else {
-                console.error(`${COLORS.red}Error: --output requires a file path argument.${COLORS.reset}`);
-                process.exit(1);
-            }
-        }
-        else if (arg.startsWith("-")) {
-            console.warn(`${COLORS.yellow}Warning: Unknown argument '${arg}'${COLORS.reset}`);
-        }
-        else {
-            if (jsFilePathArg) {
-                console.error(`${COLORS.red}Error: Multiple input files specified.${COLORS.reset}`);
-                process.exit(1);
-            }
-            jsFilePathArg = arg;
-        }
-    }
-    if (!jsFilePathArg) {
-        console.log(`${COLORS.bold}JSPP Compiler${COLORS.reset} ${COLORS.dim}v${pkg.version}${COLORS.reset}`);
-        console.log(`${COLORS.bold}Usage:${COLORS.reset} jspp <path-to-js-file> [--release] [--keep-cpp] [-o <output-path>] [-- <args...>]`);
-        process.exit(1);
-    }
-    return {
-        jsFilePath: path.resolve(process.cwd(), jsFilePathArg),
-        isRelease,
-        keepCpp,
-        outputExePath: outputExePath
-            ? path.resolve(process.cwd(), outputExePath)
-            : null,
-        scriptArgs,
-    };
-}

package/dist/cli-utils/colors.js

@@ -1,9 +0,0 @@
-export const COLORS = {
-    reset: "\x1b[0m",
-    cyan: "\x1b[36m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    red: "\x1b[31m",
-    dim: "\x1b[2m",
-    bold: "\x1b[1m",
-};

package/dist/cli-utils/file-utils.js

@@ -1,20 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-export async function getLatestMtime(dirPath) {
-    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;
-}

package/dist/cli-utils/spinner.js

@@ -1,55 +0,0 @@
-import { COLORS } from "./colors.js";
-export class Spinner {
-    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    interval = null;
-    frameIndex = 0;
-    text;
-    constructor(text) {
-        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) {
-        this.text = text;
-        this.render();
-    }
-    stop(symbol = "", color = 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) {
-        if (text)
-            this.text = text;
-        this.stop("✔", COLORS.green);
-    }
-    fail(text) {
-        if (text)
-            this.text = text;
-        this.stop("✖", COLORS.red);
-    }
-    info(text) {
-        if (text)
-            this.text = text;
-        this.stop("ℹ", COLORS.cyan);
-    }
-    render() {
-        this.clearLine();
-        const frame = this.frames[this.frameIndex];
-        process.stdout.write(`${COLORS.cyan}${frame} ${COLORS.reset} ${this.text}`);
-    }
-    clearLine() {
-        process.stdout.write("\r\x1b[K");
-    }
-}

package/dist/cli.js

@@ -1,153 +0,0 @@
-#!/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 { parseArgs } from "./cli-utils/args.js";
-import { COLORS } from "./cli-utils/colors.js";
-import { getLatestMtime } from "./cli-utils/file-utils.js";
-import { Spinner } from "./cli-utils/spinner.js";
-import { Interpreter } from "./index.js";
-const pkgDir = path.dirname(import.meta.dirname);
-async function main() {
-    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
-    const jsFileName = path.basename(jsFilePath, ".js");
-    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"] : ["-O0"];
-    if (process.platform === "win32") {
-        flags.push("-Wa,-mbig-obj");
-    }
-    const pchDir = path.resolve(pkgDir, "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();
-        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`);
-        // 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");
-        }
-        // 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));
-        }
-        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 {
-                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 = 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);
-        }
-    }
-    catch (error) {
-        spinner.fail("An unexpected error occurred");
-        console.error(error);
-        process.exit(1);
-    }
-}
-main();

package/dist/core/codegen/index.js

@@ -1,86 +0,0 @@
-import { DeclaredSymbols } from "../../ast/symbols.js";
-import { generateLambdaComponents, generateNativeLambda, generateWrappedLambda, } from "./function-handlers.js";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isDeclarationCalledAsFunction, isDeclarationUsedAsValue, isDeclarationUsedBeforeInitialization, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
-import { generateDestructuring } from "./destructuring-handlers.js";
-import { visit } from "./visitor.js";
-const MODULE_NAME = "__entry_point__";
-export class CodeGenerator {
-    indentationLevel = 0;
-    typeAnalyzer;
-    isTypescript = false;
-    globalThisVar;
-    uniqueNameCounter = 0;
-    // visitor
-    visit = visit;
-    // helpers
-    getDeclaredSymbols = getDeclaredSymbols;
-    generateUniqueName = generateUniqueName;
-    generateUniqueExceptionName = generateUniqueExceptionName;
-    hoistDeclaration = hoistDeclaration;
-    getScopeForNode = getScopeForNode;
-    indent = indent;
-    escapeString = escapeString;
-    getJsVarName = getJsVarName;
-    getDerefCode = getDerefCode;
-    getReturnCommand = getReturnCommand;
-    isBuiltinObject = isBuiltinObject;
-    isGeneratorFunction = isGeneratorFunction;
-    isAsyncFunction = isAsyncFunction;
-    prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
-    markSymbolAsInitialized = markSymbolAsInitialized;
-    isDeclarationCalledAsFunction = isDeclarationCalledAsFunction;
-    isDeclarationUsedAsValue = isDeclarationUsedAsValue;
-    isDeclarationUsedBeforeInitialization = isDeclarationUsedBeforeInitialization;
-    validateFunctionParams = validateFunctionParams;
-    generateDestructuring = generateDestructuring;
-    // function handlers
-    generateLambdaComponents = generateLambdaComponents;
-    generateNativeLambda = generateNativeLambda;
-    generateWrappedLambda = generateWrappedLambda;
-    /**
-     * Main entry point for the code generation process.
-     */
-    generate(ast, analyzer, isTypescript) {
-        this.typeAnalyzer = analyzer;
-        this.isTypescript = isTypescript;
-        this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
-        const declarations = `#include "index.hpp"\n\n`;
-        let containerCode = `jspp::JsPromise ${MODULE_NAME}() {\n`;
-        this.indentationLevel++;
-        containerCode +=
-            `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
-        containerCode += this.visit(ast, {
-            currentScopeNode: ast,
-            isMainContext: true,
-            isInsideFunction: true,
-            isFunctionBody: true,
-            isInsideAsyncFunction: true,
-            globalScopeSymbols: new DeclaredSymbols(),
-            localScopeSymbols: new DeclaredSymbols(),
-        });
-        this.indentationLevel--;
-        containerCode += "  co_return jspp::Constants::UNDEFINED;\n";
-        containerCode += "}\n\n";
-        let mainCode = "int main(int argc, char** argv) {\n";
-        mainCode += `  try {\n`;
-        mainCode += `    jspp::setup_process_argv(argc, argv);\n`;
-        mainCode += `    auto p = ${MODULE_NAME}();\n`;
-        mainCode += `    p.then(nullptr, [](jspp::AnyValue err) {\n`;
-        mainCode +=
-            `        auto error = std::make_shared<jspp::AnyValue>(err);\n`;
-        mainCode +=
-            `        console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
-        mainCode += `        std::exit(1);\n`;
-        mainCode += `    });\n`;
-        mainCode += `    jspp::Scheduler::instance().run();\n`;
-        mainCode += `  } catch (const std::exception& ex) {\n`;
-        mainCode +=
-            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n";
-        mainCode +=
-            `    console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
-        mainCode += `    return 1;\n`;
-        mainCode += `  }\n`;
-        mainCode += "  return 0;\n}";
-        return declarations + containerCode + mainCode;
-    }
-}