cluaupp 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.2
+
+- Watch does not write `out/` while any file fails to compile (Studio keeps the last good scripts).
+- Watch/build skip rewriting Luau whose contents did not change (a space in C++ no longer floods Rojo).
+- `libs/` is fill-only: missing files are restored, existing files are never overwritten or deleted. Fixes Rojo 7 crashing on `libs/ArrayIndexer` when watch/build raced a live serve.
+- Dropped `$optional` from `default.project.json` (Rojo 7.7 failed to deserialize it).
+
+## 0.1.1
+
+- DataService: `DataServiceOptions<T>.Template` is the required player-data table (`T` matches the save struct). Also documents `Exclude`.
+- Compiler: C++ designated initializers (`Type { .Field = value }`) emit Luau tables, so `DataService.Server:Init({ Template = ... })` type-checks and compiles.
+- Watch/build: delete orphaned `out/` files when a source is removed. Never wipe `out/` or `libs/` as a whole — Rojo 7 crashes if `libs/ArrayIndexer` disappears mid-serve. Vendor files are only created if missing; existing `libs/` is never overwritten on watch/build. Watch skips writing `out/` when compile fails, and skips rewriting Luau whose contents did not change.
+
 ## 0.1.0
 
 - Product name: **Cluaupp** (C++ × Luau)

package/docs/cli.md

@@ -31,6 +31,8 @@ Transpiles `src/**/*.{cpp,h,hpp}` into `out/`. Script files become PascalCase **
 - `.h` / `.hpp` with a sibling `.cpp` are not emitted twice
 - `new Folder(parent)` in a stats system becomes `CacheController.Ensure`
 - A parse error exits with code 1 and `file:line:column`
+- After emit, **orphans in `out/` are removed** (source deleted → matching Luau deleted). `out/` itself is never wiped, so a running Rojo serve keeps the live tree.
+- `libs/` and `include/cluaupp` are synced by writing missing/changed files only. They are **never** deleted as a folder — Rojo 7 unwrap-crashes if `libs/ArrayIndexer` vanishes while serving.
 
 ```bash
 cluaupp build
@@ -39,7 +41,7 @@ cluaupp build ./my-game
 
 ## `cluaupp watch [folder]`
 
-Runs a `build` and rebuilds when a `.cpp`, `.h`, or `.hpp` under `src/` changes. Parse errors are printed; the watcher stays alive.
+Runs a `build` and rebuilds when anything under `src/` changes, including deletes. Parse errors are printed; the watcher stays alive and **does not write `out/`** until the project compiles cleanly (Studio keeps the last good scripts). Rebuilds are debounced and do **not** recopy `libs/`. Deleted `.cpp` files prune their `out/` artifacts on the next successful compile.
 
 ## `cluaupp --version` / `cluaupp -v`
 

package/docs/libraries.md

@@ -67,7 +67,10 @@ void init() {
 	auto* coins = Net::Event("Coins");
 	coins->On(OnCoins);
 	print(FormatNumber::Abbreviate(1500));
-	DataService::Set(GetService<Players>()->GetPlayers()[0], "Currencies.Coins", 10);
+	DataService::Server.Init(DataServiceOptions {
+		.Template = { .Coins = 0 },
+		.StoreName = "PlayerData",
+	});
 	janitor->Add(coins);
 }
 ```

package/docs/syntax.md

@@ -108,6 +108,25 @@ The only `for` accepted today is **range-for**: `for (auto* x : list)`. C-style
 | `obj->Method(a)` | `obj:Method(a)` if the method is a Roblox API |
 | `fn(a)` | `fn(a)` |
 | `signal.Connect(fn)` | `signal:Connect(fn)` |
+| `Type { .Field = value }` | `{ Field = value }` |
+
+Designated initializers become Luau tables. Nested braces work the same way:
+
+```cpp
+DataService::Server.Init(DataServiceOptions {
+	.Template = playerData,
+	.StoreName = "PlayerData",
+	.UseMock = true,
+});
+```
+
+```luau
+DataService.Server:Init({
+	Template = playerData,
+	StoreName = "PlayerData",
+	UseMock = true,
+})
+```
 
 ## `new` and services
 

package/include/cluaupp/libs/dataservice.hpp

