cluaupp 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 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/header sync only writes missing/changed files (no `rmSync` of `libs/`). Watch rebuilds skip recopying `libs/`. `default.project.json` marks `out/*`, `libs`, and `Packages` as `$optional`.
+
 ## 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. Rebuilds are debounced and do **not** recopy `libs/` (Rojo is likely already serving those files). Deleted `.cpp` files prune their `out/` artifacts on the next tick.
 
 ## `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.1",
 	"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",
 		"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,69 @@ 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) {
+	if (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) {
+	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);
+		} else {
+			copyFileIfChanged(src, dest);
+		}
+	}
+}
+
 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 +125,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 +149,100 @@ function resolveKey(file) {
 	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 
+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 build(root, options = {}) {
 	const exitOnError = options.exitOnError !== false;
+	const syncVendor = options.syncVendor !== false;
 	const config = loadConfig(root);
-	copyRuntime(root);
-	copyHeaders(root);
-	const files = collectCpp(path.join(root, config.rootDir));
+	if (syncVendor) {
+		copyRuntime(root);
+		copyHeaders(root);
+	}
+	const srcDir = path.join(root, config.rootDir);
+	const files = collectCpp(srcDir);
 	if (files.length === 0) {
 		console.error("no .cpp/.h/.hpp files in", config.rootDir);
+		pruneOut(root, config, new Set(), []);
 		if (exitOnError) {
 			process.exit(1);
 		}
-		return;
+		return { failed: 0, written: new Set() };
 	}
 
 	const fileSet = new Set(files.map((file) => path.resolve(file)));
 	let failed = 0;
 	const written = new Set();
+	const failedPrefixes = [];
 	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,7 +250,7 @@ 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);
@@ -134,18 +262,22 @@ function build(root, options = {}) {
 			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);
-					console.log("cluaupp: removed", path.relative(root, dest));
+					if (tryRm(dest)) {
+						console.log("cluaupp: removed", path.relative(root, dest));
+					}
 				}
 			}
 		} catch (err) {
 			failed += 1;
+			failedPrefixes.push(...sourcePrefixes(rel));
 			console.error(err.message);
 		}
 	}
+	pruneOut(root, config, written, failedPrefixes);
 	if (failed > 0 && exitOnError) {
 		process.exit(1);
 	}
+	return { failed, written };
 }
 
 function init(dest) {
@@ -160,18 +292,39 @@ function init(dest) {
 }
 
 function watch(root) {
-	build(root, { exitOnError: false });
+	build(root, { exitOnError: false, syncVendor: 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 });
+		} 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, 200);
 	});
 }
 
@@ -190,3 +343,5 @@ if (cmd === "init") {
 } else {
 	printHelp();
 }
+
+module.exports = { build, watch };

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;

package/templates/game/default.project.json

@@ -5,19 +5,23 @@
 		"ServerScriptService": {
 			"$className": "ServerScriptService",
 			"Cluaupp": {
-				"$path": "out/server"
+				"$path": "out/server",
+				"$optional": true
 			}
 		},
 		"ReplicatedStorage": {
 			"$className": "ReplicatedStorage",
 			"Cluaupp": {
-				"$path": "out/shared"
+				"$path": "out/shared",
+				"$optional": true
 			},
 			"CluauppLibs": {
-				"$path": "libs"
+				"$path": "libs",
+				"$optional": true
 			},
 			"Packages": {
-				"$path": "Packages"
+				"$path": "Packages",
+				"$optional": true
 			}
 		},
 		"StarterPlayer": {
@@ -25,7 +29,8 @@
 			"StarterPlayerScripts": {
 				"$className": "StarterPlayerScripts",
 				"Cluaupp": {
-					"$path": "out/client"
+					"$path": "out/client",
+					"$optional": true
 				}
 			}
 		},