@difizen/libro-cofine-editor 0.1.18 → 0.1.20

package/es/language/lsp/type-concerters.js

@@ -1,35 +0,0 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-import { languages } from '@difizen/monaco-editor-core';
-import * as lsp from 'vscode-languageserver-protocol';
-var _from = new Map([[lsp.CompletionItemKind.Method, languages.CompletionItemKind.Method], [lsp.CompletionItemKind.Function, languages.CompletionItemKind.Function], [lsp.CompletionItemKind.Constructor, languages.CompletionItemKind.Constructor], [lsp.CompletionItemKind.Field, languages.CompletionItemKind.Field], [lsp.CompletionItemKind.Variable, languages.CompletionItemKind.Variable], [lsp.CompletionItemKind.Class, languages.CompletionItemKind.Class], [lsp.CompletionItemKind.Interface, languages.CompletionItemKind.Interface], [lsp.CompletionItemKind.Struct, languages.CompletionItemKind.Struct], [lsp.CompletionItemKind.Module, languages.CompletionItemKind.Module], [lsp.CompletionItemKind.Property, languages.CompletionItemKind.Property], [lsp.CompletionItemKind.Unit, languages.CompletionItemKind.Unit], [lsp.CompletionItemKind.Value, languages.CompletionItemKind.Value], [lsp.CompletionItemKind.Constant, languages.CompletionItemKind.Constant], [lsp.CompletionItemKind.Enum, languages.CompletionItemKind.Enum], [lsp.CompletionItemKind.EnumMember, languages.CompletionItemKind.EnumMember], [lsp.CompletionItemKind.Keyword, languages.CompletionItemKind.Keyword], [lsp.CompletionItemKind.Snippet, languages.CompletionItemKind.Snippet], [lsp.CompletionItemKind.Text, languages.CompletionItemKind.Text], [lsp.CompletionItemKind.Color, languages.CompletionItemKind.Color], [lsp.CompletionItemKind.File, languages.CompletionItemKind.File], [lsp.CompletionItemKind.Reference, languages.CompletionItemKind.Reference], [lsp.CompletionItemKind.Folder, languages.CompletionItemKind.Folder], [lsp.CompletionItemKind.Event, languages.CompletionItemKind.Event], [lsp.CompletionItemKind.Operator, languages.CompletionItemKind.Operator], [lsp.CompletionItemKind.TypeParameter, languages.CompletionItemKind.TypeParameter]
-// [lsp.CompletionItemKind.Issue, languages.CompletionItemKind.Issue],
-// [lsp.CompletionItemKind.User, languages.CompletionItemKind.User],
-]);
-var _to = new Map([[languages.CompletionItemKind.Method, lsp.CompletionItemKind.Method], [languages.CompletionItemKind.Function, lsp.CompletionItemKind.Function], [languages.CompletionItemKind.Constructor, lsp.CompletionItemKind.Constructor], [languages.CompletionItemKind.Field, lsp.CompletionItemKind.Field], [languages.CompletionItemKind.Variable, lsp.CompletionItemKind.Variable], [languages.CompletionItemKind.Class, lsp.CompletionItemKind.Class], [languages.CompletionItemKind.Interface, lsp.CompletionItemKind.Interface], [languages.CompletionItemKind.Struct, lsp.CompletionItemKind.Struct], [languages.CompletionItemKind.Module, lsp.CompletionItemKind.Module], [languages.CompletionItemKind.Property, lsp.CompletionItemKind.Property], [languages.CompletionItemKind.Unit, lsp.CompletionItemKind.Unit], [languages.CompletionItemKind.Value, lsp.CompletionItemKind.Value], [languages.CompletionItemKind.Constant, lsp.CompletionItemKind.Constant], [languages.CompletionItemKind.Enum, lsp.CompletionItemKind.Enum], [languages.CompletionItemKind.EnumMember, lsp.CompletionItemKind.EnumMember], [languages.CompletionItemKind.Keyword, lsp.CompletionItemKind.Keyword], [languages.CompletionItemKind.Snippet, lsp.CompletionItemKind.Snippet], [languages.CompletionItemKind.Text, lsp.CompletionItemKind.Text], [languages.CompletionItemKind.Color, lsp.CompletionItemKind.Color], [languages.CompletionItemKind.File, lsp.CompletionItemKind.File], [languages.CompletionItemKind.Reference, lsp.CompletionItemKind.Reference], [languages.CompletionItemKind.Folder, lsp.CompletionItemKind.Folder], [languages.CompletionItemKind.Event, lsp.CompletionItemKind.Event], [languages.CompletionItemKind.Operator, lsp.CompletionItemKind.Operator], [languages.CompletionItemKind.TypeParameter, lsp.CompletionItemKind.TypeParameter]
-// [languages.CompletionItemKind.User, lsp.CompletionItemKind.User],
-// [languages.CompletionItemKind.Issue, lsp.CompletionItemKind.Issue],
-]);
-export var CompletionItemKind = /*#__PURE__*/function () {
-  function CompletionItemKind() {
-    _classCallCheck(this, CompletionItemKind);
-  }
-  _createClass(CompletionItemKind, null, [{
-    key: "from",
-    value: function from(kind) {
-      var _from$get;
-      return (_from$get = _from.get(kind)) !== null && _from$get !== void 0 ? _from$get : languages.CompletionItemKind.Property;
-    }
-  }, {
-    key: "to",
-    value: function to(kind) {
-      var _to$get;
-      return (_to$get = _to.get(kind)) !== null && _to$get !== void 0 ? _to$get : lsp.CompletionItemKind.Property;
-    }
-  }]);
-  return CompletionItemKind;
-}();

