cluaupp 1.0.0 → 1.4.0

package/generated/flare/emit.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitFlareLuau = emitFlareLuau;
+exports.emitFlareHeader = emitFlareHeader;
+exports.emitFlare = emitFlare;
+const CLPP_TYPE = {
+    u8: "int",
+    u16: "int",
+    u32: "int",
+    i8: "int",
+    i16: "int",
+    i32: "int",
+    f32: "double",
+    f64: "double",
+    bool: "bool",
+    string: "string",
+    Vector3: "Vector3",
+    Vector2: "Vector2",
+    CFrame: "CFrame",
+    Color3: "Color3",
+    UDim: "UDim",
+    UDim2: "UDim2",
+    BrickColor: "BrickColor",
+    buffer: "buffer",
+    Instance: "Instance",
+    Player: "Player",
+};
+const WRITE = {
+    u8: (c, v) => `Flare.writeu8(${c}, ${v})`,
+    u16: (c, v) => `Flare.writeu16(${c}, ${v})`,
+    u32: (c, v) => `Flare.writeu32(${c}, ${v})`,
+    i8: (c, v) => `Flare.writei8(${c}, ${v})`,
+    i16: (c, v) => `Flare.writei16(${c}, ${v})`,
+    i32: (c, v) => `Flare.writei32(${c}, ${v})`,
+    f32: (c, v) => `Flare.writef32(${c}, ${v})`,
+    f64: (c, v) => `Flare.writef64(${c}, ${v})`,
+    bool: (c, v) => `Flare.writebool(${c}, ${v})`,
+    string: (c, v) => `Flare.writestring(${c}, ${v})`,
+    Vector3: (c, v) => `Flare.writeVector3(${c}, ${v})`,
+    Vector2: (c, v) => `Flare.writeVector2(${c}, ${v})`,
+    CFrame: (c, v) => `Flare.writeCFrame(${c}, ${v})`,
+    Color3: (c, v) => `Flare.writeColor3(${c}, ${v})`,
+    UDim: (c, v) => `Flare.writeUDim(${c}, ${v})`,
+    UDim2: (c, v) => `Flare.writeUDim2(${c}, ${v})`,
+    BrickColor: (c, v) => `Flare.writeBrickColor(${c}, ${v})`,
+    buffer: (c, v) => `Flare.writebuffer(${c}, ${v})`,
+    Instance: (c, v) => `Flare.writeInstance(${c}, ${v})`,
+    Player: (c, v) => `Flare.writeInstance(${c}, ${v})`,
+};
+const READ = {
+    u8: (c) => `Flare.readu8(${c})`,
+    u16: (c) => `Flare.readu16(${c})`,
+    u32: (c) => `Flare.readu32(${c})`,
+    i8: (c) => `Flare.readi8(${c})`,
+    i16: (c) => `Flare.readi16(${c})`,
+    i32: (c) => `Flare.readi32(${c})`,
+    f32: (c) => `Flare.readf32(${c})`,
+    f64: (c) => `Flare.readf64(${c})`,
+    bool: (c) => `Flare.readbool(${c})`,
+    string: (c) => `Flare.readstring(${c})`,
+    Vector3: (c) => `Flare.readVector3(${c})`,
+    Vector2: (c) => `Flare.readVector2(${c})`,
+    CFrame: (c) => `Flare.readCFrame(${c})`,
+    Color3: (c) => `Flare.readColor3(${c})`,
+    UDim: (c) => `Flare.readUDim(${c})`,
+    UDim2: (c) => `Flare.readUDim2(${c})`,
+    BrickColor: (c) => `Flare.readBrickColor(${c})`,
+    buffer: (c) => `Flare.readbuffer(${c})`,
+    Instance: (c) => `Flare.readInstance(${c})`,
+    Player: (c) => `Flare.readInstance(${c})`,
+};
+function params(fields) {
+    return fields.map((field) => field.name).join(", ");
+}
+function clppParams(fields) {
+    return fields.map((field) => `${CLPP_TYPE[field.type]} ${field.name}`).join(", ");
+}
+function writeFields(fields, cursor = "cursor") {
+    if (fields.length === 0) {
+        return `\treturn ${cursor}`;
+    }
+    return fields.map((field) => `\t${WRITE[field.type](cursor, field.name)}`).join("\n") + `\n\treturn ${cursor}`;
+}
+function readFields(fields, cursor = "cursor") {
+    if (fields.length === 0) {
+        return "\treturn";
+    }
+    const lines = fields.map((field) => `\tlocal ${field.name} = ${READ[field.type](cursor)}`);
+    return `${lines.join("\n")}\n\treturn ${params(fields)}`;
+}
+function emitPacketLuau(packet) {
+    const args = params(packet.fields);
+    const fnArgs = args || "";
+    return `-- packet ${packet.name} (#${packet.id})
+local function write${packet.name}(cursor${fnArgs ? `, ${fnArgs}` : ""})
+${writeFields(packet.fields)}
+end
+
+local function read${packet.name}(cursor)
+${readFields(packet.fields)}
+end
+
+local ${packet.name} = session.packet({
+	id = ${packet.id},
+	from = "${packet.from === "Client" ? "client" : "server"}",
+	reliable = ${packet.reliable},
+	write = write${packet.name},
+	read = read${packet.name},
+})
+`;
+}
+function emitQueryLuau(query) {
+    const args = params(query.request);
+    return `-- query ${query.name} (#${query.id})
+local function write${query.name}Req(cursor${args ? `, ${args}` : ""})
+${writeFields(query.request)}
+end
+
+local function read${query.name}Req(cursor)
+${readFields(query.request)}
+end
+
+local function write${query.name}Res(cursor, value)
+	${WRITE[query.returns]("cursor", "value")}
+	return cursor
+end
+
+local function read${query.name}Res(cursor)
+	return ${READ[query.returns]("cursor")}
+end
+
+local ${query.name} = session.query({
+	id = ${query.id},
+	writeReq = write${query.name}Req,
+	readReq = read${query.name}Req,
+	writeRes = write${query.name}Res,
+	readRes = read${query.name}Res,
+})
+`;
+}
+function emitFlareLuau(schema) {
+    const names = [...schema.packets.map((p) => p.name), ...schema.queries.map((q) => q.name)];
+    const body = [
+        ...schema.packets.map(emitPacketLuau),
+        ...schema.queries.map(emitQueryLuau),
+    ].join("\n");
+    return `--!native
+--!optimize 2
+--!strict
+-- Generated by Cluaupp Flare from ${schema.sourcePath}
+-- Do not edit. Change the .flare schema and run cluaupp build.
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Flare = require(ReplicatedStorage.CluauppLibs.Flare)
+
+local session = Flare.open(script)
+
+${body}
+return {
+${names.map((name) => `\t${name} = ${name},`).join("\n")}
+}
+`;
+}
+function emitPacketHeader(ns, packet) {
+    const data = clppParams(packet.fields);
+    const clientFire = data;
+    const serverFire = packet.from === "Server" ? data : "";
+    const struct = `${ns}${packet.name}`;
+    const lines = [`struct ${struct} {`];
+    if (packet.from === "Client") {
+        lines.push(`\tvoid FireServer(${clientFire});`);
+        lines.push(`\tRBXScriptConnection Connect(func fn);`);
+    }
+    else {
+        lines.push(`\tvoid Fire(Player player${serverFire ? `, ${serverFire}` : ""});`);
+        lines.push(`\tvoid FireAll(${serverFire});`);
+        lines.push(`\tRBXScriptConnection Connect(func fn);`);
+    }
+    lines.push(`};`);
+    return lines.join("\n");
+}
+function emitQueryHeader(ns, query) {
+    const req = clppParams(query.request);
+    const ret = CLPP_TYPE[query.returns];
+    return `struct ${ns}${query.name} {
+	${ret} Invoke(${req});
+	void On(func fn);
+};`;
+}
+function emitFlareHeader(schema) {
+    const ns = schema.name;
+    const structs = [
+        ...schema.packets.map((packet) => emitPacketHeader(ns, packet)),
+        ...schema.queries.map((query) => emitQueryHeader(ns, query)),
+    ];
+    const fields = [
+        ...schema.packets.map((packet) => `\t${ns}${packet.name} ${packet.name};`),
+        ...schema.queries.map((query) => `\t${ns}${query.name} ${query.name};`),
+    ];
+    return `#pragma once
+// cluaupp generated — do not edit. Change the .flare schema and run cluaupp build.
+// Generated by Cluaupp Flare from ${schema.sourcePath}
+// Tag + params in the .flare file. This header is IntelliSense; runtime is the generated .luau.
+
+${structs.join("\n\n")}
+
+struct ${ns} {
+${fields.join("\n")}
+};
+`;
+}
+function emitFlare(schema, relDir) {
+    const headerRel = `${relDir}${relDir.endsWith("/") || relDir === "" ? "" : "/"}${schema.name}.clh`.replace(/^\//, "");
+    const luauRel = `${relDir}${relDir.endsWith("/") || relDir === "" ? "" : "/"}${schema.name}.luau`.replace(/^\//, "");
+    return {
+        headerRel,
+        headerPath: headerRel,
+        header: emitFlareHeader(schema),
+        luauRel,
+        luau: emitFlareLuau(schema),
+    };
+}

package/generated/flare/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitFlareLuau = exports.emitFlareHeader = exports.emitFlare = exports.parseFlare = void 0;
+exports.isFlareFile = isFlareFile;
+exports.isGeneratedHeader = isGeneratedHeader;
+exports.collectFlareFiles = collectFlareFiles;
+exports.compileFlareFile = compileFlareFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const emit_js_1 = require("./emit.js");
+const parse_js_1 = require("./parse.js");
+var parse_js_2 = require("./parse.js");
+Object.defineProperty(exports, "parseFlare", { enumerable: true, get: function () { return parse_js_2.parseFlare; } });
+var emit_js_2 = require("./emit.js");
+Object.defineProperty(exports, "emitFlare", { enumerable: true, get: function () { return emit_js_2.emitFlare; } });
+Object.defineProperty(exports, "emitFlareHeader", { enumerable: true, get: function () { return emit_js_2.emitFlareHeader; } });
+Object.defineProperty(exports, "emitFlareLuau", { enumerable: true, get: function () { return emit_js_2.emitFlareLuau; } });
+function isFlareFile(fileName) {
+    return node_path_1.default.extname(fileName).toLowerCase() === ".flare";
+}
+function isGeneratedHeader(filePath) {
+    if (node_path_1.default.extname(filePath).toLowerCase() !== ".clh") {
+        return false;
+    }
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return false;
+    }
+    const head = node_fs_1.default.readFileSync(filePath, "utf8").slice(0, 400);
+    return /cluaupp generated/i.test(head);
+}
+function collectFlareFiles(dir, files = []) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return files;
+    }
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectFlareFiles(full, files);
+        }
+        else if (isFlareFile(entry.name)) {
+            files.push(full);
+        }
+    }
+    return files;
+}
+function compileFlareFile(file, srcDir) {
+    const source = node_fs_1.default.readFileSync(file, "utf8");
+    const rel = node_path_1.default.relative(srcDir, file).replace(/\\/g, "/");
+    const stem = node_path_1.default.basename(file, node_path_1.default.extname(file));
+    const schema = (0, parse_js_1.parseFlare)(source, rel, stem);
+    const relDir = node_path_1.default.posix.dirname(rel);
+    const dir = relDir === "." ? "" : relDir;
+    const emit = (0, emit_js_1.emitFlare)(schema, dir);
+    return { schema, emit };
+}

