@difizen/libro-lsp 0.1.2

package/src/extractors/text-extractor.ts

@@ -0,0 +1,94 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import type { LanguageIdentifier } from '../lsp.js';
+import { positionAtOffset } from '../positioning.js';
+
+import type { IExtractedCode, IForeignCodeExtractor } from './types.js';
+
+/**
+ * The code extractor for the raw and markdown text.
+ */
+export class TextForeignCodeExtractor implements IForeignCodeExtractor {
+  constructor(options: TextForeignCodeExtractor.IOptions) {
+    this.language = options.language;
+    this.standalone = options.isStandalone;
+    this.fileExtension = options.file_extension;
+    this.cellType = options.cellType;
+  }
+  /**
+   * The foreign language.
+   */
+  readonly language: LanguageIdentifier;
+
+  /**
+   * Should the foreign code be appended (False) to the previously established virtual document of the same language,
+   * or is it standalone snippet which requires separate connection?
+   */
+  readonly standalone: boolean;
+
+  /**
+   * Extension of the virtual document (some servers check extensions of files), e.g. 'py' or 'R'.
+   */
+  readonly fileExtension: string;
+
+  /**
+   * The supported cell types.
+   */
+  readonly cellType: string[];
+
+  /**
+   * Test if there is any foreign code in provided code snippet.
+   */
+  hasForeignCode(code: string, cellType: string): boolean {
+    return this.cellType.includes(cellType);
+  }
+
+  /**
+   * Split the code into the host and foreign code (if any foreign code was detected)
+   */
+  extractForeignCode(code: string): IExtractedCode[] {
+    const lines = code.split('\n');
+
+    const extracts = new Array<IExtractedCode>();
+
+    const foreignCodeFragment = code;
+
+    const start = positionAtOffset(0, lines);
+    const end = positionAtOffset(foreignCodeFragment.length, lines);
+
+    extracts.push({
+      hostCode: '',
+      foreignCode: foreignCodeFragment,
+      range: { start, end },
+      virtualShift: null,
+    });
+
+    return extracts;
+  }
+}
+
+namespace TextForeignCodeExtractor {
+  export interface IOptions {
+    /**
+     * The foreign language.
+     */
+    language: string;
+
+    /**
+     * Should the foreign code be appended (False) to the previously established virtual document of the same language,
+     * or is it standalone snippet which requires separate connection?
+     */
+    isStandalone: boolean;
+
+    /**
+     * Extension of the virtual document (some servers check extensions of files), e.g. 'py' or 'R'.
+     */
+    file_extension: string;
+
+    /**
+     * The supported cell types.
+     */
+    cellType: string[];
+  }
+}

package/src/extractors/types.ts

@@ -0,0 +1,78 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import type { IRange, IPosition } from '@difizen/libro-code-editor';
+
+import type { LanguageIdentifier } from '../lsp.js';
+
+export interface IExtractedCode {
+  /**
+   * Foreign code (may be empty, for example line of '%R') or null if none.
+   */
+  foreignCode: string | null;
+  /**
+   * Range of the foreign code relative to the original source.
+   * `null` is used internally to represent a leftover host code after extraction.
+   */
+  range: IRange | null;
+  /**
+   * Shift due to any additional code inserted at the beginning of the virtual document
+   * (usually in order to mock the arguments passed to a magic, or to provide other context clues for the linters)
+   */
+  virtualShift: IPosition | null;
+  /**
+   * Code to be retained in the virtual document of the host.
+   */
+  hostCode: string | null;
+}
+
+/**
+ * Foreign code extractor makes it possible to analyze code of language X embedded in code (or notebook) of language Y.
+ *
+ * The typical examples are:
+ *  - (X=CSS< Y=HTML), or
+ *  - (X=JavaScript, Y=HTML),
+ *
+ * while in the data analysis realm, examples include:
+ *   - (X=R, Y=IPython),
+ *   - (X=LATEX Y=IPython),
+ *   - (X=SQL, Y=IPython)
+ *
+ * This extension does not aim to provide comprehensive abilities for foreign code extraction,
+ * but it does intend to provide stable interface for other extensions to build on it.
+ *
+ * A simple, regular expression based, configurable foreign extractor is implemented
+ * to provide a good reference and a good initial experience for the users.
+ */
+export interface IForeignCodeExtractor {
+  /**
+   * The foreign language.
+   */
+  readonly language: LanguageIdentifier;
+
+  /**
+   * The supported cell types.
+   */
+  readonly cellType: string[];
+
+  /**
+   * Split the code into the host and foreign code (if any foreign code was detected)
+   */
+  extractForeignCode(code: string): IExtractedCode[];
+
+  /**
+   * Does the extractor produce code which should be appended to the previously established virtual document (False)
+   * of the same language, or does it produce standalone snippets which require separate connections (True)?
+   */
+  readonly standalone: boolean;
+
+  /**
+   * Test if there is any foreign code in provided code snippet.
+   */
+  hasForeignCode(code: string, cellType: string): boolean;
+
+  /**
+   * Extension of the virtual document (some servers check extensions of files), e.g. 'py' or 'R'.
+   */
+  readonly fileExtension: string;
+}