package/src/language/lsp/completion-provider.ts

@@ -1,213 +0,0 @@
-import { CompletionTriggerKind } from '@difizen/libro-lsp';
-import { languages } from '@difizen/monaco-editor-core';
-import type monaco from '@difizen/monaco-editor-core';
-import * as lsp from 'vscode-languageserver-protocol';
-import { InsertReplaceEdit } from 'vscode-languageserver-protocol';
-
-import { LangaugeFeatureProvider } from './language-feature-provider.js';
-import { CompletionItemKind } from './type-concerters.js';
-
-export class CompletionProvider
-  extends LangaugeFeatureProvider
-  implements monaco.languages.CompletionItemProvider
-{
-  triggerCharacters: ['.', '[', '"', "'"];
-
-  public provideCompletionItems = async (
-    model: monaco.editor.ITextModel,
-    position: monaco.Position,
-  ): Promise<monaco.languages.CompletionList | undefined> => {
-    const result = await this.provideCompletionItemsFromLSPServer(model, position);
-    return result;
-  };
-
-  protected provideCompletionItemsFromKernel = async (
-    model: monaco.editor.ITextModel,
-    position: monaco.Position,
-  ): Promise<monaco.languages.CompletionList | undefined> => {
-    const editor = this.getEditorByModel(model);
-    if (!editor || editor.getOption('lspEnabled') !== true) {
-      return;
-    }
-
-    const reply = await editor.completionProvider?.({
-      cursorPosition: editor.getOffsetAt({
-        column: position.column,
-        line: position.lineNumber,
-      }),
-    });
-
-    const start = reply?.cursor_start
-      ? editor.getPositionAt(reply?.cursor_start)
-      : editor.getCursorPosition();
-    const end = reply?.cursor_end
-      ? editor.getPositionAt(reply?.cursor_end)
-      : editor.getCursorPosition();
-
-    const suggestion: languages.CompletionItem[] = (reply?.matches ?? []).map(
-      (match) => {
-        return {
-          label: match,
-          kind: languages.CompletionItemKind.Text,
-          insertText: match,
-          range: {
-            startColumn: start?.column,
-            startLineNumber: start?.line,
-            endColumn: end?.column,
-            endLineNumber: end?.line,
-          },
-        } as languages.CompletionItem;
-      },
-    );
-
-    return {
-      suggestions: suggestion as any,
-    };
-  };
-
-  protected provideCompletionItemsFromLSPServer = async (
-    model: monaco.editor.ITextModel,
-    position: monaco.Position,
-  ): Promise<monaco.languages.CompletionList | undefined> => {
-    const provider = await this.getProvider(model);
-    if (!provider) {
-      return;
-    }
-    const editor = this.getEditorByModel(model);
-    if (!editor || editor.getOption('lspEnabled') !== true) {
-      return;
-    }
-
-    const { lspConnection, editor: docEditor, virtualDocument: doc } = provider;
-
-    if (!lspConnection.isReady || !lspConnection.provides('completionProvider')) {
-      return;
-    }
-
-    const virtualPos = doc.transformEditorToVirtual(docEditor, {
-      line: position.lineNumber - 1,
-      ch: position.column,
-      isEditor: true,
-    });
-
-    if (!virtualPos) {
-      return;
-    }
-
-    const result = await lspConnection.clientRequests[
-      'textDocument/completion'
-    ].request({
-      position: { line: virtualPos.line, character: virtualPos.ch },
-      textDocument: {
-        uri: doc.documentInfo.uri,
-      },
-      context: {
-        triggerKind: CompletionTriggerKind.Invoked,
-      },
-    });
-
-    const items = 'items' in result ? result.items : result;
-
-    const word = model.getWordUntilPosition(position);
-    const range = {
-      startLineNumber: position.lineNumber,
-      endLineNumber: position.lineNumber,
-      startColumn: word.startColumn,
-      endColumn: position.column,
-    };
-
-    const suggestions: monaco.languages.CompletionItem[] = items.map(
-      (item: lsp.CompletionItem) => {
-        return this.transformCompletion(item, range);
-      },
-    );
-
-    if (Array.isArray(result)) {
-      return { suggestions };
-    }
-
-    return {
-      incomplete: result.isIncomplete,
-      suggestions,
-    };
-  };
-
-  resolveCompletionItem = async (
-    item: monaco.languages.CompletionItem,
-    token: monaco.CancellationToken,
-  ): Promise<monaco.languages.CompletionItem | undefined> => {
-    const original = (item as any).__original as lsp.CompletionItem | undefined;
-    if (!original) {
-      return;
-    }
-    const lspConnection = await this.getLSPConnection();
-    const itemResult =
-      await lspConnection.clientRequests['completionItem/resolve'].request(original);
-    if (token.isCancellationRequested) {
-      return;
-    }
-    const resolve = this.transformCompletion(itemResult, item.range);
-    return resolve;
-  };
-
-  transformCompletion(
-    item: lsp.CompletionItem,
-    range: monaco.IRange | monaco.languages.CompletionItemRanges,
-  ): monaco.languages.CompletionItem {
-    const converted: monaco.languages.CompletionItem = {
-      ...item,
-      label: item.label,
-      sortText: item.sortText,
-      filterText: item.filterText,
-      insertText: item.insertText ? item.insertText : item.label,
-      kind: CompletionItemKind.from(item.kind ?? lsp.CompletionItemKind.Property),
-      detail: item.detail,
-      documentation: item.documentation,
-      command: item.command
-        ? {
-            id: item.command.command,
-            title: item.command.title,
-            arguments: item.command?.arguments,
-          }
-        : undefined,
-      range,
-      additionalTextEdits: undefined,
-    };
-
-    // FIXME: text edit 生成的range有可能在其他的editor上,这里似乎无法处理
-    if (item.textEdit) {
-      converted.insertText = item.textEdit.newText;
-      if (InsertReplaceEdit.is(item.textEdit)) {
-        converted.range = {
-          insert: convertRange(item.textEdit.insert),
-          replace: convertRange(item.textEdit.replace),
-        };
-      } else {
-        converted.range = convertRange(item.textEdit.range);
-      }
-    }
-
-    if (item.additionalTextEdits) {
-      converted.additionalTextEdits = item.additionalTextEdits.map((edit) => {
-        return {
-          range: convertRange(edit.range),
-          text: edit.newText,
-        };
-      });
-    }
-
-    // Stash a few additional pieces of information.
-    (converted as any).__original = item;
-
-    return converted;
-  }
-}
-
-function convertRange(range: lsp.Range): monaco.IRange {
-  return {
-    startLineNumber: range.start.line + 1,
-    startColumn: range.start.character + 1,
-    endLineNumber: range.end.line + 1,
-    endColumn: range.end.character + 1,
-  };
-}

