@difizen/libro-cofine-editor 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@difizen/libro-cofine-editor",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "",
   "keywords": [
     "libro",
@@ -32,13 +32,13 @@
     "src"
   ],
   "dependencies": {
-    "@difizen/monaco-editor-core": "latest",
-    "@difizen/libro-cofine-editor-core": "^0.1.13",
-    "@difizen/libro-cofine-textmate": "^0.1.13",
-    "@difizen/libro-lsp": "^0.1.13",
-    "@difizen/libro-code-editor": "^0.1.13",
-    "@difizen/libro-common": "^0.1.13",
-    "@difizen/libro-core": "^0.1.13",
+    "@difizen/monaco-editor-core": "0.39.4",
+    "@difizen/libro-cofine-editor-core": "^0.1.15",
+    "@difizen/libro-cofine-textmate": "^0.1.15",
+    "@difizen/libro-lsp": "^0.1.15",
+    "@difizen/libro-code-editor": "^0.1.15",
+    "@difizen/libro-common": "^0.1.15",
+    "@difizen/libro-core": "^0.1.15",
     "@difizen/mana-app": "latest",
     "resize-observer-polyfill": "^1.5.1",
     "vscode-languageserver-protocol": "^3.17.4",

package/src/editor-contribution.ts

@@ -1,11 +1,19 @@
-import type { CodeEditorFactory } from '@difizen/libro-code-editor';
+import type { CodeEditorFactory, EditorStateFactory } from '@difizen/libro-code-editor';
 import { CodeEditorContribution } from '@difizen/libro-code-editor';
 import { inject, singleton } from '@difizen/mana-app';
 
-import { libroE2DefaultConfig, LibroE2EditorFactory } from './libro-e2-editor.js';
+import { LanguageSpecRegistry } from './language-specs.js';
+import {
+  e2StateFactory,
+  libroE2DefaultConfig,
+  LibroE2EditorFactory,
+} from './libro-e2-editor.js';
 
 @singleton({ contrib: [CodeEditorContribution] })
 export class LibroE2EditorContribution implements CodeEditorContribution {
+  @inject(LanguageSpecRegistry)
+  protected readonly languageSpecRegistry: LanguageSpecRegistry;
+
   factory: CodeEditorFactory;
 
   defaultConfig = libroE2DefaultConfig;
@@ -16,6 +24,13 @@ export class LibroE2EditorContribution implements CodeEditorContribution {
     this.factory = libroE2EditorFactory;
   }
 
+  stateFactory: EditorStateFactory<any> = (options) => {
+    return e2StateFactory(this.languageSpecRegistry)({
+      uuid: options.uuid,
+      model: options.model,
+    });
+  };
+
   canHandle(mime: string): number {
     const mimes = [
       'application/vnd.libro.sql+json',

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

@@ -140,10 +140,9 @@ export class CompletionProvider
     if (!original) {
       return;
     }
+    const lspConnection = await this.getLSPConnection();
     const itemResult =
-      await this.lspConnection.clientRequests['completionItem/resolve'].request(
-        original,
-      );
+      await lspConnection.clientRequests['completionItem/resolve'].request(original);
     if (token.isCancellationRequested) {
       return;
     }

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

@@ -1,6 +1,6 @@
 import type { LibroService } from '@difizen/libro-core';
 import { EditorCellView } from '@difizen/libro-core';
-import type { LSPConnection, VirtualDocument } from '@difizen/libro-lsp';
+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';
@@ -28,10 +28,9 @@ export class DiagnosticProvider extends LangaugeFeatureProvider implements Dispo
   protected toDispose = new DisposableCollection();
   constructor(
     libroService: LibroService,
-    lspConnection: LSPConnection,
-    virtualDocument: VirtualDocument,
+    lspDocumentConnectionManager: ILSPDocumentConnectionManager,
   ) {
-    super(libroService, lspConnection, virtualDocument);
+    super(libroService, lspDocumentConnectionManager);
     this.processDiagnostic();
   }
 
@@ -79,71 +78,79 @@ export class DiagnosticProvider extends LangaugeFeatureProvider implements Dispo
   }
 
   async processDiagnostic() {
-    const toDispose = this.lspConnection.serverNotifications[
+    const lspConnection = await this.getLSPConnection();
+    const toDispose = lspConnection.serverNotifications[
       'textDocument/publishDiagnostics'
-    ].event((e) => {
+    ].event(async (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;
-        }
+      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 editorStart = this.virtualDocument.transformVirtualToEditor({
-          line: range.start.line,
-          ch: range.start.character,
-          isVirtual: true,
-        });
+          const virtualDocument = await this.getVirtualDocument();
+          if (!virtualDocument) {
+            return;
+          }
 
-        const editorEnd = this.virtualDocument.transformVirtualToEditor({
-          line: range.end.line,
-          ch: range.end.character,
-          isVirtual: true,
-        });
+          const editorStart = virtualDocument.transformVirtualToEditor({
+            line: range.start.line,
+            ch: range.start.character,
+            isVirtual: true,
+          });
 
-        if (!editorStart || !editorEnd) {
-          return;
-        }
+          const editorEnd = virtualDocument.transformVirtualToEditor({
+            line: range.end.line,
+            ch: range.end.character,
+            isVirtual: true,
+          });
 
-        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);
-      });
+          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

@@ -38,7 +38,8 @@ export class FormatProvider
     }
 
     const { virtualDocument: doc } = provider;
-    const result = await this.lspConnection.clientRequests[
+    const lspConnection = await this.getLSPConnection();
+    const result = await lspConnection.clientRequests[
       'textDocument/rangeFormatting'
     ].request({
       // TODO: range transform

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

@@ -1,7 +1,7 @@
 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 { 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';
 
@@ -9,19 +9,52 @@ import { LibroE2Editor } from '../../libro-e2-editor.js';
 
 export class LangaugeFeatureProvider {
   protected libroService: LibroService;
-  protected lspProvider?: LSPProviderResult;
-  protected lspConnection: LSPConnection;
-  virtualDocument: VirtualDocument;
+  lspDocumentConnectionManager: ILSPDocumentConnectionManager;
   constructor(
     libroService: LibroService,
-    lspConnection: LSPConnection,
-    virtualDocument: VirtualDocument,
+    lspDocumentConnectionManager: ILSPDocumentConnectionManager,
   ) {
     this.libroService = libroService;
-    this.lspConnection = lspConnection;
-    this.virtualDocument = virtualDocument;
+    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) {
@@ -42,17 +75,23 @@ export class LangaugeFeatureProvider {
     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;
+  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;
     }
-    return;
   }
 
   protected async getProvider(model: monaco.editor.ITextModel) {
@@ -63,7 +102,6 @@ export class LangaugeFeatureProvider {
     }
 
     const provider = await editor.lspProvider?.();
-    this.lspProvider = provider;
     return provider;
   }
 }

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

@@ -1,12 +1,12 @@
-import {
-  EditorHandlerContribution,
-  LanguageOptionsRegistry,
-} from '@difizen/libro-cofine-editor-core';
+import { EditorHandlerContribution } 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 { Disposable, DisposableCollection, inject, singleton } from '@difizen/mana-app';
-import * as monaco from '@difizen/monaco-editor-core';
+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';
 
@@ -19,9 +19,6 @@ import { SignatureHelpProvider } from './signature-help-provider.js';
   contrib: [EditorHandlerContribution],
 })
 export class LSPContribution implements EditorHandlerContribution {
-  @inject(LanguageOptionsRegistry)
-  protected readonly optionsResgistry: LanguageOptionsRegistry;
-
   @inject(LibroService) protected readonly libroService: LibroService;
 
   @inject(ILSPDocumentConnectionManager)
@@ -35,117 +32,84 @@ export class LSPContribution implements EditorHandlerContribution {
     //
   }
   afterCreate(editor: any) {
-    this.registerLSPFeature(editor as monaco.editor.IStandaloneCodeEditor);
+    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: monaco.editor.ITextModel,
-  ): monaco.languages.LanguageFilter {
+  getLanguageSelector(model: editor.ITextModel): 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) {
+  registerLSPFeature(editor: 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),
-          ),
-        );
-
-        const provider = new DiagnosticProvider(
-          this.libroService,
-          lspConnection,
-          virtualDocument,
-        );
-        this.toDispose.push(Disposable.create(() => provider.dispose()));
-
-        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);
+    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
-    // monaco.languages.registerSignatureHelpProvider(id, new SignatureHelpProvider(this._worker));
+    // languages.registerSignatureHelpProvider(id, new SignatureHelpProvider(this._worker));
 
     // // 定义跳转;
-    // monaco.languages.registerDefinitionProvider(id, new DefinitionAdapter(this._worker));
+    // languages.registerDefinitionProvider(id, new DefinitionAdapter(this._worker));
   }
 
   protected isDisposed = false;