package/src/feature.ts

@@ -0,0 +1,60 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import type { Event } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-app';
+import { singleton } from '@difizen/mana-app';
+import mergeWith from 'lodash.mergewith';
+
+import type { ClientCapabilities } from './lsp.js';
+import type { IFeature } from './tokens.js';
+import { ILSPFeatureManager } from './tokens.js';
+
+/**
+ * Class to manager the registered features of the language servers.
+ */
+@singleton({ token: ILSPFeatureManager })
+export class FeatureManager implements ILSPFeatureManager {
+  constructor() {
+    this._featuresRegistered = new Emitter();
+  }
+  /**
+   * List of registered features
+   */
+  readonly features: IFeature[] = [];
+
+  /**
+   * Signal emitted when a new feature is registered.
+   */
+  get featuresRegistered(): Event<IFeature> {
+    return this._featuresRegistered.event;
+  }
+
+  /**
+   * Register a new feature, skip if it is already registered.
+   */
+  register(feature: IFeature): void {
+    if (this.features.some((ft) => ft.id === feature.id)) {
+      console.warn(`Feature with id ${feature.id} is already registered, skipping.`);
+    } else {
+      this.features.push(feature);
+      this._featuresRegistered.fire(feature);
+    }
+  }
+
+  /**
+   * Get the capabilities of all clients.
+   */
+  clientCapabilities(): ClientCapabilities {
+    let capabilities: ClientCapabilities = {};
+    for (const feature of this.features) {
+      if (!feature.capabilities) {
+        continue;
+      }
+      capabilities = mergeWith(capabilities, feature.capabilities);
+    }
+    return capabilities;
+  }
+
+  protected _featuresRegistered: Emitter<IFeature>;
+}

package/src/index.spec.ts

@@ -0,0 +1,10 @@
+import 'reflect-metadata';
+import assert from 'assert';
+
+import { LibroLSPModule } from './index.js';
+
+describe('libro-lsp', () => {
+  it('#import', () => {
+    assert(LibroLSPModule);
+  });
+});

package/src/index.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+/**
+ * @packageDocumentation
+ * @module lsp
+ */
+
+export * from './module.js';
+export * from './adapters/adapter.js';
+export * from './connection-manager.js';
+export * from './extractors/index.js';
+export * from './feature.js';
+export * from './manager.js';
+export * from './plugin.js';
+export * from './positioning.js';
+export * from './tokens.js';
+export * from './utils.js';
+export * from './virtual/document.js';
+export * from './connection.js';
+export * from './lsp.js';
+export * from './lsp-protocol.js';

package/src/lsp-app-contribution.ts

