@gi-tcg/gts-language-server 0.2.0

package/bin/gts-language-server.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+if (process.argv.includes("--version")) {
+  const pkgJSON = await import("../package.json");
+  console.log(`${pkgJSON["version"]}`);
+} else {
+  await import("../dist/index.js");
+}

package/dist/index.js

@@ -0,0 +1,104 @@
+// packages/language-server/src/index.ts
+import {
+  createConnection,
+  createServer,
+  createTypeScriptProject,
+  loadTsdkByPath
+} from "@volar/language-server/node.js";
+import { create as createTypeScriptServices } from "volar-service-typescript";
+import { createGtsLanguagePlugin } from "@gi-tcg/gts-language-plugin";
+
+// packages/language-server/src/diagnostics.ts
+import {
+  DiagnosticSeverity
+} from "@volar/language-server";
+
+// packages/language-server/src/utils.ts
+import { URI } from "vscode-uri";
+import { GtsVirtualCode } from "@gi-tcg/gts-language-plugin";
+function getVirtualCode(document, context) {
+  const uri = URI.parse(document.uri);
+  const decoded = context.decodeEmbeddedDocumentUri(uri);
+  const [sourceUri, virtualCodeId] = decoded;
+  const sourceScript = context.language.scripts.get(sourceUri);
+  const virtualCode = sourceScript?.generated?.embeddedCodes.get(virtualCodeId);
+  if (!virtualCode) {
+    return [null, sourceUri];
+  }
+  if (!(virtualCode instanceof GtsVirtualCode)) {
+    return [null, sourceUri];
+  }
+  return [virtualCode, sourceUri];
+}
+
+// packages/language-server/src/diagnostics.ts
+var createDiagnosticsPlugin = () => {
+  return {
+    name: "gts-diagnostics",
+    capabilities: {
+      diagnosticProvider: {
+        interFileDependencies: false,
+        workspaceDiagnostics: false
+      }
+    },
+    create: (context) => {
+      return {
+        provideDiagnostics: (document) => {
+          try {
+            console.log(document.uri);
+            const [virtualCode] = getVirtualCode(document, context);
+            console.log(document.uri, virtualCode);
+            if (!virtualCode) {
+              return;
+            }
+            return virtualCode.errors.map((err) => {
+              const loc = err.position ?? {
+                start: { line: 1, column: 0 },
+                end: { line: 1, column: 1 }
+              };
+              const range = {
+                start: {
+                  line: loc.start.line - 1,
+                  character: loc.start.column
+                },
+                end: { line: loc.end.line - 1, character: loc.end.column }
+              };
+              console.log(range);
+              return {
+                severity: DiagnosticSeverity.Error,
+                range,
+                message: err.message,
+                source: "gts-transpiler",
+                code: "gts-transpiler-error"
+              };
+            });
+          } catch (e) {
+            console.error(e);
+            return;
+          }
+        }
+      };
+    }
+  };
+};
+
+// packages/language-server/src/index.ts
+var connection = createConnection();
+var server = createServer(connection);
+connection.listen();
+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()]);
+});
+connection.onInitialized(server.initialized);
+connection.onShutdown(server.shutdown);
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught exception:", err);
+});
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled rejection at:", promise, "reason:", reason);
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@gi-tcg/gts-language-server",
+  "version": "0.2.0",
+  "repository": "https://github.com/piovium/gts.git",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "gts-language-server": "./bin/gts-language-server.js"
+  },
+  "files": [
+    "src",
+    "dist",
+    "bin"
+  ],
+  "scripts": {},
+  "dependencies": {
+    "@gi-tcg/gts-transpiler": "0.2.0",
+    "@gi-tcg/gts-language-plugin": "0.2.0",
+    "@volar/language-server": "~2.4.0",
+    "volar-service-typescript": "volar-2.4",
+    "vscode-uri": "^3.0.8"
+  },
+  "devDependencies": {
+    "vscode-languageserver-textdocument": "^1.0.12"
+  }
+}

package/src/diagnostics.ts

