cluaupp 0.1.5 → 0.2.0

package/generated/compile.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSource = compileSource;
+exports.compileService = compileService;
+const node_path_1 = __importDefault(require("node:path"));
+const parse_js_1 = require("./parse.js");
+const emit_js_1 = require("./emit.js");
+const preprocess_js_1 = require("./preprocess.js");
+const libs_js_1 = require("./libs.js");
+const architecture_js_1 = require("./architecture.js");
+const headers_js_1 = require("./headers.js");
+function shouldAttachRequires(name, contents) {
+    const file = String(name || "").replace(/\\/g, "/");
+    if (/\.json$/i.test(file) || /\.meta\.json$/i.test(file)) {
+        return false;
+    }
+    const trimmed = String(contents || "").trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        return false;
+    }
+    return true;
+}
+function attachRequires(contents, source, ast, options, outName) {
+    if (!shouldAttachRequires(outName, contents)) {
+        return contents;
+    }
+    const libraries = String(contents).includes("CluauppLibs") ? [] : (0, libs_js_1.collectLibraries)(source, ast);
+    return (0, libs_js_1.insertPreamble)(contents, options.moduleIncludes || [], libraries, outName);
+}
+function posixRel(from, file) {
+    return node_path_1.default.relative(from, file).replace(/\\/g, "/");
+}
+function wireHeaderImpl(ast, fileName, options) {
+    const headerPath = options.filePath || null;
+    const impl = headerPath ? (0, preprocess_js_1.siblingImplementation)(headerPath) : null;
+    if (!impl) {
+        return;
+    }
+    const typeName = (0, headers_js_1.primaryHeaderName)(ast, options.relativeName || fileName);
+    const implRel = options.srcDir ? posixRel(options.srcDir, impl) : node_path_1.default.basename(impl).replace(/\\/g, "/");
+    const implOut = (0, preprocess_js_1.implOutName)(implRel);
+    options.headerImplName = `${typeName}Module`;
+    options.moduleIncludes = options.moduleIncludes || [];
+    if (!options.moduleIncludes.some((spec) => spec.name === options.headerImplName)) {
+        options.moduleIncludes.push({
+            name: options.headerImplName,
+            outRel: implOut,
+            exports: { consts: [], structs: [] },
+        });
+    }
+}
+function compileHeader(source, fileName, options, ast) {
+    wireHeaderImpl(ast, fileName, options);
+    const rel = (options.relativeName || fileName || "header.h").replace(/\\/g, "/");
+    const outName = (0, preprocess_js_1.toLuauPath)(rel);
+    const luau = attachRequires((0, headers_js_1.emitHeaderModule)(ast, options), source, ast, options, outName);
+    return {
+        kind: "module",
+        plan: { kind: "module", strict: options.strict === true },
+        files: [{ name: outName, contents: luau }],
+        stale: [],
+    };
+}
+function compileSource(source, fileName, options = {}) {
+    const opts = options;
+    opts.moduleIncludes = opts.moduleIncludes || [];
+    const prepared = (0, preprocess_js_1.preprocess)(source, opts.filePath || null, opts);
+    const ast = (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
+    if ((0, preprocess_js_1.isHeaderFile)(fileName || "") || (0, preprocess_js_1.isHeaderFile)(opts.filePath || "")) {
+        return compileHeader(source, fileName || "header.h", opts, ast).files[0].contents;
+    }
+    const luau = (0, emit_js_1.emit)(ast, opts);
+    return attachRequires(luau, source, ast, opts, opts.outName || fileName || "input.cpp");
+}
+function compileService(source, fileName, options = {}) {
+    const opts = options;
+    opts.moduleIncludes = opts.moduleIncludes || [];
+    const prepared = (0, preprocess_js_1.preprocess)(source, opts.filePath || null, opts);
+    const ast = (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
+    if ((0, preprocess_js_1.isHeaderFile)(fileName || "") || (0, preprocess_js_1.isHeaderFile)(opts.filePath || "") || (0, preprocess_js_1.isHeaderFile)(opts.relativeName || "")) {
+        return compileHeader(source, fileName || "header.h", opts, ast);
+    }
+    const implHeader = opts.filePath ? (0, preprocess_js_1.siblingHeader)(opts.filePath) : null;
+    if (implHeader) {
+        opts.skipInit = true;
+    }
+    const planned = (0, architecture_js_1.planOutput)(ast, fileName || "input.cpp", {
+        ...opts,
+        relativeName: opts.relativeName || fileName,
+        source: prepared,
+        siblingHeader: implHeader,
+    });
+    if (planned.files) {
+        return {
+            ...planned,
+            files: planned.files.map((file) => ({
+                ...file,
+                contents: attachRequires(file.contents, source, ast, opts, file.name),
+            })),
+        };
+    }
+    const luau = attachRequires((0, emit_js_1.emit)(ast, opts), source, ast, opts, planned.outName || opts.outName || fileName || "input.cpp");
+    const name = planned.outName ||
+        opts.outName ||
+        String(fileName || "input.cpp").replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+    return {
+        kind: planned.kind || "flat",
+        plan: planned.plan,
+        files: [{ name, contents: luau }],
+        stale: planned.stale || [],
+    };
+}

package/generated/editor-install.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLANGD_ID = void 0;
+exports.editorBin = editorBin;
+exports.isExtensionInstalled = isExtensionInstalled;
+exports.findClangPlusPlus = findClangPlusPlus;
+exports.ensureLlvm = ensureLlvm;
+exports.installMarketplaceExtension = installMarketplaceExtension;
+exports.reportInstall = reportInstall;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+exports.CLANGD_ID = "llvm-vs-code-extensions.vscode-clangd";
+function which(command) {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const result = (0, node_child_process_1.spawnSync)(finder, [command], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0) {
+        return null;
+    }
+    return String(result.stdout || "")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line && !line.toLowerCase().includes("info:")) || null;
+}
+function editorBin() {
+    const found = which("cursor") || which("code");
+    if (found) {
+        return found;
+    }
+    const local = process.env.LOCALAPPDATA || "";
+    const fallbacks = [
+        node_path_1.default.join(local, "Programs", "cursor", "resources", "app", "bin", "cursor.cmd"),
+        node_path_1.default.join(local, "Programs", "Microsoft VS Code", "bin", "code.cmd"),
+        "/usr/bin/cursor",
+        "/usr/local/bin/cursor",
+        "/usr/bin/code",
+        "/usr/local/bin/code",
+    ];
+    return fallbacks.find((file) => node_fs_1.default.existsSync(file)) || null;
+}
+function extensionHomes() {
+    return [node_path_1.default.join(node_os_1.default.homedir(), ".cursor", "extensions"), node_path_1.default.join(node_os_1.default.homedir(), ".vscode", "extensions")];
+}
+function isExtensionInstalled(id) {
+    for (const home of extensionHomes()) {
+        if (!node_fs_1.default.existsSync(home)) {
+            continue;
+        }
+        try {
+            if (node_fs_1.default.readdirSync(home).some((name) => name.startsWith(`${id}-`))) {
+                return true;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const bin = editorBin();
+    if (!bin) {
+        return false;
+    }
+    const listed = (0, node_child_process_1.spawnSync)(bin, ["--list-extensions"], { encoding: "utf8", windowsHide: true, timeout: 20000 });
+    return String(listed.stdout || "").split(/\r?\n/).includes(id);
+}
+function llvmCandidates() {
+    if (process.platform === "win32") {
+        return [
+            "C:/Program Files/LLVM/bin/clang++.exe",
+            "C:/Program Files (x86)/LLVM/bin/clang++.exe",
+            node_path_1.default.join(process.env.ProgramFiles || "C:/Program Files", "LLVM", "bin", "clang++.exe"),
+            "C:/msys64/ucrt64/bin/clang++.exe",
+            "C:/msys64/mingw64/bin/clang++.exe",
+        ];
+    }
+    return ["/usr/bin/clang++", "/usr/local/bin/clang++", "/opt/homebrew/bin/clang++"];
+}
+function findClangPlusPlus() {
+    for (const candidate of llvmCandidates()) {
+        if (candidate && node_fs_1.default.existsSync(candidate)) {
+            return candidate.replace(/\\/g, "/");
+        }
+    }
+    return which("clang++");
+}
+function ensureLlvm() {
+    const found = findClangPlusPlus();
+    if (found) {
+        return { status: "already", path: found };
+    }
+    if (process.platform === "win32" && which("winget")) {
+        console.log("cluaupp: installing LLVM.LLVM (clang++ / clangd) via winget");
+        const result = (0, node_child_process_1.spawnSync)("winget", ["install", "--id", "LLVM.LLVM", "-e", "--accept-package-agreements", "--accept-source-agreements"], { encoding: "utf8", windowsHide: true, timeout: 300000 });
+        const after = findClangPlusPlus();
+        if (after) {
+            return { status: "installed", path: after, how: "winget" };
+        }
+        return {
+            status: "missing",
+            detail: String(result.stderr || result.stdout || "").trim() || "winget did not install LLVM",
+            hint: "winget install --id LLVM.LLVM -e",
+        };
+    }
+    const hint = process.platform === "darwin"
+        ? "brew install llvm"
+        : process.platform === "win32"
+            ? "winget install --id LLVM.LLVM -e"
+            : "sudo apt install clang";
+    return { status: "missing", hint };
+}
+function spawnInstall(bin, target) {
+    const result = (0, node_child_process_1.spawnSync)(bin, ["--install-extension", target, "--force"], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 180000,
+    });
+    return {
+        ok: result.status === 0 && !/not found/i.test(String(result.stderr || "") + String(result.stdout || "")),
+        stdout: String(result.stdout || ""),
+        stderr: String(result.stderr || ""),
+        status: result.status,
+    };
+}
+async function installMarketplaceExtension(id, label) {
+    if (isExtensionInstalled(id)) {
+        return { status: "already", id };
+    }
+    const bin = editorBin();
+    if (!bin) {
+        return { status: "missing-editor", id };
+    }
+    console.log("cluaupp: installing", label || id);
+    const marketplace = spawnInstall(bin, id);
+    if (marketplace.ok) {
+        return { status: "installed", id, how: "marketplace" };
+    }
+    return { status: "failed", id, detail: marketplace.stderr || marketplace.stdout };
+}
+function reportInstall(result, label, extraMissing) {
+    if (!result) {
+        return;
+    }
+    const name = label || result.id;
+    if (result.status === "already") {
+        console.log("cluaupp:", name, "already installed");
+        return;
+    }
+    if (result.status === "installed") {
+        console.log("cluaupp: installed", name, result.how ? `(${result.how})` : "");
+        return;
+    }
+    if (result.status === "missing-editor") {
+        console.error("cluaupp: Cursor/VS Code CLI not found. Install", name, "from the marketplace.");
+        return;
+    }
+    if (result.status === "missing") {
+        console.error("cluaupp: LLVM clang++ not found.", result.hint || extraMissing || "");
+        if (result.detail) {
+            console.error(" ", result.detail.split(/\r?\n/)[0]);
+        }
+        return;
+    }
+    console.error("cluaupp: could not install", name + ":", result.detail || "unknown error");
+    if (extraMissing) {
+        console.error(" ", extraMissing);
+    }
+}