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

package/dist/index.js

@@ -0,0 +1,636 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TypeScriptLanguageService: () => TypeScriptLanguageService,
+  typescript: () => typescript,
+  typescriptLanguage: () => import_lang_javascript.typescriptLanguage,
+  typescriptLanguageService: () => typescriptLanguageService
+});
+module.exports = __toCommonJS(index_exports);
+var import_lang_javascript = require("@codemirror/lang-javascript");
+
+// src/service.ts
+var import_vscode_uri = require("vscode-uri");
+var import_vscode_languageserver_types2 = require("vscode-languageserver-types");
+var import_typescript2 = require("typescript");
+var import_mitt = __toESM(require("mitt"));
+var import_comlink = require("comlink");
+var import_microfuzz = __toESM(require("@nozbe/microfuzz"));
+var import_code_language_shared = require("@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
+var import_vscode_languageserver_types = require("vscode-languageserver-types");
+var import_typescript = require("typescript");
+function asCompletionItemKind(kind) {
+  switch (kind) {
+    case import_typescript.ScriptElementKind.primitiveType:
+    case import_typescript.ScriptElementKind.keyword:
+      return import_vscode_languageserver_types.CompletionItemKind.Keyword;
+    case import_typescript.ScriptElementKind.constElement:
+    case import_typescript.ScriptElementKind.letElement:
+    case import_typescript.ScriptElementKind.variableElement:
+    case import_typescript.ScriptElementKind.localVariableElement:
+    case import_typescript.ScriptElementKind.alias:
+    case import_typescript.ScriptElementKind.parameterElement:
+      return import_vscode_languageserver_types.CompletionItemKind.Variable;
+    case import_typescript.ScriptElementKind.memberVariableElement:
+    case import_typescript.ScriptElementKind.memberGetAccessorElement:
+    case import_typescript.ScriptElementKind.memberSetAccessorElement:
+      return import_vscode_languageserver_types.CompletionItemKind.Field;
+    case import_typescript.ScriptElementKind.functionElement:
+    case import_typescript.ScriptElementKind.localFunctionElement:
+      return import_vscode_languageserver_types.CompletionItemKind.Function;
+    case import_typescript.ScriptElementKind.memberFunctionElement:
+    case import_typescript.ScriptElementKind.constructSignatureElement:
+    case import_typescript.ScriptElementKind.callSignatureElement:
+    case import_typescript.ScriptElementKind.indexSignatureElement:
+      return import_vscode_languageserver_types.CompletionItemKind.Method;
+    case import_typescript.ScriptElementKind.enumElement:
+      return import_vscode_languageserver_types.CompletionItemKind.Enum;
+    case import_typescript.ScriptElementKind.enumMemberElement:
+      return import_vscode_languageserver_types.CompletionItemKind.EnumMember;
+    case import_typescript.ScriptElementKind.moduleElement:
+    case import_typescript.ScriptElementKind.externalModuleName:
+      return import_vscode_languageserver_types.CompletionItemKind.Module;
+    case import_typescript.ScriptElementKind.classElement:
+    case import_typescript.ScriptElementKind.typeElement:
+      return import_vscode_languageserver_types.CompletionItemKind.Class;
+    case import_typescript.ScriptElementKind.interfaceElement:
+      return import_vscode_languageserver_types.CompletionItemKind.Interface;
+    case import_typescript.ScriptElementKind.warning:
+      return import_vscode_languageserver_types.CompletionItemKind.Text;
+    case import_typescript.ScriptElementKind.scriptElement:
+      return import_vscode_languageserver_types.CompletionItemKind.File;
+    case import_typescript.ScriptElementKind.directory:
+      return import_vscode_languageserver_types.CompletionItemKind.Folder;
+    case import_typescript.ScriptElementKind.string:
+      return import_vscode_languageserver_types.CompletionItemKind.Constant;
+  }
+  return import_vscode_languageserver_types.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 = (0, import_mitt.default)();
+  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 = import_vscode_uri.URI.parse(textDocument.uri);
+    const path = uri.fsPath;
+    this._cachedFiles[path] = text;
+  };
+  doHover = async (ctx) => {
+    const { textDocument } = ctx;
+    const uri = import_vscode_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 = (0, import_typescript2.displayPartsToString)(info.displayParts);
+    const documentation = (0, import_typescript2.displayPartsToString)(info.documentation);
+    return {
+      kind: import_vscode_languageserver_types2.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 = import_vscode_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 = {
+        [import_typescript2.DiagnosticCategory.Error]: "error",
+        [import_typescript2.DiagnosticCategory.Warning]: "warning",
+        [import_typescript2.DiagnosticCategory.Message]: "info",
+        [import_typescript2.DiagnosticCategory.Suggestion]: "hint"
+      };
+      return diagnostics.map((d) => {
+        if (typeof d.start !== "number" || !categoryToSeverityMap[d.category]) {
+          return;
+        }
+        const tags = [];
+        if (d.reportsUnnecessary) {
+          tags.push(import_code_language_shared.MarkerTag.Unnecessary);
+        }
+        if (d.reportsDeprecated) {
+          tags.push(import_code_language_shared.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 = import_vscode_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 = (0, import_microfuzz.default)(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 = import_vscode_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: (0, import_typescript2.displayPartsToString)(details == null ? void 0 : details.displayParts),
+      documentation: documentationString ? {
+        kind: import_vscode_languageserver_types2.MarkupKind.Markdown,
+        value: documentationString
+      } : void 0
+    };
+  }
+  async format(state, options = {}) {
+    const { textDocument, originalRangeFor } = state.field(import_code_language_shared.textDocumentField);
+    const uri = import_vscode_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 = import_vscode_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 = import_vscode_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: import_vscode_languageserver_types2.MarkupKind.Markdown,
+        value: (0, import_typescript2.displayPartsToString)(item.documentation)
+      };
+      signature.label += (0, import_typescript2.displayPartsToString)(item.prefixDisplayParts);
+      item.parameters.forEach((p, i, a) => {
+        const label = (0, import_typescript2.displayPartsToString)(p.displayParts);
+        const parameter = {
+          label,
+          documentation: {
+            kind: import_vscode_languageserver_types2.MarkupKind.Markdown,
+            value: (0, import_typescript2.displayPartsToString)(p.documentation)
+          }
+        };
+        signature.label += label;
+        signature.parameters.push(parameter);
+        if (i < a.length - 1) {
+          signature.label += (0, import_typescript2.displayPartsToString)(item.separatorDisplayParts);
+        }
+      });
+      signature.label += (0, import_typescript2.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 = (0, import_comlink.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 = (0, import_typescript2.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
+var import_code_language_shared2 = require("@coze-editor/code-language-shared");
+
+// src/extensions/type-information.ts
+var import_view = require("@codemirror/view");
+var import_state = require("@codemirror/state");
+var cmdKeyPressedState = import_state.StateField.define({
+  create: () => false,
+  update: (value, tr) => {
+    for (const effect of tr.effects) {
+      if (effect.is(setCmdKeyPressedEffect)) {
+        return effect.value;
+      }
+    }
+    return value;
+  }
+});
+var setCmdKeyPressedEffect = import_state.StateEffect.define();
+var cmdKeyEventPlugin = import_view.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 = import_state.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 = import_view.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,
+    (0, import_view.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(import_code_language_shared2.textDocumentField);
+    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: import_lang_javascript.typescriptLanguage,
+  languageService: typescriptLanguageService,
+  extensions: extensions_default
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeScriptLanguageService,
+  typescript,
+  typescriptLanguage,
+  typescriptLanguageService
+});
+//# sourceMappingURL=index.js.map