@@ -0,0 +1,83 @@
+import type { LibroView } from '@difizen/libro-core';
+import { LibroService } from '@difizen/libro-core';
+import { ServerManager } from '@difizen/libro-kernel';
+import { ApplicationContribution } from '@difizen/mana-app';
+import { inject, singleton } from '@difizen/mana-app';
+
+import { NotebookAdapter } from './adapters/notebook-adapter.js';
+import {
+  ILSPCodeExtractorsManager,
+  ILSPDocumentConnectionManager,
+  ILSPFeatureManager,
+} from './tokens.js';
+
+@singleton({ contrib: [ApplicationContribution] })
+export class LSPAppContribution implements ApplicationContribution {
+  @inject(LibroService) libroService: LibroService;
+  @inject(ServerManager) serverManager: ServerManager;
+
+  @inject(ILSPDocumentConnectionManager)
+  connectionManager: ILSPDocumentConnectionManager;
+  @inject(ILSPFeatureManager) featureManager: ILSPFeatureManager;
+  @inject(ILSPCodeExtractorsManager) codeExtractorManager: ILSPCodeExtractorsManager;
+
+  onStart() {
+    /**
+     * FIXME：capability声明应该和具体的实现写在一起
+     */
+    this.featureManager.register({
+      id: 'libro-lsp',
+      capabilities: {
+        textDocument: {
+          completion: {
+            completionItem: { documentationFormat: ['markdown'] },
+          },
+          diagnostic: {
+            dynamicRegistration: true,
+          },
+          /**
+           * jedi-lsp的hover功能没有用hover的格式配置，而是使用completion的格式配置。。。
+           */
+          hover: {
+            dynamicRegistration: true,
+            contentFormat: ['markdown', 'plaintext'],
+          },
+          signatureHelp: {
+            dynamicRegistration: true,
+            contextSupport: true,
+            signatureInformation: {
+              activeParameterSupport: true,
+              documentationFormat: ['markdown'],
+              parameterInformation: {
+                labelOffsetSupport: true,
+              },
+            },
+          },
+        },
+      },
+    });
+    this.setupNotebookLanguageServer();
+  }
+
+  setupNotebookLanguageServer() {
+    this.libroService.onNotebookViewCreated(async (notebook) => {
+      this.activateNotebookLanguageServer(notebook);
+    });
+  }
+
+  /**
+   * Activate the language server for notebook.
+   */
+  async activateNotebookLanguageServer(notebook: LibroView): Promise<void> {
+    await notebook.initialized;
+    await this.serverManager.ready;
+
+    const adapter = new NotebookAdapter(notebook, {
+      connectionManager: this.connectionManager,
+      featureManager: this.featureManager,
+      foreignCodeExtractorsManager: this.codeExtractorManager,
+    });
+
+    this.connectionManager.registerAdapter(notebook.model.id, adapter);
+  }
+}

package/src/lsp-protocol.ts

@@ -0,0 +1,10 @@
+import type { LSPConnection } from './connection.js';
+import type { Document } from './tokens.js';
+import type { VirtualDocument } from './virtual/document.js';
+
+export type LSPProviderResult = {
+  virtualDocument: VirtualDocument;
+  lspConnection: LSPConnection;
+  editor: Document.IEditor;
+};
+export type LSPProvider = () => Promise<LSPProviderResult>;

package/src/lsp.ts

