@kerebron/extension-lsp 0.7.9 → 0.8.2

package/src/LSPClient.ts

@@ -4,12 +4,9 @@ import {
   TextDocumentSyncKind,
 } from 'vscode-languageserver-protocol';
 
-import {
-  DefaultWorkspace,
-  LspSource,
-  Workspace,
-  WorkspaceFile,
-} from './workspace.js';
+import { Workspace, WorkspaceFile } from './workspace.js';
+
+import { LSPSource, LSPWorkspace } from './LSPWorkspace.js';
 
 const defaultNotificationHandlers: {
   [method: string]: (client: LSPClient, params: any) => void;
@@ -76,6 +73,11 @@ const clientCapabilities: lsp.ClientCapabilities = {
       parser: 'marked',
     },
   },
+  workspace: {
+    'diagnostics': {
+      'refreshSupport': true,
+    },
+  },
   textDocument: {
     publishDiagnostics: { versionSupport: true },
     completion: {
@@ -108,7 +110,7 @@ const clientCapabilities: lsp.ClientCapabilities = {
     implementation: {},
     typeDefinition: {},
     references: {},
-    diagnostic: {},
+    // diagnostic: {},
   },
   window: {
     showMessage: {},
@@ -156,7 +158,7 @@ export class LSPError extends Error {
 }
 
 export class LSPClient extends EventTarget {
-  sources: Record<string, LspSource> = {};
+  sources: Record<string, LSPSource> = {};
 
   workspace: Workspace;
   private nextReqID = 0;
@@ -209,7 +211,7 @@ export class LSPClient extends EventTarget {
 
     this.workspace = config.workspace
       ? config.workspace(this)
-      : new DefaultWorkspace(this);
+      : new LSPWorkspace(this);
   }
 
   startInitializing() {
@@ -272,7 +274,7 @@ export class LSPClient extends EventTarget {
     this.workspace.connected();
   }
 
-  connect(uri: string, source: LspSource) {
+  connect(uri: string, source: LSPSource) {
     if (this.sources[uri] && this.sources[uri] !== source) {
       throw new Error(`Source for ${uri} already connected`);
     }
@@ -311,6 +313,14 @@ export class LSPClient extends EventTarget {
         },
       },
     );
+    await this.notification<lsp.DocumentDiagnosticParams>(
+      'textDocument/diagnostic',
+      {
+        textDocument: {
+          uri: file.uri,
+        },
+      },
+    );
     return true;
   }
 
@@ -464,7 +474,7 @@ export class LSPClient extends EventTarget {
     return this.serverCapabilities ? !!this.serverCapabilities[name] : null;
   }
 
-  sync() {
+  syncFiles() {
     this.workspace.syncFiles();
   }
 
@@ -474,8 +484,6 @@ export class LSPClient extends EventTarget {
     id: number,
     params: any,
   ) {
-    console.error('this.timeoutRequest', this.timeout, method, id, params);
-
     const index = this.requests.indexOf(req);
     if (index > -1) {
       req.reject(LSPError.createTimeout());

package/src/LSPPlugin.ts

@@ -0,0 +1,323 @@
+import { Plugin, PluginKey, Transaction } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { Diagnostic } from 'vscode-languageserver-protocol';
+
+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';
+
+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;
+}
+
+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) {
+    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);
+        },
+        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
+          // }
+
+          return value;
+        },
+      },
+      props: {
+        decorations(state) {
+          const decorations: Decoration[] = [];
+
+          const pluginState = this.getState(state);
+          if (pluginState) {
+            const { diagnostics, snapshot } = pluginState;
+
+            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,
+                );
+
+                if (from > -1 && end > -1) {
+                  const decoration = Decoration.inline(
+                    from,
+                    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/{LspWebSocketTransport.ts → LSPWebSocketTransport.ts}

@@ -7,7 +7,7 @@ function shouldReconnectOnCode(code: number) {
   return reconnectCodes.includes(code);
 }
 
-export class LspWebSocketTransport extends EventTarget implements Transport {
+export class LSPWebSocketTransport extends EventTarget implements Transport {
   socket: WebSocket | undefined;
   private reconnectAttempts = 0;
   private maxAttempts = 10;

package/src/LSPWorkspace.ts

@@ -0,0 +1,172 @@
+import type * as lsp from 'vscode-languageserver-protocol';
+import { TextDocumentSyncKind } 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';
+import { computeIncrementalChanges } from './computeIncrementalChanges.js';
+
+export interface LSPSource {
+  ui: EditorUi;
+  getMappedContent(): Promise<{ content: string; mapper: PositionMapper }>;
+}
+
+class LSPWorkspaceFile implements WorkspaceFile {
+  public syncedContent: string = '';
+  public diagnostics: Array<lsp.Diagnostic> = [];
+
+  constructor(
+    readonly uri: string,
+    readonly languageId: string,
+    public version: number,
+    public content: string,
+    public mapper: PositionMapper,
+    public source: LSPSource,
+  ) {
+  }
+
+  getUi() {
+    return this.source.ui;
+  }
+}
+
+export class LSPWorkspace extends Workspace {
+  files: LSPWorkspaceFile[] = [];
+  private fileVersions: { [uri: string]: number } = Object.create(null);
+
+  constructor(private client: LSPClient) {
+    super();
+  }
+
+  nextFileVersion(uri: string) {
+    return this.fileVersions[uri] = (this.fileVersions[uri] ?? -1) + 1;
+  }
+
+  override async connected(): Promise<void> {
+    super.connected();
+    for await (const file of this.files) {
+      const result = await this.client.didOpen(file);
+    }
+  }
+
+  override disconnected(): void {
+    for (const file of this.files) {
+      this.client.workspace.closeFile(file.uri);
+    }
+    super.disconnected();
+  }
+
+  syncFiles() {
+    if (!this.client.supportSync) {
+      return;
+    }
+
+    for (const file of this.files) {
+      this.changedFile(file.uri);
+    }
+  }
+
+  async changedFile(uri: string) {
+    const file = this.files.find((f) => f.uri == uri) || null;
+
+    if (file) {
+      const { content, mapper } = await file.source.getMappedContent();
+
+      if (!this.isConnected) {
+        file.content = content;
+        file.mapper = mapper;
+        return;
+      }
+
+      if (
+        await this.client.notification<lsp.DidChangeTextDocumentParams>(
+          'textDocument/didChange',
+          {
+            textDocument: { uri: file.uri, version: file.version },
+            contentChanges: contentChangesFor(
+              file,
+              content,
+              mapper,
+              this.client.supportSync == TextDocumentSyncKind.Incremental,
+            ),
+          },
+        )
+      ) {
+        file.syncedContent = file.content;
+        file.content = content;
+        file.mapper = mapper;
+        file.version = this.nextFileVersion(file.uri);
+        file.diagnostics = [];
+
+        this.dispatchEvent(
+          new CustomEvent('fileChanged', { // TODO: clear diagnosrics
+            detail: {
+              uri: file.uri,
+              file,
+            },
+          }),
+        );
+      }
+
+      await this.client.notification<lsp.DocumentDiagnosticParams>(
+        'textDocument/diagnostic',
+        {
+          textDocument: {
+            uri: file.uri,
+          },
+        },
+      );
+    }
+  }
+
+  async openFile(uri: string, languageId: string, source: LSPSource) {
+    // if (uri) {}
+
+    if (this.getFile(uri)) {
+      this.closeFile(uri);
+    }
+
+    const mappedContent = await source.getMappedContent();
+    const { content, mapper } = mappedContent;
+    const file = new LSPWorkspaceFile(
+      uri,
+      languageId,
+      this.nextFileVersion(uri),
+      content,
+      mapper,
+      source,
+    );
+    this.files.push(file);
+
+    this.client.didOpen(file);
+  }
+
+  closeFile(uri: string) {
+    const file = this.getFile(uri);
+    if (file) {
+      this.files = this.files.filter((f) => f.uri !== uri);
+      this.client.didClose(uri);
+    }
+  }
+}
+
+const enum Sync {
+  AlwaysIfSmaller = 1024,
+}
+
+function contentChangesFor(
+  file: WorkspaceFile,
+  newContent: string,
+  mapper: PositionMapper,
+  supportInc: boolean,
+): lsp.TextDocumentContentChangeEvent[] {
+  if (!supportInc || newContent.length < Sync.AlwaysIfSmaller) {
+    return [{ text: newContent }];
+  }
+
+  const changes = computeIncrementalChanges(file.content, newContent);
+  return changes.reverse();
+}

package/src/createLspAutocomplete.ts

@@ -1,10 +1,11 @@
-import { DefaultRenderer } from '@kerebron/extension-autocomplete/DefaultRenderer';
+import { DefaultRenderer } from '@kerebron/extension-ui/autocomplete/DefaultRenderer';
 import { type CoreEditor, TextRange } from '@kerebron/editor';
 
 import {
+  AutocompleteConfig,
   type AutocompleteProps,
   createRegexMatcher,
-} from '@kerebron/extension-autocomplete';
+} from '@kerebron/extension-ui/autocomplete';
 
 import { ExtensionLsp } from './ExtensionLsp.js';
 
@@ -35,13 +36,15 @@ export function cleanPlaceholders(input: string): string {
   return input.replace(regex, '$1');
 }
 
-export function createLspAutocomplete(extensionLsp: ExtensionLsp) {
+export function createLspAutocomplete(
+  extensionLsp: ExtensionLsp,
+): { autocompleteConfig: AutocompleteConfig } {
   const editor: CoreEditor = extensionLsp.getEditor();
   const renderer = new CustomRenderer(editor);
 
-  const config = {
-    renderer,
-    matchers: [createRegexMatcher([/\w+/, /(^|\s)@\w*/, /^#\w*/])],
+  const config: AutocompleteConfig = {
+    // renderer,
+    // matchers: [createRegexMatcher([/\w+/, /(^|\s)@\w*/, /^#\w*/])],
     getItems: async (query: string, props: AutocompleteProps) => {
       const { mapper } = await extensionLsp.source.getMappedContent();
 
@@ -49,7 +52,7 @@ export function createLspAutocomplete(extensionLsp: ExtensionLsp) {
 
       const client = extensionLsp.getClient(extensionLsp.mainLang);
       if (client) {
-        client.sync();
+        client.syncFiles();
         try {
           const completions:
             | { items: CompletionItem[] }

package/src/mod.ts

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