package/src/language/lsp/diagnostic-provider.ts

@@ -1,168 +0,0 @@
-import type { LibroService } from '@difizen/libro-core';
-import { EditorCellView } from '@difizen/libro-core';
-import type { ILSPDocumentConnectionManager } from '@difizen/libro-lsp';
-import { DisposableCollection } from '@difizen/mana-app';
-import type { Disposable } from '@difizen/mana-app';
-import * as monaco from '@difizen/monaco-editor-core';
-
-import { LibroE2Editor } from '../../libro-e2-editor.js';
-import { MonacoRange, MonacoUri } from '../../types.js';
-
-import { LangaugeFeatureProvider } from './language-feature-provider.js';
-
-export enum MarkerSeverity {
-  Hint = 1,
-  Info = 2,
-  Warning = 4,
-  Error = 8,
-}
-
-const vererityMap = {
-  1: MarkerSeverity.Error,
-  2: MarkerSeverity.Warning,
-  3: MarkerSeverity.Info,
-  4: MarkerSeverity.Hint,
-};
-
-export class DiagnosticProvider extends LangaugeFeatureProvider implements Disposable {
-  protected toDispose = new DisposableCollection();
-  constructor(
-    libroService: LibroService,
-    lspDocumentConnectionManager: ILSPDocumentConnectionManager,
-  ) {
-    super(libroService, lspDocumentConnectionManager);
-    this.processDiagnostic();
-  }
-
-  protected diagnosticList: {
-    model: monaco.editor.ITextModel;
-    markers: monaco.editor.IMarkerData[];
-  }[] = [];
-
-  protected addDiagnostic(
-    model: monaco.editor.ITextModel,
-    marker: monaco.editor.IMarkerData,
-  ) {
-    if (
-      !this.diagnosticList.some((d) => d.model.uri.toString() === model.uri.toString())
-    ) {
-      this.diagnosticList.push({
-        model,
-        markers: [marker],
-      });
-    } else {
-      this.diagnosticList
-        .find((d) => d.model.uri.toString() === model.uri.toString())
-        ?.markers.push(marker);
-    }
-  }
-
-  protected clearDiagnostic() {
-    this.libroService.active?.model.cells.forEach((item) => {
-      if (EditorCellView.is(item)) {
-        if (item.editor instanceof LibroE2Editor) {
-          const model = item.editor.monacoEditor?.getModel();
-          if (model) {
-            monaco.editor.setModelMarkers(model, 'libro-e2', []);
-          }
-        }
-      }
-    });
-  }
-
-  protected displayDiagnostic() {
-    this.clearDiagnostic();
-    this.diagnosticList.forEach((d) => {
-      monaco.editor.setModelMarkers(d.model, 'libro-e2', d.markers);
-    });
-  }
-
-  async processDiagnostic() {
-    const lspConnection = await this.getLSPConnection();
-    const toDispose = lspConnection.serverNotifications[
-      'textDocument/publishDiagnostics'
-    ].event(async (e) => {
-      this.diagnosticList = [];
-      await Promise.all(
-        e.diagnostics.map(async (diagnostic) => {
-          const { range } = diagnostic;
-          // the diagnostic range must be in current editor
-          const editor = await this.getEditorFromLSPPosition(range);
-          if (!editor || editor.getOption('lspEnabled') !== true) {
-            return;
-          }
-          const model = editor?.monacoEditor?.getModel();
-          if (!model) {
-            return;
-          }
-
-          const virtualDocument = await this.getVirtualDocument();
-          if (!virtualDocument) {
-            return;
-          }
-
-          const editorStart = virtualDocument.transformVirtualToEditor({
-            line: range.start.line,
-            ch: range.start.character,
-            isVirtual: true,
-          });
-
-          const editorEnd = virtualDocument.transformVirtualToEditor({
-            line: range.end.line,
-            ch: range.end.character,
-            isVirtual: true,
-          });
-
-          if (!editorStart || !editorEnd) {
-            return;
-          }
-
-          const markerRange = new MonacoRange(
-            editorStart.line + 1,
-            editorStart.ch,
-            editorEnd.line + 1,
-            editorEnd.ch,
-          );
-
-          const marker: monaco.editor.IMarkerData = {
-            source: diagnostic.source,
-            tags: diagnostic.tags,
-            message: diagnostic.message,
-            code: String(diagnostic.code),
-            severity: diagnostic.severity
-              ? vererityMap[diagnostic.severity]
-              : monaco.MarkerSeverity.Info,
-            relatedInformation: diagnostic.relatedInformation?.map((item) => {
-              return {
-                message: item.message,
-                resource: MonacoUri.parse(item.location.uri),
-                startLineNumber: markerRange.startLineNumber,
-                startColumn: markerRange.startColumn,
-                endLineNumber: markerRange.endLineNumber,
-                endColumn: markerRange.endColumn,
-              };
-            }),
-            startLineNumber: editorStart.line + 1,
-            startColumn: editorStart.ch + 1,
-            endLineNumber: editorEnd.line + 1,
-            endColumn: editorEnd.ch + 1,
-          };
-
-          this.addDiagnostic(model, marker);
-        }),
-      );
-
-      this.displayDiagnostic();
-    });
-    this.toDispose.push(toDispose);
-  }
-  disposed = false;
-  dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.toDispose.dispose();
-    this.clearDiagnostic();
-    this.disposed = true;
-  }
-}

