@gi-tcg/gts-language-server 0.3.7 → 0.3.9

package/dist/browser.js

@@ -2,10 +2,49 @@ import { createConnection, createServer, createTypeScriptProject, loadTsdkByUrl
 import { GtsVirtualCode, createGtsLanguagePlugin } from "@gi-tcg/gts-language-plugin";
 import path from "path-browserify-esm";
 import "@gi-tcg/gts-transpiler";
+import { fs } from "@zenfs/core";
 import { DiagnosticSeverity } from "@volar/language-server";
 import { URI } from "vscode-uri";
 import { create } from "volar-service-typescript";
-import { fs } from "@zenfs/core";
+//#region src/zen_fs_provider.ts
+function zenFsProvider(fs) {
+	return {
+		stat(uri) {
+			try {
+				const stats = fs.statSync(uri.path);
+				console.log("stat", uri.path, stats);
+				return {
+					type: stats.isFile() ? 1 : stats.isDirectory() ? 2 : stats.isSymbolicLink() ? 64 : 0,
+					ctime: stats.ctimeMs,
+					mtime: stats.mtimeMs,
+					size: stats.size
+				};
+			} catch {
+				return;
+			}
+		},
+		readFile(uri, encoding) {
+			try {
+				console.log("readFile", uri.path);
+				return fs.readFileSync(uri.path, { encoding: encoding ?? "utf-8" });
+			} catch {
+				return;
+			}
+		},
+		readDirectory(uri) {
+			try {
+				const files = fs.readdirSync(uri.path, { withFileTypes: true });
+				console.log("readDirectory", uri.path, files.map((f) => f.name));
+				return files.map((file) => {
+					return [file.name, file.isFile() ? 1 : file.isDirectory() ? 2 : file.isSymbolicLink() ? 64 : 0];
+				});
+			} catch {
+				return [];
+			}
+		}
+	};
+}
+//#endregion
 //#region src/utils.ts
 /**
 * Get virtual code from the encoded document URI
@@ -19,7 +58,73 @@ function getVirtualCode(document, context) {
 	return [virtualCode, sourceUri];
 }
 //#endregion
-//#region src/diagnostics.ts
+//#region src/services/code_lens.ts
+const createCodeLensPlugin = () => {
+	return {
+		name: "gts-code-lens",
+		capabilities: { codeLensProvider: {} },
+		create: (context) => {
+			return { provideCodeLenses: async (document, token) => {
+				const [virtualCode] = getVirtualCode(document, context);
+				if (!virtualCode) return [];
+				const result = [];
+				for (const mapping of virtualCode.mappings) if (mapping.data.directActionStub) {
+					const startOffset = mapping.generatedOffsets[0];
+					const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+					const start = document.positionAt(startOffset);
+					const end = document.positionAt(startOffset + length);
+					result.push({
+						range: {
+							start,
+							end
+						},
+						command: {
+							title: "~action",
+							command: ""
+						}
+					});
+				}
+				return result;
+			} };
+		}
+	};
+};
+//#endregion
+//#region src/services/completion.ts
+const createCompletionPlugin = () => {
+	return {
+		name: "gts-completion",
+		capabilities: { completionProvider: { triggerCharacters: [":"] } },
+		create: (context) => {
+			let tsProvideCompletionItems;
+			for (const [plugin, instance] of context.plugins) if (plugin.name === "typescript-semantic" && instance.provideCompletionItems) {
+				let originalProvideCompletionItems = instance.provideCompletionItems;
+				tsProvideCompletionItems = instance.provideCompletionItems = async (...args) => {
+					const response = await originalProvideCompletionItems.apply(instance, args);
+					if (!response) return response;
+					const items = response.items.filter((item) => !item.label.startsWith("__gts_"));
+					return {
+						...response,
+						items
+					};
+				};
+			}
+			if (!tsProvideCompletionItems) {
+				console.warn(`TS's original provideCompletionItems not found`);
+				return {};
+			}
+			return { provideCompletionItems: async (document, position, context, token) => {
+				if (context.triggerCharacter === ":") {
+					context.triggerCharacter = ".";
+					return await tsProvideCompletionItems(document, position, context, token);
+				}
+				return null;
+			} };
+		}
+	};
+};
+//#endregion
+//#region src/services/diagnostics.ts
 const createDiagnosticsPlugin = () => {
 	return {
 		name: "gts-diagnostics",
@@ -70,85 +175,97 @@ const createDiagnosticsPlugin = () => {
 	};
 };
 //#endregion
-//#region src/typescript.ts
-function createTypeScriptServices(ts) {
-	const services = create(ts);
-	const semanticService = services.find((service) => service.name === "typescript-semantic");
-	if (semanticService?.capabilities.signatureHelpProvider?.triggerCharacters) semanticService.capabilities.signatureHelpProvider.triggerCharacters.push(" ");
-	return services;
-}
-//#endregion
-//#region src/completion.ts
-const createCompletionPlugin = () => {
+//#region src/services/semantic_tokens.ts
+const createSemanticTokensPlugin = () => {
 	return {
-		name: "gts-completion",
-		capabilities: { completionProvider: { triggerCharacters: [":"] } },
+		name: "gts-semantic-tokens",
+		capabilities: { semanticTokensProvider: { legend: {
+			tokenTypes: ["string"],
+			tokenModifiers: ["gtsAttribute"]
+		} } },
 		create: (context) => {
-			let tsProvideCompletionItems;
-			for (const [plugin, instance] of context.plugins) if (plugin.name === "typescript-semantic" && instance.provideCompletionItems) {
-				let originalProvideCompletionItems = instance.provideCompletionItems;
-				tsProvideCompletionItems = instance.provideCompletionItems = async (...args) => {
-					const response = await originalProvideCompletionItems.apply(instance, args);
+			let tsSemanticTokens;
+			for (const [plugin, instance] of context.plugins) if (plugin.name === "typescript-semantic" && instance.provideDocumentSemanticTokens) {
+				let originalProvideDocumentSemanticTokens = instance.provideDocumentSemanticTokens;
+				tsSemanticTokens = instance.provideDocumentSemanticTokens = async (document, range, legend, token) => {
+					const response = await originalProvideDocumentSemanticTokens.call(instance, document, range, legend, token);
 					if (!response) return response;
-					const items = response.items.filter((item) => !item.label.startsWith("__gts_"));
-					return {
-						...response,
-						items
-					};
+					const gtsAttributeIndex = legend.tokenModifiers.indexOf("gtsAttribute");
+					if (gtsAttributeIndex === -1) return response;
+					const [virtualCode] = getVirtualCode(document, context);
+					if (!virtualCode) return response;
+					for (let i = 0; i < response.length; i++) {
+						const [line, character, length, tokenType, tokenModifiers] = response[i];
+						if (tokenType !== legend.tokenTypes.indexOf("method")) continue;
+						const offset = document.offsetAt({
+							line,
+							character
+						});
+						if (virtualCode.mappings.find((m) => m.generatedOffsets[0] === offset && m.data.gtsAttribute)) response[i][4] |= 1 << gtsAttributeIndex;
+					}
+					return response;
 				};
 			}
-			if (!tsProvideCompletionItems) {
-				console.warn(`TS's original provideCompletionItems not found`);
-				return {};
-			}
-			return { provideCompletionItems: async (document, position, context, token) => {
-				if (context.triggerCharacter === ":") {
-					context.triggerCharacter = ".";
-					return await tsProvideCompletionItems(document, position, context, token);
+			if (!tsSemanticTokens) console.warn(`TS's original provideDocumentSemanticTokens not found`);
+			return { provideDocumentSemanticTokens(document, range, legend, token) {
+				const [virtualCode] = getVirtualCode(document, context);
+				if (!virtualCode) return null;
+				const stringIdx = legend.tokenTypes.indexOf("string");
+				if (stringIdx === -1) return null;
+				const gtsAttributeIndex = legend.tokenModifiers.indexOf("gtsAttribute");
+				const result = [];
+				const text = document.getText();
+				for (const mapping of virtualCode.mappings) {
+					if (mapping.data.literalFromId) {
+						const offset = mapping.generatedOffsets[0];
+						const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+						const pos = document.positionAt(offset);
+						result.push([
+							pos.line,
+							pos.character,
+							length,
+							stringIdx,
+							0
+						]);
+					}
+					if (gtsAttributeIndex >= 0 && mapping.data.gtsAttribute) {
+						const offset = mapping.generatedOffsets[0];
+						const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+						const pos = document.positionAt(offset);
+						const char = text[offset];
+						if (char === "\"" || char === "'") result.push([
+							pos.line,
+							pos.character,
+							length,
+							stringIdx,
+							1 << gtsAttributeIndex
+						]);
+					}
 				}
-				return null;
+				return result;
 			} };
 		}
 	};
 };
 //#endregion
-//#region src/zen_fs_provider.ts
-function zenFsProvider(fs) {
-	return {
-		stat(uri) {
-			try {
-				const stats = fs.statSync(uri.path);
-				console.log("stat", uri.path, stats);
-				return {
-					type: stats.isFile() ? 1 : stats.isDirectory() ? 2 : stats.isSymbolicLink() ? 64 : 0,
-					ctime: stats.ctimeMs,
-					mtime: stats.mtimeMs,
-					size: stats.size
-				};
-			} catch {
-				return;
-			}
-		},
-		readFile(uri, encoding) {
-			try {
-				console.log("readFile", uri.path);
-				return fs.readFileSync(uri.path, { encoding: encoding ?? "utf-8" });
-			} catch {
-				return;
-			}
-		},
-		readDirectory(uri) {
-			try {
-				const files = fs.readdirSync(uri.path, { withFileTypes: true });
-				console.log("readDirectory", uri.path, files.map((f) => f.name));
-				return files.map((file) => {
-					return [file.name, file.isFile() ? 1 : file.isDirectory() ? 2 : file.isSymbolicLink() ? 64 : 0];
-				});
-			} catch {
-				return [];
-			}
-		}
-	};
+//#region src/services/typescript.ts
+function createTypeScriptServices(ts) {
+	const services = create(ts);
+	const semanticService = services.find((service) => service.name === "typescript-semantic");
+	if (semanticService?.capabilities.signatureHelpProvider?.triggerCharacters) semanticService.capabilities.signatureHelpProvider.triggerCharacters.push(" ");
+	if (semanticService?.capabilities.semanticTokensProvider?.legend) semanticService.capabilities.semanticTokensProvider.legend.tokenModifiers.push("gtsAttribute");
+	return services;
+}
+//#endregion
+//#region src/services/index.ts
+function createLanguageServicePlugins(ts) {
+	return [
+		...createTypeScriptServices(ts),
+		createDiagnosticsPlugin(),
+		createCompletionPlugin(),
+		createSemanticTokensPlugin(),
+		createCodeLensPlugin()
+	];
 }
 //#endregion
 //#region src/browser.ts
@@ -166,11 +283,7 @@ connection.onInitialize(async (params) => {
 	}
 	return server.initialize(params, createTypeScriptProject(tsdk.typescript, tsdk.diagnosticMessages, ({ env }) => {
 		return { languagePlugins: [createGtsLanguagePlugin(tsdk.typescript, inlineGtsConfig)] };
-	}), [
-		...createTypeScriptServices(tsdk.typescript),
-		createDiagnosticsPlugin(),
-		createCompletionPlugin()
-	]);
+	}), createLanguageServicePlugins(tsdk.typescript));
 });
 connection.onInitialized(server.initialized);
 connection.onShutdown(server.shutdown);

package/dist/node.js

@@ -16,7 +16,73 @@ function getVirtualCode(document, context) {
 	return [virtualCode, sourceUri];
 }
 //#endregion
-//#region src/diagnostics.ts
+//#region src/services/code_lens.ts
+const createCodeLensPlugin = () => {
+	return {
+		name: "gts-code-lens",
+		capabilities: { codeLensProvider: {} },
+		create: (context) => {
+			return { provideCodeLenses: async (document, token) => {
+				const [virtualCode] = getVirtualCode(document, context);
+				if (!virtualCode) return [];
+				const result = [];
+				for (const mapping of virtualCode.mappings) if (mapping.data.directActionStub) {
+					const startOffset = mapping.generatedOffsets[0];
+					const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+					const start = document.positionAt(startOffset);
+					const end = document.positionAt(startOffset + length);
+					result.push({
+						range: {
+							start,
+							end
+						},
+						command: {
+							title: "~action",
+							command: ""
+						}
+					});
+				}
+				return result;
+			} };
+		}
+	};
+};
+//#endregion
+//#region src/services/completion.ts
+const createCompletionPlugin = () => {
+	return {
+		name: "gts-completion",
+		capabilities: { completionProvider: { triggerCharacters: [":"] } },
+		create: (context) => {
+			let tsProvideCompletionItems;
+			for (const [plugin, instance] of context.plugins) if (plugin.name === "typescript-semantic" && instance.provideCompletionItems) {
+				let originalProvideCompletionItems = instance.provideCompletionItems;
+				tsProvideCompletionItems = instance.provideCompletionItems = async (...args) => {
+					const response = await originalProvideCompletionItems.apply(instance, args);
+					if (!response) return response;
+					const items = response.items.filter((item) => !item.label.startsWith("__gts_"));
+					return {
+						...response,
+						items
+					};
+				};
+			}
+			if (!tsProvideCompletionItems) {
+				console.warn(`TS's original provideCompletionItems not found`);
+				return {};
+			}
+			return { provideCompletionItems: async (document, position, context, token) => {
+				if (context.triggerCharacter === ":") {
+					context.triggerCharacter = ".";
+					return await tsProvideCompletionItems(document, position, context, token);
+				}
+				return null;
+			} };
+		}
+	};
+};
+//#endregion
+//#region src/services/diagnostics.ts
 const createDiagnosticsPlugin = () => {
 	return {
 		name: "gts-diagnostics",
@@ -67,48 +133,99 @@ const createDiagnosticsPlugin = () => {
 	};
 };
 //#endregion
-//#region src/typescript.ts
-function createTypeScriptServices(ts) {
-	const services = create(ts);
-	const semanticService = services.find((service) => service.name === "typescript-semantic");
-	if (semanticService?.capabilities.signatureHelpProvider?.triggerCharacters) semanticService.capabilities.signatureHelpProvider.triggerCharacters.push(" ");
-	return services;
-}
-//#endregion
-//#region src/completion.ts
-const createCompletionPlugin = () => {
+//#region src/services/semantic_tokens.ts
+const createSemanticTokensPlugin = () => {
 	return {
-		name: "gts-completion",
-		capabilities: { completionProvider: { triggerCharacters: [":"] } },
+		name: "gts-semantic-tokens",
+		capabilities: { semanticTokensProvider: { legend: {
+			tokenTypes: ["string"],
+			tokenModifiers: ["gtsAttribute"]
+		} } },
 		create: (context) => {
-			let tsProvideCompletionItems;
-			for (const [plugin, instance] of context.plugins) if (plugin.name === "typescript-semantic" && instance.provideCompletionItems) {
-				let originalProvideCompletionItems = instance.provideCompletionItems;
-				tsProvideCompletionItems = instance.provideCompletionItems = async (...args) => {
-					const response = await originalProvideCompletionItems.apply(instance, args);
+			let tsSemanticTokens;
+			for (const [plugin, instance] of context.plugins) if (plugin.name === "typescript-semantic" && instance.provideDocumentSemanticTokens) {
+				let originalProvideDocumentSemanticTokens = instance.provideDocumentSemanticTokens;
+				tsSemanticTokens = instance.provideDocumentSemanticTokens = async (document, range, legend, token) => {
+					const response = await originalProvideDocumentSemanticTokens.call(instance, document, range, legend, token);
 					if (!response) return response;
-					const items = response.items.filter((item) => !item.label.startsWith("__gts_"));
-					return {
-						...response,
-						items
-					};
+					const gtsAttributeIndex = legend.tokenModifiers.indexOf("gtsAttribute");
+					if (gtsAttributeIndex === -1) return response;
+					const [virtualCode] = getVirtualCode(document, context);
+					if (!virtualCode) return response;
+					for (let i = 0; i < response.length; i++) {
+						const [line, character, length, tokenType, tokenModifiers] = response[i];
+						if (tokenType !== legend.tokenTypes.indexOf("method")) continue;
+						const offset = document.offsetAt({
+							line,
+							character
+						});
+						if (virtualCode.mappings.find((m) => m.generatedOffsets[0] === offset && m.data.gtsAttribute)) response[i][4] |= 1 << gtsAttributeIndex;
+					}
+					return response;
 				};
 			}
-			if (!tsProvideCompletionItems) {
-				console.warn(`TS's original provideCompletionItems not found`);
-				return {};
-			}
-			return { provideCompletionItems: async (document, position, context, token) => {
-				if (context.triggerCharacter === ":") {
-					context.triggerCharacter = ".";
-					return await tsProvideCompletionItems(document, position, context, token);
+			if (!tsSemanticTokens) console.warn(`TS's original provideDocumentSemanticTokens not found`);
+			return { provideDocumentSemanticTokens(document, range, legend, token) {
+				const [virtualCode] = getVirtualCode(document, context);
+				if (!virtualCode) return null;
+				const stringIdx = legend.tokenTypes.indexOf("string");
+				if (stringIdx === -1) return null;
+				const gtsAttributeIndex = legend.tokenModifiers.indexOf("gtsAttribute");
+				const result = [];
+				const text = document.getText();
+				for (const mapping of virtualCode.mappings) {
+					if (mapping.data.literalFromId) {
+						const offset = mapping.generatedOffsets[0];
+						const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+						const pos = document.positionAt(offset);
+						result.push([
+							pos.line,
+							pos.character,
+							length,
+							stringIdx,
+							0
+						]);
+					}
+					if (gtsAttributeIndex >= 0 && mapping.data.gtsAttribute) {
+						const offset = mapping.generatedOffsets[0];
+						const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+						const pos = document.positionAt(offset);
+						const char = text[offset];
+						if (char === "\"" || char === "'") result.push([
+							pos.line,
+							pos.character,
+							length,
+							stringIdx,
+							1 << gtsAttributeIndex
+						]);
+					}
 				}
-				return null;
+				return result;
 			} };
 		}
 	};
 };
 //#endregion
+//#region src/services/typescript.ts
+function createTypeScriptServices(ts) {
+	const services = create(ts);
+	const semanticService = services.find((service) => service.name === "typescript-semantic");
+	if (semanticService?.capabilities.signatureHelpProvider?.triggerCharacters) semanticService.capabilities.signatureHelpProvider.triggerCharacters.push(" ");
+	if (semanticService?.capabilities.semanticTokensProvider?.legend) semanticService.capabilities.semanticTokensProvider.legend.tokenModifiers.push("gtsAttribute");
+	return services;
+}
+//#endregion
+//#region src/services/index.ts
+function createLanguageServicePlugins(ts) {
+	return [
+		...createTypeScriptServices(ts),
+		createDiagnosticsPlugin(),
+		createCompletionPlugin(),
+		createSemanticTokensPlugin(),
+		createCodeLensPlugin()
+	];
+}
+//#endregion
 //#region src/node.ts
 const connection = createConnection();
 const server = createServer(connection);
@@ -117,11 +234,7 @@ connection.onInitialize((params) => {
 	const tsdk = loadTsdkByPath(params.initializationOptions.typescript.tsdk, params.locale);
 	return server.initialize(params, createTypeScriptProject(tsdk.typescript, tsdk.diagnosticMessages, () => {
 		return { languagePlugins: [createGtsLanguagePlugin(tsdk.typescript)] };
-	}), [
-		...createTypeScriptServices(tsdk.typescript),
-		createDiagnosticsPlugin(),
-		createCompletionPlugin()
-	]);
+	}), createLanguageServicePlugins(tsdk.typescript));
 });
 connection.onInitialized(server.initialized);
 connection.onShutdown(server.shutdown);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-language-server",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"
@@ -31,8 +31,8 @@
     "path-browserify-esm": "^1.0.6",
     "volar-service-typescript": "volar-2.4",
     "vscode-uri": "^3.0.8",
-    "@gi-tcg/gts-transpiler": "0.3.7",
-    "@gi-tcg/gts-language-plugin": "0.3.7"
+    "@gi-tcg/gts-language-plugin": "0.3.9",
+    "@gi-tcg/gts-transpiler": "0.3.9"
   },
   "devDependencies": {
     "vscode-languageserver-textdocument": "^1.0.12"

package/src/browser.ts

@@ -11,12 +11,10 @@ import {
 import { createGtsLanguagePlugin } from "@gi-tcg/gts-language-plugin";
 import path from "path-browserify-esm";
 import { type GtsConfig } from "@gi-tcg/gts-transpiler";
-import { createDiagnosticsPlugin } from "./diagnostics.ts";
-import { createTypeScriptServices } from "./typescript.ts";
-import { createCompletionPlugin } from "./completion.ts";
-import { Dirent, fs as memfs } from "@zenfs/core";
+import { fs as memfs } from "@zenfs/core";
 import type ts from "typescript";
 import zenFsProvider from "./zen_fs_provider.ts";
+import { createLanguageServicePlugins } from "./services/index.ts";
 
 export interface GtsLanguageServerBrowserInitializationOptions {
   tsdkUrl?: string;
@@ -65,11 +63,7 @@ connection.onInitialize(
           };
         },
       ),
-      [
-        ...createTypeScriptServices(tsdk.typescript),
-        createDiagnosticsPlugin(),
-        createCompletionPlugin(),
-      ],
+      createLanguageServicePlugins(tsdk.typescript),
     );
   },
 );
@@ -95,7 +89,9 @@ async function loadLibs(tsdkUrl: string) {
   memfs.mkdirSync("/node_modules/typescript/lib", { recursive: true });
   const libs = await Promise.all(
     ALL_LIBS.map((lib) =>
-      fetch(`${tsdkUrl}/${lib}`).then((res) => res.text()).then((content) => [lib, content] as const),
+      fetch(`${tsdkUrl}/${lib}`)
+        .then((res) => res.text())
+        .then((content) => [lib, content] as const),
     ),
   );
   for (const [lib, content] of libs) {

package/src/node.ts

@@ -6,9 +6,7 @@ import {
   loadTsdkByPath,
 } from "@volar/language-server/node.js";
 import { createGtsLanguagePlugin } from "@gi-tcg/gts-language-plugin";
-import { createDiagnosticsPlugin } from "./diagnostics.ts";
-import { createTypeScriptServices } from "./typescript.ts";
-import { createCompletionPlugin } from "./completion.ts";
+import { createLanguageServicePlugins } from "./services/index.ts";
 
 const connection = createConnection();
 const server = createServer(connection);
@@ -27,11 +25,7 @@ connection.onInitialize((params) => {
         languagePlugins: [createGtsLanguagePlugin(tsdk.typescript)],
       };
     }),
-    [
-      ...createTypeScriptServices(tsdk.typescript),
-      createDiagnosticsPlugin(),
-      createCompletionPlugin(),
-    ],
+    createLanguageServicePlugins(tsdk.typescript),
   );
 });
 

package/src/services/code_lens.ts

@@ -0,0 +1,39 @@
+import { CodeLens, type LanguageServicePlugin } from "@volar/language-server";
+import { getVirtualCode } from "../utils.ts";
+
+export const createCodeLensPlugin = (): LanguageServicePlugin => {
+  return {
+    name: "gts-code-lens",
+    capabilities: {
+      codeLensProvider: {},
+    },
+    create: (context) => {
+      return {
+        provideCodeLenses: async (document, token) => {
+          const [virtualCode] = getVirtualCode(document, context);
+          if (!virtualCode) {
+            return [];
+          }
+          const result: CodeLens[] = [];
+          for (const mapping of virtualCode.mappings) {
+            if (mapping.data.directActionStub) {
+              const startOffset = mapping.generatedOffsets[0];
+              const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+              const start = document.positionAt(startOffset);
+              // two character: "0;"
+              const end = document.positionAt(startOffset + length);
+              result.push({
+                range: { start, end },
+                command: {
+                  title: "~action",
+                  command: "",
+                },
+              });
+            }
+          }
+          return result;
+        },
+      };
+    },
+  };
+};

package/src/{diagnostics.ts → services/diagnostics.ts}

@@ -3,7 +3,7 @@ import {
   Range,
   type LanguageServicePlugin,
 } from "@volar/language-server";
-import { getVirtualCode } from "./utils.ts";
+import { getVirtualCode } from "../utils.ts";
 export const createDiagnosticsPlugin = (): LanguageServicePlugin => {
   return {
     name: "gts-diagnostics",

package/src/services/index.ts

@@ -0,0 +1,18 @@
+import { createCodeLensPlugin } from "./code_lens.ts";
+import { createCompletionPlugin } from "./completion.ts";
+import { createDiagnosticsPlugin } from "./diagnostics.ts";
+import { createSemanticTokensPlugin } from "./semantic_tokens.ts";
+import { createTypeScriptServices } from "./typescript.ts";
+import type { LanguageServicePlugin } from "@volar/language-server";
+
+export function createLanguageServicePlugins(
+  ts: typeof import("typescript"),
+): LanguageServicePlugin[] {
+  return [
+    ...createTypeScriptServices(ts),
+    createDiagnosticsPlugin(),
+    createCompletionPlugin(),
+    createSemanticTokensPlugin(),
+    createCodeLensPlugin(),
+  ];
+}

package/src/services/semantic_tokens.ts

@@ -0,0 +1,121 @@
+import {
+  type LanguageServicePlugin,
+  type LanguageServicePluginInstance,
+  type SemanticToken,
+} from "@volar/language-server";
+import { getVirtualCode } from "../utils.ts";
+
+export const createSemanticTokensPlugin = (): LanguageServicePlugin => {
+  return {
+    name: "gts-semantic-tokens",
+    capabilities: {
+      semanticTokensProvider: {
+        legend: {
+          tokenTypes: ["string"],
+          tokenModifiers: ["gtsAttribute"],
+        },
+      },
+    },
+    create: (context) => {
+      let tsSemanticTokens: LanguageServicePluginInstance["provideDocumentSemanticTokens"];
+
+      for (const [plugin, instance] of context.plugins) {
+        if (
+          plugin.name === "typescript-semantic" &&
+          instance.provideDocumentSemanticTokens
+        ) {
+          let originalProvideDocumentSemanticTokens =
+            instance.provideDocumentSemanticTokens;
+          tsSemanticTokens = instance.provideDocumentSemanticTokens = async (
+            document,
+            range,
+            legend,
+            token,
+          ) => {
+            const response = await originalProvideDocumentSemanticTokens.call(
+              instance,
+              document,
+              range,
+              legend,
+              token,
+            );
+            if (!response) {
+              return response;
+            }
+            const gtsAttributeIndex =
+              legend.tokenModifiers.indexOf("gtsAttribute");
+            if (gtsAttributeIndex === -1) {
+              return response;
+            }
+            const [virtualCode] = getVirtualCode(document, context);
+            if (!virtualCode) {
+              return response;
+            }
+            for (let i = 0; i < response.length; i++) {
+              const [line, character, length, tokenType, tokenModifiers] =
+                response[i];
+              if (tokenType !== legend.tokenTypes.indexOf("method")) {
+                continue;
+              }
+              const offset = document.offsetAt({ line, character });
+              const mapping = virtualCode.mappings.find(
+                (m) => m.generatedOffsets[0] === offset && m.data.gtsAttribute,
+              );
+              if (mapping) {
+                response[i][4] |= 1 << gtsAttributeIndex;
+              }
+            }
+            return response;
+          };
+        }
+      }
+      if (!tsSemanticTokens) {
+        console.warn(`TS's original provideDocumentSemanticTokens not found`);
+      }
+      return {
+        // Attribute value that is a string literal but no wrapping quotation with it,
+        // add a semantic token of type "string" to them so they show same color as string literal
+        provideDocumentSemanticTokens(document, range, legend, token) {
+          const [virtualCode] = getVirtualCode(document, context);
+          if (!virtualCode) {
+            return null;
+          }
+          const stringIdx = legend.tokenTypes.indexOf("string");
+          if (stringIdx === -1) {
+            return null;
+          }
+          const gtsAttributeIndex =
+            legend.tokenModifiers.indexOf("gtsAttribute");
+          const result: SemanticToken[] = [];
+          const text = document.getText();
+          for (const mapping of virtualCode.mappings) {
+            if (mapping.data.literalFromId) {
+              const offset = mapping.generatedOffsets[0];
+              const length = mapping.generatedLengths?.[0] ?? mapping.lengths[0];
+              const pos = document.positionAt(offset);
+              result.push([pos.line, pos.character, length, stringIdx, 0]);
+            }
+            if (gtsAttributeIndex >= 0 && mapping.data.gtsAttribute) {
+              const offset = mapping.generatedOffsets[0];
+              const length = mapping.generatedLengths?.[0] ??mapping.lengths[0];
+              const pos = document.positionAt(offset);
+              const char = text[offset];
+              if (char === '"' || char === "'") {
+                // A GTS attribute name with quotation, that will not have TS semantic token ("member")
+                // we add it as "string" with "gtsAttribute" modifier too.
+                result.push([
+                  pos.line,
+                  pos.character,
+                  length,
+                  stringIdx,
+                  1 << gtsAttributeIndex,
+                ]);
+              }
+            }
+          }
+          return result;
+        },
+      };
+    },
+  };
+};

package/src/{typescript.ts → services/typescript.ts}

@@ -16,5 +16,10 @@ export function createTypeScriptServices(
       " ",
     );
   }
+  if (semanticService?.capabilities.semanticTokensProvider?.legend) {
+    semanticService.capabilities.semanticTokensProvider.legend.tokenModifiers.push(
+      "gtsAttribute",
+    );
+  }
   return services;
 }

package/src/document_highlight.ts

@@ -1,114 +0,0 @@
-import type {
-  LanguageServicePluginInstance,
-  LanguageServicePlugin,
-} from "@volar/language-server";
-import { getVirtualCode, getWordFromPosition } from "./utils.ts";
-
-export function createDocumentHighlightService(): LanguageServicePlugin {
-  return {
-    name: "gts-document-highlight",
-    capabilities: {
-      documentHighlightProvider: true,
-    },
-    create(context) {
-      let originalProvideDocumentHighlights: LanguageServicePluginInstance["provideDocumentHighlights"];
-      let originalInstance: LanguageServicePluginInstance;
-
-      // Get TypeScript's document highlights provider
-      for (const [plugin, instance] of context.plugins) {
-        if (
-          plugin.name === "typescript-semantic" &&
-          instance.provideDocumentHighlights
-        ) {
-          originalInstance = instance;
-          originalProvideDocumentHighlights =
-            instance.provideDocumentHighlights;
-          instance.provideDocumentHighlights = undefined;
-          break;
-        }
-      }
-
-      if (!originalProvideDocumentHighlights) {
-        console?.log(
-          "'typescript-semantic plugin' was not found or has no 'provideDocumentHighlights'. \
-					Document highlights will be limited to custom GamingTS keywords only."
-        );
-      }
-
-      return {
-        async provideDocumentHighlights(document, position, token) {
-          if (!originalProvideDocumentHighlights) {
-            return null;
-          }
-
-          let tsHighlights = await originalProvideDocumentHighlights.call(
-            originalInstance,
-            document,
-            position,
-            token
-          );
-
-          if (!tsHighlights || tsHighlights.length > 0) {
-            // If TypeScript recognized tokens and provided highlights, return them
-            return tsHighlights;
-          }
-
-          const [virtualCode] = getVirtualCode(document, context);
-
-          if (!virtualCode) {
-            return tsHighlights;
-          }
-
-          // Check if we're on a custom Ripple keyword
-          const offset = document.offsetAt(position);
-          const text = document.getText();
-
-          // Find word boundaries
-          const { word } = getWordFromPosition(text, offset);
-
-          // If the word is a Ripple keyword, find all occurrences in the document
-
-          const regex = new RegExp(`\\b${word}\\b`, "g");
-          let match;
-
-          // while ((match = regex.exec(text)) !== null) {
-          //   const start = match.index;
-          //   const end = match.index + word.length;
-          //   const mapping = virtualCode.findMappingByGeneratedRange(start, end);
-
-          //   if (!mapping) {
-          //     // If no mapping, skip all others as well
-          //     // This shouldn't happen as TS handles only mapped ranges
-          //     return tsHighlights;
-          //   }
-
-          //   if (!mapping.data.customData?.wordHighlight?.kind) {
-          //     // Skip if we didn't define word highlighting in segments
-          //     continue;
-          //   }
-
-          //   if (!tsHighlights) {
-          //     tsHighlights = [];
-          //   }
-
-          //   tsHighlights.push({
-          //     range: {
-          //       start: document.positionAt(start),
-          //       end: document.positionAt(end),
-          //     },
-
-          //     kind: mapping.data.customData.wordHighlight.kind,
-          //   });
-          // }
-
-          if (tsHighlights.length > 0) {
-            console?.log(`Found ${tsHighlights.length} occurrences of '${word}'`);
-          }
-
-          // Return TypeScript highlights if no custom keyword was found
-          return [...tsHighlights];
-        },
-      };
-    },
-  };
-}