@difizen/libro-cofine-editor 0.1.18 → 0.1.19

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

@@ -1,107 +0,0 @@
-import type { LibroService } from '@difizen/libro-core';
-import { EditorCellView } from '@difizen/libro-core';
-import type { ILSPDocumentConnectionManager } from '@difizen/libro-lsp';
-import type { LSPConnection } 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;
-  lspDocumentConnectionManager: ILSPDocumentConnectionManager;
-  constructor(
-    libroService: LibroService,
-    lspDocumentConnectionManager: ILSPDocumentConnectionManager,
-  ) {
-    this.libroService = libroService;
-    this.lspDocumentConnectionManager = lspDocumentConnectionManager;
-  }
-
-  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;
-  }
-
-  /**
-   * find cell editor from active notebook by model uri
-   * @param model
-   * @returns
-   */
-  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 async getEditorFromLSPPosition(range: lsp.Range) {
-    try {
-      const virtualDocument = await this.getVirtualDocument();
-      const currentEditor = virtualDocument?.getEditorAtVirtualLine({
-        line: range.start.line,
-        ch: range.start.character,
-        isVirtual: true,
-      });
-      const editor = currentEditor?.getEditor();
-      if (editor instanceof LibroE2Editor) {
-        return editor;
-      }
-      return;
-    } catch (error) {
-      console.warn(error);
-      return;
-    }
-  }
-
-  protected async getProvider(model: monaco.editor.ITextModel) {
-    const editor = this.getEditorByModel(model);
-
-    if (!editor) {
-      return;
-    }
-
-    const provider = await editor.lspProvider?.();
-    return provider;
-  }
-}

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

@@ -1,129 +0,0 @@
-import { EditorHandlerContribution } from '@difizen/libro-cofine-editor-core';
-import { LibroService } from '@difizen/libro-core';
-import { ILSPDocumentConnectionManager } from '@difizen/libro-lsp';
-import { Disposable, DisposableCollection, inject, singleton } from '@difizen/mana-app';
-import type { editor } from '@difizen/monaco-editor-core';
-import { languages } from '@difizen/monaco-editor-core';
-// import { ILanguageFeaturesService } from '@difizen/monaco-editor-core/esm/vs/editor/common/services/languageFeatures.js';
-// import { StandaloneServices } from '@difizen/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices.js';
-// import { getSingletonServiceDescriptors } from '@difizen/monaco-editor-core/esm/vs/platform/instantiation/common/extensions.js';
-
-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(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 editor.IStandaloneCodeEditor);
-    // const languageFeaturesService = getOrigin(StandaloneServices).get(
-    //   ILanguageFeaturesService,
-    // );
-    // for (const [id, descriptor] of getSingletonServiceDescriptors()) {
-    //   if (id === ILanguageFeaturesService) {
-    //     console.log('lll', descriptor);
-    //   }
-    // }
-    // console.log(
-    //   StandaloneServices,
-    //   StandaloneServices.initialize(),
-    //   getOrigin(languageFeaturesService),
-    // );
-  }
-  canHandle(language: string) {
-    return this.lspLangs.includes(language);
-  }
-
-  getLanguageSelector(model: editor.ITextModel): languages.LanguageFilter {
-    return {
-      scheme: LibroE2URIScheme,
-      pattern: model.uri.path,
-    };
-  }
-
-  registerLSPFeature(editor: editor.IStandaloneCodeEditor) {
-    const model = editor.getModel();
-    if (!model) {
-      return;
-    }
-
-    this.toDispose.push(
-      languages.registerCompletionItemProvider(
-        this.getLanguageSelector(model),
-        new CompletionProvider(this.libroService, this.lspDocumentConnectionManager),
-      ),
-    );
-
-    this.toDispose.push(
-      languages.registerHoverProvider(
-        this.getLanguageSelector(model),
-        new HoverProvider(this.libroService, this.lspDocumentConnectionManager),
-      ),
-    );
-
-    const provider = new DiagnosticProvider(
-      this.libroService,
-      this.lspDocumentConnectionManager,
-    );
-    this.toDispose.push(Disposable.create(() => provider.dispose()));
-
-    this.toDispose.push(
-      languages.registerSignatureHelpProvider(
-        this.getLanguageSelector(model),
-        new SignatureHelpProvider(this.libroService, this.lspDocumentConnectionManager),
-      ),
-    );
-    // const formatProvider = new FormatProvider(
-    //   this.libroService,
-    //   lspConnection,
-    //   virtualDocument,
-    // );
-    // languages.registerDocumentFormattingEditProvider(
-    //   this.getLanguageSelector(model),
-    //   formatProvider,
-    // );
-    // languages.registerDocumentRangeFormattingEditProvider(
-    //   this.getLanguageSelector(model),
-    //   formatProvider,
-    // );
-    return;
-
-    // // SignatureHelp
-    // languages.registerSignatureHelpProvider(id, new SignatureHelpProvider(this._worker));
-
-    // // 定义跳转;
-    // languages.registerDefinitionProvider(id, new DefinitionAdapter(this._worker));
-  }
-
-  protected isDisposed = false;
-
-  get disposed() {
-    return this.isDisposed;
-  }
-
-  disposeLanguageFeature() {
-    this.toDispose.dispose();
-  }
-
-  dispose() {
-    this.disposeLanguageFeature();
-    this.isDisposed = false;
-  }
-}

package/src/language/lsp/module.ts

@@ -1,5 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/* 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

@@ -1,65 +0,0 @@
-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: () => {
-        //
-      },
-    };
-  };
-}

package/src/language/lsp/type-concerters.ts

@@ -1,72 +0,0 @@
-import { languages } from '@difizen/monaco-editor-core';
-import * as lsp from 'vscode-languageserver-protocol';
-
-const _from = new Map<lsp.CompletionItemKind, languages.CompletionItemKind>([
-  [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],
-]);
-
-const _to = new Map<languages.CompletionItemKind, lsp.CompletionItemKind>([
-  [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 class CompletionItemKind {
-  static from(kind: lsp.CompletionItemKind): languages.CompletionItemKind {
-    return _from.get(kind) ?? languages.CompletionItemKind.Property;
-  }
-
-  static to(kind: languages.CompletionItemKind): lsp.CompletionItemKind {
-    return _to.get(kind) ?? lsp.CompletionItemKind.Property;
-  }
-}