@difizen/libro-language-client 0.1.18

package/src/common/vscodeAdaptor/services.ts

@@ -0,0 +1,278 @@
+import type {
+  NotebookDocument,
+  WorkspaceFolder,
+  WorkspaceFoldersChangeEvent,
+  ConfigurationChangeEvent,
+  ConfigurationScope,
+  WorkspaceConfiguration,
+  WorkspaceEdit,
+  WorkspaceEditMetadata,
+  NotebookDocumentChangeEvent,
+  TextDocumentWillSaveEvent,
+  TextDocumentChangeEvent,
+  FileCreateEvent,
+  FileRenameEvent,
+  FileWillRenameEvent,
+  FileDeleteEvent,
+  FileWillDeleteEvent,
+  FileWillCreateEvent,
+  GlobPattern,
+  FileSystemWatcher,
+  TextDocument,
+} from 'vscode';
+import type {
+  TabGroups,
+  TextEditor,
+  Event,
+  OutputChannel,
+  MessageOptions,
+  MessageItem,
+  Uri,
+  ProgressOptions,
+  Progress,
+  ViewColumn,
+  TextDocumentShowOptions,
+  CancellationToken,
+} from 'vscode';
+import type {
+  DiagnosticCollection,
+  DocumentSelector,
+  Disposable,
+  CallHierarchyProvider,
+  CodeActionProviderMetadata,
+  CodeActionProvider,
+  CompletionItemProvider,
+  DocumentSemanticTokensProvider,
+  CodeLensProvider,
+  DeclarationProvider,
+  DefinitionProvider,
+  DocumentColorProvider,
+  DocumentFormattingEditProvider,
+  DocumentHighlightProvider,
+  DocumentLinkProvider,
+  DocumentRangeFormattingEditProvider,
+  DocumentRangeSemanticTokensProvider,
+  DocumentSymbolProvider,
+  DocumentSymbolProviderMetadata,
+  FoldingRangeProvider,
+  HoverProvider,
+  ImplementationProvider,
+  InlineCompletionItemProvider,
+  InlineValuesProvider,
+  LanguageConfiguration,
+  LinkedEditingRangeProvider,
+  OnTypeFormattingEditProvider,
+  ReferenceProvider,
+  RenameProvider,
+  SelectionRangeProvider,
+  SemanticTokensLegend,
+  SignatureHelpProvider,
+  SignatureHelpProviderMetadata,
+  TypeDefinitionProvider,
+  TypeHierarchyProvider,
+  WorkspaceSymbolProvider,
+  InlayHintsProvider,
+  FileSystem,
+} from 'vscode';
+
+export const ILibroWorkspace = Symbol('ILibroWorkspace');
+export interface ILibroWorkspace {
+  workspaceFolders: WorkspaceFolder[] | undefined;
+  getWorkspaceFolder(uri: Uri): WorkspaceFolder | undefined;
+  notebookDocuments: NotebookDocument[];
+  textDocuments: TextDocument[];
+  fs: FileSystem;
+  onDidChangeWorkspaceFolders: Event<WorkspaceFoldersChangeEvent>;
+  onDidChangeConfiguration: Event<ConfigurationChangeEvent>;
+  getConfiguration(
+    section?: string | undefined,
+    scope?: ConfigurationScope | null | undefined,
+  ): WorkspaceConfiguration;
+  applyEdit(edit: WorkspaceEdit, metadata?: WorkspaceEditMetadata): Thenable<boolean>;
+  onDidOpenNotebookDocument: Event<NotebookDocument>;
+  onDidSaveNotebookDocument: Event<NotebookDocument>;
+  onDidCloseNotebookDocument: Event<NotebookDocument>;
+  onDidChangeNotebookDocument: Event<NotebookDocumentChangeEvent>;
+  onDidOpenTextDocument: Event<TextDocument>;
+  onDidSaveTextDocument: Event<TextDocument>;
+  onWillSaveTextDocument: Event<TextDocumentWillSaveEvent>;
+  onDidCloseTextDocument: Event<TextDocument>;
+  onDidChangeTextDocument: Event<TextDocumentChangeEvent>;
+  onDidCreateFiles: Event<FileCreateEvent>;
+  onDidRenameFiles: Event<FileRenameEvent>;
+  onWillRenameFiles: Event<FileWillRenameEvent>;
+  onDidDeleteFiles: Event<FileDeleteEvent>;
+  onWillDeleteFiles: Event<FileWillDeleteEvent>;
+  onWillCreateFiles: Event<FileWillCreateEvent>;
+  createFileSystemWatcher(
+    pattern: GlobPattern,
+    optionsOrIgnoreCreate: any,
+    ignoreChange?: boolean,
+    ignoreDelete?: boolean,
+  ): FileSystemWatcher;
+}
+
+export type MsgFunc = <T extends MessageOptions | string | MessageItem>(
+  message: string,
+  ...items: T[]
+) => Thenable<T>;
+
+export const ILibroWindow = Symbol('ILibroWindow');
+export interface ILibroWindow {
+  tabGroups: TabGroups;
+  activeTextEditor: TextEditor | undefined;
+  onDidChangeActiveTextEditor: Event<TextEditor | undefined>;
+  createOutputChannel: (
+    name: string,
+    options?: string | { log: true },
+  ) => OutputChannel;
+  showErrorMessage: MsgFunc;
+  showWarningMessage: MsgFunc;
+  showInformationMessage: MsgFunc;
+  showTextDocument(
+    documentOrUri: TextDocument | Uri,
+    columnOrOptions?: ViewColumn | TextDocumentShowOptions,
+    preserveFocus?: boolean,
+  ): Promise<TextEditor>;
+  withProgress<R>(
+    options: ProgressOptions,
+    task: (
+      progress: Progress<{ message?: string; worked?: number }>,
+      token: CancellationToken,
+    ) => Thenable<R>,
+  ): void;
+}
+
+export const IMonacoLanguages = Symbol('IMonacoLanguages');
+export interface IMonacoLanguages {
+  createDiagnosticCollection(name?: string): DiagnosticCollection;
+  match(selector: DocumentSelector, document: TextDocument): number;
+
+  registerCodeActionsProvider(
+    selector: DocumentSelector,
+    provider: CodeActionProvider,
+    metadata?: CodeActionProviderMetadata,
+  ): Disposable;
+  registerCodeLensProvider(
+    selector: DocumentSelector,
+    provider: CodeLensProvider,
+  ): Disposable;
+  registerDefinitionProvider(
+    selector: DocumentSelector,
+    provider: DefinitionProvider,
+  ): Disposable;
+  registerDeclarationProvider(
+    selector: DocumentSelector,
+    provider: DeclarationProvider,
+  ): Disposable;
+  registerImplementationProvider(
+    selector: DocumentSelector,
+    provider: ImplementationProvider,
+  ): Disposable;
+  registerTypeDefinitionProvider(
+    selector: DocumentSelector,
+    provider: TypeDefinitionProvider,
+  ): Disposable;
+  registerHoverProvider(
+    selector: DocumentSelector,
+    provider: HoverProvider,
+  ): Disposable;
+  registerInlineValuesProvider(
+    selector: DocumentSelector,
+    provider: InlineValuesProvider,
+  ): Disposable;
+  registerDocumentHighlightProvider(
+    selector: DocumentSelector,
+    provider: DocumentHighlightProvider,
+  ): Disposable;
+  registerLinkedEditingRangeProvider(
+    selector: DocumentSelector,
+    provider: LinkedEditingRangeProvider,
+  ): Disposable;
+  registerReferenceProvider(
+    selector: DocumentSelector,
+    provider: ReferenceProvider,
+  ): Disposable;
+  registerRenameProvider(
+    selector: DocumentSelector,
+    provider: RenameProvider,
+  ): Disposable;
+  registerDocumentSymbolProvider(
+    selector: DocumentSelector,
+    provider: DocumentSymbolProvider,
+    metadata?: DocumentSymbolProviderMetadata,
+  ): Disposable;
+  registerWorkspaceSymbolProvider(provider: WorkspaceSymbolProvider): Disposable;
+  registerDocumentFormattingEditProvider(
+    selector: DocumentSelector,
+    provider: DocumentFormattingEditProvider,
+  ): Disposable;
+  registerDocumentRangeFormattingEditProvider(
+    selector: DocumentSelector,
+    provider: DocumentRangeFormattingEditProvider,
+  ): Disposable;
+  registerOnTypeFormattingEditProvider(
+    selector: DocumentSelector,
+    provider: OnTypeFormattingEditProvider,
+    firstTriggerCharacter: string,
+    ...moreTriggerCharacters: string[]
+  ): Disposable;
+  registerDocumentSemanticTokensProvider(
+    selector: DocumentSelector,
+    provider: DocumentSemanticTokensProvider,
+    legend: SemanticTokensLegend,
+  ): Disposable;
+  registerDocumentRangeSemanticTokensProvider(
+    selector: DocumentSelector,
+    provider: DocumentRangeSemanticTokensProvider,
+    legend: SemanticTokensLegend,
+  ): Disposable;
+  registerSignatureHelpProvider(
+    selector: DocumentSelector,
+    provider: SignatureHelpProvider,
+    firstItem?: string | SignatureHelpProviderMetadata,
+    ...remaining: string[]
+  ): Disposable;
+  registerCompletionItemProvider(
+    selector: DocumentSelector,
+    provider: CompletionItemProvider,
+    ...triggerCharacters: string[]
+  ): Disposable;
+  registerInlineCompletionItemProvider(
+    selector: DocumentSelector,
+    provider: InlineCompletionItemProvider,
+    // metadata?: InlineCompletionItemProviderMetadata,
+  ): Disposable;
+  registerDocumentLinkProvider(
+    selector: DocumentSelector,
+    provider: DocumentLinkProvider,
+  ): Disposable;
+  registerColorProvider(
+    selector: DocumentSelector,
+    provider: DocumentColorProvider,
+  ): Disposable;
+  registerFoldingRangeProvider(
+    selector: DocumentSelector,
+    provider: FoldingRangeProvider,
+  ): Disposable;
+  registerSelectionRangeProvider(
+    selector: DocumentSelector,
+    provider: SelectionRangeProvider,
+  ): Disposable;
+  registerCallHierarchyProvider(
+    selector: DocumentSelector,
+    provider: CallHierarchyProvider,
+  ): Disposable;
+  registerTypeHierarchyProvider(
+    selector: DocumentSelector,
+    provider: TypeHierarchyProvider,
+  ): Disposable;
+  setLanguageConfiguration(
+    language: string,
+    configuration: LanguageConfiguration,
+  ): Disposable;
+  registerInlayHintsProvider(
+    selector: DocumentSelector,
+    provider: InlayHintsProvider,
+  ): Disposable;
+}

