cluaupp 1.0.0 → 1.4.0

package/generated/utils/project.js

@@ -7,12 +7,15 @@ 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"));
 const node_path_1 = __importDefault(require("node:path"));
 const package_info_js_1 = require("../package-info.js");
 const paths_js_1 = require("../clpp/paths.js");
+const index_js_1 = require("../flare/index.js");
+const index_js_2 = require("../native/index.js");
 const intellisense_js_1 = require("../intellisense.js");
 const process_orchestrator_js_1 = require("./process-orchestrator.js");
 const rojo_mapper_js_1 = require("./rojo-mapper.js");
@@ -96,15 +99,17 @@ function tryRm(target, root) {
     }
 }
 function copyFileIfChanged(src, dest, mode = "fill") {
-    if (mode === "fill" && node_fs_1.default.existsSync(dest)) {
-        return;
-    }
-    if (mode === "update" && node_fs_1.default.existsSync(dest)) {
-        const from = node_fs_1.default.statSync(src);
-        const to = node_fs_1.default.statSync(dest);
-        if (from.size === to.size && from.mtimeMs <= to.mtimeMs) {
+    if (mode !== "force") {
+        if (mode === "fill" && node_fs_1.default.existsSync(dest)) {
             return;
         }
+        if (mode === "update" && node_fs_1.default.existsSync(dest)) {
+            const from = node_fs_1.default.statSync(src);
+            const to = node_fs_1.default.statSync(dest);
+            if (from.size === to.size && from.mtimeMs <= to.mtimeMs) {
+                return;
+            }
+        }
     }
     node_fs_1.default.mkdirSync(node_path_1.default.dirname(dest), { recursive: true });
     try {
@@ -135,12 +140,54 @@ function syncDir(from, to, mode = "fill") {
         }
     }
 }
+function pruneStaleLibs(libs) {
+    if (!node_fs_1.default.existsSync(libs)) {
+        return;
+    }
+    const staleNames = [
+        "Janitor",
+        "Signal",
+        "MathUtils",
+        "FormatNumber",
+        "Module3D",
+        "Twinkle",
+        "EzVisualz",
+        "Spring",
+        "Display",
+        "StickyBillboard",
+        "Icon",
+        "TopbarPlus",
+        "Cmdr",
+        "Chrono",
+        "Iris",
+        "Fusion",
+        "StateMachine",
+        "VfxUtil",
+        "DataService",
+        "TutorialKit",
+        "TutorialServer",
+        "QuickNet",
+    ];
+    const stale = [
+        ...staleNames.map((name) => node_path_1.default.join(libs, name)),
+        node_path_1.default.join(libs, "Keep", "Packages"),
+        node_path_1.default.join(libs, "Keep", "ProfileStore.luau"),
+    ];
+    for (const target of stale) {
+        if (!node_fs_1.default.existsSync(target)) {
+            continue;
+        }
+        node_fs_1.default.rmSync(target, { recursive: true, force: true });
+    }
+}
 function copyRuntime(dest) {
     const runtime = node_path_1.default.join(__dirname, "..", "..", "runtime");
     if (!node_fs_1.default.existsSync(runtime)) {
         return;
     }
-    syncDir(runtime, node_path_1.default.join(dest, "libs"));
+    const libs = node_path_1.default.join(dest, "libs");
+    pruneStaleLibs(libs);
+    syncDir(runtime, libs, "force");
 }
 function copyHeaders(dest) {
     const from = node_path_1.default.join(__dirname, "..", "..", "include", "clpp");
@@ -241,25 +288,104 @@ function createMapper(root, config, rojoPath) {
     mapper.loadSync();
     return mapper;
 }
-function compileProject(root, config, mapper) {
+function compileOptions(root, config, file, rel) {
     const srcDir = node_path_1.default.join(root, config.rootDir);
-    const files = (0, paths_js_1.collectSources)(srcDir);
+    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 compileSchemaJobs(root, config, srcDir) {
+    const jobs = [];
+    const errors = [];
+    const flare = compileFlareJobs(root, config, srcDir);
+    jobs.push(...flare.jobs);
+    errors.push(...flare.errors);
+    for (const file of (0, index_js_2.collectNativeSchemaFiles)(srcDir)) {
+        const rel = posixRel(srcDir, file);
+        try {
+            const emit = (0, index_js_2.compileNativeSchemaFile)(file, srcDir);
+            const headerDest = node_path_1.default.join(srcDir, emit.headerRel);
+            if (!(0, safe_paths_js_1.isInside)(node_path_1.default.resolve(root, config.rootDir), headerDest) && !(0, safe_paths_js_1.isInside)(srcDir, headerDest)) {
+                throw new Error(`cluaupp schema: skip unsafe header ${emit.headerRel}`);
+            }
+            writeTextIfChanged(headerDest, emit.header);
+            jobs.push({
+                rel,
+                files: [{ name: emit.luauRel, contents: emit.luau }],
+                stale: [],
+            });
+        }
+        catch (err) {
+            errors.push({
+                rel,
+                prefixes: sourcePrefixes(rel.replace(/\.(mint|bloom|helm|shift|hive|axiom)$/i, ".clh")),
+                message: err.message,
+            });
+        }
+    }
+    return { jobs, errors };
+}
+function compileFlareJobs(root, config, srcDir) {
     const jobs = [];
     const errors = [];
+    for (const file of (0, index_js_1.collectFlareFiles)(srcDir)) {
+        const rel = posixRel(srcDir, file);
+        try {
+            const { emit } = (0, index_js_1.compileFlareFile)(file, srcDir);
+            const headerDest = node_path_1.default.join(srcDir, emit.headerRel);
+            if (!(0, safe_paths_js_1.isInside)(node_path_1.default.resolve(root, config.rootDir), headerDest) && !(0, safe_paths_js_1.isInside)(srcDir, headerDest)) {
+                throw new Error(`cluaupp flare: skip unsafe header ${emit.headerRel}`);
+            }
+            writeTextIfChanged(headerDest, emit.header);
+            jobs.push({
+                rel,
+                files: [{ name: emit.luauRel, contents: emit.luau }],
+                stale: [],
+            });
+        }
+        catch (err) {
+            errors.push({ rel, prefixes: sourcePrefixes(rel.replace(/\.flare$/i, ".clh")), message: err.message });
+        }
+    }
+    return { jobs, errors };
+}
+function compileProject(root, config, mapper) {
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    const schema = compileSchemaJobs(root, config, srcDir);
+    const files = (0, paths_js_1.collectSources)(srcDir);
+    const jobs = [...schema.jobs];
+    const errors = [...schema.errors];
     for (const file of files) {
         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 schema = compileSchemaJobs(root, config, srcDir);
+    const files = (0, paths_js_1.collectSources)(srcDir);
+    const jobs = [...schema.jobs];
+    const errors = [...schema.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 +448,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 +491,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 +585,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 +596,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);

package/generated/utils/rojo-mapper.js

@@ -108,14 +108,20 @@ class RojoMapper {
             segments.shift();
         }
         const alias = this.safeAlias(baseName);
-        if (segments[0] === "shared") {
-            return { alias, path: `ReplicatedStorage.Cluaupp.${segments.slice(1).join(".")}` };
+        if (segments[0] === "ReplicatedFirst") {
+            return { alias, path: `ReplicatedFirst.${segments.slice(1).join(".")}` };
         }
-        if (segments[0] === "server") {
-            return { alias, path: `ServerScriptService.Cluaupp.${segments.slice(1).join(".")}` };
+        if (segments[0] === "ReplicatedStorage") {
+            return { alias, path: `ReplicatedStorage.${segments.slice(1).join(".")}` };
         }
-        if (segments[0] === "client") {
-            return { alias, path: `StarterPlayer.StarterPlayerScripts.Cluaupp.${segments.slice(1).join(".")}` };
+        if (segments[0] === "ServerScriptService") {
+            return { alias, path: `ServerScriptService.${segments.slice(1).join(".")}` };
+        }
+        if (segments[0] === "StarterPlayer") {
+            return { alias, path: `StarterPlayer.${segments.slice(1).join(".")}` };
+        }
+        if (segments[0] === "ServerStorage") {
+            return { alias, path: `ServerStorage.${segments.slice(1).join(".")}` };
         }
         return { alias, path: `ReplicatedStorage.${segments.join(".")}` };
     }

package/include/clpp/datatypes.clh

@@ -27,10 +27,7 @@ struct Player;
 // Stand-in for values the C++ IntelliSense stubs cannot name precisely.
 struct LuauValue {
 	LuauValue();
-	template <typename T>
-	LuauValue(const T&);
-	template <typename T>
-	operator T() const;
+	LuauValue(auto value);
 };
 
 template <typename T>
@@ -240,7 +237,7 @@ struct Ray {
 
 // Filters for WorldRoot:Raycast.
 struct RaycastParams {
-	Instance* FilterDescendantsInstances;
+	LuaArray<Instance> FilterDescendantsInstances;
 	RaycastFilterType FilterType;
 	bool IgnoreWater;
 	string CollisionGroup;
@@ -251,7 +248,7 @@ struct RaycastParams {
 
 // Result of a raycast.
 struct RaycastResult {
-	Instance* Instance;
+	Instance Instance;
 	Vector3 Position;
 	Vector3 Normal;
 	double Distance;
@@ -260,7 +257,7 @@ struct RaycastResult {
 
 // Filters for GetPartBoundsInBox / GetPartsInPart.
 struct OverlapParams {
-	Instance* FilterDescendantsInstances;
+	LuaArray<Instance> FilterDescendantsInstances;
 	RaycastFilterType FilterType;
 	int MaxParts;
 	string CollisionGroup;
@@ -434,12 +431,9 @@ struct RBXScriptConnection {
 
 // Event. PlayerAdded.Connect(callback) — F matches any listener arity.
 struct RBXScriptSignal {
-	template <typename F>
-	RBXScriptConnection Connect(F callback);
-	template <typename F>
-	RBXScriptConnection Once(F callback);
-	template <typename F>
-	RBXScriptConnection ConnectParallel(F callback);
+	RBXScriptConnection Connect(func callback);
+	RBXScriptConnection Once(func callback);
+	RBXScriptConnection ConnectParallel(func callback);
 	LuauValue Wait();
 };
 
@@ -507,9 +501,41 @@ struct Secret {
 	Secret();
 };
 
-// buffer
+// Luau binary buffer. Library + type: buffer::create, buffer::writeu32, buffer::readf64.
 struct buffer {
 	buffer();
+	static buffer create(int size);
+	static buffer fromstring(string str);
+	static string tostring(buffer b);
+	static string tostring(buffer b, int offset);
+	static string tostring(buffer b, int offset, int count);
+	static int len(buffer b);
+	static void copy(buffer target, int targetOffset, buffer source);
+	static void copy(buffer target, int targetOffset, buffer source, int sourceOffset);
+	static void copy(buffer target, int targetOffset, buffer source, int sourceOffset, int count);
+	static void fill(buffer b, int offset, int value);
+	static void fill(buffer b, int offset, int value, int count);
+	static int readi8(buffer b, int offset);
+	static int readu8(buffer b, int offset);
+	static int readi16(buffer b, int offset);
+	static int readu16(buffer b, int offset);
+	static int readi32(buffer b, int offset);
+	static int readu32(buffer b, int offset);
+	static double readf32(buffer b, int offset);
+	static double readf64(buffer b, int offset);
+	static string readstring(buffer b, int offset, int count);
+	static int readbits(buffer b, int bitOffset, int bitCount);
+	static void writei8(buffer b, int offset, int value);
+	static void writeu8(buffer b, int offset, int value);
+	static void writei16(buffer b, int offset, int value);
+	static void writeu16(buffer b, int offset, int value);
+	static void writei32(buffer b, int offset, int value);
+	static void writeu32(buffer b, int offset, int value);
+	static void writef32(buffer b, int offset, double value);
+	static void writef64(buffer b, int offset, double value);
+	static void writestring(buffer b, int offset, string value);
+	static void writestring(buffer b, int offset, string value, int count);
+	static void writebits(buffer b, int bitOffset, int bitCount, int value);
 };
 
 // BinaryString