@gi-tcg/gts-language-plugin 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { LanguagePlugin } from "@volar/language-core";
+import { URI } from "vscode-uri";
+import * as import_8myeez from "typescript";
+declare function createGtsLanguagePlugin(ts: typeof import_8myeez): LanguagePlugin<URI | string>;
+import { GtsTranspilerError, GtsConfig } from "@gi-tcg/gts-transpiler";
+import { CodeMapping, VirtualCode } from "@volar/language-core";
+import * as ts from "typescript";
+declare class GtsVirtualCode implements VirtualCode {
+	id: string;
+	languageId: string;
+	mappings: CodeMapping[];
+	snapshot: ts.IScriptSnapshot;
+	errors: GtsTranspilerError[];
+	constructor(filename: string, snapshot: ts.IScriptSnapshot, config: Required<GtsConfig>);
+}
+export { createGtsLanguagePlugin, GtsVirtualCode };

package/dist/index.js

@@ -0,0 +1,101 @@
+// packages/language-plugin/src/language_plugin.ts
+import { resolveGtsConfigSync } from "@gi-tcg/gts-transpiler";
+
+// packages/language-plugin/src/virtual_code.ts
+import {
+  GtsTranspilerError,
+  transpileForVolar
+} from "@gi-tcg/gts-transpiler";
+
+class GtsVirtualCode {
+  id = "root";
+  languageId = "gaming-ts";
+  mappings;
+  snapshot;
+  errors = [];
+  constructor(filename, snapshot, config) {
+    const source = snapshot.getText(0, snapshot.getLength());
+    try {
+      const { code, mappings } = transpileForVolar(source, filename, config);
+      this.errors = [];
+      this.mappings = mappings;
+      this.snapshot = {
+        getText: (start, end) => code.slice(start, end),
+        getLength: () => code.length,
+        getChangeRange: () => {
+          return;
+        }
+      };
+    } catch (e) {
+      if (e instanceof GtsTranspilerError) {
+        this.errors = [e];
+      } else {
+        this.errors = [new GtsTranspilerError(e?.message, null)];
+      }
+      const emptyGeneration = source.split(`
+`).map((line) => " ".repeat(line.length)).join(`
+`);
+      this.mappings = [
+        {
+          sourceOffsets: [0],
+          generatedOffsets: [0],
+          lengths: [emptyGeneration.length],
+          data: {
+            verification: true
+          }
+        }
+      ];
+      this.snapshot = {
+        getText: (start, end) => emptyGeneration.substring(start, end),
+        getLength: () => emptyGeneration.length,
+        getChangeRange: () => {
+          return;
+        }
+      };
+    }
+  }
+}
+
+// packages/language-plugin/src/language_plugin.ts
+function createGtsLanguagePlugin(ts) {
+  return {
+    getLanguageId(uri) {
+      const path = typeof uri === "string" ? uri : uri.path;
+      if (path.endsWith(".gts")) {
+        return "gaming-ts";
+      }
+    },
+    createVirtualCode(uri, languageId, snapshot) {
+      const filename = typeof uri === "string" ? uri : uri.path;
+      if (languageId === "gaming-ts") {
+        const resolvedConfig = resolveGtsConfigSync(filename, {}, {
+          cwd: ts.sys.getCurrentDirectory(),
+          readFileFn: (path, encoding) => ts.sys.readFile(path, encoding) || ""
+        });
+        return new GtsVirtualCode(filename, snapshot, resolvedConfig);
+      }
+    },
+    typescript: {
+      extraFileExtensions: [
+        {
+          extension: "gts",
+          isMixedContent: false,
+          scriptKind: 7
+        }
+      ],
+      getServiceScript(root) {
+        if (root.languageId === "gaming-ts") {
+          return {
+            code: root,
+            extension: ".ts",
+            scriptKind: 3
+          };
+        }
+      }
+    }
+  };
+}
+export {
+  createGtsLanguagePlugin,
+  GtsVirtualCode
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@gi-tcg/gts-language-plugin",
+  "version": "0.2.0",
+  "repository": "https://github.com/piovium/gts.git",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "dependencies": {
+    "@gi-tcg/gts-transpiler": "0.2.0",
+    "@volar/language-core": "~2.4.0",
+    "@volar/typescript": "~2.4.0",
+    "vscode-uri": "^3.0.8"
+  }
+}

