@kerebron/extension-lsp 0.8.4 → 0.8.6

package/src/LSPPlugin.ts

@@ -1,323 +1,90 @@
 import { Plugin, PluginKey, Transaction } from 'prosemirror-state';
-import { Decoration, DecorationSet } from 'prosemirror-view';
-import { Diagnostic } from 'vscode-languageserver-protocol';
+import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
 
-import { PositionMapper } from '@kerebron/extension-markdown/PositionMapper';
 import { CoreEditor } from '@kerebron/editor';
-import {
-  type ExtensionMarkdown,
-  type MarkdownResult,
-} from '@kerebron/extension-markdown';
 
-import { ExtensionLsp, LspConfig } from './ExtensionLsp.js';
+import type { LspConfig } from './ExtensionLsp.js';
+import { LSPSync } from './LSPSync.js';
 
-export interface LspRange {
-  line: number;
-  character: number;
-}
-
-interface DiagnosticsItem {
-  severity: number;
-  range: {
-    start: LspRange;
-    end: LspRange;
-  };
-  message: string;
-  source: string;
-  code: string;
-  data: any; // "data":{"kind":"todo","keyword":"TODO"}},
-}
-
-interface LSPMeta {
-}
-
-interface WorkspaceMetaOpen {
-  operation: 'openFile';
-  uri: string;
-  lang: string;
-}
-
-interface WorkspaceMetaModify {
-  operation: 'modifyFile';
-  uri: string;
-}
-
-interface WorkspaceMetaClose {
-  operation: 'closeFile';
-  uri: string;
-}
+export const LSPPluginKey = new PluginKey<LSPSync>('lsp');
 
