cluaupp 0.1.4 → 0.2.0

package/src/{layout.js → layout.ts}

@@ -1,129 +1,114 @@
-"use strict";
-
-const SECTION = {
-	api: "API",
-	constants: "CONSTANTES",
-	variables: "VARIAVEIS",
-	types: "TIPAGENS",
-	support: "FUNÇÕES DE SUPORTE",
-	principal: "FUNÇÕES PRINCIPAIS",
-	cleanup: "LIMPEZA",
-	returns: "RETORNO",
-};
-
-const CLEANUP_FN = /^(OnClose|OnPlayerRemoving|Cleanup|Shutdown|OnDestroy)$/i;
-const PRINCIPAL_FN = /^(init|start|main|setup)/i;
-const ENTRY_FN = /^(init|main)$/i;
-
-function isGetService(node) {
-	return Boolean(node && node.type === "getService");
-}
-
-function isDataServiceAlias(node) {
-	let current = node;
-	while (current && current.type === "member") {
-		if (current.object && current.object.type === "ident" && current.object.name === "DataService") {
-			return true;
-		}
-		current = current.object;
-	}
-	return false;
-}
-
-function isJanitorDecl(decl) {
-	if (!decl || decl.type !== "decl") {
-		return false;
-	}
-	const name = String(decl.name || "").toLowerCase();
-	const typeName = String(decl.valueType || "").toLowerCase();
-	const created = decl.value && decl.value.type === "new" && decl.value.className === "Janitor";
-	return name.includes("janitor") || typeName.includes("janitor") || created;
-}
-
-function isApiDecl(decl) {
-	if (!decl || decl.type !== "decl") {
-		return false;
-	}
-	return isGetService(decl.value) || isDataServiceAlias(decl.value);
-}
-
-function classifyDecl(decl) {
-	if (!decl || decl.type === "proto") {
-		return null;
-	}
-	if (decl.type === "decl") {
-		if (isApiDecl(decl)) {
-			return "api";
-		}
-		if (isJanitorDecl(decl)) {
-			return "variables";
-		}
-		if (decl.isConst) {
-			return "constants";
-		}
-		return "variables";
-	}
-	if (decl.type === "function") {
-		if (CLEANUP_FN.test(decl.name || "")) {
-			return "cleanup";
-		}
-		if (PRINCIPAL_FN.test(decl.name || "")) {
-			return "principal";
-		}
-		return "support";
-	}
-	return null;
-}
-
-function organizeDecls(keep) {
-	const groups = {
-		api: [],
-		constants: [],
-		variables: [],
-		support: [],
-		principal: [],
-		cleanup: [],
-	};
-	for (const decl of keep) {
-		const bucket = classifyDecl(decl);
-		if (bucket && groups[bucket]) {
-			groups[bucket].push(decl);
-		}
-	}
-	return groups;
-}
-
-function janitorNames(keep) {
-	return (keep || []).filter(isJanitorDecl).map((decl) => decl.name);
-}
-
-function emitSection(_title, body) {
-	const text = String(body || "").trimEnd();
-	if (!text) {
-		return "";
-	}
-	return `${text}\n\n`;
-}
-
-function joinBlocks(parts) {
-	return parts.filter((part) => Boolean(part && String(part).trim())).join("\n\n");
-}
-
-function commentLine(title) {
-	return `-- ${title}`;
-}
-
-module.exports = {
-	SECTION,
-	CLEANUP_FN,
-	PRINCIPAL_FN,
-	ENTRY_FN,
-	isJanitorDecl,
-	isApiDecl,
-	classifyDecl,
-	organizeDecls,
-	janitorNames,
-	emitSection,
-	joinBlocks,
-	commentLine,
-};
+import type { AstNode } from "./ast.js";
+
+export const SECTION = {
+	api: "API",
+	constants: "CONSTANTS",
+	variables: "VARIABLES",
+	types: "TYPES",
+	support: "HELPERS FUNCTIONS",
+	principal: "MAIN FUNCTIONS",
+	cleanup: "JANITOR",
+	returns: "RETURN",
+};
+
+export const CLEANUP_FN = /^(OnClose|OnPlayerRemoving|Cleanup|Shutdown|OnDestroy)$/i;
+export const PRINCIPAL_FN = /^(init|start|main|setup)/i;
+export const ENTRY_FN = /^(init|main)$/i;
+
+function isGetService(node: AstNode | null | undefined): boolean {
+	return Boolean(node && node.type === "getService");
+}
+
+function isDataServiceAlias(node: AstNode | null | undefined): boolean {
+	let current: AstNode | undefined = node || undefined;
+	while (current && current.type === "member") {
+		if (current.object && current.object.type === "ident" && current.object.name === "DataService") {
+			return true;
+		}
+		current = current.object;
+	}
+	return false;
+}
+
+export function isJanitorDecl(decl: AstNode | null | undefined): boolean {
+	if (!decl || decl.type !== "decl") {
+		return false;
+	}
+	const name = String(decl.name || "").toLowerCase();
+	const typeName = String(decl.valueType || "").toLowerCase();
+	const created = decl.value && decl.value.type === "new" && decl.value.className === "Janitor";
+	return name.includes("janitor") || typeName.includes("janitor") || created;
+}
+
+export function isApiDecl(decl: AstNode | null | undefined): boolean {
+	if (!decl || decl.type !== "decl") {
+		return false;
+	}
+	return isGetService(decl.value) || isDataServiceAlias(decl.value);
+}
+
+export function classifyDecl(decl: AstNode | null | undefined): string | null {
+	if (!decl || decl.type === "proto") {
+		return null;
+	}
+	if (decl.type === "decl") {
+		if (isApiDecl(decl)) {
+			return "api";
+		}
+		if (isJanitorDecl(decl)) {
+			return "variables";
+		}
+		if (decl.isConst) {
+			return "constants";
+		}
+		return "variables";
+	}
+	if (decl.type === "function") {
+		if (CLEANUP_FN.test(decl.name || "")) {
+			return "cleanup";
+		}
+		if (PRINCIPAL_FN.test(decl.name || "")) {
+			return "principal";
+		}
+		return "support";
+	}
+	return null;
+}
+
+export function organizeDecls(keep: AstNode[]): Record<string, AstNode[]> {
+	const groups: Record<string, AstNode[]> = {
+		api: [],
+		constants: [],
+		variables: [],
+		support: [],
+		principal: [],
+		cleanup: [],
+	};
+	for (const decl of keep) {
+		const bucket = classifyDecl(decl);
+		if (bucket && groups[bucket]) {
+			groups[bucket].push(decl);
+		}
+	}
+	return groups;
+}
+
+export function janitorNames(keep: AstNode[] | null | undefined): string[] {
+	return (keep || []).filter(isJanitorDecl).map((decl) => decl.name);
+}
+
+export function emitSection(_title: string, body: string): string {
+	const text = String(body || "").trimEnd();
+	if (!text) {
+		return "";
+	}
+	return `${text}\n\n`;
+}
+
+export function joinBlocks(parts: Array<string | null | undefined>): string {
+	return parts.filter((part) => Boolean(part && String(part).trim())).join("\n\n");
+}
+
+export function commentLine(title: string): string {
+	return `-- ${title}`;
+}