package/generated/flare/parse.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlare = parseFlare;
+const TYPES = {
+    u8: "u8",
+    u16: "u16",
+    u32: "u32",
+    i8: "i8",
+    i16: "i16",
+    i32: "i32",
+    int: "i32",
+    f32: "f32",
+    f64: "f64",
+    float: "f32",
+    double: "f64",
+    number: "f64",
+    bool: "bool",
+    boolean: "bool",
+    string: "string",
+    Vector3: "Vector3",
+    Vector2: "Vector2",
+    CFrame: "CFrame",
+    Color3: "Color3",
+    UDim: "UDim",
+    UDim2: "UDim2",
+    BrickColor: "BrickColor",
+    buffer: "buffer",
+    Instance: "Instance",
+    Player: "Player",
+};
+const IDENT = "[A-Za-z_][A-Za-z0-9_]*";
+function fail(file, line, message) {
+    throw new Error(`cluaupp flare: ${file}:${line}: ${message}`);
+}
+function parseType(raw, file, line) {
+    const mapped = TYPES[raw];
+    if (!mapped) {
+        fail(file, line, `unknown type '${raw}'`);
+    }
+    return mapped;
+}
+function parseFields(list, file, line) {
+    const trimmed = list.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const fields = [];
+    for (const part of trimmed.split(",")) {
+        const piece = part.trim();
+        if (!piece) {
+            continue;
+        }
+        const match = piece.match(new RegExp(`^(${IDENT})\\s+(${IDENT})$`));
+        if (!match) {
+            fail(file, line, `expected 'Type name' in '${piece}'`);
+        }
+        fields.push({ type: parseType(match[1], file, line), name: match[2] });
+    }
+    return fields;
+}
+function parseSide(raw, file, line) {
+    const side = raw.toLowerCase();
+    if (side === "client") {
+        return "Client";
+    }
+    if (side === "server") {
+        return "Server";
+    }
+    fail(file, line, `from must be Client or Server, got '${raw}'`);
+}
+function parseFlare(source, filePath, defaultName) {
+    const file = filePath.replace(/\\/g, "/");
+    let name = defaultName;
+    const packets = [];
+    const queries = [];
+    let packetId = 1;
+    let queryId = 1;
+    const lines = String(source).replace(/\r\n/g, "\n").split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const lineNo = i + 1;
+        let line = lines[i].trim();
+        if (!line || line.startsWith("#") || line.startsWith("//")) {
+            continue;
+        }
+        const opt = line.match(/^opt\s+name\s*=\s*(.+)$/i);
+        if (opt) {
+            const value = opt[1].trim().replace(/^["']|["']$/g, "");
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+                fail(file, lineNo, `opt name must be an identifier`);
+            }
+            name = value;
+            continue;
+        }
+        const packet = line.match(new RegExp(`^packet\\s+(${IDENT})\\s*\\((.*)\\)\\s+from\\s+(Client|Server)(?:\\s+(unreliable|reliable))?\\s*$`, "i"));
+        if (packet) {
+            const reliable = String(packet[4] || "reliable").toLowerCase() !== "unreliable";
+            if (packetId > 255) {
+                fail(file, lineNo, "too many packets (max 255)");
+            }
+            packets.push({
+                kind: "packet",
+                name: packet[1],
+                id: packetId++,
+                from: parseSide(packet[3], file, lineNo),
+                reliable,
+                fields: parseFields(packet[2], file, lineNo),
+            });
+            continue;
+        }
+        const query = line.match(new RegExp(`^query\\s+(${IDENT})\\s*\\((.*)\\)\\s*->\\s*(${IDENT})\\s*$`, "i"));
+        if (query) {
+            if (queryId > 255) {
+                fail(file, lineNo, "too many queries (max 255)");
+            }
+            queries.push({
+                kind: "query",
+                name: query[1],
+                id: queryId++,
+                request: parseFields(query[2], file, lineNo),
+                returns: parseType(query[3], file, lineNo),
+            });
+            continue;
+        }
+        fail(file, lineNo, `expected packet Tag(Type name, ...) from Client|Server or query Tag(...) -> Type`);
+    }
+    if (packets.length === 0 && queries.length === 0) {
+        fail(file, 1, "schema is empty — add a packet or query");
+    }
+    return { name, sourcePath: file, packets, queries };
+}

package/generated/flare/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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);