@@ -0,0 +1,160 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import type * as lsp from 'vscode-languageserver-protocol';
+
+export type ClientCapabilities = lsp.ClientCapabilities;
+
+export enum DiagnosticSeverity {
+  Error = 1,
+  Warning = 2,
+  Information = 3,
+  Hint = 4,
+}
+
+export enum DiagnosticTag {
+  Unnecessary = 1,
+  Deprecated = 2,
+}
+
+export enum CompletionItemTag {
+  Deprecated = 1,
+}
+
+export enum CompletionItemKind {
+  Text = 1,
+  Method = 2,
+  Function = 3,
+  Constructor = 4,
+  Field = 5,
+  Variable = 6,
+  Class = 7,
+  Interface = 8,
+  Module = 9,
+  Property = 10,
+  Unit = 11,
+  Value = 12,
+  Enum = 13,
+  Keyword = 14,
+  Snippet = 15,
+  Color = 16,
+  File = 17,
+  Reference = 18,
+  Folder = 19,
+  EnumMember = 20,
+  Constant = 21,
+  Struct = 22,
+  Event = 23,
+  Operator = 24,
+  TypeParameter = 25,
+}
+
+export enum DocumentHighlightKind {
+  Text = 1,
+  Read = 2,
+  Write = 3,
+}
+
+export enum CompletionTriggerKind {
+  Invoked = 1,
+  TriggerCharacter = 2,
+  TriggerForIncompleteCompletions = 3,
+}
+
+export enum AdditionalCompletionTriggerKinds {
+  AutoInvoked = 9999,
+}
+
+export type ExtendedCompletionTriggerKind =
+  | CompletionTriggerKind
+  | AdditionalCompletionTriggerKinds;
+
+export type CompletionItemKindStrings = keyof typeof CompletionItemKind;
+
+export type RecommendedLanguageIdentifier = keyof typeof Languages;
+
+/**
+ * Language identifier for the LSP server, allowing any string but preferring
+ * the identifiers as recommended by the LSP documentation.
+ */
+export type LanguageIdentifier = RecommendedLanguageIdentifier | string;
+
+/**
+ * Type represents a location inside a resource, such as a line
+ * inside a text file.
+ */
+export type AnyLocation =
+  | lsp.Location
+  | lsp.Location[]
+  | lsp.LocationLink[]
+  | undefined
+  | null;
+
+/**
+ * Type represents the completion result.
+ */
+export type AnyCompletion = lsp.CompletionList | lsp.CompletionItem[];
+
+/**
+ * The language identifier for LSP, with the preferred identifier as defined in the documentation
+ * see the table in https://microsoft.github.io/language-server-protocol/specification#textDocumentItem
+ */
+export const Languages = {
+  'git-commit': 'Git (commit)',
+  'git-rebase': 'Git (rebase)',
+  'objective-c': 'Objective-C',
+  'objective-cpp': 'Objective-C++',
+  abap: 'ABAP',
+  bat: 'Windows Bat',
+  bibtex: 'BibTeX',
+  clojure: 'Clojure',
+  coffeescript: 'Coffeescript',
+  c: 'C',
+  cpp: 'C++',
+  csharp: 'C#',
+  css: 'CSS',
+  diff: 'Diff',
+  dart: 'Dart',
+  dockerfile: 'Dockerfile',
+  elixir: 'Elixir',
+  erlang: 'Erlang',
+  fsharp: 'F#',
+  go: 'Go',
+  groovy: 'Groovy',
+  handlebars: 'Handlebars',
+  html: 'HTML',
+  ini: 'Ini',
+  java: 'Java',
+  javascript: 'JavaScript',
+  javascriptreact: 'JavaScript React',
+  json: 'JSON',
+  latex: 'LaTeX',
+  less: 'Less',
+  lua: 'Lua',
+  makefile: 'Makefile',
+  markdown: 'Markdown',
+  perl: 'Perl',
+  perl6: 'Perl 6',
+  php: 'PHP',
+  powershell: 'Powershell',
+  jade: 'Pug',
+  python: 'Python',
+  r: 'R',
+  razor: 'Razor (cshtml)',
+  ruby: 'Ruby',
+  rust: 'Rust',
+  scss: 'SCSS (syntax using curly brackets)',
+  sass: 'SCSS (indented syntax)',
+  scala: 'Scala',
+  shaderlab: 'ShaderLab',
+  shellscript: 'Shell Script (Bash)',
+  sql: 'SQL',
+  swift: 'Swift',
+  typescript: 'TypeScript',
+  typescriptreact: 'TypeScript React',
+  tex: 'TeX',
+  vb: 'Visual Basic',
+  xml: 'XML',
+  xsl: 'XSL',
+  yaml: 'YAML',
+};