package/src/common/vscodeAdaptor/typings.d.ts

@@ -0,0 +1,10 @@
+declare module '@difizen/monaco-editor-core/esm/vs/editor/common/languageSelector.js' {
+  function score(
+    selector: LanguageSelector | undefined,
+    candidateUri: URI,
+    candidateLanguage: string,
+    candidateIsSynchronized: boolean,
+    candidateNotebookUri: URI | undefined,
+    candidateNotebookType: string | undefined,
+  ): number;
+}

package/src/common/vscodeAdaptor/util.ts

@@ -0,0 +1,7 @@
+export const unsupported = () => {
+  throw new Error('unsupported');
+};
+
+export const noop = () => {
+  // no-op
+};

package/src/common/vscodeAdaptor/vscodeAdaptor.ts

@@ -0,0 +1,122 @@
+import type { Syringe } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-common';
+import * as monaco from '@difizen/monaco-editor-core';
+import type { Disposable } from 'vscode';
+import { URI } from 'vscode-uri';
+
+import { ILibroWindow, ILibroWorkspace, IMonacoLanguages } from './services.js';
+
+export const CompletionItemTag = monaco.languages.CompletionItemTag;
+export type CompletionItemTag = monaco.languages.CompletionItemTag;
+export const SignatureHelpTriggerKind = monaco.languages.SignatureHelpTriggerKind;
+export type SignatureHelpTriggerKind = monaco.languages.SignatureHelpTriggerKind;
+export const CompletionTriggerKind = monaco.languages.CompletionTriggerKind;
+export type CompletionTriggerKind = monaco.languages.CompletionTriggerKind;
+
+export const lspEnv: {
+  libroContainer: Syringe.Container;
+} = {
+  libroContainer: {} as Syringe.Container,
+};
+
+export let workspace: ILibroWorkspace = undefined as any;
+export let window: ILibroWindow = undefined as any;
+export let languages: IMonacoLanguages = undefined as any;
+
+export const setupLspEnv = (container: Syringe.Container) => {
+  lspEnv.libroContainer = container;
+};
+
+export const initLspEnv = () => {
+  workspace = lspEnv.libroContainer.get(ILibroWorkspace);
+  window = lspEnv.libroContainer.get(ILibroWindow);
+  languages = lspEnv.libroContainer.get(IMonacoLanguages);
+};
+
+export class Uri extends URI {}
+
+export const version = '1.85.1';
+
+class VscodeEnv {
+  language = 'python';
+  appName = 'libro';
+  openExternal(target: Uri): Thenable<boolean> {
+    return Promise.resolve(true);
+  }
+}
+
+export const env = new VscodeEnv();
+
+export class CancellationTokenSource extends monaco.CancellationTokenSource {}
+
+const canceledName = 'Canceled';
+export class CancellationError extends Error {
+  constructor() {
+    super(canceledName);
+    this.name = this.message;
+  }
+}
+
+class Commands {
+  registerCommand(
+    command: string,
+    callback: (...args: any[]) => any,
+    thisArg?: any,
+  ): Disposable {
+    return {
+      dispose() {
+        return;
+      },
+    };
+  }
+}
+
+export const commands = new Commands();
+
+export { Emitter as EventEmitter };
+
+export class TabInputText {
+  constructor(readonly uri: Uri) {}
+}
+
+export class TabInputTextDiff {
+  constructor(
+    readonly original: Uri,
+    readonly modified: Uri,
+  ) {}
+}
+
+export class TabInputCustom {
+  constructor(
+    readonly uri: Uri,
+    readonly viewType: string,
+  ) {}
+}
+
+export enum FileType {
+  /**
+   * File is unknown (neither file, directory nor symbolic link).
+   */
+  Unknown = 0,
+
+  /**
+   * File is a normal file.
+   */
+  File = 1,
+
+  /**
+   * File is a directory.
+   */
+  Directory = 2,
+
+  /**
+   * File is a symbolic link.
+   *
+   * Note: even when the file is a symbolic link, you can test for
+   * `FileType.File` and `FileType.Directory` to know the type of
+   * the target the link points to.
+   */
+  SymbolicLink = 64,
+}
+
+export * from './extHostTypes.js';