@@ -34,10 +34,13 @@ struct DataServiceEnum {
 	DataOrderList OrderList;
 };
 
+template <typename T>
 struct DataServiceOptions {
+	T Template;
 	string StoreName;
 	bool UseMock;
 	string KeyPrefix;
+	LuaArray<DataPath> Exclude;
 	bool StrictPaths;
 	bool AutoCreateMissingTables;
 };
@@ -112,7 +115,8 @@ public:
 class DataServiceServer {
 public:
 	DataPath Paths;
-	DataServiceServer* Init(DataServiceOptions options);
+	template <typename T>
+	DataServiceServer* Init(DataServiceOptions<T> options);
 	Data* WaitFor(Player* player);
 	Data* Get(Player* player);
 	bool HasData(Player* player);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cluaupp",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
 	"author": "KartzDev",
 	"license": "MIT",
@@ -29,7 +29,7 @@
 		"cluau": "node bin/cluaupp.js",
 		"build": "node bin/cluaupp.js build",
 		"watch": "node bin/cluaupp.js watch",
-		"test": "node test/leaderstats.test.js && node test/understand.test.js && node test/datatypes.test.js && node test/headers.test.js && node test/libs.test.js && node test/runtime-libs.test.js && node test/intellisense.test.js",
+		"test": "node test/leaderstats.test.js && node test/understand.test.js && node test/datatypes.test.js && node test/headers.test.js && node test/libs.test.js && node test/runtime-libs.test.js && node test/intellisense.test.js && node test/dataservice.test.js && node test/prune.test.js && node test/hold.test.js",
 		"generate-api": "node scripts/generate-api.js",
 		"check-highlight": "node scripts/check-highlight.js",
 		"vendor-libs": "node scripts/vendor-libs.js",

package/src/cli.js

@@ -34,27 +34,72 @@ function copyDir(from, to) {
 	}
 }
 
+function tryRm(target) {
+	try {
+		fs.rmSync(target, { recursive: true, force: true });
+		return true;
+	} catch (err) {
+		if (err.code === "EPERM" || err.code === "EBUSY" || err.code === "ENOTEMPTY") {
+			console.error("cluaupp: skip remove", target, `(${err.code})`);
+			return false;
+		}
+		throw err;
+	}
+}
+
+function copyFileIfChanged(src, dest, mode = "fill") {
+	if (mode === "fill" && fs.existsSync(dest)) {
+		return;
+	}
+	if (mode === "update" && fs.existsSync(dest)) {
+		const from = fs.statSync(src);
+		const to = fs.statSync(dest);
+		if (from.size === to.size && from.mtimeMs <= to.mtimeMs) {
+			return;
+		}
+	}
+	fs.mkdirSync(path.dirname(dest), { recursive: true });
+	try {
+		fs.copyFileSync(src, dest);
+	} catch (err) {
+		if (err.code === "EPERM" || err.code === "EBUSY") {
+			console.error("cluaupp: skip copy", dest, `(${err.code})`);
+			return;
+		}
+		throw err;
+	}
+}
+
+function syncDir(from, to, mode = "fill") {
+	if (!fs.existsSync(from)) {
+		return;
+	}
+	fs.mkdirSync(to, { recursive: true });
+	for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+		const src = path.join(from, entry.name);
+		const dest = path.join(to, entry.name);
+		if (entry.isDirectory()) {
+			syncDir(src, dest, mode);
+		} else {
+			copyFileIfChanged(src, dest, mode);
+		}
+	}
+}
+
 function copyRuntime(dest) {
 	const runtime = path.join(__dirname, "..", "runtime");
-	const libs = path.join(dest, "libs");
-	if (fs.existsSync(libs)) {
-		fs.rmSync(libs, { recursive: true, force: true });
-	}
-	if (fs.existsSync(runtime)) {
-		copyDir(runtime, libs);
+	if (!fs.existsSync(runtime)) {
+		return;
 	}
+	syncDir(runtime, path.join(dest, "libs"));
 }
 
 function copyHeaders(dest) {
 	const from = path.join(__dirname, "..", "include", "cluaupp");
-	const to = path.join(dest, "include", "cluaupp");
 	if (!fs.existsSync(from)) {
 		return;
 	}
-	if (fs.existsSync(to)) {
-		fs.rmSync(to, { recursive: true, force: true });
-	}
-	copyDir(from, to);
+	syncDir(from, path.join(dest, "include", "cluaupp"));
 }
 
 function loadConfig(root) {
@@ -83,6 +128,21 @@ function collectCpp(dir, files = []) {
 	return files;
 }
 
+function collectFiles(dir, files = []) {
+	if (!fs.existsSync(dir)) {
+		return files;
+	}
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			collectFiles(full, files);
+		} else {
+			files.push(full);
+		}
+	}
+	return files;
+}
+
 function siblingCpp(file) {
 	return file.replace(/\.(h|hpp|hh)$/i, ".cpp");
 }
