vscode-languageclient.js.flow

/**
 * Copyright (c) 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the license found in the LICENSE file in
 * the root directory of this source tree.
 *
 * @flow
 * @format
 */

declare module 'vscode-languageclient' {
  import type {
    ClientCapabilities,
    DocumentSelector,
    InitializeError,
    InitializeParams,
    MessageReader,
    MessageWriter,
    ServerCapabilities,
  } from 'vscode-languageserver-protocol';

  declare type ExecutableOptions = {
    cwd?: string,
    stdio?: string | string[],
    env?: any,
    detached?: boolean,
  };

  declare type Executable = {
    command: string,
    args?: string[],
    options?: ExecutableOptions,
  };

  declare type ForkOptions = {
    cwd?: string,
    env?: any,
    encoding?: string,
    execArgv?: string[],
  };

  declare type TransportKind = 'stdio' | 'ipc' | 'pipe';

  declare type NodeModule = {
    module: string,
    transport?: TransportKind,
    args?: string[],
    runtime?: string,
    options?: ForkOptions,
  };

  declare export type StreamInfo = {
    writer: stream$Writable,
    reader: stream$Readable,
    detached?: boolean,
  };

  declare type ChildProcessInfo = {
    process: child_process$ChildProcess,
    detached: boolean,
  };

  declare type MessageTransports = {
    reader: MessageReader,
    writer: MessageWriter,
    detached?: boolean,
  };

  declare export type ServerOptions =
    | Executable
    | {run: Executable, debug: Executable}
    | {run: NodeModule, debug: NodeModule}
    | NodeModule
    | (() => Thenable<
        | child_process$ChildProcess
        | StreamInfo
        | MessageTransports
        | ChildProcessInfo,
      >);

  declare export interface StaticFeature {
    /**
     * Called to fill the initialize params.
     *
     * @params the initialize params.
     */
    fillInitializeParams?: (params: InitializeParams) => void;

    /**
     * Called to fill in the client capabilities this feature implements.
     *
     * @param capabilities The client capabilities to fill.
     */
    fillClientCapabilities(capabilities: ClientCapabilities): void;

    /**
     * Initialize the feature. This method is called on a feature instance
     * when the client has successfully received the initalize request from
     * the server and before the client sends the initialized notification
     * to the server.
     *
     * @param capabilities the server capabilities
     * @param documentSelector the document selector pass to the client's constuctor.
     *  May be `undefined` if the client was created without a selector.
     */
    initialize(
      capabilities: ServerCapabilities,
      documentSelector: ?DocumentSelector,
    ): void;
  }

  declare export interface LanguageClientOptions {
    documentSelector?: DocumentSelector | Array<string>;
    // synchronize?: SynchronizeOptions;
    // diagnosticCollectionName?: string;
    // outputChannel?: OutputChannel;
    outputChannelName?: string;
    // revealOutputChannelOn?: RevealOutputChannelOn;
    /**
     * The encoding use to read stdout and stderr. Defaults
     * to 'utf8' if ommitted.
     */
    stdioEncoding?: string;
    // initializationOptions?: any | (() => any);
    // initializationFailedHandler?: (error: ResponseError<InitializeError> | Error | any) => boolean;
    // errorHandler?: ErrorHandler;
    // middleware?: Middleware;
    // uriConverters?: {
    //   code2Protocol: c2p.URIConverter,
    //   protocol2Code: p2c.URIConverter,
    // };
    // workspaceFolder?: VWorkspaceFolder;
  }

  declare export class LanguageClient {
    constructor(
      name: string,
      serverOptions: ServerOptions,
      clientOptions: LanguageClientOptions,
      forceDebug?: boolean,
    ): void;
    constructor(
      id: string,
      name: string,
      serverOptions: ServerOptions,
      clientOptions: LanguageClientOptions,
      forceDebug?: boolean,
    ): void;
    constructor(
      arg1: string,
      arg2: ServerOptions | string,
      arg3: LanguageClientOptions | ServerOptions,
      arg4?: boolean | LanguageClientOptions,
      arg5?: boolean,
    ): void;

    start(): IDisposable;
    registerFeature(feature: StaticFeature): void;
  }
}