package/src/common/workspaceFolder.ts

@@ -0,0 +1,236 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type {
+  ClientCapabilities,
+  InitializeParams,
+  CancellationToken,
+  ServerCapabilities,
+  WorkspaceFolder,
+  DidChangeWorkspaceFoldersParams,
+  RegistrationType,
+} from '@difizen/vscode-languageserver-protocol';
+import {
+  WorkspaceFoldersRequest,
+  DidChangeWorkspaceFoldersNotification,
+} from '@difizen/vscode-languageserver-protocol';
+import type {
+  Disposable,
+  WorkspaceFolder as VWorkspaceFolder,
+  WorkspaceFoldersChangeEvent as VWorkspaceFoldersChangeEvent,
+} from 'vscode';
+
+import type {
+  DynamicFeature,
+  RegistrationData,
+  FeatureClient,
+  NextSignature,
+  FeatureState,
+} from './features.js';
+import * as UUID from './utils/uuid.js';
+import { workspace } from './vscodeAdaptor/vscodeAdaptor.js';
+
+function access<T, K extends keyof T>(target: T | undefined, key: K): T[K] | undefined {
+  if (target === undefined || target === null) {
+    return undefined;
+  }
+  return target[key];
+}
+
+export function arrayDiff<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): T[] {
+  return left.filter((element) => right.indexOf(element) < 0);
+}
+
+export type WorkspaceFolderMiddleware = {
+  workspaceFolders?: WorkspaceFoldersRequest.MiddlewareSignature;
+  didChangeWorkspaceFolders?: NextSignature<
+    VWorkspaceFoldersChangeEvent,
+    Promise<void>
+  >;
+};
+
+type WorkspaceFolderWorkspaceMiddleware = {
+  workspace?: WorkspaceFolderMiddleware;
+};
+
+export class WorkspaceFoldersFeature implements DynamicFeature<void> {
+  private readonly _client: FeatureClient<WorkspaceFolderWorkspaceMiddleware>;
+  private readonly _listeners: Map<string, Disposable>;
+  private _initialFolders: ReadonlyArray<VWorkspaceFolder> | undefined;
+
+  constructor(client: FeatureClient<WorkspaceFolderWorkspaceMiddleware>) {
+    this._client = client;
+    this._listeners = new Map();
+  }
+
+  getState(): FeatureState {
+    return {
+      kind: 'workspace',
+      id: this.registrationType.method,
+      registrations: this._listeners.size > 0,
+    };
+  }
+
+  public get registrationType(): RegistrationType<void> {
+    return DidChangeWorkspaceFoldersNotification.type;
+  }
+
+  public fillInitializeParams(params: InitializeParams): void {
+    const folders = workspace.workspaceFolders;
+    this.initializeWithFolders(folders);
+
+    if (folders === void 0) {
+      params.workspaceFolders = null;
+    } else {
+      params.workspaceFolders = folders.map((folder) => this.asProtocol(folder));
+    }
+  }
+
+  protected initializeWithFolders(
+    currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined,
+  ) {
+    this._initialFolders = currentWorkspaceFolders;
+  }
+
+  public fillClientCapabilities(capabilities: ClientCapabilities): void {
+    capabilities.workspace = capabilities.workspace || {};
+    capabilities.workspace.workspaceFolders = true;
+  }
+
+  public initialize(capabilities: ServerCapabilities): void {
+    const client = this._client;
+    client.onRequest(WorkspaceFoldersRequest.type, (token: CancellationToken) => {
+      const workspaceFolders: WorkspaceFoldersRequest.HandlerSignature = () => {
+        const folders = workspace.workspaceFolders;
+        if (folders === undefined) {
+          return null;
+        }
+        const result: WorkspaceFolder[] = folders.map((folder) => {
+          return this.asProtocol(folder);
+        });
+        return result;
+      };
+      const middleware = client.middleware.workspace;
+      return middleware && middleware.workspaceFolders
+        ? middleware.workspaceFolders(token, workspaceFolders)
+        : workspaceFolders(token);
+    });
+    const value = access(
+      access(access(capabilities, 'workspace'), 'workspaceFolders'),
+      'changeNotifications',
+    );
+    let id: string | undefined;
+    if (typeof value === 'string') {
+      id = value;
+    } else if (value === true) {
+      id = UUID.generateUuid();
+    }
+    if (id) {
+      this.register({ id: id, registerOptions: undefined });
+    }
+  }
+
+  protected sendInitialEvent(
+    currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined,
+  ) {
+    let promise: Promise<void> | undefined;
+    if (this._initialFolders && currentWorkspaceFolders) {
+      const removed: VWorkspaceFolder[] = arrayDiff(
+        this._initialFolders,
+        currentWorkspaceFolders,
+      );
+      const added: VWorkspaceFolder[] = arrayDiff(
+        currentWorkspaceFolders,
+        this._initialFolders,
+      );
+      if (added.length > 0 || removed.length > 0) {
+        promise = this.doSendEvent(added, removed);
+      }
+    } else if (this._initialFolders) {
+      promise = this.doSendEvent([], this._initialFolders);
+    } else if (currentWorkspaceFolders) {
+      promise = this.doSendEvent(currentWorkspaceFolders, []);
+    }
+    if (promise !== undefined) {
+      promise.catch((error) => {
+        this._client.error(
+          `Sending notification ${DidChangeWorkspaceFoldersNotification.type.method} failed`,
+          error,
+        );
+      });
+    }
+  }
+
+  private doSendEvent(
+    addedFolders: ReadonlyArray<VWorkspaceFolder>,
+    removedFolders: ReadonlyArray<VWorkspaceFolder>,
+  ): Promise<void> {
+    const params: DidChangeWorkspaceFoldersParams = {
+      event: {
+        added: addedFolders.map((folder) => this.asProtocol(folder)),
+        removed: removedFolders.map((folder) => this.asProtocol(folder)),
+      },
+    };
+    return this._client.sendNotification(
+      DidChangeWorkspaceFoldersNotification.type,
+      params,
+    );
+  }
+
+  public register(data: RegistrationData<undefined>): void {
+    const id = data.id;
+    const client = this._client;
+    const disposable = workspace.onDidChangeWorkspaceFolders((event) => {
+      const didChangeWorkspaceFolders = (
+        event: VWorkspaceFoldersChangeEvent,
+      ): Promise<void> => {
+        return this.doSendEvent(event.added, event.removed);
+      };
+      const middleware = client.middleware.workspace;
+      const promise =
+        middleware && middleware.didChangeWorkspaceFolders
+          ? middleware.didChangeWorkspaceFolders(event, didChangeWorkspaceFolders)
+          : didChangeWorkspaceFolders(event);
+      promise.catch((error) => {
+        this._client.error(
+          `Sending notification ${DidChangeWorkspaceFoldersNotification.type.method} failed`,
+          error,
+        );
+      });
+    });
+    this._listeners.set(id, disposable);
+    this.sendInitialEvent(workspace.workspaceFolders);
+  }
+
+  public unregister(id: string): void {
+    const disposable = this._listeners.get(id);
+    if (disposable === void 0) {
+      return;
+    }
+    this._listeners.delete(id);
+    disposable.dispose();
+  }
+
+  public clear(): void {
+    for (const disposable of this._listeners.values()) {
+      disposable.dispose();
+    }
+    this._listeners.clear();
+  }
+
+  private asProtocol(workspaceFolder: VWorkspaceFolder): WorkspaceFolder;
+  private asProtocol(workspaceFolder: undefined): null;
+  private asProtocol(
+    workspaceFolder: VWorkspaceFolder | undefined,
+  ): WorkspaceFolder | null {
+    if (workspaceFolder === void 0) {
+      return null;
+    }
+    return {
+      uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri),
+      name: workspaceFolder.name,
+    };
+  }
+}