-type WorkspaceMeta =
-  | WorkspaceMetaOpen
-  | WorkspaceMetaClose
-  | WorkspaceMetaModify;
-
-class LSPPluginState {
-  diagnostics: DiagnosticsItem[] = [];
-
-  snapshot?: {
-    version: number;
-    mapper: PositionMapper;
-    markdownResult: MarkdownResult;
-  };
-
-  constructor(private editor: CoreEditor) {
-  }
-}
-
-const LSPPluginKey = new PluginKey('lsp');
-
-export class LSPPlugin extends Plugin<LSPPluginState> {
-  listenerDiag: ((event: Event) => void) | undefined;
-  listenerDisconnect: ((event: Event) => void) | undefined;
-  listenerChange: ((event: Event) => void) | undefined;
-
-  constructor(config: LspConfig, extension: ExtensionLsp) {
+export class LSPPlugin extends Plugin<LSPSync> {
+  constructor(config: LspConfig, editor: CoreEditor) {
     super({
       key: LSPPluginKey,
-      view(view) {
-        return {
-          destroy: () => {
-            const client = extension.getClient(extension.mainLang);
-
-            if (this.listenerDiag && client) {
-              client.removeEventListener(
-                'textDocument/publishDiagnostics',
-                this.listenerDiag,
-              );
-            }
-            if (this.listenerDisconnect && client) {
-              client.removeEventListener(
-                'close',
-                this.listenerDisconnect,
-              );
-            }
-            // if (this.listenerChange) {
-            //   extension.getEditor().removeEventListener(
-            //     'change',
-            //     this.listenerChange,
-            //   );
-            // }
-          },
-        };
-      },
       state: {
         init() {
-          return new LSPPluginState(editor);
+          return new LSPSync(config, editor);
         },
-        apply(
-          tr: Transaction,
-          value: LSPPluginState,
-          oldState,
-          newState,
-        ) {
-          const workspaceMeta: WorkspaceMeta | undefined = tr.getMeta(
-            'workspace',
-          );
-
-          if (workspaceMeta) {
-            console.log(
-              'workspaceMeta',
-              workspaceMeta.operation,
-              workspaceMeta,
-            );
-
-            const uri = workspaceMeta.uri;
-            // const lang = workspaceMeta.lang;
-
-            switch (workspaceMeta.operation) {
-              case 'openFile':
-                {
-                  const client = extension.getClient(workspaceMeta.lang);
-                  if (client) {
-                    client.addEventListener(
-                      'textDocument/publishDiagnostics',
-                      this.diagListener,
-                    );
-
-                    const go = async () => {
-                      client.connect(uri, this.source);
-                      if (uri === editor.config.uri) {
-                        await client.restart();
-                      }
-                      client.workspace.openFile(
-                        workspaceMeta.uri,
-                        workspaceMeta.lang,
-                        this.source,
-                      );
-                    };
-
-                    go();
-                  }
-                }
-                break;
-              case 'modifyFile':
-                break;
-              case 'closeFile':
-                // this.editor.view.dispatch(tr);
-                // const client = this.getClient(this.mainLang);
-                // if (client) {
-                //   client.disconnect(this.uri);
-                // }
-
-                break;
-            }
-
-            return value;
-          }
-
-          const meta: LSPMeta | undefined = tr.getMeta(LSPPluginKey);
-          if (meta?.diagnostics) {
-            value.diagnostics = meta.diagnostics;
-          }
-
-          const markdownMeta = tr.getMeta('markdown');
-          if (markdownMeta?.snapshot) {
-            value.snapshot = markdownMeta.snapshot;
-            return value;
-          }
-          if (markdownMeta?.clearSnapshot) {
-            value.snapshot = undefined;
-            return value;
-          }
-
-          if (tr.docChanged) {
-            // value.snapshot = undefined;
-          }
-
-          // let codeBlockChanged = false;
-
-          // // Compare changed ranges only
-          // tr.mapping.maps.forEach((stepMap) => {
-          //   stepMap.forEach((oldStart, oldEnd, newStart, newEnd) => {
-          //     oldState.doc.nodesBetween(oldStart, oldEnd, (node) => {
-          //       if (node.type.name === "code_block") {
-          //         codeBlockChanged = true;
-          //       }
-          //     });
-
-          //     newState.doc.nodesBetween(newStart, newEnd, (node) => {
-          //       if (node.type.name === "code_block") {
-          //         codeBlockChanged = true;
-          //       }
-          //     });
-          //   });
-          // });
-
-          // if (codeBlockChanged) {
-          //   console.log("Code block changed");
-          //   // trigger your logic here
-          // }
-
+        apply(_tr: Transaction, value) {
           return value;
         },
       },
+      view(view) {
+        const pluginState = LSPPluginKey.getState(view.state);
+        return {
+          destroy() {
+            pluginState?.destroy();
+          },
+        };
+      },
       props: {
         decorations(state) {
           const decorations: Decoration[] = [];
 
-          const pluginState = this.getState(state);
+          const pluginState = LSPPluginKey.getState(editor.state);
+
           if (pluginState) {
-            const { diagnostics, snapshot } = pluginState;
+            state.doc.forEach((node, pos) => {
+              const dom = (editor.view as EditorView).nodeDOM(
+                pos,
+              ) as HTMLElement;
+              if (!dom || !dom.querySelector) {
+                return;
+              }
 
-            if (snapshot?.version === editor.version) {
-              for (const diag of diagnostics) {
-                const from = snapshot.mapper.fromLineChar(
-                  diag.range.start.line,
-                  diag.range.start.character,
-                );
-                const end = snapshot.mapper.fromLineChar(
-                  diag.range.end.line,
-                  diag.range.end.character,
-                );
+              const editorElement = dom.querySelector('[data-uri]');
+              const uri = (editorElement
+                ? editorElement.getAttribute('data-uri')
+                : undefined) ||
+                undefined;
+
+              if (uri) {
+                const diags = pluginState.uriToDiagnostics[uri];
+                if (!diags) {
+                  return;
+                }
+                const { diagnostics, version, contentMapper } = diags;
+
+                if (version === editor.version) {
+                  for (const diag of diagnostics) {
+                    const from = contentMapper.fromLineChar(
+                      diag.range.start.line,
+                      diag.range.start.character,
+                    );
+                    const end = contentMapper.fromLineChar(
+                      diag.range.end.line,
+                      diag.range.end.character,
+                    );
 
-                if (from > -1 && end > -1) {
-                  const decoration = Decoration.inline(
-                    from,
-                    end,
-                    { class: 'kb-lsp__error', title: diag.message },
-                  );
-                  decorations.push(decoration);
+                    if (from > -1 && end > -1) {
+                      const decoration = Decoration.inline(
+                        pos + 1 + from,
+                        pos + 1 + end,
+                        {},
+                        { class: 'kb-lsp__error', title: diag.message },
+                      );
+                      decorations.push(decoration);
+                    }
+                  }
                 }
               }
-            }
+            });
           }
 
           return DecorationSet.create(state.doc, decorations);
         },
       },
     });
-
-    let lastDiag = 0;
-
-    const editor = extension.getEditor();
-
-    const uri = editor.config.uri;
-    if (uri) {
-      const client = extension.getClient(extension.mainLang);
-
-      this.listenerDiag = (event: Event) => {
-        const detail = (event as CustomEvent).detail;
-        if (detail.params.uri !== uri) {
-          return;
-        }
-
-        event.preventDefault();
-
-        lastDiag = +Date();
-
-        if (client) {
-          const file = client.workspace.getFile(uri);
-          if (file) {
-            const { mapper } = file;
-
-            const diagnostics: Array<Diagnostic> = detail.params.diagnostics;
-
-            // file.dia
-
-            const tr = editor.view.state.tr.setMeta(LSPPluginKey, {
-              diagnostics: detail.params.diagnostics,
-              mapper,
-            });
-            editor.view.dispatch(tr);
-          }
-        }
-      };
-
-      if (client) {
-        client.addEventListener(
-          'textDocument/publishDiagnostics',
-          this.listenerDiag,
-        );
-      }
-
-      this.listenerDisconnect = (event: Event) => {
-        const tr = editor.view.state.tr.setMeta(LSPPluginKey, {
-          diagnostics: [],
-          mapper: undefined,
-        });
-        editor.view.dispatch(tr);
-      };
-
-      if (client) {
-        client.addEventListener(
-          'close',
-          this.listenerDisconnect,
-        );
-      }
-
-      this.listenerChange = (event: Event) => {
-        if (lastDiag === 0 && +Date() - lastDiag > 10_1000) {
-          return;
-        }
-        const tr = editor.view.state.tr.setMeta(LSPPluginKey, {
-          diagnostics: [],
-          mapper: undefined,
-        });
-        editor.view.dispatch(tr);
-      };
-
-      // extension.getEditor().addEventListener('changed', this.listenerChange);
-    }
   }
 }

package/src/LSPSync.ts

@@ -0,0 +1,169 @@
+import * as lsp from 'vscode-languageserver-protocol';
+
+import { CoreEditor } from '@kerebron/editor';
+import type {
+  ContentMapper,
+  Workspace,
+  WorkspaceCloseParams,
+  WorkspaceModifyParams,
+} from '@kerebron/workspace';
+
+import type { LspConfig } from './ExtensionLsp.js';
+import { LSPClient, LSPClientImpl } from './LSPClient.js';
+
+export class LSPSync {
+  clients: Record<string, LSPClient> = {};
+
+  uriToClient: Record<string, LSPClient> = {};
+  uriToDiagnostics: Record<
+    string,
+    {
+      diagnostics: lsp.Diagnostic[];
+      version: number;
+      contentMapper: ContentMapper;
+    }
+  > = {};
+
+  listenerDiag: (
+    event: CustomEvent<{ params: lsp.PublishDiagnosticsParams }>,
+  ) => void;
+  listenerDisconnect: (event: CustomEvent<void>) => void;
+  listenerChange: (event: CustomEvent<WorkspaceModifyParams>) => Promise<void>;
+
+  constructor(private config: LspConfig, private editor: CoreEditor) {
+    this.listenerDiag = async (
+      event: CustomEvent<{ params: lsp.PublishDiagnosticsParams }>,
+    ) => {
+      const { uri, diagnostics, version } = event.detail.params;
+
+      const client = event.target as LSPClientImpl;
+
+      const entry = client.entries[uri];
+      if (!entry || !version) {
+        return;
+      }
+
+      const contentMapper = await entry.getContentMapper();
+
+      this.uriToDiagnostics[uri] = {
+        diagnostics,
+        version,
+        contentMapper,
+      };
+
+      const tr = editor.state.tr;
+      editor.dispatchTransaction(tr);
+    };
+
+    this.listenerDisconnect = (event: Event) => {
+      const client = event.target as LSPClient;
+      this.disconnected(client);
+    };
+
+    const workspace: Workspace = this.editor.ci.resolve('workspace');
+
+    this.listenerChange = async (event: CustomEvent<WorkspaceModifyParams>) => {
+      await this.changeFile(event.detail);
+    };
+
+    workspace.addEventListener('openFile', this.listenerChange);
+    workspace.addEventListener('modifyFile', this.listenerChange);
+    workspace.addEventListener(
+      'closeFile',
+      (event: CustomEvent<WorkspaceCloseParams>) => {
+        this.closeFile(event.detail.uri);
+      },
+    );
+  }
+
+  async changeFile(modified: WorkspaceModifyParams) {
+    const langClient = this.getClient(modified.lang);
+    if (!langClient) {
+      return;
+    }
+
+    const client: LSPClient | undefined = this.uriToClient[modified.uri];
+
+    if (!client) {
+      this.uriToClient[modified.uri] = langClient;
+      await langClient.changeFile(modified);
+      return;
+    }
+
+    if (client.lang !== langClient.lang) {
+      await client.closeFile(modified.uri);
+      this.uriToClient[modified.uri] = langClient;
+      await langClient.changeFile(modified);
+      return;
+    }
+
+    await client.changeFile(modified);
+  }
+
+  async closeFile(uri: string) {
+    const client = this.uriToClient[uri];
+
+    if (client) {
+      delete this.uriToClient[uri];
+      await client.closeFile(uri);
+    }
+  }
+
+  disconnected(disconnectedClient: LSPClient): void {
+    for (const [uri, client] of Object.entries(this.uriToClient)) {
+      if (client !== disconnectedClient) {
+        continue;
+      }
+      this.closeFile(uri);
+    }
+  }
+
+  getClient(lang: string): LSPClient | undefined {
+    if (!this.clients[lang]) {
+      const transport = this.config.getLspTransport(lang);
+      if (!transport) {
+        console.warn(`No lsp transport for ${lang}`);
+        return undefined;
+      }
+      const ui = this.editor.ui;
+
+      const client: LSPClient = new LSPClientImpl(transport, {
+        lang,
+        rootUri: 'file:///',
+        ui,
+      });
+
+      client.addEventListener(
+        'textDocument/publishDiagnostics',
+        this.listenerDiag,
+      );
+      client.addEventListener('close', this.listenerDisconnect);
+
+      this.clients[lang] = client;
+    }
+
+    return this.clients[lang];
+  }
+
+  destroy() {
+    const workspace: Workspace = this.editor.ci.resolve('workspace');
+
+    workspace.removeEventListener('openFile', this.listenerChange);
+    workspace.removeEventListener('modifyFile', this.listenerChange);
+
+    for (const client of Object.values(this.clients)) {
+      client.removeEventListener(
+        'textDocument/publishDiagnostics',
+        this.listenerDiag,
+      );
+      client.removeEventListener(
+        'close',
+        this.listenerDisconnect,
+      );
+      client.destroy();
+    }
+    this.clients = {};
+    this.uriToClient = {};
+    this.uriToDiagnostics = {};
+  }
+}

package/src/computeIncrementalChanges.ts

@@ -99,3 +99,20 @@ export function computeIncrementalChanges(
 
   return changes;
 }
+
+const enum Sync {
+  AlwaysIfSmaller = 1024,
+}
+
+export function contentChangesFor(
+  supportInc: boolean,
+  newContent: string,
+  oldContent?: string,
+): lsp.TextDocumentContentChangeEvent[] {
+  if (!supportInc || newContent.length < Sync.AlwaysIfSmaller || !oldContent) {
+    return [{ text: newContent }];
+  }
+
+  const changes = computeIncrementalChanges(oldContent, newContent);
+  return changes.reverse();
+}

package/src/mod.ts

@@ -1,3 +1,2 @@
 export * from './ExtensionLsp.js';
 export * from './LSPClient.js';
-export * from './LSPWorkspace.js';

package/esm/LSPWorkspace.d.ts

@@ -1,39 +0,0 @@
-import type * as lsp from 'vscode-languageserver-protocol';
-import type { EditorUi } from '@kerebron/editor';
-import { Workspace, WorkspaceFile } from './workspace.js';
-import { PositionMapper } from '@kerebron/extension-markdown/PositionMapper';
-import { LSPClient } from './LSPClient.js';
-export interface LSPSource {
-    ui: EditorUi;
-    getMappedContent(): Promise<{
-        content: string;
-        mapper: PositionMapper;
-    }>;
-}
-declare class LSPWorkspaceFile implements WorkspaceFile {
-    readonly uri: string;
-    readonly languageId: string;
-    version: number;
-    content: string;
-    mapper: PositionMapper;
-    source: LSPSource;
-    syncedContent: string;
-    diagnostics: Array<lsp.Diagnostic>;
-    constructor(uri: string, languageId: string, version: number, content: string, mapper: PositionMapper, source: LSPSource);
-    getUi(): EditorUi;
-}
-export declare class LSPWorkspace extends Workspace {
-    private client;
-    files: LSPWorkspaceFile[];
-    private fileVersions;
-    constructor(client: LSPClient);
-    nextFileVersion(uri: string): number;
-    connected(): Promise<void>;
-    disconnected(): void;
-    syncFiles(): void;
-    changedFile(uri: string): Promise<void>;
-    openFile(uri: string, languageId: string, source: LSPSource): Promise<void>;
-    closeFile(uri: string): void;
-}
-export {};
-//# sourceMappingURL=LSPWorkspace.d.ts.map

package/esm/LSPWorkspace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LSPWorkspace.d.ts","sourceRoot":"","sources":["../src/LSPWorkspace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,gCAAgC,CAAC;AAG3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAE7E,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,QAAQ,CAAC;IACb,gBAAgB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,cAAc,CAAA;KAAE,CAAC,CAAC;CAC1E;AAED,cAAM,gBAAiB,YAAW,aAAa;IAK3C,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM;IACpB,OAAO,EAAE,MAAM;IACf,OAAO,EAAE,MAAM;IACf,MAAM,EAAE,cAAc;IACtB,MAAM,EAAE,SAAS;IATnB,aAAa,EAAE,MAAM,CAAM;IAC3B,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAM;gBAGpC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,SAAS;IAI1B,KAAK;CAGN;AAED,qBAAa,YAAa,SAAQ,SAAS;IAI7B,OAAO,CAAC,MAAM;IAH1B,KAAK,EAAE,gBAAgB,EAAE,CAAM;IAC/B,OAAO,CAAC,YAAY,CAAkD;gBAElD,MAAM,EAAE,SAAS;IAIrC,eAAe,CAAC,GAAG,EAAE,MAAM;IAIZ,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAOhC,YAAY,IAAI,IAAI;IAO7B,SAAS;IAUH,WAAW,CAAC,GAAG,EAAE,MAAM;IAqDvB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS;IAsBjE,SAAS,CAAC,GAAG,EAAE,MAAM;CAOtB"}