cluaupp 1.0.0 → 1.3.0

package/generated/clpp/runner.js

@@ -1,27 +1,117 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasClpp = hasClpp;
 exports.resolveClppBinary = resolveClppBinary;
+exports.formatClppFailure = formatClppFailure;
 exports.compileViaClpp = compileViaClpp;
+exports.compileViaClppAsync = compileViaClppAsync;
 exports.clppManifest = clppManifest;
 exports.clppVersion = clppVersion;
+exports.clppInstalls = clppInstalls;
 const node_child_process_1 = require("node:child_process");
+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 contract_js_1 = require("./contract.js");
 const MISSING_CLPP = `cluaupp: clpp not found. ${contract_js_1.CLPP_INSTALL_HINT}`;
-function whichClpp() {
-    if (process.env.CLPP_PATH) {
-        return process.env.CLPP_PATH;
+let cachedBin;
+function parseSemver(text) {
+    const match = String(text).match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match) {
+        return null;
+    }
+    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+function cmpSemver(a, b) {
+    return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+}
+function minClpp() {
+    return parseSemver(contract_js_1.MIN_CLPP_VERSION) || { major: 0, minor: 3, patch: 2 };
+}
+function tooOldMessage(bin, version) {
+    return `cluaupp: clpp ${version || "unknown"} is too old (${bin}). Need CL++ ${contract_js_1.MIN_CLPP_VERSION}+. Install https://github.com/KartzRbx/CLPP/releases/download/v0.3.2/clpp-setup.exe or set CLPP / CLPP_PATH.`;
+}
+function probeVersion(bin) {
+    const result = (0, node_child_process_1.spawnSync)(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0) {
+        return null;
+    }
+    return String(result.stdout || result.stderr || "").trim() || null;
+}
+function pushCandidate(out, seen, item) {
+    const value = String(item || "").trim();
+    if (!value) {
+        return;
+    }
+    const key = value.toLowerCase();
+    if (seen.has(key)) {
+        return;
+    }
+    seen.add(key);
+    out.push(value);
+}
+function existsBin(bin) {
+    try {
+        return node_fs_1.default.existsSync(bin);
     }
+    catch {
+        return false;
+    }
+}
+function listClppCandidates() {
+    const seen = new Set();
+    const override = [];
+    pushCandidate(override, seen, process.env.CLPP);
+    pushCandidate(override, seen, process.env.CLPP_PATH);
+    const overrideExisting = override.filter(existsBin);
+    if (overrideExisting.length > 0) {
+        return overrideExisting;
+    }
+    const out = [];
     const finder = process.platform === "win32" ? "where" : "which";
     const found = (0, node_child_process_1.spawnSync)(finder, ["clpp"], { encoding: "utf8", windowsHide: true });
-    if (found.status !== 0) {
+    if (found.status === 0) {
+        for (const line of String(found.stdout || "").split(/\r?\n/)) {
+            pushCandidate(out, seen, line);
+        }
+    }
+    if (process.platform === "win32") {
+        const local = process.env.LOCALAPPDATA || node_path_1.default.join(node_os_1.default.homedir(), "AppData", "Local");
+        pushCandidate(out, seen, node_path_1.default.join(local, "Programs", "CLPP", "clpp.exe"));
+    }
+    return out.filter(existsBin);
+}
+function pickClppBinary() {
+    const candidates = listClppCandidates();
+    if (candidates.length === 0) {
         return null;
     }
-    const line = String(found.stdout || "")
-        .split(/\r?\n/)
-        .map((item) => item.trim())
-        .find((item) => item.length > 0);
-    return line || "clpp";
+    let best = null;
+    let fallback = null;
+    for (const bin of candidates) {
+        const version = probeVersion(bin);
+        const parsed = parseSemver(version || "");
+        if (!fallback) {
+            fallback = bin;
+        }
+        if (!parsed) {
+            continue;
+        }
+        if (!best || cmpSemver(parsed, best.parsed) > 0) {
+            best = { bin, parsed };
+        }
+    }
+    return best?.bin || fallback;
+}
+function whichClpp() {
+    if (cachedBin !== undefined) {
+        return cachedBin;
+    }
+    cachedBin = pickClppBinary();
+    return cachedBin;
 }
 function hasClpp() {
     return Boolean(whichClpp());
@@ -31,6 +121,11 @@ function resolveClppBinary() {
     if (!bin) {
         throw new Error(MISSING_CLPP);
     }
+    const version = probeVersion(bin);
+    const parsed = parseSemver(version || "");
+    if (!parsed || cmpSemver(parsed, minClpp()) < 0) {
+        throw new Error(tooOldMessage(bin, version));
+    }
     return bin;
 }
 function parseArtifact(stdout, fileName, fallbackError) {
@@ -57,12 +152,24 @@ function parseArtifact(stdout, fileName, fallbackError) {
         error: fallbackError || "clpp returned invalid JSON",
     };
 }
+function formatClppFailure(artifact, fallback) {
+    const diags = Array.isArray(artifact.diagnostics) ? artifact.diagnostics : [];
+    if (diags.length > 0) {
+        return diags
+            .map((d) => {
+            const where = `${artifact.fileName || "clpp"}:${d.line}:${d.column}`;
+            return `${where}: ${d.message}`;
+        })
+            .join("\n");
+    }
+    return artifact.error || fallback;
+}
 function compileViaClpp(request) {
     const bin = resolveClppBinary();
     const payload = JSON.stringify({
         source: request.source,
         fileName: request.fileName,
-        strict: request.strict,
+        strict: request.strict ?? null,
     });
     const result = (0, node_child_process_1.spawnSync)(bin, ["api", "compile"], {
         input: payload,
@@ -74,10 +181,50 @@ function compileViaClpp(request) {
     const stderr = String(result.stderr || "").trim();
     const artifact = parseArtifact(result.stdout, request.fileName, stderr || result.error?.message || "clpp api compile failed");
     if (!artifact.ok) {
-        throw new Error(artifact.error || stderr || `clpp failed (${result.status})`);
+        throw new Error(formatClppFailure(artifact, stderr || result.error?.message || `clpp failed (${result.status})`));
     }
     return artifact;
 }
+function compileViaClppAsync(request) {
+    return new Promise((resolve, reject) => {
+        let bin;
+        try {
+            bin = resolveClppBinary();
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        const child = (0, node_child_process_1.spawn)(bin, ["api", "compile"], {
+            cwd: request.cwd,
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const artifact = parseArtifact(stdout, request.fileName, stderr.trim() || `clpp api compile failed (${code})`);
+            if (!artifact.ok) {
+                reject(new Error(formatClppFailure(artifact, stderr.trim() || `clpp failed (${code})`)));
+                return;
+            }
+            resolve(artifact);
+        });
+        child.stdin.end(JSON.stringify({
+            source: request.source,
+            fileName: request.fileName,
+            strict: request.strict ?? null,
+        }));
+    });
+}
 function clppManifest() {
     const bin = resolveClppBinary();
     const result = (0, node_child_process_1.spawnSync)(bin, ["api", "manifest"], {
@@ -94,9 +241,13 @@ function clppVersion() {
     if (!bin) {
         return null;
     }
-    const result = (0, node_child_process_1.spawnSync)(bin, ["--version"], { encoding: "utf8", windowsHide: true });
-    if (result.status !== 0) {
-        return null;
-    }
-    return String(result.stdout || "").trim() || null;
+    return probeVersion(bin);
+}
+function clppInstalls() {
+    const selected = whichClpp();
+    return listClppCandidates().map((bin) => ({
+        bin,
+        version: probeVersion(bin),
+        selected: bin === selected,
+    }));
 }

package/generated/compile.js

@@ -5,25 +5,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileSource = compileSource;
 exports.compileService = compileService;
+exports.compileServiceAsync = compileServiceAsync;
 const node_path_1 = __importDefault(require("node:path"));
 const runner_js_1 = require("./clpp/runner.js");
 const postprocess_js_1 = require("./clpp/postprocess.js");
 const paths_js_1 = require("./clpp/paths.js");
-function compileSource(source, fileName, options = {}) {
-    return compileService(source, fileName, options).files[0]?.contents ?? "";
-}
-function compileService(source, fileName, options = {}) {
+function compileArgs(source, fileName, options) {
     const relative = (options.relativeName || fileName || "input.clpp").replace(/\\/g, "/");
     const outName = options.outName || (0, paths_js_1.toLuauPath)(relative);
     const header = options.filePath ? (0, paths_js_1.siblingHeader)(options.filePath) : null;
     const skipInit = options.skipInit === true || (0, postprocess_js_1.shouldSkipInit)(relative, Boolean(header));
     const diskPath = options.filePath ? node_path_1.default.resolve(options.filePath) : null;
-    const artifact = (0, runner_js_1.compileViaClpp)({
-        source,
-        fileName: diskPath ? diskPath.replace(/\\/g, "/") : relative,
-        strict: options.strict,
-        cwd: diskPath ? node_path_1.default.dirname(diskPath) : options.srcDir,
-    });
+    return {
+        request: {
+            source,
+            fileName: diskPath ? diskPath.replace(/\\/g, "/") : relative,
+            strict: options.strict,
+            cwd: diskPath ? node_path_1.default.dirname(diskPath) : options.srcDir,
+        },
+        relative,
+        outName,
+        skipInit,
+        options,
+    };
+}
+function finishArtifact(artifact, relative, outName, options, skipInit) {
     const luau = (0, postprocess_js_1.clppLuauToGame)(artifact, {
         relativeName: relative,
         outName,
@@ -39,3 +45,16 @@ function compileService(source, fileName, options = {}) {
         stale: [],
     };
 }
+function compileSource(source, fileName, options = {}) {
+    return compileService(source, fileName, options).files[0]?.contents ?? "";
+}
+function compileService(source, fileName, options = {}) {
+    const args = compileArgs(source, fileName, options);
+    const artifact = (0, runner_js_1.compileViaClpp)(args.request);
+    return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit);
+}
+async function compileServiceAsync(source, fileName, options = {}) {
+    const args = compileArgs(source, fileName, options);
+    const artifact = await (0, runner_js_1.compileViaClppAsync)(args.request);
+    return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit);
+}

package/generated/intellisense.js

@@ -94,22 +94,10 @@ function writeVscode(root) {
         unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
     });
 }
-function diagnosticsFor(source, fileName) {
-    if (!(0, runner_js_1.hasClpp)()) {
-        return [];
-    }
-    try {
-        (0, runner_js_1.compileViaClpp)({ source, fileName: fileName || "input.clpp" });
-        return [];
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const match = message.match(/:(\d+):(\d+):\s*(.*)$/);
-        if (match) {
-            return [{ line: Number(match[1]), col: Number(match[2]), message: match[3], severity: "error" }];
-        }
-        return [{ line: 1, col: 1, message, severity: "error" }];
-    }
+function diagnosticsFor(_source, _fileName) {
+    // Language diagnostics belong to `clpp install`. Do not spawn `clpp api compile`
+    // from the editor — that duplicates source=clpp and freezes on every keystroke.
+    return [];
 }
 function syncEditorSupport(root, _config = {}) {
     writeVscode(root);

package/generated/lsp.js

@@ -3,17 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.start = start;
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const intellisense_js_1 = require("./intellisense.js");
 const package_info_js_1 = require("./package-info.js");
-function uriPath(uri) {
-    let file = String(uri || "").replace(/^file:\/\//, "");
-    if (/^\/[A-Za-z]:/.test(file)) {
-        file = file.slice(1);
-    }
-    return decodeURIComponent(file);
-}
-function start(options = {}) {
-    const projectRoot = options.projectRoot || process.cwd();
+function start(_options = {}) {
     const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
     const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
     connection.onInitialize(() => ({
@@ -22,27 +13,12 @@ function start(options = {}) {
         },
         serverInfo: { name: "cluaupp", version: package_info_js_1.pkg.version },
     }));
-    const publish = (document) => {
-        const file = uriPath(document.uri);
-        const items = (0, intellisense_js_1.diagnosticsFor)(document.getText(), file);
-        connection.sendDiagnostics({
-            uri: document.uri,
-            diagnostics: items.map((item) => ({
-                range: {
-                    start: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(0, (item.col || 1) - 1) },
-                    end: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(1, item.col || 1) },
-                },
-                severity: 1,
-                source: "cluaupp",
-                message: item.message,
-            })),
-        });
+    const clear = (uri) => {
+        connection.sendDiagnostics({ uri, diagnostics: [] });
     };
-    documents.onDidOpen((event) => publish(event.document));
-    documents.onDidChangeContent((event) => publish(event.document));
-    documents.onDidClose((event) => {
-        connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
-    });
+    documents.onDidOpen((event) => clear(event.document.uri));
+    documents.onDidChangeContent((event) => clear(event.document.uri));
+    documents.onDidClose((event) => clear(event.document.uri));
     documents.listen(connection);
     connection.listen();
 }

package/generated/transpile.js

@@ -4,12 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transpileSource = transpileSource;
+exports.transpileSourceAsync = transpileSourceAsync;
 exports.outputNameFor = outputNameFor;
 const node_path_1 = __importDefault(require("node:path"));
 const compile_js_1 = require("./compile.js");
 function transpileSource(source, fileName, options, _mapper) {
     return (0, compile_js_1.compileService)(source, fileName, options);
 }
+function transpileSourceAsync(source, fileName, options, _mapper) {
+    return (0, compile_js_1.compileServiceAsync)(source, fileName, options);
+}
 function outputNameFor(inputFile, outputPath) {
     if (/\.luau$/i.test(outputPath)) {
         return outputPath;

package/generated/utils/project.js

@@ -7,6 +7,7 @@ exports.collectSourcesFiles = void 0;
 exports.loadConfig = loadConfig;
 exports.collectCpp = collectCpp;
 exports.build = build;
+exports.buildAsync = buildAsync;
 exports.init = init;
 exports.watch = watch;
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -241,6 +242,19 @@ function createMapper(root, config, rojoPath) {
     mapper.loadSync();
     return mapper;
 }
+function compileOptions(root, config, file, rel) {
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    return {
+        ...config,
+        filePath: file,
+        relativeName: rel,
+        outName: (0, paths_js_1.toLuauPath)(rel),
+        architecture: config.architecture === true,
+        includeDirs: [node_path_1.default.dirname(file), srcDir, node_path_1.default.join(root, "include")],
+        srcDir,
+        outDir: config.outDir,
+    };
+}
 function compileProject(root, config, mapper) {
     const srcDir = node_path_1.default.join(root, config.rootDir);
     const files = (0, paths_js_1.collectSources)(srcDir);
@@ -250,16 +264,25 @@ function compileProject(root, config, mapper) {
         const source = node_fs_1.default.readFileSync(file, "utf8");
         const rel = posixRel(srcDir, file);
         try {
-            const result = (0, transpile_js_1.transpileSource)(source, rel, {
-                ...config,
-                filePath: file,
-                relativeName: rel,
-                outName: (0, paths_js_1.toLuauPath)(rel),
-                architecture: config.architecture === true,
-                includeDirs: [node_path_1.default.dirname(file), srcDir, node_path_1.default.join(root, "include")],
-                srcDir,
-                outDir: config.outDir,
-            }, mapper);
+            const result = (0, transpile_js_1.transpileSource)(source, rel, compileOptions(root, config, file, rel), mapper);
+            jobs.push({ rel, files: result.files, stale: result.stale || [] });
+        }
+        catch (err) {
+            errors.push({ rel, prefixes: sourcePrefixes(rel), message: err.message });
+        }
+    }
+    return { files, jobs, errors };
+}
+async function compileProjectAsync(root, config, mapper) {
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    const files = (0, paths_js_1.collectSources)(srcDir);
+    const jobs = [];
+    const errors = [];
+    for (const file of files) {
+        const source = node_fs_1.default.readFileSync(file, "utf8");
+        const rel = posixRel(srcDir, file);
+        try {
+            const result = await (0, transpile_js_1.transpileSourceAsync)(source, rel, compileOptions(root, config, file, rel), mapper);
             jobs.push({ rel, files: result.files, stale: result.stale || [] });
         }
         catch (err) {
@@ -322,27 +345,10 @@ function ensureVendor(root) {
     copyRuntime(root);
     copyHeaders(root);
 }
-function build(root, options = {}) {
+function finishBuild(root, config, compiled, options) {
     const exitOnError = options.exitOnError !== false;
     const holdOnError = options.holdOnError === true;
     const format = options.format === true;
-    const config = loadConfig(root);
-    if (options.syncVendor !== false) {
-        ensureVendor(root);
-    }
-    const srcDir = node_path_1.default.join(root, config.rootDir);
-    if (!node_fs_1.default.existsSync(srcDir) || (0, paths_js_1.collectSources)(srcDir).length === 0) {
-        console.error("no .clpp/.clp/.clh files in", config.rootDir);
-        if (!holdOnError) {
-            pruneOut(root, config, new Set(), []);
-        }
-        if (exitOnError) {
-            process.exit(1);
-        }
-        return { failed: 0, written: new Set() };
-    }
-    const mapper = createMapper(root, config, options.rojo);
-    const compiled = compileProject(root, config, mapper);
     if (compiled.errors.length > 0) {
         for (const err of compiled.errors) {
             console.error(err.message);
@@ -382,6 +388,45 @@ function build(root, options = {}) {
     }
     return { failed: compiled.errors.length, written };
 }
+function prepareBuild(root, options) {
+    const exitOnError = options.exitOnError !== false;
+    const holdOnError = options.holdOnError === true;
+    const config = loadConfig(root);
+    if (options.strict === true) {
+        config.strict = true;
+    }
+    if (options.syncVendor !== false) {
+        ensureVendor(root);
+    }
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    if (!node_fs_1.default.existsSync(srcDir) || (0, paths_js_1.collectSources)(srcDir).length === 0) {
+        console.error("no .clpp/.clp/.clh files in", config.rootDir);
+        if (!holdOnError) {
+            pruneOut(root, config, new Set(), []);
+        }
+        if (exitOnError) {
+            process.exit(1);
+        }
+        return null;
+    }
+    return { config, mapper: createMapper(root, config, options.rojo) };
+}
+function build(root, options = {}) {
+    const prepared = prepareBuild(root, options);
+    if (!prepared) {
+        return { failed: 0, written: new Set() };
+    }
+    const compiled = compileProject(root, prepared.config, prepared.mapper);
+    return finishBuild(root, prepared.config, compiled, options);
+}
+async function buildAsync(root, options = {}) {
+    const prepared = prepareBuild(root, options);
+    if (!prepared) {
+        return { failed: 0, written: new Set() };
+    }
+    const compiled = await compileProjectAsync(root, prepared.config, prepared.mapper);
+    return finishBuild(root, prepared.config, compiled, options);
+}
 async function init(dest) {
     const target = (0, safe_paths_js_1.assertInitDest)(dest);
     const template = node_path_1.default.join(__dirname, "..", "..", "templates", "game");
@@ -437,7 +482,6 @@ function acquireWatchLock(root) {
 }
 function watch(root, options = {}) {
     acquireWatchLock(root);
-    build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
     const config = loadConfig(root);
     const dir = node_path_1.default.join(root, config.rootDir);
     let timer = null;
@@ -449,24 +493,23 @@ function watch(root, options = {}) {
             return;
         }
         running = true;
-        try {
-            build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
-        }
-        catch (err) {
+        void buildAsync(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo })
+            .catch((err) => {
             console.error(err.message);
-        }
-        finally {
+        })
+            .finally(() => {
             running = false;
             if (queued) {
                 queued = false;
                 run();
             }
-        }
+        });
     };
     console.log("cluaupp", package_info_js_1.pkg.version, "watching", dir, "(libs untouched)");
     if (!node_fs_1.default.existsSync(dir)) {
         node_fs_1.default.mkdirSync(dir, { recursive: true });
     }
+    run();
     node_fs_1.default.watch(dir, { recursive: true }, () => {
         if (timer) {
             clearTimeout(timer);