@webgal/language-service 0.0.2-alpha.0

package/build/monaco.mjs

@@ -0,0 +1,134 @@
+import { createMemoryFileSystem, createWebgalClientHandlers, registerWebgalClientHandlers } from "./index.mjs";
+import { WebSocketMessageReader, WebSocketMessageWriter, toSocket } from "vscode-ws-jsonrpc";
+import { BrowserMessageReader, BrowserMessageWriter, CloseAction, ErrorAction } from "vscode-languageclient/browser.js";
+import { MonacoLanguageClient } from "monaco-languageclient";
+
+//#region src/monaco.ts
+const createWebgalMonacoLanguageClient = (options) => {
+	const { languageServerUrl, editor } = options;
+	const editorInstance = editor;
+	const vfs = options.virtualFileSystem || createMemoryFileSystem({ root: "file:///game" });
+	if (!options.virtualFileSystem) {
+		vfs.writeFile("file:///game/scene/start.txt", "WebGal:Start;");
+		vfs.writeFile("file:///game/config.txt", "");
+	}
+	const webSocket = new WebSocket(languageServerUrl);
+	webSocket.onopen = () => {
+		const socket = toSocket(webSocket);
+		const reader = new WebSocketMessageReader(socket);
+		const languageClient = createLanguageClient({
+			reader,
+			writer: new WebSocketMessageWriter(socket)
+		}, {
+			editor: editorInstance,
+			vfs
+		});
+		languageClient.start();
+		reader.onClose(() => languageClient.stop());
+	};
+	return {
+		webSocket,
+		vfs
+	};
+};
+const createWebgalMonacoLanguageClientWithWorker = (options) => {
+	const { worker, editor } = options;
+	const editorInstance = editor;
+	const vfs = options.virtualFileSystem || createMemoryFileSystem({ root: "file:///game" });
+	if (!options.virtualFileSystem) {
+		vfs.writeFile("file:///game/scene/start.txt", "WebGal:Start;");
+		vfs.writeFile("file:///game/config.txt", "");
+	}
+	const languageClient = createLanguageClient({
+		reader: new BrowserMessageReader(worker),
+		writer: new BrowserMessageWriter(worker)
+	}, {
+		editor: editorInstance,
+		vfs
+	});
+	languageClient.start();
+	worker.onerror = () => languageClient.stop();
+	worker.onmessageerror = () => languageClient.stop();
+	return {
+		worker,
+		vfs
+	};
+};
+const createWebgalMonacoLanguageClientWithPort = (options) => {
+	const { port, editor } = options;
+	const editorInstance = editor;
+	const vfs = options.virtualFileSystem || createMemoryFileSystem({ root: "file:///game" });
+	if (!options.virtualFileSystem) {
+		vfs.writeFile("file:///game/scene/start.txt", "WebGal:Start;");
+		vfs.writeFile("file:///game/config.txt", "");
+	}
+	const languageClient = createLanguageClient({
+		reader: new BrowserMessageReader(port),
+		writer: new BrowserMessageWriter(port)
+	}, {
+		editor: editorInstance,
+		vfs
+	});
+	languageClient.start();
+	port.onmessageerror = () => languageClient.stop();
+	return {
+		port,
+		vfs
+	};
+};
+const createLanguageClient = (messageTransports, options) => {
+	const handlers = createWebgalClientHandlers({
+		vfs: options.vfs,
+		overrides: { "client/showTip": function(message) {
+			console.log(message);
+		} }
+	});
+	const client = new MonacoLanguageClient({
+		name: "WebGAL Language Client",
+		clientOptions: {
+			documentSelector: [
+				{
+					scheme: "file",
+					language: "webgal"
+				},
+				{
+					scheme: "file",
+					language: "webgal-config"
+				},
+				{
+					scheme: "inmemory",
+					language: "webgal"
+				},
+				{
+					scheme: "inmemory",
+					language: "webgal-config"
+				}
+			],
+			errorHandler: {
+				error: () => ({ action: ErrorAction.Continue }),
+				closed: () => ({ action: CloseAction.DoNotRestart })
+			},
+			synchronize: { configurationSection: ["webgal", "http"] },
+			initializationOptions() {
+				const model = options.editor.getModel();
+				return {
+					processId: Math.random(),
+					rootPath: "file:///game",
+					rootUri: "file:///game",
+					capabilities: {},
+					workspaceFolders: [{
+						uri: "file:///game",
+						name: "example"
+					}],
+					...model ? { textDocument: { uri: model.uri.toString() } } : {}
+				};
+			}
+		},
+		messageTransports
+	});
+	registerWebgalClientHandlers(client, handlers);
+	return client;
+};
+
+//#endregion
+export { createWebgalMonacoLanguageClient, createWebgalMonacoLanguageClientWithPort, createWebgalMonacoLanguageClientWithWorker };