package/src/{lex.js → lex.ts}

@@ -1,4 +1,4 @@
-"use strict";
+import type { Token } from "./ast.js";
 
 const KEYWORDS = new Set([
 	"if",
@@ -34,13 +34,13 @@ const KEYWORDS = new Set([
 	"break",
 ]);
 
-function tokenize(source) {
-	const tokens = [];
+export function tokenize(source: string): Token[] {
+	const tokens: Token[] = [];
 	let i = 0;
 	let line = 1;
 	let col = 1;
 
-	const push = (type, value, startLine, startCol, start, end) => {
+	const push = (type: string, value: string, startLine: number, startCol: number, start: number, end: number) => {
 		tokens.push({ type, value, line: startLine, col: startCol, start, end });
 	};
 
@@ -153,5 +153,3 @@ function tokenize(source) {
 	push("eof", "", line, col, source.length, source.length);
 	return tokens;
 }
-
-module.exports = { tokenize };

package/src/{libs.js → libs.ts}

@@ -1,6 +1,5 @@
-"use strict";
-
-const path = require("path");
+// @ts-nocheck
+import path from "node:path";
 
 const TYPE_EXPORTS = {
 	Janitor: "Janitor",
@@ -299,17 +298,64 @@ function collectLibraries(source, ast) {
 	return unique;
 }
 
+const ROJO_ROOTS = {
+	shared: { service: "ReplicatedStorage", expr: "ReplicatedStorage.Cluaupp" },
+	server: { service: "ServerScriptService", expr: "ServerScriptService.Cluaupp" },
+	client: { service: "StarterPlayer", expr: "StarterPlayer.StarterPlayerScripts.Cluaupp" },
+};
+
+const SERVICE_ORDER = ["ReplicatedStorage", "ServerScriptService", "StarterPlayer"];
+
+const SERVICE_GET = {
+	ReplicatedStorage: 'const ReplicatedStorage = game:GetService("ReplicatedStorage")',
+	ServerScriptService: 'const ServerScriptService = game:GetService("ServerScriptService")',
+	StarterPlayer: 'const StarterPlayer = game:GetService("StarterPlayer")',
+};
+
 function requireCluauppLib(name) {
 	return `require(ReplicatedStorage.CluauppLibs.${name})`;
 }
 
-function emitRequireParts(libraries) {
+function parseOutRel(toOutRel) {
+	const posix = String(toOutRel || "module.luau")
+		.replace(/\\/g, "/")
+		.replace(/\.luau$/i, "");
+	const parts = posix.split("/").filter(Boolean);
+	const tree = parts[0];
+	const root = ROJO_ROOTS[tree] || null;
+	const rest = root ? parts.slice(1) : parts;
+	return { tree, root, rest, posix };
+}
+
+function robloxRequireFrom(_fromOutRel, toOutRel) {
+	const { root, rest } = parseOutRel(toOutRel);
+	if (root) {
+		const tail = rest.join(".");
+		return tail ? `require(${root.expr}.${tail})` : `require(${root.expr})`;
+	}
+	const fromDir = path.posix.dirname(String(_fromOutRel || "module.luau").replace(/\\/g, "/"));
+	const toMod = String(toOutRel || "module.luau")
+		.replace(/\\/g, "/")
+		.replace(/\.luau$/i, "");
+	let rel = path.posix.relative(fromDir, toMod);
+	if (!rel || rel === ".") {
+		rel = path.posix.basename(toMod);
+	}
+	const parts = rel.split("/");
+	let expr = "script.Parent";
+	for (const part of parts) {
+		if (part === "..") {
+			expr += ".Parent";
+		} else if (part && part !== ".") {
+			expr += `.${part}`;
+		}
+	}
+	return `require(${expr})`;
+}
+
+function emitLibraryLines(libraries) {
 	const api = [];
 	const types = [];
-	if (!libraries.length) {
-		return { api: "", types: "" };
-	}
-	api.push('const ReplicatedStorage = game:GetService("ReplicatedStorage")');
 	for (const spec of libraries) {
 		api.push(`const ${spec.bind} = ${requireCluauppLib(spec.file)}`);
 		const exported = TYPE_EXPORTS[spec.bind];
@@ -323,6 +369,15 @@ function emitRequireParts(libraries) {
 			}
 		}
 	}
+	return { api, types };
+}
+
+function emitRequireParts(libraries) {
+	if (!libraries.length) {
+		return { api: "", types: "" };
+	}
+	const { api, types } = emitLibraryLines(libraries);
+	api.unshift(SERVICE_GET.ReplicatedStorage);
 	return {
 		api: `${api.join("\n")}\n`,
 		types: types.length ? `${types.join("\n")}\n` : "",
@@ -339,34 +394,7 @@ function insertRequires(luau, libraries) {
 	if (!block) {
 		return luau;
 	}
-	const match = String(luau).match(/^(?:--[^\n]*\n)+/);
-	if (!match) {
-		return `${block}\n${luau}`;
-	}
-	const insertAt = match[0].length;
-	const rest = luau.slice(insertAt).replace(/^\n*/, "\n");
-	return `${luau.slice(0, insertAt)}\n${block}\n${rest}`;
-}
-
-function robloxRequireFrom(fromOutRel, toOutRel) {
-	const fromDir = path.posix.dirname(String(fromOutRel || "module.luau").replace(/\\/g, "/"));
-	const toMod = String(toOutRel || "module.luau")
-		.replace(/\\/g, "/")
-		.replace(/\.luau$/i, "");
-	let rel = path.posix.relative(fromDir, toMod);
-	if (!rel || rel === ".") {
-		rel = path.posix.basename(toMod);
-	}
-	const parts = rel.split("/");
-	let expr = "script.Parent";
-	for (const part of parts) {
-		if (part === "..") {
-			expr += ".Parent";
-		} else if (part && part !== ".") {
-			expr += `.${part}`;
-		}
-	}
-	return `require(${expr})`;
+	return insertBlock(luau, block);
 }
 
 function moduleIsUsed(luau, spec) {
@@ -377,13 +405,11 @@ function moduleIsUsed(luau, spec) {
 	return exported.some((name) => String(luau).includes(name));
 }
 
-function insertModuleRequires(luau, modules, fromOutRel) {
-	if (!modules || modules.length === 0) {
-		return luau;
-	}
+function moduleRequireLines(modules, fromOutRel, luau) {
 	const lines = [];
+	const services = new Set();
 	const seen = new Set();
-	for (const spec of modules) {
+	for (const spec of modules || []) {
 		if (!spec || !spec.name || seen.has(spec.name)) {
 			continue;
 		}
@@ -391,20 +417,65 @@ function insertModuleRequires(luau, modules, fromOutRel) {
 			continue;
 		}
 		seen.add(spec.name);
+		const { root } = parseOutRel(spec.outRel);
+		if (root) {
+			services.add(root.service);
+		}
 		lines.push(`const ${spec.name} = ${robloxRequireFrom(fromOutRel, spec.outRel)}`);
 		for (const name of (spec.exports && spec.exports.consts) || []) {
 			if (name !== spec.name) {
 				lines.push(`const ${name} = ${spec.name}.${name}`);
 			}
 		}
-		if ((spec.exports && spec.exports.structs || []).includes(spec.name) && !spec.impl) {
-			lines.push(`type ${spec.name} = typeof(${spec.name}())`);
+		if (((spec.exports && spec.exports.structs) || []).includes(spec.name) || (spec.exports && spec.exports.hasProtos)) {
+			lines.push(`type ${spec.name} = ${spec.name}.${spec.name}`);
 		}
 	}
-	if (lines.length === 0) {
+	return { lines, services };
+}
+
+function insertModuleRequires(luau, modules, fromOutRel) {
+	return insertPreamble(luau, modules, [], fromOutRel);
+}
+
+function stripServiceGets(luau, services) {
+	let next = String(luau);
+	for (const name of services) {
+		const line = SERVICE_GET[name];
+		if (!line) {
+			continue;
+		}
+		next = next.replace(new RegExp(`^${line.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "m"), "");
+	}
+	return next;
+}
+
+function insertPreamble(luau, modules, libraries, fromOutRel) {
+	const text = String(luau || "");
+	const trimmed = text.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[") || /\.json$/i.test(String(fromOutRel || ""))) {
 		return luau;
 	}
-	return insertBlock(luau, lines.join("\n"));
+	const { lines: moduleLines, services } = moduleRequireLines(modules, fromOutRel, luau);
+	const libList = libraries || [];
+	if (libList.length) {
+		services.add("ReplicatedStorage");
+	}
+	if (moduleLines.length === 0 && libList.length === 0) {
+		return luau;
+	}
+	const { api: libApi, types: libTypes } = emitLibraryLines(libList);
+	const blockLines = [];
+	for (const name of SERVICE_ORDER) {
+		if (services.has(name)) {
+			blockLines.push(SERVICE_GET[name]);
+		}
+	}
+	blockLines.push(...moduleLines);
+	blockLines.push(...libApi);
+	blockLines.push(...libTypes);
+	const body = stripServiceGets(luau, services);
+	return insertBlock(body, blockLines.join("\n"));
 }
 
 function insertBlock(luau, block) {
@@ -417,8 +488,9 @@ function insertBlock(luau, block) {
 	return `${luau.slice(0, insertAt)}\n${block}\n${rest}`;
 }
 
-module.exports = {
+export {
 	MODULES,
+	INCLUDE_TO_MODULE,
 	TYPE_EXPORTS,
 	EXTRA_TYPE_EXPORTS,
 	LIBRARY_TYPES,
@@ -431,4 +503,5 @@ module.exports = {
 	emitRequires,
 	insertRequires,
 	insertModuleRequires,
+	insertPreamble,
 };

package/src/lsp.ts

@@ -0,0 +1,60 @@
+import path from "node:path";
+import {
+	createConnection,
+	ProposedFeatures,
+	TextDocuments,
+	TextDocumentSyncKind,
+} from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { diagnosticsFor } from "./intellisense.js";
+import { pkg } from "./package-info.js";
+
+function uriPath(uri: string): string {
+	let file = String(uri || "").replace(/^file:\/\//, "");
+	if (/^\/[A-Za-z]:/.test(file)) {
+		file = file.slice(1);
+	}
+	return decodeURIComponent(file);
+}
+
+export function start(options: { projectRoot?: string } = {}): void {
+	const projectRoot = options.projectRoot || process.cwd();
+	const connection = createConnection(ProposedFeatures.all);
+	const documents = new TextDocuments(TextDocument);
+
+	connection.onInitialize(() => ({
+		capabilities: {
+			textDocumentSync: TextDocumentSyncKind.Full,
+		},
+		serverInfo: { name: "cluaupp", version: pkg.version },
+	}));
+
+	const publish = (document: TextDocument) => {
+		const file = uriPath(document.uri);
+		const items = diagnosticsFor(document.getText(), file, {
+			filePath: file,
+			includeDirs: [path.dirname(file), path.join(projectRoot, "src"), path.join(projectRoot, "include")],
+		});
+		connection.sendDiagnostics({
+			uri: document.uri,
+			diagnostics: items.map((item) => ({
+				range: {
+					start: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(0, (item.col || 1) - 1) },
+					end: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(1, item.col || 1) },
+				},
+				severity: 1,
+				source: "cluaupp",
+				message: item.message,
+			})),
+		});
+	};
+
+	documents.onDidOpen((event) => publish(event.document));
+	documents.onDidChangeContent((event) => publish(event.document));
+	documents.onDidClose((event) => {
+		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+	});
+
+	documents.listen(connection);
+	connection.listen();
+}

package/src/package-info.ts

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+
+export const projectRoot = path.resolve(__dirname, "..");
+
+const fromPkg = createRequire(path.join(projectRoot, "package.json"));
+export const pkg = fromPkg("./package.json") as { name: string; version: string };

package/src/{parse.js → parse.ts}

@@ -1,6 +1,5 @@
-"use strict";
-
-const { tokenize } = require("./lex");
+// @ts-nocheck
+import { tokenize } from "./lex.js";
 
 function parse(source, fileName) {
 	const tokens = tokenize(source);
@@ -628,4 +627,4 @@ function parse(source, fileName) {
 	return { type: "program", body: parseProgramInside(), fileName };
 }
 
-module.exports = { parse };
+export { parse };