@@ -92,29 +152,84 @@ function resolveKey(file) {
 	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 
-function build(root, options = {}) {
-	const exitOnError = options.exitOnError !== false;
-	const config = loadConfig(root);
-	copyRuntime(root);
-	copyHeaders(root);
-	const files = collectCpp(path.join(root, config.rootDir));
-	if (files.length === 0) {
-		console.error("no .cpp/.h/.hpp files in", config.rootDir);
-		if (exitOnError) {
-			process.exit(1);
+function posixRel(from, file) {
+	return path.relative(from, file).replace(/\\/g, "/");
+}
+
+function sourcePrefixes(rel) {
+	const noExt = rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, "");
+	const noTag = noExt.replace(/\.(server|client)$/i, "");
+	return [...new Set([noExt, noTag, toLuauPath(rel).replace(/\\/g, "/")])];
+}
+
+function matchesPrefix(relOut, prefixes) {
+	const n = relOut.replace(/\\/g, "/").toLowerCase();
+	return prefixes.some((prefix) => {
+		const k = prefix.replace(/\\/g, "/").toLowerCase();
+		return n === k || n === `${k}.luau` || n.startsWith(`${k}/`) || n.startsWith(`${k}.`);
+	});
+}
+
+function removeEmptyOutDirs(outDir, projectRoot) {
+	if (!fs.existsSync(outDir)) {
+		return;
+	}
+	const walk = (dir) => {
+		if (resolveKey(dir) === resolveKey(outDir)) {
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+				if (entry.isDirectory()) {
+					walk(path.join(dir, entry.name));
+				}
+			}
+			return;
+		}
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			if (entry.isDirectory()) {
+				walk(path.join(dir, entry.name));
+			}
 		}
+		if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+			if (tryRm(dir)) {
+				console.log("cluaupp: removed", path.relative(projectRoot, dir));
+			}
+		}
+	};
+	walk(outDir);
+}
+
+function pruneOut(root, config, written, failedPrefixes) {
+	const outDir = path.join(root, config.outDir);
+	if (!fs.existsSync(outDir)) {
 		return;
 	}
+	for (const file of collectFiles(outDir)) {
+		if (written.has(resolveKey(file))) {
+			continue;
+		}
+		const rel = posixRel(outDir, file);
+		if (matchesPrefix(rel, failedPrefixes)) {
+			continue;
+		}
+		if (tryRm(file)) {
+			console.log("cluaupp: removed", path.relative(root, file));
+		}
+	}
+	removeEmptyOutDirs(outDir, root);
+}
 