package/src/language/lsp/format-provider.ts

@@ -1,88 +0,0 @@
-import type monaco from '@difizen/monaco-editor-core';
-
-import { LangaugeFeatureProvider } from './language-feature-provider.js';
-
-export class FormatProvider
-  extends LangaugeFeatureProvider
-  implements
-    monaco.languages.DocumentFormattingEditProvider,
-    monaco.languages.DocumentRangeFormattingEditProvider
-{
-  displayName = 'libro-e2-format';
-
-  provideDocumentRangeFormattingEdits = async (
-    model: monaco.editor.ITextModel,
-    range: monaco.Range,
-    options: monaco.languages.FormattingOptions,
-    token: monaco.CancellationToken,
-  ): Promise<monaco.languages.TextEdit[]> => {
-    return this.formatDocumentByRange(model, range, options, token);
-  };
-  provideDocumentFormattingEdits = async (
-    model: monaco.editor.ITextModel,
-    options: monaco.languages.FormattingOptions,
-    token: monaco.CancellationToken,
-  ): Promise<monaco.languages.TextEdit[]> => {
-    return this.formatDocumentByRange(model, model.getFullModelRange(), options, token);
-  };
-
-  formatDocumentByRange = async (
-    model: monaco.editor.ITextModel,
-    range: monaco.Range,
-    options: monaco.languages.FormattingOptions,
-    token: monaco.CancellationToken,
-  ): Promise<monaco.languages.TextEdit[]> => {
-    const provider = await this.getProvider(model);
-    if (!provider) {
-      return [];
-    }
-
-    const { virtualDocument: doc } = provider;
-    const lspConnection = await this.getLSPConnection();
-    const result = await lspConnection.clientRequests[
-      'textDocument/rangeFormatting'
-    ].request({
-      // TODO: range transform
-      // TODO: pyright-extend supoport range format
-      range: {
-        start: {
-          line: range.startLineNumber - 1,
-          character: range.startColumn - 1,
-        },
-        end: {
-          line: range.endLineNumber - 1,
-          character: range.endColumn - 1,
-        },
-      },
-      textDocument: {
-        uri: doc.documentInfo.uri,
-      },
-      options: {
-        insertSpaces: options.insertSpaces,
-        tabSize: options.tabSize,
-      },
-    });
-
-    if (token.isCancellationRequested) {
-      return [];
-    }
-
-    if (!result) {
-      return [];
-    }
-
-    const edits: monaco.languages.TextEdit[] = result.map((item) => {
-      return {
-        range: {
-          startColumn: item.range.start.character + 1,
-          startLineNumber: item.range.start.line + 1,
-          endColumn: item.range.end.character + 1,
-          endLineNumber: item.range.end.line + 1,
-        },
-        text: item.newText,
-      };
-    });
-
-    return edits;
-  };
-}

