@coze-editor/code-language-typescript 0.1.0-alpha.0fd19e

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 coze-dev
+
+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/esm/index.js

@@ -0,0 +1,615 @@
+// src/index.ts
+import { typescriptLanguage } from "@codemirror/lang-javascript";
+
+// src/service.ts
+import { URI } from "vscode-uri";
+import {
+  MarkupKind
+} from "vscode-languageserver-types";
+import {
+  DiagnosticCategory,
+  displayPartsToString
+} from "typescript";
+import mitt from "mitt";
+import { wrap } from "comlink";
+import createFuzzySearch from "@nozbe/microfuzz";
+import {
+  MarkerTag,
+  textDocumentField
+} from "@coze-editor/code-language-shared";
+
+// src/utils.ts
+function tagToString(tag) {
+  let tagLabel = `*@${tag.name}*`;
+  if (tag.name === "param" && tag.text) {
+    const [paramName, ...rest] = tag.text;
+    tagLabel += `\`${paramName.text}\``;
+    if (rest.length > 0) {
+      tagLabel += ` \u2014 ${rest.map((r) => r.text).join(" ")}`;
+    }
+  } else if (Array.isArray(tag.text)) {
+    tagLabel += ` \u2014 ${tag.text.map((r) => r.text).join(" ")}`;
+  } else if (tag.text) {
+    tagLabel += ` \u2014 ${tag.text}`;
+  }
+  return tagLabel;
+}
+
+// src/as.ts
+import { CompletionItemKind } from "vscode-languageserver-types";
+import { ScriptElementKind } from "typescript";
+function asCompletionItemKind(kind) {
+  switch (kind) {
+    case ScriptElementKind.primitiveType:
+    case ScriptElementKind.keyword:
+      return CompletionItemKind.Keyword;
+    case ScriptElementKind.constElement:
+    case ScriptElementKind.letElement:
+    case ScriptElementKind.variableElement:
+    case ScriptElementKind.localVariableElement:
+    case ScriptElementKind.alias:
+    case ScriptElementKind.parameterElement:
+      return CompletionItemKind.Variable;
+    case ScriptElementKind.memberVariableElement:
+    case ScriptElementKind.memberGetAccessorElement:
+    case ScriptElementKind.memberSetAccessorElement:
+      return CompletionItemKind.Field;
+    case ScriptElementKind.functionElement:
+    case ScriptElementKind.localFunctionElement:
+      return CompletionItemKind.Function;
+    case ScriptElementKind.memberFunctionElement:
+    case ScriptElementKind.constructSignatureElement:
+    case ScriptElementKind.callSignatureElement:
+    case ScriptElementKind.indexSignatureElement:
+      return CompletionItemKind.Method;
+    case ScriptElementKind.enumElement:
+      return CompletionItemKind.Enum;
+    case ScriptElementKind.enumMemberElement:
+      return CompletionItemKind.EnumMember;
+    case ScriptElementKind.moduleElement:
+    case ScriptElementKind.externalModuleName:
+      return CompletionItemKind.Module;
+    case ScriptElementKind.classElement:
+    case ScriptElementKind.typeElement:
+      return CompletionItemKind.Class;
+    case ScriptElementKind.interfaceElement:
+      return CompletionItemKind.Interface;
+    case ScriptElementKind.warning:
+      return CompletionItemKind.Text;
+    case ScriptElementKind.scriptElement:
+      return CompletionItemKind.File;
+    case ScriptElementKind.directory:
+      return CompletionItemKind.Folder;
+    case ScriptElementKind.string:
+      return CompletionItemKind.Constant;
+  }
+  return CompletionItemKind.Property;
+}
+
+// src/service.ts
+var identRe = /^[\w$]+$/;
+function isDiagnostic(v) {
+  return Boolean(v);
+}
+function isChangeDesc(v) {
+  return Boolean(v);
+}
+var TypeScriptLanguageService = class {
+  worker = null;
+  starting = null;
+  _cachedFiles = /* @__PURE__ */ Object.create(null);
+  events = mitt();
+  async synchronize(paths) {
+    await this.starting;
+    if (!this.worker) {
+      throw new Error("TypeScript LanguageService is not initialized");
+    }
+    const files = {};
+    paths.forEach((path) => {
+      files[path] = this._cachedFiles[path] ?? "";
+    });
+    await this.worker.syncFiles(files);
+    return this.worker;
+  }
+  onTextDocumentDidChange = (ctx) => {
+    const { textDocument } = ctx;
+    const text = textDocument.getText();
+    const uri = URI.parse(textDocument.uri);
+    const path = uri.fsPath;
+    this._cachedFiles[path] = text;
+  };
+  doHover = async (ctx) => {
+    const { textDocument } = ctx;
+    const uri = URI.parse(textDocument.uri);
+    const path = uri.fsPath;
+    const worker = await this.synchronize([path]);
+    const info = await worker.getQuickInfoAtPosition(path, ctx.offset);
+    if (!info) {
+      return;
+    }
+    const tags = info.tags ? info.tags.map((tag) => tagToString(tag)).join("  \n\n") : "";
+    const contents = displayPartsToString(info.displayParts);
+    const documentation = displayPartsToString(info.documentation);
+    return {
+      kind: MarkupKind.Markdown,
+      value: `\`\`\`ts
+${contents}
+\`\`\`
+${documentation}${tags ? `
+
+${tags}` : ""}`
+    };
+  };
+  async synchronizeByURI(uri, content) {
+    await this.onTextDocumentDidChange({
+      textDocument: {
+        uri,
+        getText() {
+          return content;
+        }
+      }
+    });
+  }
+  async validateByURI(uri) {
+    return this.doValidation({
+      textDocument: {
+        uri
+      }
+    });
+  }
+  doValidation = async (ctx) => {
+    const { textDocument } = ctx;
+    const uri = URI.parse(textDocument.uri);
+    const path = uri.fsPath;
+    const worker = await this.synchronize([path]);
+    try {
+      const diagnostics = [
+        ...await worker.getSyntacticDiagnostics(path),
+        ...await worker.getSemanticDiagnostics(path),
+        ...await worker.getSuggestionDiagnostics(path)
+      ];
+      const categoryToSeverityMap = {
+        [DiagnosticCategory.Error]: "error",
+        [DiagnosticCategory.Warning]: "warning",
+        [DiagnosticCategory.Message]: "info",
+        [DiagnosticCategory.Suggestion]: "hint"
+      };
+      return diagnostics.map((d) => {
+        if (typeof d.start !== "number" || !categoryToSeverityMap[d.category]) {
+          return;
+        }
+        const tags = [];
+        if (d.reportsUnnecessary) {
+          tags.push(MarkerTag.Unnecessary);
+        }
+        if (d.reportsDeprecated) {
+          tags.push(MarkerTag.Deprecated);
+        }
+        return {
+          from: d.start,
+          to: d.start + (d.length ?? 0),
+          severity: categoryToSeverityMap[d.category],
+          message: typeof d.messageText === "string" ? d.messageText : d.messageText.messageText,
+          tags
+        };
+      }).filter((v) => isDiagnostic(v));
+    } catch (e) {
+      return [];
+    }
+  };
+  doComplete = async (ctx) => {
+    const uri = URI.parse(ctx.textDocument.uri);
+    const path = uri.fsPath;
+    const content = ctx.textDocument.getText();
+    const worker = await this.synchronize([path]);
+    const result = await worker.getCompletionsAtPosition(path, ctx.offset);
+    if (!result) {
+      return null;
+    }
+    const items = result.entries.map((entry) => ({
+      label: entry.name,
+      kind: asCompletionItemKind(entry.kind)
+    }));
+    const fuzzySearch = createFuzzySearch(items, {
+      key: "label"
+    });
+    let i = ctx.offset - 1;
+    let query = "";
+    while (i >= 0) {
+      const char = content.slice(i, i + 1);
+      if (char === "\n") {
+        break;
+      }
+      if (!identRe.test(char) && i + 1 <= ctx.offset) {
+        break;
+      }
+      i--;
+    }
+    query = content.slice(i + 1, ctx.offset);
+    const charBefore = content.slice(ctx.offset - 1, ctx.offset);
+    const triggerCharacters = [".", "'", '"'];
+    if (triggerCharacters.includes(charBefore)) {
+      return {
+        isIncomplete: true,
+        items
+      };
+    }
+    return query ? {
+      isIncomplete: true,
+      items: fuzzySearch(query).map((v) => ({
+        ...v.item,
+        textEdit: {
+          range: {
+            start: ctx.textDocument.positionAt(i + 1),
+            end: ctx.textDocument.positionAt(ctx.offset)
+          },
+          newText: v.item.label
+        }
+      }))
+    } : {
+      isIncomplete: true,
+      items: []
+    };
+  };
+  async resolveCompletionItem(ctx, item) {
+    const uri = URI.parse(ctx.textDocument.uri);
+    const path = uri.fsPath;
+    const worker = await this.synchronize([path]);
+    const details = await worker.getCompletionEntryDetails(
+      path,
+      ctx.offset,
+      item.label,
+      void 0,
+      void 0,
+      void 0,
+      void 0
+    );
+    if (!details) {
+      return item;
+    }
+    const documentationString = createDocumentationString(details);
+    return {
+      label: details.name,
+      detail: displayPartsToString(details == null ? void 0 : details.displayParts),
+      documentation: documentationString ? {
+        kind: MarkupKind.Markdown,
+        value: documentationString
+      } : void 0
+    };
+  }
+  async format(state, options = {}) {
+    const { textDocument, originalRangeFor } = state.field(textDocumentField);
+    const uri = URI.parse(textDocument.uri);
+    const path = uri.fsPath;
+    const worker = await this.synchronize([path]);
+    const edits = await worker.getFormattingEditsForDocument(path, {
+      indentSize: 2,
+      tabSize: 2,
+      convertTabsToSpaces: true,
+      newLineCharacter: "\n",
+      ...options
+    });
+    if (!edits) {
+      return {
+        changes: []
+      };
+    }
+    const changes = edits.map((edit) => {
+      const range = originalRangeFor({
+        from: edit.span.start,
+        to: edit.span.start + edit.span.length
+      });
+      if (range) {
+        return {
+          ...range,
+          insert: edit.newText
+        };
+      }
+    }).filter((v) => isChangeDesc(v));
+    return {
+      changes
+    };
+  }
+  async getTypeInformation(ctx) {
+    const { textDocument } = ctx;
+    const uri = URI.parse(textDocument.uri);
+    const path = uri.fsPath;
+    const worker = await this.synchronize([path]);
+    const info = await worker.getTypeInfoAtPosition(path, ctx.offset);
+    return info;
+  }
+  async doSignatureHelp(ctx) {
+    const uri = URI.parse(ctx.textDocument.uri);
+    const path = uri.fsPath;
+    const worker = await this.synchronize([path]);
+    const info = await worker.getSignatureHelpItems(path, ctx.offset, {});
+    if (!info) {
+      return null;
+    }
+    const ret = {
+      activeSignature: info.selectedItemIndex,
+      activeParameter: info.argumentIndex,
+      signatures: []
+    };
+    info.items.forEach((item) => {
+      const signature = {
+        label: "",
+        parameters: []
+      };
+      signature.documentation = {
+        kind: MarkupKind.Markdown,
+        value: displayPartsToString(item.documentation)
+      };
+      signature.label += displayPartsToString(item.prefixDisplayParts);
+      item.parameters.forEach((p, i, a) => {
+        const label = displayPartsToString(p.displayParts);
+        const parameter = {
+          label,
+          documentation: {
+            kind: MarkupKind.Markdown,
+            value: displayPartsToString(p.documentation)
+          }
+        };
+        signature.label += label;
+        signature.parameters.push(parameter);
+        if (i < a.length - 1) {
+          signature.label += displayPartsToString(item.separatorDisplayParts);
+        }
+      });
+      signature.label += displayPartsToString(item.suffixDisplayParts);
+      ret.signatures.push(signature);
+    });
+    return ret;
+  }
+  // async findDefinition(ctx) {
+  //   const uri = URI.parse(ctx.textDocument.uri)
+  //   const path = uri.fsPath
+  //   const worker = await this.synchronize([path])
+  //   const info = await worker.getDefinitionAtPosition(path, ctx.offset)
+  //   if (!info) {
+  //     return
+  //   }
+  //   return info.map(def => {
+  //     return {
+  //       from: def.textSpan.start,
+  //       to: def.textSpan.start + def.textSpan.length,
+  //     }
+  //   })
+  // }
+  initialize(tsWorker, options) {
+    this.worker = wrap(tsWorker);
+    this.starting = this.worker.initialize({
+      compilerOptions: (options == null ? void 0 : options.compilerOptions) ?? {},
+      initialFiles: {
+        ...this.extraFiles,
+        ...(options == null ? void 0 : options.initialFiles) ?? {}
+      }
+    });
+  }
+  extraFiles = /* @__PURE__ */ Object.create(null);
+  async addExtraFiles(files) {
+    this.extraFiles = Object.assign({}, this.extraFiles, files);
+    await this.starting;
+    if (this.worker) {
+      await this.worker.syncFiles(files);
+      this.events.emit("refresh-diagnostics");
+    }
+  }
+};
+function createDocumentationString(details) {
+  let documentationString = displayPartsToString(details.documentation);
+  if (details.tags) {
+    for (const tag of details.tags) {
+      documentationString += `
+
+${tagToString(tag)}`;
+    }
+  }
+  return documentationString;
+}
+var typescriptLanguageService = new TypeScriptLanguageService();
+
+// src/extensions/index.ts
+import { textDocumentField as textDocumentField2 } from "@coze-editor/code-language-shared";
+
+// src/extensions/type-information.ts
+import {
+  EditorView,
+  hoverTooltip,
+  ViewPlugin
+} from "@codemirror/view";
+import {
+  StateField,
+  StateEffect,
+  Facet
+} from "@codemirror/state";
+var cmdKeyPressedState = StateField.define({
+  create: () => false,
+  update: (value, tr) => {
+    for (const effect of tr.effects) {
+      if (effect.is(setCmdKeyPressedEffect)) {
+        return effect.value;
+      }
+    }
+    return value;
+  }
+});
+var setCmdKeyPressedEffect = StateEffect.define();
+var cmdKeyEventPlugin = ViewPlugin.fromClass(
+  class {
+    dispose;
+    constructor(view) {
+      const onKeyDown = (event) => {
+        if (event.metaKey && !view.state.field(cmdKeyPressedState)) {
+          view.dispatch({ effects: setCmdKeyPressedEffect.of(true) });
+        }
+      };
+      const onKeyUp = (event) => {
+        if (!event.metaKey && view.state.field(cmdKeyPressedState)) {
+          view.dispatch({ effects: setCmdKeyPressedEffect.of(false) });
+        }
+      };
+      const onBlur = () => {
+        if (view.state.field(cmdKeyPressedState)) {
+          view.dispatch({ effects: setCmdKeyPressedEffect.of(false) });
+        }
+      };
+      window.addEventListener("keydown", onKeyDown);
+      window.addEventListener("keyup", onKeyUp);
+      window.addEventListener("blur", onBlur);
+      this.dispose = () => {
+        window.removeEventListener("keydown", onKeyDown);
+        window.removeEventListener("keyup", onKeyUp);
+        window.removeEventListener("blur", onBlur);
+      };
+    }
+    destroy() {
+      this.dispose();
+    }
+  }
+);
+var getTypeInformationFacet = Facet.define({
+  combine(values) {
+    return values[values.length - 1];
+  }
+});
+var cmdHoverTooltipSource = async (view, pos, side) => {
+  const word = view.state.wordAt(pos);
+  if (!word) {
+    return null;
+  }
+  if (!view.state.facet(getTypeInformationFacet)) {
+    return null;
+  }
+  const doTypeInfoFn = view.state.facet(getTypeInformationFacet);
+  const info = await (doTypeInfoFn == null ? void 0 : doTypeInfoFn(view.state, word.from));
+  if (!info) {
+    return null;
+  }
+  return {
+    pos: word.from,
+    end: word.to,
+    above: true,
+    create() {
+      var _a;
+      const dom = document.createElement("div");
+      dom.className = "cm-type-tooltip";
+      const cmdPressed = view.state.field(cmdKeyPressedState, false);
+      dom.style.display = cmdPressed ? "block" : "none";
+      if ((_a = info == null ? void 0 : info.properties) == null ? void 0 : _a.length) {
+        const propsDiv = document.createElement("div");
+        propsDiv.className = "cm-type-tooltip-properties";
+        const propsHeader = document.createElement("div");
+        propsHeader.className = "cm-type-tooltip-props-header";
+        propsHeader.textContent = "Properties:";
+        propsDiv.appendChild(propsHeader);
+        const propsList = document.createElement("ul");
+        propsList.className = "cm-type-tooltip-props-list";
+        info.properties.forEach((prop) => {
+          if (prop && typeof prop.name === "string" && typeof prop.type === "string") {
+            const propItem = document.createElement("li");
+            propItem.className = "cm-type-tooltip-prop-item";
+            const propName = document.createElement("span");
+            propName.className = "cm-type-tooltip-prop-name";
+            propName.textContent = prop.name;
+            propItem.appendChild(propName);
+            const separator = document.createTextNode(": ");
+            propItem.appendChild(separator);
+            const propType = document.createElement("span");
+            propType.className = "cm-type-tooltip-prop-type";
+            propType.textContent = prop.type;
+            propItem.appendChild(propType);
+            propsList.appendChild(propItem);
+          }
+        });
+        propsDiv.appendChild(propsList);
+        dom.appendChild(propsDiv);
+      }
+      return {
+        dom,
+        update(update) {
+          for (const tr of update.transactions) {
+            for (const effect of tr.effects) {
+              if (effect.is(setCmdKeyPressedEffect)) {
+                const show = effect.value;
+                dom.style.display = show ? "block" : "none";
+                break;
+              }
+            }
+          }
+        }
+      };
+    }
+  };
+};
+var tooltipTheme = EditorView.theme({
+  ".cm-tooltip .cm-type-tooltip": {
+    padding: "0 10px 6px 10px",
+    maxWidth: "350px"
+  },
+  ".cm-type-tooltip-properties": {
+    paddingTop: "6px"
+  },
+  ".cm-type-tooltip-props-header": {
+    fontWeight: "bold",
+    marginBottom: "4px",
+    color: "#E06C75"
+  },
+  ".cm-type-tooltip-props-list": {
+    listStyle: "none",
+    margin: "0"
+  },
+  ".cm-type-tooltip-prop-item": {
+    marginBottom: "3px"
+  },
+  ".cm-type-tooltip-prop-name": {
+    color: "#E5C07B"
+  },
+  ".cm-type-tooltip-prop-type": {
+    color: "#ABB2BF"
+  }
+});
+function typeInformation(getTypeInformation) {
+  return [
+    getTypeInformationFacet.of(getTypeInformation),
+    tooltipTheme,
+    cmdKeyPressedState,
+    cmdKeyEventPlugin,
+    hoverTooltip(cmdHoverTooltipSource, {
+      hoverTime: 300
+    })
+  ];
+}
+var type_information_default = typeInformation;
+
+// src/extensions/index.ts
+var extensions = [
+  type_information_default(async (state, pos) => {
+    const { textDocument, generatedRangeFor } = state.field(textDocumentField2);
+    const range = generatedRangeFor({ from: pos, to: pos });
+    const offset = range == null ? void 0 : range.from;
+    if (typeof offset !== "number") {
+      return null;
+    }
+    const result = await typescriptLanguageService.getTypeInformation({
+      textDocument,
+      offset
+    });
+    return result;
+  })
+];
+var extensions_default = extensions;
+
+// src/index.ts
+var typescript = {
+  language: typescriptLanguage,
+  languageService: typescriptLanguageService,
+  extensions: extensions_default
+};
+export {
+  TypeScriptLanguageService,
+  typescript,
+  typescriptLanguage,
+  typescriptLanguageService
+};
+//# sourceMappingURL=index.js.map