+function compileProject(root, config) {
+	const srcDir = path.join(root, config.rootDir);
+	const files = collectCpp(srcDir);
 	const fileSet = new Set(files.map((file) => path.resolve(file)));
-	let failed = 0;
-	const written = new Set();
+	const jobs = [];
+	const errors = [];
+
 	for (const file of files) {
 		if (isHeaderFile(file) && fileSet.has(path.resolve(siblingCpp(file)))) {
 			continue;
 		}
 		const source = fs.readFileSync(file, "utf8");
-		const rel = path.relative(path.join(root, config.rootDir), file).replace(/\\/g, "/");
+		const rel = posixRel(srcDir, file);
 		try {
 			const result = compileService(source, rel, {
 				...config,
@@ -122,30 +237,100 @@ function build(root, options = {}) {
 				relativeName: rel,
 				outName: toLuauPath(rel),
 				architecture: config.architecture !== false,
-				includeDirs: [path.dirname(file), path.join(root, config.rootDir), path.join(root, "include")],
+				includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
 			});
-			for (const artifact of result.files) {
-				const dest = path.join(root, config.outDir, artifact.name);
-				fs.mkdirSync(path.dirname(dest), { recursive: true });
-				fs.writeFileSync(dest, artifact.contents, "utf8");
-				written.add(resolveKey(dest));
-				console.log("cluaupp:", rel, "→", path.relative(root, dest));
+			jobs.push({ rel, files: result.files, stale: result.stale || [] });
+		} catch (err) {
+			errors.push({ rel, prefixes: sourcePrefixes(rel), message: err.message });
+		}
+	}
+
+	return { files, jobs, errors };
+}
+
+function writeTextIfChanged(dest, contents) {
+	if (fs.existsSync(dest) && fs.readFileSync(dest, "utf8") === contents) {
+		return false;
+	}
+	fs.mkdirSync(path.dirname(dest), { recursive: true });
+	fs.writeFileSync(dest, contents, "utf8");
+	return true;
+}
+
+function writeJobs(root, config, jobs) {
+	const written = new Set();
+	for (const job of jobs) {
+		for (const artifact of job.files) {
+			const dest = path.join(root, config.outDir, artifact.name);
+			const changed = writeTextIfChanged(dest, artifact.contents);
+			written.add(resolveKey(dest));
+			if (changed) {
+				console.log("cluaupp:", job.rel, "→", path.relative(root, dest));
 			}
-			for (const stale of result.stale || []) {
-				const dest = path.join(root, config.outDir, stale);
-				if (fs.existsSync(dest) && !written.has(resolveKey(dest))) {
-					fs.unlinkSync(dest);
+		}
+		for (const stale of job.stale) {
+			const dest = path.join(root, config.outDir, stale);
+			if (fs.existsSync(dest) && !written.has(resolveKey(dest))) {
+				if (tryRm(dest)) {
 					console.log("cluaupp: removed", path.relative(root, dest));
 				}
 			}
-		} catch (err) {
-			failed += 1;
+		}
+	}
+	return written;
+}
+
+function libsPresent(root) {
+	const libs = path.join(root, "libs");
+	return fs.existsSync(libs) && fs.readdirSync(libs).length > 0;
+}
+
+function ensureVendor(root) {
+	copyRuntime(root);
+	copyHeaders(root);
+}
+
+function build(root, options = {}) {
+	const exitOnError = options.exitOnError !== false;
+	const holdOnError = options.holdOnError === true;
+	const syncVendor = options.syncVendor === true;
+	const config = loadConfig(root);
+	if (syncVendor) {
+		copyRuntime(root);
+		copyHeaders(root);
+	} else {
+		ensureVendor(root);
+	}
+	const srcDir = path.join(root, config.rootDir);
+	if (!fs.existsSync(srcDir) || collectCpp(srcDir).length === 0) {
+		console.error("no .cpp/.h/.hpp files in", config.rootDir);
+		if (!holdOnError) {
+			pruneOut(root, config, new Set(), []);
+		}
+		if (exitOnError) {
+			process.exit(1);
+		}
+		return { failed: 0, written: new Set() };
+	}
+
+	const compiled = compileProject(root, config);
+	if (compiled.errors.length > 0) {
+		for (const err of compiled.errors) {
 			console.error(err.message);
 		}
+		if (holdOnError) {
+			console.error(`cluaupp: out not updated (${compiled.errors.length} compile error${compiled.errors.length === 1 ? "" : "s"})`);
+			return { failed: compiled.errors.length, written: new Set() };
+		}
 	}
-	if (failed > 0 && exitOnError) {
+
+	const written = writeJobs(root, config, compiled.jobs);
+	const failedPrefixes = compiled.errors.flatMap((err) => err.prefixes);
+	pruneOut(root, config, written, failedPrefixes);
+	if (compiled.errors.length > 0 && exitOnError) {
 		process.exit(1);
 	}
+	return { failed: compiled.errors.length, written };
 }
 
 function init(dest) {
@@ -160,33 +345,62 @@ function init(dest) {
 }
 
 function watch(root) {
-	build(root, { exitOnError: false });
+	build(root, { exitOnError: false, syncVendor: false, holdOnError: true });
 	const config = loadConfig(root);
 	const dir = path.join(root, config.rootDir);
-	console.log("watching", dir);
-	fs.watch(dir, { recursive: true }, (_event, filename) => {
-		if (filename && isSourceFile(filename)) {
-			try {
-				build(root, { exitOnError: false });
-			} catch (err) {
-				console.error(err.message);
+	let timer = null;
+	let running = false;
+	let queued = false;
+
+	const run = () => {
+		if (running) {
+			queued = true;
+			return;
+		}
+		running = true;
+		try {
+			build(root, { exitOnError: false, syncVendor: false, holdOnError: true });
+		} catch (err) {
+			console.error(err.message);
+		} finally {
+			running = false;
+			if (queued) {
+				queued = false;
+				run();
 			}
 		}
+	};
+
+	console.log("watching", dir);
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+	fs.watch(dir, { recursive: true }, () => {
+		clearTimeout(timer);
+		timer = setTimeout(run, 400);
 	});
 }
 
-const args = process.argv.slice(2);
-const cmd = args[0] || "help";
-const cwd = process.cwd();
+function dispatch(args) {
+	const cmd = args[0] || "help";
+	const cwd = process.cwd();
+	if (cmd === "init") {
+		init(path.resolve(cwd, args[1] || "."));
+	} else if (cmd === "build") {
+		build(path.resolve(cwd, args[1] || "."));
+	} else if (cmd === "watch") {
+		watch(path.resolve(cwd, args[1] || "."));
+	} else if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+		console.log(pkg.version);
+	} else {
+		printHelp();
+	}
+}
 
-if (cmd === "init") {
-	init(path.resolve(cwd, args[1] || "."));
-} else if (cmd === "build") {
-	build(path.resolve(cwd, args[1] || "."));
-} else if (cmd === "watch") {
-	watch(path.resolve(cwd, args[1] || "."));
-} else if (cmd === "--version" || cmd === "-v" || cmd === "version") {
-	console.log(pkg.version);
-} else {
-	printHelp();
+const launchedAsCli =
+	require.main && ["cli.js", "cluaupp.js", "cluau.js"].includes(path.basename(require.main.filename));
+if (launchedAsCli) {
+	dispatch(process.argv.slice(2));
 }
+
+module.exports = { build, watch, dispatch };

package/src/emit.js

@@ -31,6 +31,13 @@ function emit(ast, options = {}) {
 				return `"${node.value}"`;
 			case "ident":
 				return node.name;
+			case "initlist": {
+				const entries = (node.fields || []).map((field) => `${field.name} = ${emitExpr(field.value)}`);
+				if (entries.length === 0) {
+					return "{}";
+				}
+				return `{ ${entries.join(", ")} }`;
+			}
 			case "unary": {
 				const inner = emitExpr(node.argument);
 				if (node.op === "!") {

package/src/parse.js

@@ -84,6 +84,28 @@ function parse(source, fileName) {
 		return args;
 	}
 
+	function parseInitList() {
+		eat("op", "{");
+		const fields = [];
+		while (!at("op", "}") && !at("eof")) {
+			if (at("op", ".")) {
+				i += 1;
+				const name = eat("ident").value;
+				eat("op", "=");
+				fields.push({ name, value: parseExpr() });
+			} else {
+				throw error("expected designated initializer .Field = value");
+			}
+			if (at("op", ",")) {
+				i += 1;
+			} else {
+				break;
+			}
+		}
+		eat("op", "}");
+		return { type: "initlist", fields };
+	}
+
 	function parsePrimary() {
 		if (at("kw", "true") || at("kw", "false")) {
 			return { type: "bool", value: eat("kw").value === "true" };
@@ -120,6 +142,9 @@ function parse(source, fileName) {
 			eat("op", ")");
 			return expr;
 		}
+		if (at("op", "{")) {
+			return parseInitList();
+		}
 		throw error("invalid expression");
 	}
 
@@ -155,6 +180,10 @@ function parse(source, fileName) {
 				node = { type: "call", object: null, name: node.name, args: parseArgs(), access: "." };
 				continue;
 			}
+			if (at("op", "{") && (node.type === "ident" || node.type === "member")) {
+				node = parseInitList();
+				continue;
+			}
 			break;
 		}
 		return node;