cluaupp 1.4.1 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+## 1.5.0
+
+- **Flare IntelliSense** — VS Code / Cursor extension for `.flare` (highlighting, completions, hover, diagnostics, outline, snippets). `cluaupp intellisense` installs it; `cluaupp lsp` serves the same engine.
+- **Roster** constructor is `new Roster()` / `new Roster(table)` (emits Luau `Roster.new`). `Find` is array search; dictionary keys use `Has` / `Set` / `Remove`.
+- Init DataBoot builds `PlayerTemplate playerData = PlayerTemplate()` so Keep.Server.Init receives a table. Prefer CL++ **0.3.4** for nested template types and `Roster.new`.
+
 ## 1.4.1
 
 - **`cluaupp init --help`** names the 1.4.0 service tree (`ReplicatedStorage`, `ServerScriptService`, `StarterPlayer`), not `src/server` / `src/client` / `src/shared`.

package/README.md

@@ -71,7 +71,7 @@ cluaupp init [folder]
 cluaupp build [folder]
 cluaupp watch [folder]
 cluaupp language          # clpp api manifest
-cluaupp intellisense      # files.associations + clpp setup
+cluaupp intellisense      # Flare extension + clpp setup
 ```
 
 `clpp` missing? Set `CLPP` / `CLPP_PATH` or install [CL++ 0.3.2](https://github.com/KartzRbx/CLPP/releases/tag/v0.3.2).

package/editors/vscode/README.md

@@ -0,0 +1,17 @@
+# Cluaupp Flare
+
+VS Code / Cursor language support for Cluaupp `.flare` schemas.
+
+Installed by `cluaupp intellisense` into `~/.cursor/extensions` and `~/.vscode/extensions`.
+
+## Features
+
+- Syntax highlighting (`packet`, `query`, types, `from Client|Server`)
+- Completions and snippets (packet from Client/Server, query, `opt name`)
+- Hover on types, keywords, and declared packets/queries (generated `Fire` / `Invoke` API)
+- Live diagnostics from the same parser `cluaupp build` uses
+- Outline (document symbols)
+- Signature help inside `(Type name, …)`
+- Quick fix when a type is misspelled
+
+CL++ (`.clpp` / `.clp` / `.clh`) highlighting still comes from `clpp setup`.

package/editors/vscode/extension.js

@@ -4,7 +4,27 @@ const fs = require("fs");
 const path = require("path");
 const vscode = require("vscode");
 
-function loadEngine(context) {
+const KIND = {
+	keyword: vscode.CompletionItemKind.Keyword,
+	type: vscode.CompletionItemKind.TypeParameter,
+	snippet: vscode.CompletionItemKind.Snippet,
+	value: vscode.CompletionItemKind.EnumMember,
+	field: vscode.CompletionItemKind.Field,
+};
+
+const SEVERITY = {
+	error: vscode.DiagnosticSeverity.Error,
+	warning: vscode.DiagnosticSeverity.Warning,
+	hint: vscode.DiagnosticSeverity.Hint,
+};
+
+const SYMBOL = {
+	packet: vscode.SymbolKind.Event,
+	query: vscode.SymbolKind.Method,
+	option: vscode.SymbolKind.Namespace,
+};
+
+function loadLanguage(context) {
 	const folders = vscode.workspace.workspaceFolders || [];
 	const workspaceFolder = folders[0] ? folders[0].uri.fsPath : null;
 	const rootFile = path.join(context.extensionPath, "cluaupp.root");
@@ -17,55 +37,154 @@ function loadEngine(context) {
 		roots.push(path.join(workspaceFolder, "node_modules", "cluaupp"));
 	}
 	roots.push(path.join(context.extensionPath, "..", ".."));
+	roots.push(path.join(context.extensionPath, "..", "..", ".."));
 	for (const root of roots) {
-		const candidates = [
-			path.join(root, "generated", "intellisense.js"),
-			path.join(root, "src", "intellisense.js"),
-		];
-		for (const engine of candidates) {
-			if (fs.existsSync(engine)) {
-				return { engine: require(engine), root, workspaceFolder, enginePath: engine };
-			}
+		const engine = path.join(root, "generated", "flare", "language.js");
+		if (fs.existsSync(engine)) {
+			return { language: require(engine), root, enginePath: engine };
 		}
 	}
-	throw new Error("Cluaupp editor helper not found. Run `cluaupp intellisense` then `clpp install`.");
+	throw new Error("Cluaupp Flare language engine not found. Run `cluaupp intellisense` from a Cluaupp install.");
+}
+
+function isFlareDoc(document) {
+	if (!document) {
+		return false;
+	}
+	if (document.languageId === "flare") {
+		return true;
+	}
+	return document.uri.fsPath.toLowerCase().endsWith(".flare");
 }
 
 function activate(context) {
 	let loaded;
 	try {
-		loaded = loadEngine(context);
+		loaded = loadLanguage(context);
 	} catch (err) {
 		vscode.window.showWarningMessage(String(err.message || err));
 		return;
 	}
 
-	const diagnostics = vscode.languages.createDiagnosticCollection("cluaupp");
-	context.subscriptions.push(diagnostics);
+	const collection = vscode.languages.createDiagnosticCollection("flare");
+	context.subscriptions.push(collection);
+
+	const selector = [{ language: "flare", scheme: "file" }, { pattern: "**/*.flare", scheme: "file" }];
 
-	const clearCluaupp = (document) => {
-		if (!document || document.languageId !== "clpp") {
+	const refresh = (document) => {
+		if (!isFlareDoc(document)) {
 			return;
 		}
-		diagnostics.set(document.uri, []);
+		const diagnostics = loaded.language.diagnoseFlare(document.getText(), document.uri.fsPath).map((item) => {
+			const range = new vscode.Range(item.line, item.start, item.line, Math.max(item.end, item.start + 1));
+			const diagnostic = new vscode.Diagnostic(range, item.message, SEVERITY[item.severity] ?? vscode.DiagnosticSeverity.Error);
+			diagnostic.source = "flare";
+			return diagnostic;
+		});
+		collection.set(document.uri, diagnostics);
 	};
 
 	context.subscriptions.push(
-		vscode.workspace.onDidOpenTextDocument(clearCluaupp),
+		vscode.workspace.onDidOpenTextDocument(refresh),
+		vscode.workspace.onDidChangeTextDocument((event) => refresh(event.document)),
+		vscode.workspace.onDidCloseTextDocument((document) => collection.delete(document.uri)),
 		vscode.commands.registerCommand("cluaupp.restartIntelliSense", () => {
 			try {
 				delete require.cache[require.resolve(loaded.enginePath)];
-				loaded = loadEngine(context);
-				diagnostics.clear();
-				vscode.window.showInformationMessage("Cluaupp helper reloaded. Language diagnostics come from clpp install.");
+				loaded = loadLanguage(context);
+				collection.clear();
+				for (const document of vscode.workspace.textDocuments) {
+					refresh(document);
+				}
+				vscode.window.showInformationMessage("Cluaupp Flare IntelliSense reloaded.");
 			} catch (err) {
 				vscode.window.showErrorMessage(String(err.message || err));
 			}
 		}),
+		vscode.languages.registerCompletionItemProvider(
+			selector,
+			{
+				provideCompletionItems(document, position) {
+					return loaded.language.completionsAt(document.getText(), position.line, position.character).map((entry) => {
+						const item = new vscode.CompletionItem(entry.label, KIND[entry.kind]);
+						item.detail = entry.detail;
+						item.documentation = new vscode.MarkdownString(entry.documentation);
+						item.insertText = entry.snippet ? new vscode.SnippetString(entry.insertText) : entry.insertText;
+						item.sortText = entry.sortText;
+						return item;
+					});
+				},
+			},
+			" ",
+			"(",
+			",",
+			">",
+			"=",
+		),
+		vscode.languages.registerHoverProvider(selector, {
+			provideHover(document, position) {
+				const hover = loaded.language.hoverAt(document.getText(), position.line, position.character);
+				if (!hover) {
+					return null;
+				}
+				const range = new vscode.Range(position.line, hover.start, position.line, hover.end);
+				return new vscode.Hover(new vscode.MarkdownString(hover.contents), range);
+			},
+		}),
+		vscode.languages.registerDocumentSymbolProvider(selector, {
+			provideDocumentSymbols(document) {
+				return loaded.language.symbolsIn(document.getText()).map((symbol) => {
+					const range = new vscode.Range(symbol.line, 0, symbol.line, Math.max(symbol.end, 1));
+					const selection = new vscode.Range(symbol.line, symbol.start, symbol.line, Math.max(symbol.end, symbol.start + 1));
+					return new vscode.DocumentSymbol(symbol.name, symbol.detail, SYMBOL[symbol.kind], range, selection);
+				});
+			},
+		}),
+		vscode.languages.registerSignatureHelpProvider(
+			selector,
+			{
+				provideSignatureHelp(document, position) {
+					const signature = loaded.language.signatureAt(document.getText(), position.line, position.character);
+					if (!signature) {
+						return null;
+					}
+					const help = new vscode.SignatureHelp();
+					const info = new vscode.SignatureInformation(signature.label, signature.documentation);
+					info.parameters = signature.parameters.map(
+						(parameter) => new vscode.ParameterInformation(parameter.label, parameter.documentation),
+					);
+					help.signatures = [info];
+					help.activeSignature = 0;
+					help.activeParameter = signature.activeParameter;
+					return help;
+				},
+			},
+			"(",
+			",",
+		),
+		vscode.languages.registerCodeActionsProvider(selector, {
+			provideCodeActions(document, _range, actionContext) {
+				const actions = [];
+				for (const diagnostic of actionContext.diagnostics) {
+					const match = String(diagnostic.message).match(/did you mean '([^']+)'/);
+					if (!match) {
+						continue;
+					}
+					const edit = new vscode.WorkspaceEdit();
+					edit.replace(document.uri, diagnostic.range, match[1]);
+					const action = new vscode.CodeAction(`Replace with ${match[1]}`, vscode.CodeActionKind.QuickFix);
+					action.diagnostics = [diagnostic];
+					action.edit = edit;
+					action.isPreferred = true;
+					actions.push(action);
+				}
+				return actions;
+			},
+		}),
 	);
 
 	for (const document of vscode.workspace.textDocuments) {
-		clearCluaupp(document);
+		refresh(document);
 	}
 }
 

package/editors/vscode/icons/flare.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="6" fill="#0F766E"/>
+  <path d="M8 22 L16 8 L24 22 Z" fill="none" stroke="#ECFDF5" stroke-width="2.2" stroke-linejoin="round"/>
+  <circle cx="16" cy="16" r="2.2" fill="#99F6E4"/>
+</svg>

package/editors/vscode/language-configuration.json

@@ -0,0 +1,21 @@
+{
+	"comments": {
+		"lineComment": "//"
+	},
+	"brackets": [
+		["(", ")"]
+	],
+	"autoClosingPairs": [
+		{ "open": "(", "close": ")" },
+		{ "open": "\"", "close": "\"" }
+	],
+	"surroundingPairs": [
+		["(", ")"],
+		["\"", "\""]
+	],
+	"wordPattern": "[A-Za-z_][A-Za-z0-9_]*",
+	"indentationRules": {
+		"increaseIndentPattern": "^\\s*(packet|query)\\b.*\\([^)]*$",
+		"decreaseIndentPattern": "^\\s*\\)"
+	}
+}

package/editors/vscode/package.json

@@ -1,25 +1,79 @@
 {
-	"name": "cluaupp-diagnostics",
-	"displayName": "Cluaupp",
-	"description": "Cluaupp project diagnostics. Language highlighting and IntelliSense come from clpp install (CL++).",
-	"version": "1.4.0",
+	"name": "cluaupp-flare",
+	"displayName": "Cluaupp Flare",
+	"description": "IntelliSense for Cluaupp .flare network schemas: highlighting, completions, hover, diagnostics, outline, and snippets.",
+	"version": "1.5.0",
 	"publisher": "kartzdev",
 	"engines": {
 		"vscode": "^1.74.0"
 	},
 	"categories": [
+		"Programming Languages",
+		"Snippets",
 		"Linters"
 	],
+	"keywords": [
+		"flare",
+		"cluaupp",
+		"roblox",
+		"clpp"
+	],
 	"activationEvents": [
-		"onLanguage:clpp"
+		"onLanguage:flare",
+		"workspaceContains:**/*.flare"
 	],
 	"main": "./extension.js",
 	"contributes": {
+		"languages": [
+			{
+				"id": "flare",
+				"aliases": [
+					"Flare",
+					"flare"
+				],
+				"extensions": [
+					".flare"
+				],
+				"configuration": "./language-configuration.json",
+				"icon": {
+					"light": "./icons/flare.svg",
+					"dark": "./icons/flare.svg"
+				}
+			}
+		],
+		"grammars": [
+			{
+				"language": "flare",
+				"scopeName": "source.flare",
+				"path": "./syntaxes/flare.tmLanguage.json"
+			}
+		],
+		"snippets": [
+			{
+				"language": "flare",
+				"path": "./snippets/flare.json"
+			}
+		],
 		"commands": [
 			{
 				"command": "cluaupp.restartIntelliSense",
-				"title": "Cluaupp: Reload editor helper"
+				"title": "Cluaupp: Reload Flare IntelliSense"
+			}
+		],
+		"configurationDefaults": {
+			"files.associations": {
+				"*.flare": "flare"
+			},
+			"[flare]": {
+				"editor.quickSuggestions": {
+					"other": true,
+					"comments": false,
+					"strings": false
+				},
+				"editor.suggest.insertMode": "replace",
+				"editor.tabCompletion": "on",
+				"editor.wordBasedSuggestions": false
 			}
-		]
+		}
 	}
 }

package/editors/vscode/snippets/flare.json

@@ -0,0 +1,27 @@
+{
+	"Packet from Client": {
+		"prefix": ["packetc", "packet"],
+		"body": "packet ${1:Hit}(${2:Player} ${3:target}, ${4:i32} ${5:damage}) from Client",
+		"description": "Client → server packet (FireServer / Connect with Player first)"
+	},
+	"Packet from Server": {
+		"prefix": "packets",
+		"body": "packet ${1:Welcome}(${2:i32} ${3:userId}, ${4:f64} ${5:clock}) from Server",
+		"description": "Server → client packet (Fire recipient first, then schema fields)"
+	},
+	"Packet unreliable": {
+		"prefix": "packetu",
+		"body": "packet ${1:Spark}(${2:Vector3} ${3:pos}) from Server unreliable",
+		"description": "Unreliable server packet — visuals, not economy"
+	},
+	"Query RPC": {
+		"prefix": "query",
+		"body": "query ${1:Session}() -> ${2:i32}",
+		"description": "RPC query (Invoke / On, server must return)"
+	},
+	"opt name": {
+		"prefix": "opt",
+		"body": "opt name = ${1:Net}",
+		"description": "Generated module name (Net.clh / Net.Hit)"
+	}
+}

package/editors/vscode/syntaxes/flare.tmLanguage.json

@@ -0,0 +1,75 @@
+{
+	"$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+	"name": "Flare",
+	"scopeName": "source.flare",
+	"patterns": [
+		{ "include": "#comments" },
+		{ "include": "#strings" },
+		{ "include": "#keywords" },
+		{ "include": "#types" },
+		{ "include": "#operators" },
+		{ "include": "#names" }
+	],
+	"repository": {
+		"comments": {
+			"patterns": [
+				{
+					"name": "comment.line.double-slash.flare",
+					"match": "//.*$"
+				},
+				{
+					"name": "comment.line.number-sign.flare",
+					"match": "#.*$"
+				}
+			]
+		},
+		"strings": {
+			"name": "string.quoted.double.flare",
+			"begin": "\"",
+			"end": "\""
+		},
+		"keywords": {
+			"patterns": [
+				{
+					"name": "keyword.declaration.flare",
+					"match": "\\b(packet|query|opt)\\b"
+				},
+				{
+					"name": "keyword.other.flare",
+					"match": "\\b(from|name)\\b"
+				},
+				{
+					"name": "constant.language.flare",
+					"match": "\\b(Client|Server)\\b"
+				},
+				{
+					"name": "storage.modifier.flare",
+					"match": "\\b(unreliable|reliable)\\b"
+				}
+			]
+		},
+		"types": {
+			"name": "storage.type.flare",
+			"match": "\\b(u8|u16|u32|i8|i16|i32|int|f32|f64|float|double|number|bool|boolean|string|Vector3|Vector2|CFrame|Color3|UDim|UDim2|BrickColor|buffer|Instance|Player)\\b"
+		},
+		"operators": {
+			"patterns": [
+				{
+					"name": "keyword.operator.arrow.flare",
+					"match": "->"
+				},
+				{
+					"name": "keyword.operator.assignment.flare",
+					"match": "="
+				}
+			]
+		},
+		"names": {
+			"match": "\\b(packet|query)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+			"captures": {
+				"1": { "name": "keyword.declaration.flare" },
+				"2": { "name": "entity.name.function.flare" }
+			}
+		}
+	}
+}

package/examples/game/.vscode/extensions.json

@@ -2,5 +2,7 @@
 	"unwantedRecommendations": [
 		"ms-vscode.cpptools"
 	],
-	"recommendations": []
+	"recommendations": [
+		"kartzdev.cluaupp-flare"
+	]
 }

package/examples/game/.vscode/settings.json

@@ -5,6 +5,7 @@
 		"*.clh": "clpp",
 		"*.server.clpp": "clpp",
 		"*.client.clpp": "clpp",
-		"*.plugin.clpp": "clpp"
+		"*.plugin.clpp": "clpp",
+		"*.flare": "flare"
 	}
 }

package/examples/game/include/clpp/libs/roster.clh

@@ -5,7 +5,10 @@
 // Table = u16 count + key/value pairs. Array = u16 len + values. Methods also work as Roster::X(rawTable).
 
 struct Roster {
+	// Construct with `new Roster()` / `new Roster(table)` — emits Luau Roster.new.
+	// `New` is the CL++ name because `new` is a keyword.
 	static Roster New();
+	static Roster New(auto initial);
 
 	int Size();
 	int Length();
@@ -13,6 +16,7 @@ struct Roster {
 	auto GetData();
 
 	auto At(int index);
+	// Array value search (1-based index). Dictionary keys: Has / Get / Set / Remove.
 	int Find(auto value);
 	int Find(auto value, int initPos);
 	int Find(auto value, int initPos, int maxPos);
@@ -23,6 +27,7 @@ struct Roster {
 	auto Shift();
 	int Unshift(auto value);
 	auto RemoveAt(int index);
+	Roster Remove(auto key);
 
 	Roster Map(func mapper);
 	Roster Filter(func predicate);
@@ -74,6 +79,7 @@ struct Roster {
 	static auto Shift(auto data);
 	static int Unshift(auto data, auto value);
 	static auto RemoveAt(auto data, int index);
+	static Roster Remove(auto data, auto key);
 	static Roster Map(auto data, func mapper);
 	static Roster Filter(auto data, func predicate);
 	static auto Reduce(auto data, func reducer, auto initial);

package/examples/game/src/ReplicatedStorage/Shared/Net/Net.flare

@@ -0,0 +1,5 @@
+opt name = Net
+
+packet Ready() from Client
+packet Welcome(i32 userId, f64 clock) from Server
+query Session() -> i32

package/examples/game/src/ServerScriptService/Boot/DataBoot.server.clpp

@@ -4,7 +4,7 @@
 #include "../../ReplicatedStorage/Shared/Constants/Datas/TemplateData.clh"
 
 void init() {
-	PlayerTemplate playerData;
+	PlayerTemplate playerData = PlayerTemplate();
 	Keep.Server.Init(DataServiceOptions {
 		.Template = playerData,
 		.StoreName = "PlayerData",

package/generated/cli.js

@@ -93,7 +93,7 @@ program
 });
 program
     .command("lsp")
-    .description("Language server stdio (JSON-RPC). Use `clpp install` for CL++ IntelliSense.")
+    .description("Language server stdio — Flare `.flare` IntelliSense. CL++ still uses `clpp setup`.")
     .argument("[folder]", "project folder", ".")
     .action((folder) => {
     (0, lsp_js_1.start)({ projectRoot: node_path_1.default.resolve(process.cwd(), folder) });
@@ -101,7 +101,7 @@ program
 program
     .command("intellisense")
     .alias("intelisense")
-    .description("Point the editor at CL++ (`clpp install`)")
+    .description("Install Flare IntelliSense and point CL++ at `clpp setup`")
     .argument("[folder]", "project folder", ".")
     .action(async (folder) => {
     try {

package/generated/flare/index.js

@@ -3,7 +3,7 @@ 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.FLARE_TYPE_DOCS = exports.FLARE_CANONICAL_TYPES = exports.symbolsIn = exports.signatureAt = exports.isFlareDocument = exports.hoverAt = exports.diagnoseFlare = exports.completionsAt = exports.analyzeFlare = exports.FLARE_IDENT = exports.FLARE_TYPE_ALIASES = exports.parseFlare = exports.emitFlareLuau = exports.emitFlareHeader = exports.emitFlare = void 0;
 exports.isFlareFile = isFlareFile;
 exports.isGeneratedHeader = isGeneratedHeader;
 exports.collectFlareFiles = collectFlareFiles;
@@ -12,12 +12,24 @@ 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; } });
+var parse_js_2 = require("./parse.js");
+Object.defineProperty(exports, "parseFlare", { enumerable: true, get: function () { return parse_js_2.parseFlare; } });
+Object.defineProperty(exports, "FLARE_TYPE_ALIASES", { enumerable: true, get: function () { return parse_js_2.FLARE_TYPE_ALIASES; } });
+Object.defineProperty(exports, "FLARE_IDENT", { enumerable: true, get: function () { return parse_js_2.FLARE_IDENT; } });
+var language_js_1 = require("./language.js");
+Object.defineProperty(exports, "analyzeFlare", { enumerable: true, get: function () { return language_js_1.analyzeFlare; } });
+Object.defineProperty(exports, "completionsAt", { enumerable: true, get: function () { return language_js_1.completionsAt; } });
+Object.defineProperty(exports, "diagnoseFlare", { enumerable: true, get: function () { return language_js_1.diagnoseFlare; } });
+Object.defineProperty(exports, "hoverAt", { enumerable: true, get: function () { return language_js_1.hoverAt; } });
+Object.defineProperty(exports, "isFlareDocument", { enumerable: true, get: function () { return language_js_1.isFlareDocument; } });
+Object.defineProperty(exports, "signatureAt", { enumerable: true, get: function () { return language_js_1.signatureAt; } });
+Object.defineProperty(exports, "symbolsIn", { enumerable: true, get: function () { return language_js_1.symbolsIn; } });
+Object.defineProperty(exports, "FLARE_CANONICAL_TYPES", { enumerable: true, get: function () { return language_js_1.FLARE_CANONICAL_TYPES; } });
+Object.defineProperty(exports, "FLARE_TYPE_DOCS", { enumerable: true, get: function () { return language_js_1.FLARE_TYPE_DOCS; } });
 function isFlareFile(fileName) {
     return node_path_1.default.extname(fileName).toLowerCase() === ".flare";
 }