@rs-x/typescript-plugin 2.0.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 robert-sanders-software-ontwikkeling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,330 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// lib/index.ts
+var import_compiler = require("@rs-x/compiler");
+function init(modules) {
+  const ts = modules.typescript;
+  function create(info) {
+    const languageService = info.languageService;
+    const proxy = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(languageService)) {
+      const value = languageService[key];
+      proxy[key] = typeof value === "function" ? value.bind(languageService) : value;
+    }
+    proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+      const baseCompletions = languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);
+      const program = languageService.getProgram?.();
+      if (!program) {
+        return baseCompletions;
+      }
+      const rsxRegion = (0, import_compiler.findRsxExpressionRegionAtPosition)(program, fileName, position);
+      if (!rsxRegion) {
+        return baseCompletions;
+      }
+      const rsxCompletions = (0, import_compiler.getRsxCompletionsAtPosition)(program, fileName, position);
+      const pluginEntries = rsxCompletions.map((completion) => ({
+        name: completion.name,
+        kind: completion.kind === "method" ? ts.ScriptElementKind.memberFunctionElement : completion.kind === "constructor" ? ts.ScriptElementKind.classElement : ts.ScriptElementKind.memberVariableElement,
+        kindModifiers: "",
+        sortText: "0"
+      }));
+      const uniquePluginEntries = dedupeCompletionEntries(pluginEntries);
+      return {
+        entries: uniquePluginEntries,
+        isGlobalCompletion: false,
+        isMemberCompletion: true,
+        isNewIdentifierLocation: false
+      };
+    };
+    proxy.getQuickInfoAtPosition = (fileName, position) => {
+      const program = languageService.getProgram?.();
+      if (!program) {
+        return languageService.getQuickInfoAtPosition(fileName, position);
+      }
+      const hover = (0, import_compiler.getRsxHoverAtPosition)(program, fileName, position);
+      if (!hover) {
+        return languageService.getQuickInfoAtPosition(fileName, position);
+      }
+      const sourceFile = program.getSourceFile(fileName);
+      const hoveredIdentifier = sourceFile?.text.slice(hover.start, hover.end) ?? "";
+      const hoverLabel = hoveredIdentifier && !hover.text.startsWith(`${hoveredIdentifier}:`) ? `${hoveredIdentifier}: ${hover.text}` : hover.text;
+      return {
+        // Use a neutral symbol kind and an explicit label to avoid duplicated
+        // type-only renderings in VS Code tooltips.
+        kind: ts.ScriptElementKind.unknown,
+        kindModifiers: "",
+        textSpan: {
+          start: hover.start,
+          length: hover.end - hover.start
+        },
+        displayParts: [
+          {
+            kind: "text",
+            text: hoverLabel
+          }
+        ],
+        documentation: []
+      };
+    };
+    proxy.getSignatureHelpItems = (fileName, position, options) => {
+      const baseSignatureHelp = languageService.getSignatureHelpItems(fileName, position, options);
+      const program = languageService.getProgram?.();
+      if (!program) {
+        return baseSignatureHelp;
+      }
+      const rsxRegion = (0, import_compiler.findRsxExpressionRegionAtPosition)(program, fileName, position);
+      if (!rsxRegion) {
+        return baseSignatureHelp;
+      }
+      const rsxSignatureHelp = (0, import_compiler.getRsxSignatureHelpAtPosition)(program, fileName, position);
+      if (!rsxSignatureHelp) {
+        return void 0;
+      }
+      const signatureItems = rsxSignatureHelp.items.map((item) => ({
+        isVariadic: item.parameters.some((parameter) => parameter.isRest),
+        prefixDisplayParts: [
+          {
+            kind: "punctuation",
+            text: "("
+          }
+        ],
+        suffixDisplayParts: [
+          {
+            kind: "text",
+            text: `): ${item.returnTypeText}`
+          }
+        ],
+        separatorDisplayParts: [
+          {
+            kind: "punctuation",
+            text: ", "
+          }
+        ],
+        parameters: item.parameters.map((parameter) => ({
+          name: parameter.name,
+          isOptional: parameter.isOptional,
+          isRest: parameter.isRest,
+          documentation: [],
+          displayParts: [
+            {
+              kind: "parameterName",
+              text: parameter.name
+            },
+            {
+              kind: "text",
+              text: ": "
+            },
+            {
+              kind: "text",
+              text: parameter.typeText
+            }
+          ]
+        })),
+        documentation: [],
+        tags: []
+      }));
+      return {
+        items: signatureItems,
+        applicableSpan: {
+          start: rsxSignatureHelp.applicableStart,
+          length: Math.max(1, rsxSignatureHelp.applicableEnd - rsxSignatureHelp.applicableStart)
+        },
+        selectedItemIndex: 0,
+        argumentIndex: rsxSignatureHelp.argumentIndex,
+        argumentCount: rsxSignatureHelp.argumentCount
+      };
+    };
+    proxy.getEncodedSemanticClassifications = (fileName, span, format) => {
+      const base = languageService.getEncodedSemanticClassifications(fileName, span, format) ?? {
+        spans: [],
+        endOfLineState: ts.EndOfLineState.None
+      };
+      const program = languageService.getProgram?.();
+      if (!program) {
+        return base;
+      }
+      const pluginSpans = getRsxEncodedClassifications({
+        ts,
+        program,
+        fileName,
+        span,
+        format
+      });
+      if (pluginSpans.length === 0) {
+        return base;
+      }
+      return {
+        ...base,
+        spans: [
+          ...base.spans,
+          ...pluginSpans
+        ]
+      };
+    };
+    proxy.getSemanticDiagnostics = (fileName) => {
+      const baseDiagnostics = languageService.getSemanticDiagnostics(fileName);
+      const program = languageService.getProgram?.();
+      if (!program) {
+        return baseDiagnostics;
+      }
+      const sourceFile = program.getSourceFile(fileName);
+      if (!sourceFile) {
+        return baseDiagnostics;
+      }
+      const rsxDiagnostics = (0, import_compiler.getRsxDiagnosticsForFile)(program, fileName).map((diagnostic) => ({
+        file: sourceFile,
+        start: diagnostic.start,
+        length: diagnostic.end - diagnostic.start,
+        category: toTsDiagnosticCategory(ts, diagnostic.category),
+        code: diagnosticCode(diagnostic.category),
+        messageText: diagnostic.message,
+        source: "@rs-x/typescript-plugin"
+      }));
+      return [
+        ...baseDiagnostics,
+        ...rsxDiagnostics
+      ];
+    };
+    return proxy;
+  }
+  __name(create, "create");
+  return {
+    create
+  };
+}
+__name(init, "init");
+function dedupeCompletionEntries(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    if (seen.has(entry.name)) {
+      return false;
+    }
+    seen.add(entry.name);
+    return true;
+  });
+}
+__name(dedupeCompletionEntries, "dedupeCompletionEntries");
+function getRsxEncodedClassifications(args) {
+  const { ts, program, fileName, span, format } = args;
+  const sourceFile = program.getSourceFile(fileName);
+  if (!sourceFile) {
+    return [];
+  }
+  const checker = program.getTypeChecker();
+  const sites = (0, import_compiler.detectExpressionSitesInSourceFile)(sourceFile, checker);
+  if (sites.length === 0) {
+    return [];
+  }
+  const spanStart = span.start;
+  const spanEnd = span.start + span.length;
+  const encoded = [];
+  for (const site of sites) {
+    const expressionStart = site.expressionLiteral.getStart(sourceFile) + 1;
+    const expressionEnd = site.expressionLiteral.getEnd() - 1;
+    if (expressionEnd <= spanStart || expressionStart >= spanEnd) {
+      continue;
+    }
+    const expressionText = sourceFile.text.slice(expressionStart, expressionEnd);
+    const tokens = (0, import_compiler.tokenizeRsxExpression)(expressionText);
+    if (tokens.length === 0) {
+      continue;
+    }
+    for (const token of tokens) {
+      const tokenStart = expressionStart + token.start;
+      const tokenEnd = expressionStart + token.end;
+      if (tokenEnd <= spanStart || tokenStart >= spanEnd) {
+        continue;
+      }
+      const clippedStart = tokenStart < spanStart ? spanStart : tokenStart;
+      const clippedEnd = tokenEnd > spanEnd ? spanEnd : tokenEnd;
+      if (clippedEnd <= clippedStart) {
+        continue;
+      }
+      const classification = encodeClassification({
+        ts,
+        token,
+        format,
+        text: expressionText
+      });
+      if (classification === null) {
+        continue;
+      }
+      encoded.push(clippedStart, clippedEnd - clippedStart, classification);
+    }
+  }
+  return encoded;
+}
+__name(getRsxEncodedClassifications, "getRsxEncodedClassifications");
+function encodeClassification(args) {
+  const { ts, token, format, text } = args;
+  if (token.kind !== "identifier" && token.kind !== "keyword") {
+    return null;
+  }
+  if (format === ts.SemanticClassificationFormat.TwentyTwenty) {
+    const semanticTokenType = resolveSemanticTokenTypeForIdentifier(text, token);
+    return semanticTokenType + 1 << 8;
+  }
+  return token.kind === "keyword" ? ts.ClassificationType.keyword : ts.ClassificationType.identifier;
+}
+__name(encodeClassification, "encodeClassification");
+function resolveSemanticTokenTypeForIdentifier(text, token) {
+  const prev = previousNonWhitespaceChar(text, token.start - 1);
+  const next = nextNonWhitespaceChar(text, token.end);
+  if (prev === ".") {
+    return 9;
+  }
+  if (next === "(") {
+    return 10;
+  }
+  return 7;
+}
+__name(resolveSemanticTokenTypeForIdentifier, "resolveSemanticTokenTypeForIdentifier");
+function previousNonWhitespaceChar(text, from) {
+  for (let i = from; i >= 0; i--) {
+    if (!isWhitespace(text[i])) {
+      return text[i];
+    }
+  }
+  return null;
+}
+__name(previousNonWhitespaceChar, "previousNonWhitespaceChar");
+function nextNonWhitespaceChar(text, from) {
+  for (let i = from; i < text.length; i++) {
+    if (!isWhitespace(text[i])) {
+      return text[i];
+    }
+  }
+  return null;
+}
+__name(nextNonWhitespaceChar, "nextNonWhitespaceChar");
+function isWhitespace(char) {
+  return /\s/u.test(char);
+}
+__name(isWhitespace, "isWhitespace");
+function toTsDiagnosticCategory(ts, category) {
+  switch (category) {
+    case "syntax":
+    case "semantic":
+    case "unsupported":
+      return ts.DiagnosticCategory.Error;
+    default:
+      return ts.DiagnosticCategory.Warning;
+  }
+}
+__name(toTsDiagnosticCategory, "toTsDiagnosticCategory");
+function diagnosticCode(category) {
+  switch (category) {
+    case "syntax":
+      return 97001;
+    case "semantic":
+      return 97002;
+    case "unsupported":
+      return 97003;
+    default:
+      return 97e3;
+  }
+}
+__name(diagnosticCode, "diagnosticCode");
+module.exports = init;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rs-x/typescript-plugin",
+  "version": "2.0.0-next.0",
+  "description": "TypeScript server plugin that adds RS-X IntelliSense inside expression strings",
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@rs-x/compiler": "2.0.0-next.0"
+  },
+  "devDependencies": {
+    "rimraf": "^6.1.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "typescript",
+    "tsserver",
+    "plugin",
+    "rs-x"
+  ],
+  "scripts": {
+    "build": "tsup lib/index.ts --format cjs --tsconfig ../tsconfig.build.json",
+    "clean": "rimraf dist"
+  }
+}