@webgal/language-service 0.0.2-alpha.0

package/build/index.mjs

@@ -0,0 +1,293 @@
+//#region src/index.ts
+const normalizePath = (input) => {
+	let path = input.replace(/\\/g, "/").replace(/\/+/g, "/");
+	if (path === "") return "/";
+	if (!path.startsWith("/")) path = "/" + path;
+	if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+	return path;
+};
+const joinPaths = (...parts) => {
+	return normalizePath(parts.filter((part) => part && part !== "/").join("/"));
+};
+const uriToPath = (uriString) => {
+	if (uriString.startsWith("file://")) {
+		const stripped = uriString.replace(/^file:\/*/i, "/");
+		const decoded = decodeURIComponent(stripped).replace(/\\/g, "/");
+		if (/^\/[a-zA-Z]:\//.test(decoded)) return decoded.slice(1);
+		return normalizePath(decoded);
+	}
+	return normalizePath(uriString);
+};
+const toVfsPath = (value) => value.startsWith("file://") ? uriToPath(value) : value;
+function createMemoryFileSystem(options) {
+	const root = normalizePath(options?.root ?? "/");
+	let rootEntry = options?.tree && options.tree.type === "dir" ? options.tree : {
+		type: "dir",
+		children: {}
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = (changes) => {
+		for (const listener of listeners) listener(changes);
+	};
+	const resolveToSegments = (path) => {
+		let resolved = normalizePath(path);
+		if (root !== "/" && resolved.startsWith(root)) resolved = resolved.slice(root.length);
+		if (resolved.startsWith("/")) resolved = resolved.slice(1);
+		return resolved ? resolved.split("/") : [];
+	};
+	const ensureDirectoryEntry = (segments) => {
+		let current = rootEntry;
+		for (const segment of segments) {
+			if (current.type !== "dir") throw new Error("Path segment is not a directory");
+			const directory = current;
+			const existing = directory.children[segment];
+			if (!existing) {
+				const created = {
+					type: "dir",
+					children: {}
+				};
+				directory.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 getEntry = (path) => {
+		const segments = resolveToSegments(path);
+		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 readDirectory = async (path) => {
+		const entry = getEntry(path);
+		if (!entry || entry.type !== "dir") return null;
+		return Object.entries(entry.children).map(([name, child]) => ({
+			name,
+			isDirectory: child.type === "dir"
+		}));
+	};
+	const readFile = async (path) => {
+		const entry = getEntry(path);
+		if (!entry || entry.type !== "file") return null;
+		return entry.content;
+	};
+	const stat = async (path) => {
+		const entry = getEntry(path);
+		if (!entry) return null;
+		return {
+			isFile: entry.type === "file",
+			isDirectory: entry.type === "dir"
+		};
+	};
+	const findFile = async (startPath, targetName) => {
+		const startEntry = getEntry(startPath);
+		if (!startEntry || startEntry.type !== "dir") return null;
+		const stack = [{
+			path: normalizePath(startPath),
+			entry: startEntry
+		}];
+		while (stack.length) {
+			const current = stack.pop();
+			if (!current) break;
+			if (current.entry.type === "dir") for (const [name, child] of Object.entries(current.entry.children)) {
+				const nextPath = joinPaths(current.path, name);
+				if (child.type === "file" && name === targetName) return nextPath;
+				if (child.type === "dir") stack.push({
+					path: nextPath,
+					entry: child
+				});
+			}
+		}
+		return null;
+	};
+	const getResourceDirectory = async (urls) => {
+		return readDirectory(joinPaths(root, ...urls));
+	};
+	const getAllTextWithScene = async () => {
+		const scenePath = joinPaths(root, "scene");
+		const sceneEntry = getEntry(scenePath);
+		if (!sceneEntry || sceneEntry.type !== "dir") return null;
+		const map = {};
+		for (const [name, child] of Object.entries(sceneEntry.children)) if (child.type === "file" && name.endsWith(".txt")) {
+			const fullPath = joinPaths(scenePath, name);
+			map[name] = {
+				path: fullPath,
+				name,
+				text: child.content,
+				fullPath
+			};
+		}
+		return map;
+	};
+	const getTree = () => rootEntry;
+	const setTree = (tree) => {
+		rootEntry = tree.type === "dir" ? tree : {
+			type: "dir",
+			children: {}
+		};
+		emit([{
+			type: "setTree",
+			tree: rootEntry
+		}]);
+	};
+	const writeFile = async (targetPath, content) => {
+		const segments = resolveToSegments(targetPath);
+		if (segments.length === 0) return;
+		const fileName = segments[segments.length - 1];
+		const parent = ensureDirectoryEntry(segments.slice(0, -1));
+		parent.children[fileName] = {
+			type: "file",
+			content
+		};
+		emit([{
+			type: "writeFile",
+			path: normalizePath(targetPath),
+			content
+		}]);
+	};
+	const mkdir = async (targetPath) => {
+		ensureDirectoryEntry(resolveToSegments(targetPath));
+		emit([{
+			type: "mkdir",
+			path: normalizePath(targetPath)
+		}]);
+	};
+	const deletePath = async (targetPath) => {
+		const segments = resolveToSegments(targetPath);
+		if (segments.length === 0) return;
+		const name = segments[segments.length - 1];
+		const parentSegments = segments.slice(0, -1);
+		const parentEntry = parentSegments.length === 0 ? rootEntry : getEntry(joinPaths(root, ...parentSegments));
+		if (!parentEntry || parentEntry.type !== "dir") return;
+		delete parentEntry.children[name];
+		emit([{
+			type: "deletePath",
+			path: normalizePath(targetPath)
+		}]);
+	};
+	const rename = async (from, to) => {
+		const fromSegments = resolveToSegments(from);
+		if (fromSegments.length === 0) return;
+		const fromName = fromSegments[fromSegments.length - 1];
+		const fromParentSegments = fromSegments.slice(0, -1);
+		const fromParentEntry = fromParentSegments.length === 0 ? rootEntry : getEntry(joinPaths(root, ...fromParentSegments));
+		if (!fromParentEntry || fromParentEntry.type !== "dir") return;
+		const entry = fromParentEntry.children[fromName];
+		if (!entry) return;
+		delete fromParentEntry.children[fromName];
+		const toSegments = resolveToSegments(to);
+		if (toSegments.length === 0) return;
+		const toName = toSegments[toSegments.length - 1];
+		const toParent = ensureDirectoryEntry(toSegments.slice(0, -1));
+		toParent.children[toName] = entry;
+		emit([{
+			type: "rename",
+			from: normalizePath(from),
+			to: normalizePath(to)
+		}]);
+	};
+	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);
+		};
+	};
+	return {
+		root,
+		currentDirectory: () => root,
+		join: (...parts) => joinPaths(...parts),
+		stat,
+		readDirectory,
+		readFile,
+		findFile,
+		getResourceDirectory,
+		getAllTextWithScene,
+		getTree,
+		setTree,
+		writeFile,
+		deletePath,
+		mkdir,
+		rename,
+		applyChanges,
+		onDidChange
+	};
+}
+function createWebgalClientHandlers(options) {
+	const normalizeChange = (change) => {
+		if (change.type === "writeFile") return {
+			type: "writeFile",
+			path: toVfsPath(change.path),
+			content: change.content
+		};
+		if (change.type === "deletePath") return {
+			type: "deletePath",
+			path: toVfsPath(change.path)
+		};
+		if (change.type === "mkdir") return {
+			type: "mkdir",
+			path: toVfsPath(change.path)
+		};
+		if (change.type === "rename") return {
+			type: "rename",
+			from: toVfsPath(change.from),
+			to: toVfsPath(change.to)
+		};
+		return change;
+	};
+	return {
+		"client/showTip": options.showTip ?? (() => null),
+		"client/currentDirectory": () => options.vfs.currentDirectory(),
+		"client/FJoin": (args) => options.vfs.join(...Array.isArray(args) ? args : [args]),
+		"client/FStat": (path) => options.vfs.stat(path),
+		"client/findFile": ([startPath, targetName]) => options.vfs.findFile(startPath, targetName),
+		"client/goPropertyDoc": options.goPropertyDoc ?? (() => null),
+		"client/readDirectory": (uriString) => options.vfs.readDirectory(uriToPath(uriString)),
+		"client/getAllTextWithScene": () => options.vfs.getAllTextWithScene(),
+		"client/getResourceDirectory": (urls) => options.vfs.getResourceDirectory(urls),
+		"client/vfs/getTree": () => options.vfs.getTree(),
+		"client/vfs/setTree": (tree) => options.vfs.setTree(tree),
+		"client/vfs/readFile": (path) => options.vfs.readFile(toVfsPath(path)),
+		"client/vfs/writeFile": ({ path, content }) => options.vfs.writeFile(toVfsPath(path), content),
+		"client/vfs/deletePath": (path) => options.vfs.deletePath(toVfsPath(path)),
+		"client/vfs/mkdir": (path) => options.vfs.mkdir(toVfsPath(path)),
+		"client/vfs/rename": ({ from, to }) => options.vfs.rename(toVfsPath(from), toVfsPath(to)),
+		"client/vfs/applyChanges": (changes) => options.vfs.applyChanges(changes.map(normalizeChange)),
+		...options.overrides ?? {}
+	};
+}
+function registerWebgalClientHandlers(client, handlers) {
+	for (const [method, handler] of Object.entries(handlers)) client.onRequest(method, handler);
+}
+
+//#endregion
+export { createMemoryFileSystem, createWebgalClientHandlers, registerWebgalClientHandlers };

package/build/language-configuration-BeRkRSII.mjs

@@ -0,0 +1,214 @@
+//#region syntaxes/webgal.tmLanguage.json
+var webgal_tmLanguage_default = {
+	$schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+	name: "WebGAL Script",
+	patterns: [{ "include": "#comment-line" }, { "include": "#statement" }],
+	repository: {
+		"argument-list": { "patterns": [{
+			"comment": ">1 arguments left, ie -kwarg0=val0 -kwarg1=val1 ...",
+			"match": "(\\s\\-)(.*?)(\\s\\-.*)$",
+			"captures": {
+				"1": { "patterns": [{ "include": "#operator" }] },
+				"2": { "patterns": [{ "include": "#parameter" }] },
+				"3": { "patterns": [{ "include": "#argument-list" }] }
+			}
+		}, {
+			"comment": "only one argument left, ie -kwarg0=val0",
+			"match": "(\\s\\-)(.*)",
+			"captures": {
+				"1": { "patterns": [{ "include": "#operator" }] },
+				"2": { "patterns": [{ "include": "#parameter" }] }
+			}
+		}] },
+		"character": {
+			"match": ".*",
+			"name": "entity.name.type.character.webgal"
+		},
+		"command": {
+			"match": ".*",
+			"name": "support.function.command.webgal"
+		},
+		"comment-line": {
+			"match": "\\;.*?$",
+			"name": "comment.line.webgal"
+		},
+		"operator": {
+			"match": "[\\:\\=\\<\\>\\|\\+\\-]",
+			"name": "keyword.operator.webgal"
+		},
+		"parameter": { "patterns": [{
+			"comment": "value only, ie val0",
+			"match": "(?!.*\\=).+",
+			"name": "variable.parameter.webgal"
+		}, {
+			"comment": "name and value, ie [kwarg0]=[val0]",
+			"match": "(.*?)(\\=)(.*?)$",
+			"captures": {
+				"1": { "name": "variable.parameter.webgal" },
+				"2": { "patterns": [{ "include": "#operator" }] },
+				"3": { "name": "variable.other.webgal" }
+			}
+		}] },
+		"utterance": { "patterns": [{
+			"comment": "utterance only",
+			"match": "(?!.*\\s\\-)(.+)",
+			"captures": { "0": { "name": "string.unquoted.utterance.webgal" } }
+		}, {
+			"comment": "utterance and argument list",
+			"match": "(.*?)(\\s\\-.*?)$",
+			"captures": {
+				"1": { "name": "string.unquoted.utterance.webgal" },
+				"2": { "patterns": [{ "include": "#argument-list" }] }
+			}
+		}] },
+		"character-colon": {
+			"comment": "[char]:[utt[ -args]][;cmt]",
+			"match": "^(?!(?:say|changeBg|changeFigure|bgm|playVideo|pixiPerform|pixiInit|intro|miniAvatar|changeScene|choose|end|setComplexAnimation|label|jumpLabel|setVar|callScene|showVars|unlockCg|unlockBgm|filmMode|setTextbox|setAnimation|playEffect|setTempAnimation|setTransform|setTransition|getUserInput|applyStyle|wait)\\:)(.*?)(\\:)([^\\;\\n]*?)($|\\;.*?$)",
+			"captures": {
+				"1": {
+					"name": "meta.character.webgal",
+					"patterns": [{ "include": "#character" }]
+				},
+				"2": { "patterns": [{ "include": "#operator" }] },
+				"3": { "patterns": [{ "include": "#utterance" }] },
+				"4": { "patterns": [{ "include": "#comment-line" }] }
+			}
+		},
+		"command-colon": {
+			"comment": "cmd:[arg0[ -args]][;cmt]",
+			"match": "^(say|changeBg|changeFigure|bgm|playVideo|pixiPerform|pixiInit|intro|miniAvatar|changeScene|choose|end|setComplexAnimation|label|jumpLabel|setVar|callScene|showVars|unlockCg|unlockBgm|filmMode|setTextbox|setAnimation|playEffect|setTempAnimation|setTransform|setTransition|getUserInput|applyStyle|wait)(\\:)([^\\;\\n]*?)($|\\;.*?$)",
+			"captures": {
+				"1": {
+					"name": "meta.command.webgal",
+					"patterns": [{ "include": "#command" }]
+				},
+				"2": { "patterns": [{ "include": "#operator" }] },
+				"3": { "patterns": [{ "include": "#argument-list" }] },
+				"4": { "patterns": [{ "include": "#comment-line" }] }
+			}
+		},
+		"command-semicolon": {
+			"comment": "cmd;[cmt]",
+			"match": "^(say|changeBg|changeFigure|bgm|playVideo|pixiPerform|pixiInit|intro|miniAvatar|changeScene|choose|end|setComplexAnimation|label|jumpLabel|setVar|callScene|showVars|unlockCg|unlockBgm|filmMode|setTextbox|setAnimation|playEffect|setTempAnimation|setTransform|setTransition|getUserInput|applyStyle|wait)($|\\;.*?$)",
+			"captures": {
+				"1": {
+					"name": "meta.command.webgal",
+					"patterns": [{ "include": "#command" }]
+				},
+				"2": { "patterns": [{ "include": "#comment-line" }] }
+			}
+		},
+		"utterance-semicolon": {
+			"comment": "utt[ -args];[cmt]",
+			"match": "^(?!(?:say|changeBg|changeFigure|bgm|playVideo|pixiPerform|pixiInit|intro|miniAvatar|changeScene|choose|end|setComplexAnimation|label|jumpLabel|setVar|callScene|showVars|unlockCg|unlockBgm|filmMode|setTextbox|setAnimation|playEffect|setTempAnimation|setTransform|setTransition|getUserInput|applyStyle|wait)\\;)([^\\:\\;\\n]+?)($|\\;.*?$)",
+			"captures": {
+				"1": { "patterns": [{ "include": "#utterance" }] },
+				"2": { "patterns": [{ "include": "#comment-line" }] }
+			}
+		},
+		"statement": { "patterns": [
+			{ "include": "#character-colon" },
+			{ "include": "#command-colon" },
+			{ "include": "#command-semicolon" },
+			{ "include": "#utterance-semicolon" }
+		] }
+	},
+	scopeName: "source.webgal"
+};
+
+//#endregion
+//#region syntaxes/webgal-config.tmLanguage.json
+var webgal_config_tmLanguage_default = {
+	$schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+	name: "WebGAL Config",
+	patterns: [{ "include": "#comment-line" }, { "include": "#statement" }],
+	repository: {
+		"command": {
+			"match": ".+",
+			"name": "markup.quote.webgal-config"
+		},
+		"comment-line": {
+			"match": "\\;.*?$",
+			"name": "comment.line.webgal-config"
+		},
+		"operator": {
+			"match": "[\\:\\=\\<\\>\\|\\+\\-]",
+			"name": "keyword.operator.webgal-config"
+		},
+		"parameter": {
+			"match": ".+",
+			"name": "variable.other.webgal-config"
+		},
+		"command-colon": {
+			"comment": "cmd:[arg][;cmt]",
+			"match": "^(Game_Logo|Game_key|Game_name|Textbox_theme|Title_bgm|Title_img|Enable_Appreciation|Default_Language|Show_panic|Legacy_Expression_Blend_Mode)(\\:)([^\\;\\n]*?)($|\\;.*?$)",
+			"captures": {
+				"1": { "patterns": [{ "include": "#command" }] },
+				"2": { "patterns": [{ "include": "#operator" }] },
+				"3": { "patterns": [{ "include": "#parameter" }] },
+				"4": { "patterns": [{ "include": "#comment-line" }] }
+			}
+		},
+		"statement": { "patterns": [{ "include": "#command-colon" }] }
+	},
+	scopeName: "source.webgal-config"
+};
+
+//#endregion
+//#region syntaxes/language-configuration.json
+var language_configuration_default = {
+	comments: { "lineComment": { "comment": ";" } },
+	autoClosingPairs: [
+		{
+			"open": "{",
+			"close": "}"
+		},
+		{
+			"open": "[",
+			"close": "]"
+		},
+		{
+			"open": "(",
+			"close": ")"
+		},
+		{
+			"open": "'",
+			"close": "'",
+			"notIn": ["string", "comment"]
+		},
+		{
+			"open": "\"",
+			"close": "\"",
+			"notIn": ["string"]
+		},
+		{
+			"open": "`",
+			"close": "`",
+			"notIn": ["string", "comment"]
+		},
+		{
+			"open": ":",
+			"close": ";"
+		},
+		{
+			"open": ";area",
+			"close": ";endarea"
+		}
+	],
+	folding: { "markers": {
+		"start": "^\\s*;\\s*area\\b",
+		"end": "^\\s*;\\s*endarea\\b"
+	} },
+	surroundingPairs: [
+		["{", "}"],
+		["[", "]"],
+		["(", ")"],
+		["'", "'"],
+		["\"", "\""],
+		["`", "`"]
+	],
+	wordPattern: "([^:\\s])+\\.(.[^;\\s])|([^\\`\\~\\!\\@\\#\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)"
+};
+
+//#endregion
+export { webgal_config_tmLanguage_default as n, webgal_tmLanguage_default as r, language_configuration_default as t };