@difizen/libro-cofine-editor 0.1.2

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

@@ -0,0 +1,148 @@
+import type { LibroService } from '@difizen/libro-core';
+import { EditorCellView } from '@difizen/libro-core';
+import type { LSPConnection, VirtualDocument } from '@difizen/libro-lsp';
+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 {
+  constructor(
+    libroService: LibroService,
+    lspConnection: LSPConnection,
+    virtualDocument: VirtualDocument,
+  ) {
+    super(libroService, lspConnection, virtualDocument);
+    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() {
+    this.lspConnection.serverNotifications['textDocument/publishDiagnostics'].event(
+      (e) => {
+        this.diagnosticList = [];
+        e.diagnostics.forEach((diagnostic) => {
+          const { range } = diagnostic;
+          // the diagnostic range must be in current editor
+          const editor = this.getEditorFromLSPPosition(range);
+          if (!editor || editor.getOption('lspEnabled') !== true) {
+            return;
+          }
+          const model = editor?.monacoEditor?.getModel();
+          if (!model) {
+            return;
+          }
+
+          const editorStart = this.virtualDocument.transformVirtualToEditor({
+            line: range.start.line,
+            ch: range.start.character,
+            isVirtual: true,
+          });
+
+          const editorEnd = this.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();
+      },
+    );
+  }
+}

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

@@ -0,0 +1,87 @@
+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 result = await this.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

@@ -0,0 +1,98 @@
+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;
+  }
+}

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

@@ -0,0 +1,69 @@
+import type { LibroService } from '@difizen/libro-core';
+import { EditorCellView } from '@difizen/libro-core';
+import type { LSPProviderResult } from '@difizen/libro-lsp';
+import type { LSPConnection, VirtualDocument } from '@difizen/libro-lsp';
+import type monaco from '@difizen/monaco-editor-core';
+import type * as lsp from 'vscode-languageserver-protocol';
+
+import { LibroE2Editor } from '../../libro-e2-editor.js';
+
+export class LangaugeFeatureProvider {
+  protected libroService: LibroService;
+  protected lspProvider?: LSPProviderResult;
+  protected lspConnection: LSPConnection;
+  virtualDocument: VirtualDocument;
+  constructor(
+    libroService: LibroService,
+    lspConnection: LSPConnection,
+    virtualDocument: VirtualDocument,
+  ) {
+    this.libroService = libroService;
+    this.lspConnection = lspConnection;
+    this.virtualDocument = virtualDocument;
+  }
+
+  protected getEditorByModel(model: monaco.editor.ITextModel) {
+    const cells = this.libroService.active?.model.cells;
+    if (!cells) {
+      return;
+    }
+    const cell = cells.find((item) => {
+      const editorUuid = model.uri.path.split('.')[0];
+      if (!EditorCellView.is(item)) {
+        return false;
+      }
+      const e2editor = item.editor;
+      if (!(e2editor instanceof LibroE2Editor)) {
+        return false;
+      }
+      return editorUuid === e2editor.uuid;
+    });
+
+    return (cell as EditorCellView).editor as LibroE2Editor | undefined;
+  }
+
+  protected getEditorFromLSPPosition(range: lsp.Range) {
+    const currentEditor = this.virtualDocument.getEditorAtVirtualLine({
+      line: range.start.line,
+      ch: range.start.character,
+      isVirtual: true,
+    });
+    const editor = currentEditor.getEditor();
+    if (editor instanceof LibroE2Editor) {
+      return editor;
+    }
+    return;
+  }
+
+  protected async getProvider(model: monaco.editor.ITextModel) {
+    const editor = this.getEditorByModel(model);
+
+    if (!editor) {
+      return;
+    }
+
+    const provider = await editor.lspProvider?.();
+    this.lspProvider = provider;
+    return provider;
+  }
+}

package/src/language/lsp/lsp-contribution.ts

@@ -0,0 +1,159 @@
+import {
+  EditorHandlerContribution,
+  LanguageOptionsRegistry,
+} from '@difizen/libro-cofine-editor-core';
+import { LibroService } from '@difizen/libro-core';
+import type { LSPConnection } from '@difizen/libro-lsp';
+import { ILSPDocumentConnectionManager } from '@difizen/libro-lsp';
+import { DisposableCollection, inject, singleton } from '@difizen/mana-app';
+import * as monaco from '@difizen/monaco-editor-core';
+
+import { LibroE2URIScheme } from '../../libro-e2-editor.js';
+
+import { CompletionProvider } from './completion-provider.js';
+import { DiagnosticProvider } from './diagnostic-provider.js';
+import { HoverProvider } from './hover-provider.js';
+import { SignatureHelpProvider } from './signature-help-provider.js';
+
+@singleton({
+  contrib: [EditorHandlerContribution],
+})
+export class LSPContribution implements EditorHandlerContribution {
+  @inject(LanguageOptionsRegistry)
+  protected readonly optionsResgistry: LanguageOptionsRegistry;
+
+  @inject(LibroService) protected readonly libroService: LibroService;
+
+  @inject(ILSPDocumentConnectionManager)
+  protected readonly lspDocumentConnectionManager: ILSPDocumentConnectionManager;
+
+  protected toDispose = new DisposableCollection();
+
+  protected lspLangs = ['python'];
+
+  beforeCreate() {
+    //
+  }
+  afterCreate(editor: any) {
+    this.registerLSPFeature(editor as monaco.editor.IStandaloneCodeEditor);
+  }
+  canHandle(language: string) {
+    return this.lspLangs.includes(language);
+  }
+
+  getLanguageSelector(
+    model: monaco.editor.ITextModel,
+  ): monaco.languages.LanguageFilter {
+    return {
+      scheme: LibroE2URIScheme,
+      pattern: model.uri.path,
+    };
+  }
+
+  async getVirtualDocument() {
+    const libroView = this.libroService.active;
+    if (!libroView) {
+      return;
+    }
+    await this.lspDocumentConnectionManager.ready;
+    const adapter = this.lspDocumentConnectionManager.adapters.get(libroView.model.id);
+    if (!adapter) {
+      throw new Error('no adapter');
+    }
+
+    await adapter.ready;
+
+    // Get the associated virtual document of the opened document
+    const virtualDocument = adapter.virtualDocument;
+    return virtualDocument;
+  }
+
+  async getLSPConnection() {
+    const virtualDocument = await this.getVirtualDocument();
+    if (!virtualDocument) {
+      throw new Error('no virtualDocument');
+    }
+
+    // Get the LSP connection of the virtual document.
+    const lspConnection = this.lspDocumentConnectionManager.connections.get(
+      virtualDocument.uri,
+    ) as LSPConnection;
+
+    return lspConnection;
+  }
+
+  registerLSPFeature(editor: monaco.editor.IStandaloneCodeEditor) {
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+
+    Promise.all([this.getVirtualDocument(), this.getLSPConnection()])
+      .then(([virtualDocument, lspConnection]) => {
+        if (!lspConnection || !virtualDocument) {
+          return;
+        }
+        this.toDispose.push(
+          monaco.languages.registerCompletionItemProvider(
+            this.getLanguageSelector(model),
+            new CompletionProvider(this.libroService, lspConnection, virtualDocument),
+          ),
+        );
+
+        this.toDispose.push(
+          monaco.languages.registerHoverProvider(
+            this.getLanguageSelector(model),
+            new HoverProvider(this.libroService, lspConnection, virtualDocument),
+          ),
+        );
+
+        new DiagnosticProvider(this.libroService, lspConnection, virtualDocument);
+
+        this.toDispose.push(
+          monaco.languages.registerSignatureHelpProvider(
+            this.getLanguageSelector(model),
+            new SignatureHelpProvider(
+              this.libroService,
+              lspConnection,
+              virtualDocument,
+            ),
+          ),
+        );
+        // const formatProvider = new FormatProvider(
+        //   this.libroService,
+        //   lspConnection,
+        //   virtualDocument,
+        // );
+        // monaco.languages.registerDocumentFormattingEditProvider(
+        //   this.getLanguageSelector(model),
+        //   formatProvider,
+        // );
+        // monaco.languages.registerDocumentRangeFormattingEditProvider(
+        //   this.getLanguageSelector(model),
+        //   formatProvider,
+        // );
+        return;
+      })
+      .catch(console.error);
+
+    // // SignatureHelp
+    // monaco.languages.registerSignatureHelpProvider(id, new SignatureHelpProvider(this._worker));
+
+    // // 定义跳转;
+    // monaco.languages.registerDefinitionProvider(id, new DefinitionAdapter(this._worker));
+  }
+
+  protected isDisposed = false;
+  get disposed() {
+    return this.isDisposed;
+  }
+
+  beforeDestory() {
+    this.toDispose.dispose();
+  }
+
+  dispose() {
+    this.toDispose.dispose();
+    this.isDisposed = false;
+  }
+}

package/src/language/lsp/module.ts

@@ -0,0 +1,5 @@
+import { Module } from '@difizen/mana-app';
+
+import { LSPContribution } from './lsp-contribution.js';
+
+export const LSPFeatureModule = Module().register(LSPContribution);

package/src/language/lsp/semantic-highlight-provider.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type monaco from '@difizen/monaco-editor-core';
+
+import { LangaugeFeatureProvider } from './language-feature-provider.js';
+
+export class SemanticHighlightProvider
+  extends LangaugeFeatureProvider
+  implements monaco.languages.DocumentSemanticTokensProvider
+{
+  onDidChange?: monaco.IEvent<void> | undefined;
+  getLegend(): monaco.languages.SemanticTokensLegend {
+    throw new Error('Method not implemented.');
+  }
+  provideDocumentSemanticTokens(
+    model: monaco.editor.ITextModel,
+    lastResultId: string | null,
+    token: monaco.CancellationToken,
+  ): monaco.languages.ProviderResult<
+    monaco.languages.SemanticTokens | monaco.languages.SemanticTokensEdits
+  > {
+    throw new Error('Method not implemented.');
+  }
+  releaseDocumentSemanticTokens(resultId: string | undefined): void {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/language/lsp/signature-help-provider.ts

@@ -0,0 +1,65 @@
+import type monaco from '@difizen/monaco-editor-core';
+
+import { LangaugeFeatureProvider } from './language-feature-provider.js';
+
+export class SignatureHelpProvider
+  extends LangaugeFeatureProvider
+  implements monaco.languages.SignatureHelpProvider
+{
+  signatureHelpTriggerCharacters: ['(', ',', ')'];
+  signatureHelpRetriggerCharacters?: readonly string[] | undefined;
+  provideSignatureHelp = async (
+    model: monaco.editor.ITextModel,
+    position: monaco.Position,
+    token: monaco.CancellationToken,
+    context: monaco.languages.SignatureHelpContext,
+  ): Promise<monaco.languages.SignatureHelpResult | 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 - 1,
+      isEditor: true,
+    });
+
+    if (!virtualPos) {
+      return;
+    }
+
+    const sigInfo = await lspConnection.clientRequests[
+      'textDocument/signatureHelp'
+    ].request({
+      position: { line: virtualPos.line, character: virtualPos.ch },
+      textDocument: {
+        uri: doc.documentInfo.uri,
+      },
+    });
+
+    return {
+      value: {
+        signatures: sigInfo.signatures.map((sig: any) => {
+          return {
+            label: sig.label,
+            documentation: sig.documentation,
+            parameters: sig.parameters ?? [],
+            activeParameter: sig.activeParameter,
+          };
+        }),
+        activeSignature: sigInfo.activeSignature ?? 0,
+        activeParameter: sigInfo.activeParameter ?? 0,
+      },
+      dispose: () => {
+        //
+      },
+    };
+  };
+}