@webgal/language-service 0.0.2-alpha.0 → 0.0.2-alpha.2

package/build/index.mjs

@@ -1,293 +1,10 @@
+import { a as registerWebgalClientHandlers, c as createVolarFileSystem, d as pathToUri, f as toVfsPath, i as createWebgalClientHandlers, l as joinPaths, n as createWebgalMonacoLanguageClient, o as createMemoryVolarFileSystem, p as uriToPath, r as createWebgalMonacoLanguageClientWithWorker, s as createVirtualFileSystem, t as initWebgalMonaco, u as normalizePath } from "./monaco-init-D6m312d3.mjs";
+import "./monaco/index.mjs";
+
 //#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);
+	return createVirtualFileSystem(createMemoryVolarFileSystem(options));
 }
 
 //#endregion
-export { createMemoryFileSystem, createWebgalClientHandlers, registerWebgalClientHandlers };
+export { createMemoryFileSystem, createMemoryVolarFileSystem, createVirtualFileSystem, createVolarFileSystem, createWebgalClientHandlers, createWebgalMonacoLanguageClient, createWebgalMonacoLanguageClientWithWorker, initWebgalMonaco, joinPaths, normalizePath, pathToUri, registerWebgalClientHandlers, toVfsPath, uriToPath };

package/build/monaco/index.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_monaco_init = require('../monaco-init-PW92JiUH.cjs');
+
+exports.createWebgalMonacoLanguageClient = require_monaco_init.createWebgalMonacoLanguageClient;
+exports.createWebgalMonacoLanguageClientWithWorker = require_monaco_init.createWebgalMonacoLanguageClientWithWorker;
+exports.initWebgalMonaco = require_monaco_init.initWebgalMonaco;

package/build/monaco/index.d.cts

@@ -0,0 +1,2 @@
+import { a as createWebgalMonacoLanguageClientWithWorker, i as createWebgalMonacoLanguageClient, n as CreateWebgalMonacoLanguageClientOptions, r as CreateWebgalMonacoLanguageClientWorkerOptions, t as initWebgalMonaco } from "../monaco-init-DUnVu1qx.cjs";
+export { CreateWebgalMonacoLanguageClientOptions, CreateWebgalMonacoLanguageClientWorkerOptions, createWebgalMonacoLanguageClient, createWebgalMonacoLanguageClientWithWorker, initWebgalMonaco };

package/build/monaco/index.d.mts

@@ -0,0 +1,2 @@
+import { a as createWebgalMonacoLanguageClientWithWorker, i as createWebgalMonacoLanguageClient, n as CreateWebgalMonacoLanguageClientOptions, r as CreateWebgalMonacoLanguageClientWorkerOptions, t as initWebgalMonaco } from "../monaco-init-BR2AgVuN.mjs";
+export { CreateWebgalMonacoLanguageClientOptions, CreateWebgalMonacoLanguageClientWorkerOptions, createWebgalMonacoLanguageClient, createWebgalMonacoLanguageClientWithWorker, initWebgalMonaco };

package/build/monaco/index.mjs

@@ -0,0 +1,3 @@
+import { n as createWebgalMonacoLanguageClient, r as createWebgalMonacoLanguageClientWithWorker, t as initWebgalMonaco } from "../monaco-init-D6m312d3.mjs";
+
+export { createWebgalMonacoLanguageClient, createWebgalMonacoLanguageClientWithWorker, initWebgalMonaco };

package/build/monaco-init-BR2AgVuN.d.mts