package/build/node.cjs

@@ -0,0 +1,374 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('./chunk-C0xms8kb.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_chunk.__toESM(fs_promises);
+let path = require("path");
+path = require_chunk.__toESM(path);
+
+//#region src/node.ts
+const listDirectory = async (dirPath) => {
+	try {
+		return (await fs_promises.default.readdir(dirPath, { withFileTypes: true })).map((entry) => ({
+			name: entry.name,
+			isDirectory: entry.isDirectory()
+		}));
+	} catch {
+		return null;
+	}
+};
+const findFileInDirectory = async (dirPath, targetName, ignoreDirs) => {
+	const entries = await fs_promises.default.readdir(dirPath, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.isFile() && entry.name === targetName) return path.default.join(dirPath, entry.name);
+		if (entry.isDirectory() && !ignoreDirs.has(entry.name)) {
+			const result = await findFileInDirectory(path.default.join(dirPath, entry.name), targetName, ignoreDirs);
+			if (result) return result;
+		}
+	}
+	return null;
+};
+function createNodeFileSystem(options) {
+	const root = path.default.resolve(options.root);
+	const ignoreDirs = new Set(options.ignoreDirs ?? ["node_modules", ".git"]);
+	const sceneDir = options.sceneDir ?? "scene";
+	let rootEntry = {
+		type: "dir",
+		children: {}
+	};
+	const loadedDirectories = /* @__PURE__ */ new Set();
+	const loadedFiles = /* @__PURE__ */ new Set();
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = (changes) => {
+		for (const listener of listeners) listener(changes);
+	};
+	const isWithinRoot = (targetPath) => {
+		const absolute = path.default.resolve(targetPath);
+		const rel = path.default.relative(root, absolute);
+		if (rel === "" || rel === ".") return true;
+		return !rel.startsWith("..") && !path.default.isAbsolute(rel);
+	};
+	const toSegments = (targetPath) => {
+		const absolute = path.default.resolve(targetPath);
+		const rel = path.default.relative(root, absolute);
+		if (rel === "" || rel === ".") return [];
+		if (rel.startsWith("..") || path.default.isAbsolute(rel)) return null;
+		return rel.split(path.default.sep).filter((s) => s.length > 0);
+	};
+	const getEntryBySegments = (segments) => {
+		let current = rootEntry;
+		for (const segment of segments) {
+			if (current.type !== "dir") return null;
+			const next = current.children[segment];
+			if (!next) return null;
+			current = next;
+		}
+		return current;
+	};
+	const ensureDirectoryBySegments = (segments) => {
+		let current = rootEntry;
+		for (const segment of segments) {
+			if (current.type !== "dir") throw new Error("Path segment is not a directory");
+			const dir = current;
+			const existing = dir.children[segment];
+			if (!existing) {
+				const created = {
+					type: "dir",
+					children: {}
+				};
+				dir.children[segment] = created;
+				current = created;
+				continue;
+			}
+			if (existing.type !== "dir") throw new Error("Path segment is not a directory");
+			current = existing;
+		}
+		if (current.type !== "dir") throw new Error("Path is not a directory");
+		return current;
+	};
+	const ensureDirectoryLoaded = async (dirPath) => {
+		const absolute = path.default.resolve(dirPath);
+		if (!isWithinRoot(absolute)) return;
+		if (loadedDirectories.has(absolute)) return;
+		const segments = toSegments(absolute);
+		if (!segments) return;
+		const dirEntry = ensureDirectoryBySegments(segments);
+		const entries = await listDirectory(absolute);
+		if (!entries) {
+			loadedDirectories.add(absolute);
+			return;
+		}
+		for (const entry of entries) if (entry.isDirectory) dirEntry.children[entry.name] ??= {
+			type: "dir",
+			children: {}
+		};
+		else dirEntry.children[entry.name] ??= {
+			type: "file",
+			content: ""
+		};
+		loadedDirectories.add(absolute);
+	};
+	const getTree = () => rootEntry;
+	const setTree = (tree) => {
+		rootEntry = tree.type === "dir" ? tree : {
+			type: "dir",
+			children: {}
+		};
+		loadedDirectories.clear();
+		loadedFiles.clear();
+		emit([{
+			type: "setTree",
+			tree: rootEntry
+		}]);
+	};
+	const writeFile = async (targetPath, content) => {
+		const absolute = path.default.resolve(targetPath);
+		if (!isWithinRoot(absolute)) return;
+		const segments = toSegments(absolute);
+		if (!segments || segments.length === 0) return;
+		const fileName = segments[segments.length - 1];
+		const parent = ensureDirectoryBySegments(segments.slice(0, -1));
+		parent.children[fileName] = {
+			type: "file",
+			content
+		};
+		loadedFiles.add(absolute);
+		emit([{
+			type: "writeFile",
+			path: absolute,
+			content
+		}]);
+	};
+	const mkdir = async (targetPath) => {
+		const absolute = path.default.resolve(targetPath);
+		if (!isWithinRoot(absolute)) return;
+		const segments = toSegments(absolute);
+		if (!segments) return;
+		ensureDirectoryBySegments(segments);
+		emit([{
+			type: "mkdir",
+			path: absolute
+		}]);
+	};
+	const deletePath = async (targetPath) => {
+		const absolute = path.default.resolve(targetPath);
+		if (!isWithinRoot(absolute)) return;
+		const segments = toSegments(absolute);
+		if (!segments || segments.length === 0) return;
+		const name = segments[segments.length - 1];
+		const parentSegments = segments.slice(0, -1);
+		const parentEntry = parentSegments.length === 0 ? rootEntry : getEntryBySegments(parentSegments);
+		if (!parentEntry || parentEntry.type !== "dir") return;
+		delete parentEntry.children[name];
+		loadedFiles.delete(absolute);
+		loadedDirectories.delete(absolute);
+		emit([{
+			type: "deletePath",
+			path: absolute
+		}]);
+	};
+	const rename = async (from, to) => {
+		const fromAbs = path.default.resolve(from);
+		const toAbs = path.default.resolve(to);
+		if (!isWithinRoot(fromAbs) || !isWithinRoot(toAbs)) return;
+		const fromSegments = toSegments(fromAbs);
+		if (!fromSegments || fromSegments.length === 0) return;
+		const fromName = fromSegments[fromSegments.length - 1];
+		const fromParentSegments = fromSegments.slice(0, -1);
+		const fromParentEntry = fromParentSegments.length === 0 ? rootEntry : getEntryBySegments(fromParentSegments);
+		if (!fromParentEntry || fromParentEntry.type !== "dir") return;
+		const entry = fromParentEntry.children[fromName];
+		if (!entry) return;
+		delete fromParentEntry.children[fromName];
+		const toPathSegments = toSegments(toAbs);
+		if (!toPathSegments || toPathSegments.length === 0) return;
+		const toName = toPathSegments[toPathSegments.length - 1];
+		const toParent = ensureDirectoryBySegments(toPathSegments.slice(0, -1));
+		toParent.children[toName] = entry;
+		if (loadedFiles.has(fromAbs)) {
+			loadedFiles.delete(fromAbs);
+			loadedFiles.add(toAbs);
+		}
+		if (loadedDirectories.has(fromAbs)) {
+			loadedDirectories.delete(fromAbs);
+			loadedDirectories.add(toAbs);
+		}
+		emit([{
+			type: "rename",
+			from: fromAbs,
+			to: toAbs
+		}]);
+	};
+	const applyChanges = async (changes) => {
+		for (const change of changes) {
+			if (change.type === "writeFile") {
+				await writeFile(change.path, change.content);
+				continue;
+			}
+			if (change.type === "mkdir") {
+				await mkdir(change.path);
+				continue;
+			}
+			if (change.type === "deletePath") {
+				await deletePath(change.path);
+				continue;
+			}
+			if (change.type === "rename") {
+				await rename(change.from, change.to);
+				continue;
+			}
+			if (change.type === "setTree") setTree(change.tree);
+		}
+	};
+	const onDidChange = (listener) => {
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	};
+	const stat = async (targetPath) => {
+		const absolute = path.default.resolve(targetPath);
+		if (isWithinRoot(absolute)) {
+			const segments = toSegments(absolute);
+			if (segments) {
+				const existing = getEntryBySegments(segments);
+				if (existing) return {
+					isFile: existing.type === "file",
+					isDirectory: existing.type === "dir"
+				};
+			}
+		}
+		try {
+			const stats = await fs_promises.default.stat(absolute);
+			if (isWithinRoot(absolute)) {
+				const segments = toSegments(absolute);
+				if (segments) {
+					if (stats.isDirectory()) ensureDirectoryBySegments(segments);
+					else if (segments.length > 0) {
+						const name = segments[segments.length - 1];
+						const parent = ensureDirectoryBySegments(segments.slice(0, -1));
+						parent.children[name] ??= {
+							type: "file",
+							content: ""
+						};
+					}
+				}
+			}
+			return {
+				isFile: stats.isFile(),
+				isDirectory: stats.isDirectory()
+			};
+		} catch {
+			return null;
+		}
+	};
+	const readDirectory = async (targetPath) => {
+		const absolute = path.default.resolve(targetPath);
+		if (isWithinRoot(absolute)) {
+			await ensureDirectoryLoaded(absolute);
+			const segments = toSegments(absolute);
+			if (!segments) return null;
+			const entry = getEntryBySegments(segments);
+			if (!entry || entry.type !== "dir") return null;
+			return Object.entries(entry.children).map(([name, child]) => ({
+				name,
+				isDirectory: child.type === "dir"
+			}));
+		}
+		return listDirectory(absolute);
+	};
+	const readFile = async (targetPath) => {
+		const absolute = path.default.resolve(targetPath);
+		if (isWithinRoot(absolute)) {
+			const segments = toSegments(absolute);
+			if (segments) {
+				const existing = getEntryBySegments(segments);
+				if (existing && existing.type === "file") {
+					if (loadedFiles.has(absolute)) return existing.content;
+					try {
+						const content = await fs_promises.default.readFile(absolute, "utf-8");
+						existing.content = content;
+						loadedFiles.add(absolute);
+						return content;
+					} catch {
+						return null;
+					}
+				}
+			}
+			try {
+				const content = await fs_promises.default.readFile(absolute, "utf-8");
+				await writeFile(absolute, content);
+				return content;
+			} catch {
+				return null;
+			}
+		}
+		try {
+			return await fs_promises.default.readFile(absolute, "utf-8");
+		} catch {
+			return null;
+		}
+	};
+	const findFile = async (startPath, targetName) => {
+		const absoluteStart = path.default.resolve(startPath);
+		try {
+			const found = await findFileInDirectory(absoluteStart, targetName, ignoreDirs);
+			if (found && isWithinRoot(found)) {
+				const foundSegments = toSegments(found);
+				if (foundSegments && foundSegments.length > 0) {
+					const name = foundSegments[foundSegments.length - 1];
+					const parent = ensureDirectoryBySegments(foundSegments.slice(0, -1));
+					parent.children[name] ??= {
+						type: "file",
+						content: ""
+					};
+				}
+			}
+			return found;
+		} catch {
+			return null;
+		}
+	};
+	const getResourceDirectory = async (urls) => {
+		return readDirectory(path.default.join(root, ...urls));
+	};
+	const getAllTextWithScene = async () => {
+		const target = path.default.join(root, sceneDir);
+		const entries = await readDirectory(target);
+		if (!entries) return null;
+		const result = {};
+		for (const entry of entries) if (!entry.isDirectory && entry.name.endsWith(".txt")) {
+			const fullPath = path.default.join(target, entry.name);
+			const text = await readFile(fullPath);
+			if (text === null) continue;
+			result[entry.name] = {
+				path: fullPath,
+				name: entry.name,
+				text,
+				fullPath
+			};
+		}
+		return result;
+	};
+	return {
+		root,
+		currentDirectory: () => root,
+		join: (...parts) => path.default.join(...parts),
+		stat,
+		readDirectory,
+		readFile,
+		findFile,
+		getResourceDirectory,
+		getAllTextWithScene,
+		getTree,
+		setTree,
+		writeFile,
+		deletePath,
+		mkdir,
+		rename,
+		applyChanges,
+		onDidChange
+	};
+}
+
+//#endregion
+exports.createNodeFileSystem = createNodeFileSystem;

package/build/node.d.cts

@@ -0,0 +1,11 @@
+import { VirtualFileSystem } from "./index.cjs";
+
+//#region src/node.d.ts
+type NodeFileSystemOptions = {
+  root: string;
+  ignoreDirs?: string[];
+  sceneDir?: string;
+};
+declare function createNodeFileSystem(options: NodeFileSystemOptions): VirtualFileSystem;
+//#endregion
+export { NodeFileSystemOptions, createNodeFileSystem };

package/build/node.d.mts

@@ -0,0 +1,11 @@
+import { VirtualFileSystem } from "./index.mjs";
+
+//#region src/node.d.ts
+type NodeFileSystemOptions = {
+  root: string;
+  ignoreDirs?: string[];
+  sceneDir?: string;
+};
+declare function createNodeFileSystem(options: NodeFileSystemOptions): VirtualFileSystem;
+//#endregion
+export { NodeFileSystemOptions, createNodeFileSystem };