@@ -0,0 +1,55 @@
+import {
+  DiagnosticSeverity,
+  Range,
+  type LanguageServicePlugin,
+} from "@volar/language-server";
+import { getVirtualCode } from "./utils";
+export const createDiagnosticsPlugin = (): LanguageServicePlugin => {
+  return {
+    name: "gts-diagnostics",
+    capabilities: {
+      diagnosticProvider: {
+        interFileDependencies: false,
+        workspaceDiagnostics: false,
+      },
+    },
+    create: (context) => {
+      return {
+        provideDiagnostics: (document) => {
+          try {
+            console.log(document.uri);
+            const [virtualCode] = getVirtualCode(document, context);
+            console.log(document.uri, virtualCode);
+            if (!virtualCode) {
+              return;
+            }
+            return virtualCode.errors.map((err) => {
+              const loc = err.position ?? {
+                start: { line: 1, column: 0 },
+                end: { line: 1, column: 1 },
+              };
+              const range: Range = {
+                start: {
+                  line: loc.start.line - 1,
+                  character: loc.start.column,
+                },
+                end: { line: loc.end.line - 1, character: loc.end.column },
+              };
+              console.log(range);
+              return {
+                severity: DiagnosticSeverity.Error,
+                range,
+                message: err.message,
+                source: "gts-transpiler",
+                code: "gts-transpiler-error",
+              };
+            });
+          } catch (e) {
+            console.error(e);
+            return;
+          }
+        },
+      };
+    },
+  };
+};

package/src/document_highlight.ts

@@ -0,0 +1,114 @@
+import type {
+  LanguageServicePluginInstance,
+  LanguageServicePlugin,
+} from "@volar/language-server";
+import { getVirtualCode, getWordFromPosition } from "./utils";
+
+export function createDocumentHighlightPlugin(): 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];
+        },
+      };
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+import {
+  createConnection,
+  createServer,
+  createTypeScriptProject,
+  Diagnostic,
+  loadTsdkByPath,
+} from "@volar/language-server/node.js";
+import { create as createTypeScriptServices } from "volar-service-typescript";
+import { createGtsLanguagePlugin } from "@gi-tcg/gts-language-plugin";
+import { createDiagnosticsPlugin } from "./diagnostics";
+
+const connection = createConnection();
+const server = createServer(connection);
+
+connection.listen();
+
+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()],
+  );
+});
+
+connection.onInitialized(server.initialized);
+
+connection.onShutdown(server.shutdown);
+
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught exception:", err);
+});
+
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled rejection at:", promise, "reason:", reason);
+});

package/src/utils.ts

@@ -0,0 +1,59 @@
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import type { LanguageServiceContext } from "@volar/language-server";
+
+import { URI } from "vscode-uri";
+import { GtsVirtualCode } from "@gi-tcg/gts-language-plugin";
+
+/**
+ * Get virtual code from the encoded document URI
+ */
+export function getVirtualCode(
+  document: TextDocument,
+  context: LanguageServiceContext
+): [GtsVirtualCode | null, URI] {
+  const uri = URI.parse(document.uri);
+  const decoded = context.decodeEmbeddedDocumentUri(uri) as [
+    documentUri: URI,
+    embeddedCodeId: string
+  ];
+  const [sourceUri, virtualCodeId] = decoded;
+  const sourceScript = context.language.scripts.get(sourceUri);
+  const virtualCode = sourceScript?.generated?.embeddedCodes.get(
+    virtualCodeId
+  );
+
+  if (!virtualCode) {
+    return [null, sourceUri];
+  }
+  if (!(virtualCode instanceof GtsVirtualCode)) {
+    return [null, sourceUri];
+  }
+  return [virtualCode, sourceUri];
+}
+
+const wordRegex = /\w/;
+
+/**
+ * Get the word at a specific position in the text
+ */
+export function getWordFromPosition(
+  text: string,
+  start: number
+): { word: string; start: number; end: number } {
+  let wordStart = start;
+  let wordEnd = start;
+  while (wordStart > 0 && wordRegex.test(text[wordStart - 1])) {
+    wordStart--;
+  }
+  while (wordEnd < text.length && wordRegex.test(text[wordEnd])) {
+    wordEnd++;
+  }
+
+  const word = text.substring(wordStart, wordEnd);
+
+  return {
+    word,
+    start: wordStart,
+    end: wordEnd,
+  };
+}