package/src/env.d.ts

@@ -0,0 +1,10 @@
+declare global {
+  var console:
+    | {
+        log: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+      }
+    | undefined;
+}
+
+export {};

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createGtsLanguagePlugin } from "./language_plugin";
+export { GtsVirtualCode } from "./virtual_code";

package/src/language_plugin.ts

@@ -0,0 +1,52 @@
+import { type LanguagePlugin } from "@volar/language-core";
+import type {} from "@volar/typescript";
+import type * as ts from "typescript";
+import { URI } from "vscode-uri";
+import { resolveGtsConfigSync, type GtsConfig } from "@gi-tcg/gts-transpiler";
+import { GtsVirtualCode } from "./virtual_code";
+
+export function createGtsLanguagePlugin(
+  ts: typeof import("typescript"),
+): LanguagePlugin<URI | string> {
+  return {
+    getLanguageId(uri) {
+      const path = typeof uri === "string" ? uri : uri.path;
+      if (path.endsWith(".gts")) {
+        return "gaming-ts";
+      }
+    },
+    createVirtualCode(uri, languageId, snapshot) {
+      const filename = typeof uri === "string" ? uri : uri.path;
+      if (languageId === "gaming-ts") {
+        const resolvedConfig = resolveGtsConfigSync(
+          filename,
+          {},
+          {
+            cwd: ts.sys.getCurrentDirectory(),
+            readFileFn: (path, encoding) =>
+              ts.sys.readFile(path, encoding) || "",
+          },
+        );
+        return new GtsVirtualCode(filename, snapshot, resolvedConfig);
+      }
+    },
+    typescript: {
+      extraFileExtensions: [
+        {
+          extension: "gts",
+          isMixedContent: false,
+          scriptKind: 7 satisfies ts.ScriptKind.Deferred,
+        },
+      ],
+      getServiceScript(root) {
+        if (root.languageId === "gaming-ts") {
+          return {
+            code: root,
+            extension: ".ts",
+            scriptKind: 3 satisfies ts.ScriptKind.TS,
+          };
+        }
+      },
+    },
+  };
+}

package/src/virtual_code.ts

@@ -0,0 +1,60 @@
+import {
+  GtsTranspilerError,
+  transpileForVolar,
+  type GtsConfig,
+} from "@gi-tcg/gts-transpiler";
+import { type CodeMapping, type VirtualCode } from "@volar/language-core";
+import type * as ts from "typescript";
+
+export class GtsVirtualCode implements VirtualCode {
+  id = "root";
+  languageId = "gaming-ts";
+  mappings: CodeMapping[];
+  snapshot: ts.IScriptSnapshot;
+  errors: GtsTranspilerError[] = [];
+
+  constructor(
+    filename: string,
+    snapshot: ts.IScriptSnapshot,
+    config: Required<GtsConfig>,
+  ) {
+    const source = snapshot.getText(0, snapshot.getLength());
+    try {
+      const { code, mappings } = transpileForVolar(source, filename, config);
+      this.errors = [];
+      this.mappings = mappings;
+      this.snapshot = {
+        getText: (start, end) => code.slice(start, end),
+        getLength: () => code.length,
+        getChangeRange: () => void 0,
+      };
+    } catch (e) {
+      if (e instanceof GtsTranspilerError) {
+        this.errors = [e];
+      } else {
+        this.errors = [new GtsTranspilerError((e as Error)?.message, null)];
+      }
+
+      const emptyGeneration = source
+        .split("\n")
+        .map((line) => " ".repeat(line.length))
+        .join("\n");
+      this.mappings = [
+        {
+          sourceOffsets: [0],
+          generatedOffsets: [0],
+          lengths: [emptyGeneration.length],
+          data: {
+            verification: true,
+          },
+        },
+      ];
+
+      this.snapshot = {
+        getText: (start, end) => emptyGeneration.substring(start, end),
+        getLength: () => emptyGeneration.length,
+        getChangeRange: () => void 0,
+      };
+    }
+  }
+}