package/src/language/lsp/hover-provider.ts

@@ -1,98 +0,0 @@
-import type monaco from '@difizen/monaco-editor-core';
-import type * as lsp from 'vscode-languageserver-protocol';
-
-import { MonacoRange } from '../../types.js';
-
-import { LangaugeFeatureProvider } from './language-feature-provider.js';
-
-export class HoverProvider
-  extends LangaugeFeatureProvider
-  implements monaco.languages.HoverProvider
-{
-  provideHover = async (
-    model: monaco.editor.ITextModel,
-    position: monaco.Position,
-    token: monaco.CancellationToken,
-  ): Promise<monaco.languages.Hover | undefined> => {
-    const editor = this.getEditorByModel(model);
-    if (!editor || editor.getOption('lspEnabled') !== true) {
-      return;
-    }
-    const provider = await this.getProvider(model);
-    if (!provider) {
-      return;
-    }
-
-    const { lspConnection, editor: docEditor, virtualDocument: doc } = provider;
-
-    const virtualPos = doc.transformEditorToVirtual(docEditor, {
-      line: position.lineNumber - 1, // lsp is zero based, monaco is one based
-      ch: position.column,
-      isEditor: true,
-    });
-
-    if (!virtualPos) {
-      return;
-    }
-
-    const result = await lspConnection.clientRequests['textDocument/hover'].request({
-      position: { line: virtualPos.line, character: virtualPos.ch },
-      textDocument: {
-        uri: doc.documentInfo.uri,
-      },
-    });
-
-    if (!result) {
-      return;
-    }
-
-    const { contents, range } = result;
-
-    const resultContents = [{ value: formatContents(contents) }];
-
-    let resultRange: monaco.Range | undefined;
-
-    if (range) {
-      const editorStart = doc.transformVirtualToEditor({
-        line: range.start.line,
-        ch: range.start.character,
-        isVirtual: true,
-      });
-
-      const editorEnd = doc.transformVirtualToEditor({
-        line: range.end.line,
-        ch: range.end.character,
-        isVirtual: true,
-      });
-      if (editorStart && editorEnd) {
-        resultRange = new MonacoRange(
-          editorStart.line + 1,
-          editorStart.ch + 1,
-          editorEnd.line + 1,
-          editorEnd.ch + 1,
-        );
-      }
-    }
-
-    if (token.isCancellationRequested) {
-      return;
-    }
-
-    return {
-      contents: resultContents,
-      range: resultRange,
-    };
-  };
-}
-
-export function formatContents(
-  contents: lsp.MarkupContent | lsp.MarkedString | lsp.MarkedString[],
-): string {
-  if (Array.isArray(contents)) {
-    return contents.map((c) => formatContents(c) + '\n\n').join('');
-  } else if (typeof contents === 'string') {
-    return contents;
-  } else {
-    return contents.value;
-  }
-}