@@ -0,0 +1,158 @@
+import { createMemoryFileSystem } from "./index.mjs";
+import { FileSystem } from "@volar/language-service";
+import { URI } from "vscode-uri";
+import "vscode/localExtensionHost";
+
+//#region src/vfs/types.d.ts
+type DirectoryEntry = {
+  name: string;
+  isDirectory: boolean;
+};
+type VirtualFileEntry = {
+  type: "file";
+  content: string;
+};
+type VirtualDirectoryEntry = {
+  type: "dir";
+  children: Record<string, VirtualEntry>;
+};
+type VirtualEntry = VirtualFileEntry | VirtualDirectoryEntry;
+type MaybePromise<T> = T | Promise<T>;
+type VirtualFileSystemChange = {
+  type: "writeFile";
+  path: string;
+  content: string;
+} | {
+  type: "deletePath";
+  path: string;
+} | {
+  type: "mkdir";
+  path: string;
+} | {
+  type: "rename";
+  from: string;
+  to: string;
+} | {
+  type: "setTree";
+  tree: VirtualEntry;
+};
+type VirtualFileSystemChangeListener = (changes: VirtualFileSystemChange[]) => void;
+type VirtualFileSystem = {
+  root: string;
+  currentDirectory: () => string | null;
+  join: (...parts: string[]) => string;
+  stat: (path: string) => Promise<{
+    isFile: boolean;
+    isDirectory: boolean;
+  } | null>;
+  readDirectory: (path: string) => Promise<DirectoryEntry[] | null>;
+  readFile: (path: string) => Promise<string | null>;
+  findFile: (startPath: string, targetName: string) => Promise<string | null>;
+  getResourceDirectory: (urls: string[]) => Promise<DirectoryEntry[] | null>;
+  getAllTextWithScene: () => Promise<Record<string, {
+    path: string;
+    name: string;
+    text: string;
+    fullPath: string;
+  }> | null>;
+  getTree: () => VirtualEntry;
+  setTree: (tree: VirtualEntry) => void;
+  writeFile: (path: string, content: string) => Promise<void>;
+  deletePath: (path: string) => Promise<void>;
+  mkdir: (path: string) => Promise<void>;
+  rename: (from: string, to: string) => Promise<void>;
+  applyChanges: (changes: VirtualFileSystemChange[]) => Promise<void>;
+  onDidChange: (listener: VirtualFileSystemChangeListener) => () => void;
+};
+type WebgalClientHandlers = {
+  "client/showTip": (message: string) => MaybePromise<unknown>;
+  "client/currentDirectory": () => MaybePromise<string | null>;
+  "client/FJoin": (args: string | string[]) => MaybePromise<string | null>;
+  "client/FStat": (path: string) => MaybePromise<unknown>;
+  "client/findFile": (args: [string, string]) => MaybePromise<string | null>;
+  "client/goPropertyDoc": (pathSegments: string[]) => MaybePromise<unknown>;
+  "client/readDirectory": (uriString: string) => MaybePromise<unknown>;
+  "client/getAllTextWithScene": () => MaybePromise<unknown>;
+  "client/getResourceDirectory": (urls: string[]) => MaybePromise<unknown>;
+  "client/vfs/getTree": () => MaybePromise<VirtualEntry>;
+  "client/vfs/setTree": (tree: VirtualEntry) => MaybePromise<unknown>;
+  "client/vfs/readFile": (path: string) => MaybePromise<string | null>;
+  "client/vfs/writeFile": (args: {
+    path: string;
+    content: string;
+  }) => MaybePromise<unknown>;
+  "client/vfs/deletePath": (path: string) => MaybePromise<unknown>;
+  "client/vfs/mkdir": (path: string) => MaybePromise<unknown>;
+  "client/vfs/rename": (args: {
+    from: string;
+    to: string;
+  }) => MaybePromise<unknown>;
+  "client/vfs/applyChanges": (changes: VirtualFileSystemChange[]) => MaybePromise<unknown>;
+};
+type LanguageClientLike = {
+  onRequest: (method: string, handler: (...args: any[]) => unknown) => void;
+};
+type CreateWebgalClientHandlersOptions = {
+  vfs: VirtualFileSystem;
+  showTip?: (message: string) => unknown;
+  goPropertyDoc?: (pathSegments: string[]) => unknown;
+  overrides?: Partial<WebgalClientHandlers>;
+};
+interface VolarWritableFileSystem extends FileSystem {
+  writeFile(uri: URI, content: string): Promise<void>;
+  mkdir(uri: URI): Promise<void>;
+  delete(uri: URI): Promise<void>;
+  rename(oldUri: URI, newUri: URI): Promise<void>;
+  getTree(): VirtualEntry;
+  setTree(tree: VirtualEntry): void;
+  onDidChange(listener: VirtualFileSystemChangeListener): () => void;
+  root: string;
+}
+//#endregion
+//#region src/client-handlers.d.ts
+declare function createWebgalClientHandlers(options: CreateWebgalClientHandlersOptions): WebgalClientHandlers;
+declare function registerWebgalClientHandlers(client: LanguageClientLike, handlers: Partial<WebgalClientHandlers>): void;
+//#endregion
+//#region src/vfs/adapter.d.ts
+declare function createVirtualFileSystem(fs: VolarWritableFileSystem): VirtualFileSystem;
+declare function createVolarFileSystem(vfs: VirtualFileSystem, options?: {
+  uriToPath?: (uri: URI) => string;
+}): FileSystem;
+//#endregion
+//#region src/vfs/memory.d.ts
+declare function createMemoryVolarFileSystem(options?: {
+  root?: string;
+  tree?: VirtualEntry;
+}): VolarWritableFileSystem;
+//#endregion
+//#region src/vfs/utils.d.ts
+declare const normalizePath: (input: string) => string;
+declare const joinPaths: (...parts: string[]) => string;
+declare const uriToPath: (value: string | URI) => string;
+declare const pathToUri: (path: string) => URI;
+declare const toVfsPath: (value: string) => string;
+//#endregion
+//#region src/monaco/monaco.d.ts
+interface CreateWebgalMonacoLanguageClientOptions {
+  languageServerUrl: string;
+  editor: any;
+  virtualFileSystem?: ReturnType<typeof createMemoryFileSystem>;
+}
+declare const createWebgalMonacoLanguageClient: (options: CreateWebgalMonacoLanguageClientOptions) => {
+  webSocket: WebSocket;
+  vfs: ReturnType<typeof createMemoryFileSystem>;
+};
+interface CreateWebgalMonacoLanguageClientWorkerOptions {
+  editor: any;
+  worker: Worker;
+  virtualFileSystem?: ReturnType<typeof createMemoryFileSystem>;
+}
+declare const createWebgalMonacoLanguageClientWithWorker: (options: CreateWebgalMonacoLanguageClientWorkerOptions) => {
+  worker: Worker;
+  vfs: ReturnType<typeof createMemoryFileSystem>;
+};
+//#endregion
+//#region src/monaco/monaco-init.d.ts
+declare function initWebgalMonaco(): Promise<void>;
+//#endregion
+export { VirtualFileSystem as C, WebgalClientHandlers as D, VolarWritableFileSystem as E, VirtualFileEntry as S, VirtualFileSystemChangeListener as T, DirectoryEntry as _, createWebgalMonacoLanguageClientWithWorker as a, VirtualDirectoryEntry as b, pathToUri as c, createMemoryVolarFileSystem as d, createVirtualFileSystem as f, CreateWebgalClientHandlersOptions as g, registerWebgalClientHandlers as h, createWebgalMonacoLanguageClient as i, toVfsPath as l, createWebgalClientHandlers as m, CreateWebgalMonacoLanguageClientOptions as n, joinPaths as o, createVolarFileSystem as p, CreateWebgalMonacoLanguageClientWorkerOptions as r, normalizePath as s, initWebgalMonaco as t, uriToPath as u, LanguageClientLike as v, VirtualFileSystemChange as w, VirtualEntry as x, MaybePromise as y };