atom-languageclient/build/lib/adapters/code-format-adapter.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const convert_1 = require("../convert");
/** Public: Adapts the language server protocol "textDocument/completion" to the Atom IDE UI Code-format package. */
class CodeFormatAdapter {
    /**
     * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities
     * matrix containing either a documentFormattingProvider or a documentRangeFormattingProvider.
     *
     * @param serverCapabilities The {ServerCapabilities} of the language server to consider.
     * @returns A {Boolean} indicating this adapter can adapt the server based on the given serverCapabilities.
     */
    static canAdapt(serverCapabilities) {
        return (serverCapabilities.documentRangeFormattingProvider === true ||
            serverCapabilities.documentFormattingProvider === true);
    }
    /**
     * Public: Format text in the editor using the given language server connection and an optional range. If the server
     * does not support range formatting then range will be ignored and the entire document formatted.
     *
     * @param connection A {LanguageClientConnection} to the language server that will format the text.
     * @param serverCapabilities The {ServerCapabilities} of the language server that will be used.
     * @param editor The Atom {TextEditor} containing the text that will be formatted.
     * @param range The optional Atom {Range} containing the subset of the text to be formatted.
     * @returns A {Promise} of an {Array} of {Object}s containing the AutoComplete+ suggestions to display.
     */
    static format(connection, serverCapabilities, editor, range) {
        if (serverCapabilities.documentRangeFormattingProvider) {
            return CodeFormatAdapter.formatRange(connection, editor, range);
        }
        if (serverCapabilities.documentFormattingProvider) {
            return CodeFormatAdapter.formatDocument(connection, editor);
        }
        throw new Error("Can not format document, language server does not support it");
    }
    /**
     * Public: Format the entire document of an Atom {TextEditor} by using a given language server.
     *
     * @param connection A {LanguageClientConnection} to the language server that will format the text.
     * @param editor The Atom {TextEditor} containing the document to be formatted.
     * @returns A {Promise} of an {Array} of {TextEdit} objects that can be applied to the Atom TextEditor to format the document.
     */
    static formatDocument(connection, editor) {
        return __awaiter(this, void 0, void 0, function* () {
            const edits = yield connection.documentFormatting(CodeFormatAdapter.createDocumentFormattingParams(editor));
            return convert_1.default.convertLsTextEdits(edits);
        });
    }
    /**
     * Public: Create {DocumentFormattingParams} to be sent to the language server when requesting an entire document is formatted.
     *
     * @param editor The Atom {TextEditor} containing the document to be formatted.
     * @returns A {DocumentFormattingParams} containing the identity of the text document as well as options to be used in
     *   formatting the document such as tab size and tabs vs spaces.
     */
    static createDocumentFormattingParams(editor) {
        return {
            textDocument: convert_1.default.editorToTextDocumentIdentifier(editor),
            options: CodeFormatAdapter.getFormatOptions(editor),
        };
    }
    /**
     * Public: Format a range within an Atom {TextEditor} by using a given language server.
     *
     * @param connection A {LanguageClientConnection} to the language server that will format the text.
     * @param range The Atom {Range} containing the range of text that should be formatted.
     * @param editor The Atom {TextEditor} containing the document to be formatted.
     * @returns A {Promise} of an {Array} of {TextEdit} objects that can be applied to the Atom TextEditor to format the document.
     */
    static formatRange(connection, editor, range) {
        return __awaiter(this, void 0, void 0, function* () {
            const edits = yield connection.documentRangeFormatting(CodeFormatAdapter.createDocumentRangeFormattingParams(editor, range));
            return convert_1.default.convertLsTextEdits(edits);
        });
    }
    /**
     * Public: Create {DocumentRangeFormattingParams} to be sent to the language server when requesting an entire document
     * is formatted.
     *
     * @param editor The Atom {TextEditor} containing the document to be formatted.
     * @param range The Atom {Range} containing the range of text that should be formatted.
     * @returns A {DocumentRangeFormattingParams} containing the identity of the text document, the range of the text to
     *   be formatted as well as the options to be used in formatting the document such as tab size and tabs vs spaces.
     */
    static createDocumentRangeFormattingParams(editor, range) {
        return {
            textDocument: convert_1.default.editorToTextDocumentIdentifier(editor),
            range: convert_1.default.atomRangeToLSRange(range),
            options: CodeFormatAdapter.getFormatOptions(editor),
        };
    }
    /**
     * Public: Format on type within an Atom {TextEditor} by using a given language server.
     *
     * @param connection A {LanguageClientConnection} to the language server that will format the text.
     * @param editor The Atom {TextEditor} containing the document to be formatted.
     * @param point The {Point} at which the document to be formatted.
     * @param character A character that triggered formatting request.
     * @returns A {Promise} of an {Array} of {TextEdit} objects that can be applied to the Atom TextEditor to format the document.
     */
    static formatOnType(connection, editor, point, character) {
        return __awaiter(this, void 0, void 0, function* () {
            const edits = yield connection.documentOnTypeFormatting(CodeFormatAdapter.createDocumentOnTypeFormattingParams(editor, point, character));
            return convert_1.default.convertLsTextEdits(edits);
        });
    }
    /**
     * Public: Create {DocumentOnTypeFormattingParams} to be sent to the language server when requesting an entire
     * document is formatted.
     *
     * @param editor The Atom {TextEditor} containing the document to be formatted.
     * @param point The {Point} at which the document to be formatted.
     * @param character A character that triggered formatting request.
     * @returns A {DocumentOnTypeFormattingParams} containing the identity of the text document, the position of the text
     *   to be formatted, the character that triggered formatting request as well as the options to be used in formatting
     *   the document such as tab size and tabs vs spaces.
     */
    static createDocumentOnTypeFormattingParams(editor, point, character) {
        return {
            textDocument: convert_1.default.editorToTextDocumentIdentifier(editor),
            position: convert_1.default.pointToPosition(point),
            ch: character,
            options: CodeFormatAdapter.getFormatOptions(editor),
        };
    }
    /**
     * Public: Create {DocumentRangeFormattingParams} to be sent to the language server when requesting an entire document
     * is formatted.
     *
     * @param editor The Atom {TextEditor} containing the document to be formatted.
     * @param range The Atom {Range} containing the range of document that should be formatted.
     * @returns The {FormattingOptions} to be used containing the keys:
     *
     *   - `tabSize` The number of spaces a tab represents.
     *   - `insertSpaces` {True} if spaces should be used, {False} for tab characters.
     */
    static getFormatOptions(editor) {
        return {
            tabSize: editor.getTabLength(),
            insertSpaces: editor.getSoftTabs(),
        };
    }
}
exports.default = CodeFormatAdapter;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code-format-adapter.js","sourceRoot":"","sources":["../../../lib/adapters/code-format-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as atomIde from \"atom-ide-base\"\nimport Convert from \"../convert\"\nimport {\n  LanguageClientConnection,\n  DocumentFormattingParams,\n  DocumentRangeFormattingParams,\n  DocumentOnTypeFormattingParams,\n  FormattingOptions,\n  ServerCapabilities,\n} from \"../languageclient\"\nimport { TextEditor, Range, Point } from \"atom\"\n\n/** Public: Adapts the language server protocol \"textDocument/completion\" to the Atom IDE UI Code-format package. */\nexport default class CodeFormatAdapter {\n  /**\n   * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities\n   * matrix containing either a documentFormattingProvider or a documentRangeFormattingProvider.\n   *\n   * @param serverCapabilities The {ServerCapabilities} of the language server to consider.\n   * @returns A {Boolean} indicating this adapter can adapt the server based on the given serverCapabilities.\n   */\n  public static canAdapt(serverCapabilities: ServerCapabilities): boolean {\n    return (\n      serverCapabilities.documentRangeFormattingProvider === true ||\n      serverCapabilities.documentFormattingProvider === true\n    )\n  }\n\n  /**\n   * Public: Format text in the editor using the given language server connection and an optional range. If the server\n   * does not support range formatting then range will be ignored and the entire document formatted.\n   *\n   * @param connection A {LanguageClientConnection} to the language server that will format the text.\n   * @param serverCapabilities The {ServerCapabilities} of the language server that will be used.\n   * @param editor The Atom {TextEditor} containing the text that will be formatted.\n   * @param range The optional Atom {Range} containing the subset of the text to be formatted.\n   * @returns A {Promise} of an {Array} of {Object}s containing the AutoComplete+ suggestions to display.\n   */\n  public static format(\n    connection: LanguageClientConnection,\n    serverCapabilities: ServerCapabilities,\n    editor: TextEditor,\n    range: Range\n  ): Promise<atomIde.TextEdit[]> {\n    if (serverCapabilities.documentRangeFormattingProvider) {\n      return CodeFormatAdapter.formatRange(connection, editor, range)\n    }\n\n    if (serverCapabilities.documentFormattingProvider) {\n      return CodeFormatAdapter.formatDocument(connection, editor)\n    }\n\n    throw new Error(\"Can not format document, language server does not support it\")\n  }\n\n  /**\n   * Public: Format the entire document of an Atom {TextEditor} by using a given language server.\n   *\n   * @param connection A {LanguageClientConnection} to the language server that will format the text.\n   * @param editor The Atom {TextEditor} containing the document to be formatted.\n   * @returns A {Promise} of an {Array} of {TextEdit} objects that can be applied to the Atom TextEditor to format the document.\n   */\n  public static async formatDocument(\n    connection: LanguageClientConnection,\n    editor: TextEditor\n  ): Promise<atomIde.TextEdit[]> {\n    const edits = await connection.documentFormatting(CodeFormatAdapter.createDocumentFormattingParams(editor))\n    return Convert.convertLsTextEdits(edits)\n  }\n\n  /**\n   * Public: Create {DocumentFormattingParams} to be sent to the language server when requesting an entire document is formatted.\n   *\n   * @param editor The Atom {TextEditor} containing the document to be formatted.\n   * @returns A {DocumentFormattingParams} containing the identity of the text document as well as options to be used in\n   *   formatting the document such as tab size and tabs vs spaces.\n   */\n  public static createDocumentFormattingParams(editor: TextEditor): DocumentFormattingParams {\n    return {\n      textDocument: Convert.editorToTextDocumentIdentifier(editor),\n      options: CodeFormatAdapter.getFormatOptions(editor),\n    }\n  }\n\n  /**\n   * Public: Format a range within an Atom {TextEditor} by using a given language server.\n   *\n   * @param connection A {LanguageClientConnection} to the language server that will format the text.\n   * @param range The Atom {Range} containing the range of text that should be formatted.\n   * @param editor The Atom {TextEditor} containing the document to be formatted.\n   * @returns A {Promise} of an {Array} of {TextEdit} objects that can be applied to the Atom TextEditor to format the document.\n   */\n  public static async formatRange(\n    connection: LanguageClientConnection,\n    editor: TextEditor,\n    range: Range\n  ): Promise<atomIde.TextEdit[]> {\n    const edits = await connection.documentRangeFormatting(\n      CodeFormatAdapter.createDocumentRangeFormattingParams(editor, range)\n    )\n    return Convert.convertLsTextEdits(edits)\n  }\n\n  /**\n   * Public: Create {DocumentRangeFormattingParams} to be sent to the language server when requesting an entire document\n   * is formatted.\n   *\n   * @param editor The Atom {TextEditor} containing the document to be formatted.\n   * @param range The Atom {Range} containing the range of text that should be formatted.\n   * @returns A {DocumentRangeFormattingParams} containing the identity of the text document, the range of the text to\n   *   be formatted as well as the options to be used in formatting the document such as tab size and tabs vs spaces.\n   */\n  public static createDocumentRangeFormattingParams(editor: TextEditor, range: Range): DocumentRangeFormattingParams {\n    return {\n      textDocument: Convert.editorToTextDocumentIdentifier(editor),\n      range: Convert.atomRangeToLSRange(range),\n      options: CodeFormatAdapter.getFormatOptions(editor),\n    }\n  }\n\n  /**\n   * Public: Format on type within an Atom {TextEditor} by using a given language server.\n   *\n   * @param connection A {LanguageClientConnection} to the language server that will format the text.\n   * @param editor The Atom {TextEditor} containing the document to be formatted.\n   * @param point The {Point} at which the document to be formatted.\n   * @param character A character that triggered formatting request.\n   * @returns A {Promise} of an {Array} of {TextEdit} objects that can be applied to the Atom TextEditor to format the document.\n   */\n  public static async formatOnType(\n    connection: LanguageClientConnection,\n    editor: TextEditor,\n    point: Point,\n    character: string\n  ): Promise<atomIde.TextEdit[]> {\n    const edits = await connection.documentOnTypeFormatting(\n      CodeFormatAdapter.createDocumentOnTypeFormattingParams(editor, point, character)\n    )\n    return Convert.convertLsTextEdits(edits)\n  }\n\n  /**\n   * Public: Create {DocumentOnTypeFormattingParams} to be sent to the language server when requesting an entire\n   * document is formatted.\n   *\n   * @param editor The Atom {TextEditor} containing the document to be formatted.\n   * @param point The {Point} at which the document to be formatted.\n   * @param character A character that triggered formatting request.\n   * @returns A {DocumentOnTypeFormattingParams} containing the identity of the text document, the position of the text\n   *   to be formatted, the character that triggered formatting request as well as the options to be used in formatting\n   *   the document such as tab size and tabs vs spaces.\n   */\n  public static createDocumentOnTypeFormattingParams(\n    editor: TextEditor,\n    point: Point,\n    character: string\n  ): DocumentOnTypeFormattingParams {\n    return {\n      textDocument: Convert.editorToTextDocumentIdentifier(editor),\n      position: Convert.pointToPosition(point),\n      ch: character,\n      options: CodeFormatAdapter.getFormatOptions(editor),\n    }\n  }\n\n  /**\n   * Public: Create {DocumentRangeFormattingParams} to be sent to the language server when requesting an entire document\n   * is formatted.\n   *\n   * @param editor The Atom {TextEditor} containing the document to be formatted.\n   * @param range The Atom {Range} containing the range of document that should be formatted.\n   * @returns The {FormattingOptions} to be used containing the keys:\n   *\n   *   - `tabSize` The number of spaces a tab represents.\n   *   - `insertSpaces` {True} if spaces should be used, {False} for tab characters.\n   */\n  public static getFormatOptions(editor: TextEditor): FormattingOptions {\n    return {\n      tabSize: editor.getTabLength(),\n      insertSpaces: editor.getSoftTabs(),\n    }\n  }\n}\n"]}