atom-languageclient/build/lib/adapters/document-sync-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 });
exports.TextEditorSyncAdapter = void 0;
const convert_1 = require("../convert");
const languageclient_1 = require("../languageclient");
const apply_edit_adapter_1 = require("./apply-edit-adapter");
const atom_1 = require("atom");
const Utils = require("../utils");
/**
 * Public: Synchronizes the documents between Atom and the language server by notifying each end of changes, opening,
 * closing and other events as well as sending and applying changes either in whole or in part depending on what the
 * language server supports.
 */
class DocumentSyncAdapter {
    /**
     * Public: Create a new {DocumentSyncAdapter} for the given language server.
     *
     * @param _connection A {LanguageClientConnection} to the language server to be kept in sync.
     * @param documentSync The document syncing options.
     * @param _editorSelector A predicate function that takes a {TextEditor} and returns a {boolean} indicating whether
     *   this adapter should care about the contents of the editor.
     * @param _getLanguageIdFromEditor A function that returns a {string} of `languageId` used for `textDocument/didOpen`
     *   notification.
     */
    constructor(_connection, _editorSelector, documentSync, _reportBusyWhile, _getLanguageIdFromEditor) {
        this._connection = _connection;
        this._editorSelector = _editorSelector;
        this._reportBusyWhile = _reportBusyWhile;
        this._getLanguageIdFromEditor = _getLanguageIdFromEditor;
        this._disposable = new atom_1.CompositeDisposable();
        this._editors = new WeakMap();
        this._versions = new Map();
        if (typeof documentSync === "object") {
            this._documentSync = documentSync;
        }
        else {
            this._documentSync = {
                change: documentSync || languageclient_1.TextDocumentSyncKind.Full,
            };
        }
        this._disposable.add(atom.textEditors.observe(this.observeTextEditor.bind(this)));
    }
    /**
     * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities
     * matrix textDocumentSync capability either being Full or Incremental.
     *
     * @param serverCapabilities The {ServerCapabilities} of the language server to consider.
     * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.
     */
    static canAdapt(serverCapabilities) {
        return this.canAdaptV2(serverCapabilities) || this.canAdaptV3(serverCapabilities);
    }
    static canAdaptV2(serverCapabilities) {
        return (serverCapabilities.textDocumentSync === languageclient_1.TextDocumentSyncKind.Incremental ||
            serverCapabilities.textDocumentSync === languageclient_1.TextDocumentSyncKind.Full);
    }
    static canAdaptV3(serverCapabilities) {
        const options = serverCapabilities.textDocumentSync;
        return (options !== null &&
            typeof options === "object" &&
            (options.change === languageclient_1.TextDocumentSyncKind.Incremental || options.change === languageclient_1.TextDocumentSyncKind.Full));
    }
    /** Dispose this adapter ensuring any resources are freed and events unhooked. */
    dispose() {
        this._disposable.dispose();
    }
    /**
     * Examine a {TextEditor} and decide if we wish to observe it. If so ensure that we stop observing it when it is
     * closed or otherwise destroyed.
     *
     * @param editor A {TextEditor} to consider for observation.
     */
    observeTextEditor(editor) {
        const listener = editor.observeGrammar((_grammar) => this._handleGrammarChange(editor));
        this._disposable.add(editor.onDidDestroy(() => {
            this._disposable.remove(listener);
            listener.dispose();
        }));
        this._disposable.add(listener);
        if (!this._editors.has(editor) && this._editorSelector(editor)) {
            this._handleNewEditor(editor);
        }
    }
    _handleGrammarChange(editor) {
        const sync = this._editors.get(editor);
        if (sync != null && !this._editorSelector(editor)) {
            this._editors.delete(editor);
            this._disposable.remove(sync);
            sync.didClose();
            sync.dispose();
        }
        else if (sync == null && this._editorSelector(editor)) {
            this._handleNewEditor(editor);
        }
    }
    _handleNewEditor(editor) {
        const sync = new TextEditorSyncAdapter(editor, this._connection, this._documentSync, this._versions, this._reportBusyWhile, this._getLanguageIdFromEditor);
        this._editors.set(editor, sync);
        this._disposable.add(sync);
        this._disposable.add(editor.onDidDestroy(() => {
            const destroyedSync = this._editors.get(editor);
            if (destroyedSync) {
                this._editors.delete(editor);
                this._disposable.remove(destroyedSync);
                destroyedSync.dispose();
            }
        }));
    }
    getEditorSyncAdapter(editor) {
        return this._editors.get(editor);
    }
}
exports.default = DocumentSyncAdapter;
/** Public: Keep a single {TextEditor} in sync with a given language server. */
class TextEditorSyncAdapter {
    /**
     * Public: Create a {TextEditorSyncAdapter} in sync with a given language server.
     *
     * @param _editor A {TextEditor} to keep in sync.
     * @param _connection A {LanguageClientConnection} to a language server to keep in sync.
     * @param _documentSync The document syncing options.
     */
    constructor(_editor, _connection, _documentSync, _versions, _reportBusyWhile, _getLanguageIdFromEditor) {
        this._editor = _editor;
        this._connection = _connection;
        this._documentSync = _documentSync;
        this._versions = _versions;
        this._reportBusyWhile = _reportBusyWhile;
        this._getLanguageIdFromEditor = _getLanguageIdFromEditor;
        this._disposable = new atom_1.CompositeDisposable();
        this._fakeDidChangeWatchedFiles = atom.project.onDidChangeFiles == null;
        const changeTracking = this.setupChangeTracking(_documentSync);
        if (changeTracking != null) {
            this._disposable.add(changeTracking);
        }
        // These handlers are attached only if server supports them
        if (_documentSync.willSave) {
            this._disposable.add(_editor.getBuffer().onWillSave(this.willSave.bind(this)));
        }
        if (_documentSync.willSaveWaitUntil) {
            this._disposable.add(_editor.getBuffer().onWillSave(this.willSaveWaitUntil.bind(this)));
        }
        // Send close notifications unless it's explicitly disabled
        if (_documentSync.openClose !== false) {
            this._disposable.add(_editor.onDidDestroy(this.didClose.bind(this)));
        }
        this._disposable.add(_editor.onDidSave(this.didSave.bind(this)), _editor.onDidChangePath(this.didRename.bind(this)));
        this._currentUri = this.getEditorUri();
        if (_documentSync.openClose !== false) {
            this.didOpen();
        }
    }
    /** The change tracking disposable listener that will ensure that changes are sent to the language server as appropriate. */
    setupChangeTracking(documentSync) {
        switch (documentSync.change) {
            case languageclient_1.TextDocumentSyncKind.Full:
                return this._editor.onDidChange(this.sendFullChanges.bind(this));
            case languageclient_1.TextDocumentSyncKind.Incremental:
                return this._editor.getBuffer().onDidChangeText(this.sendIncrementalChanges.bind(this));
        }
        return null;
    }
    /** Dispose this adapter ensuring any resources are freed and events unhooked. */
    dispose() {
        this._disposable.dispose();
    }
    /** Get the languageId field that will be sent to the language server by simply using the `_getLanguageIdFromEditor`. */
    getLanguageId() {
        return this._getLanguageIdFromEditor(this._editor);
    }
    /**
     * Public: Create a {VersionedTextDocumentIdentifier} for the document observed by this adapter including both the Uri
     * and the current Version.
     */
    getVersionedTextDocumentIdentifier() {
        return {
            uri: this.getEditorUri(),
            version: this._getVersion(this._editor.getPath() || ""),
        };
    }
    /** Public: Send the entire document to the language server. This is used when operating in Full (1) sync mode. */
    sendFullChanges() {
        if (!this._isPrimaryAdapter()) {
            return;
        } // Multiple editors, we are not first
        this._bumpVersion();
        this._connection.didChangeTextDocument({
            textDocument: this.getVersionedTextDocumentIdentifier(),
            contentChanges: [{ text: this._editor.getText() }],
        });
    }
    /**
     * Public: Send the incremental text changes to the language server. This is used when operating in Incremental (2) sync mode.
     *
     * @param event The event fired by Atom to indicate the document has stopped changing including a list of changes
     *   since the last time this event fired for this text editor. NOTE: The order of changes in the event is guaranteed
     *   top to bottom. Language server expects this in reverse.
     */
    sendIncrementalChanges(event) {
        if (event.changes.length > 0) {
            if (!this._isPrimaryAdapter()) {
                return;
            } // Multiple editors, we are not first
            this._bumpVersion();
            this._connection.didChangeTextDocument({
                textDocument: this.getVersionedTextDocumentIdentifier(),
                contentChanges: event.changes.map(TextEditorSyncAdapter.textEditToContentChange).reverse(),
            });
        }
    }
    /**
     * Public: Convert an Atom {TextEditEvent} to a language server {TextDocumentContentChangeEvent} object.
     *
     * @param change The Atom {TextEditEvent} to convert.
     * @returns A {TextDocumentContentChangeEvent} that represents the converted {TextEditEvent}.
     */
    static textEditToContentChange(change) {
        return {
            range: convert_1.default.atomRangeToLSRange(change.oldRange),
            rangeLength: change.oldText.length,
            text: change.newText,
        };
    }
    _isPrimaryAdapter() {
        const lowestIdForBuffer = Math.min(...atom.workspace
            .getTextEditors()
            .filter((t) => t.getBuffer() === this._editor.getBuffer())
            .map((t) => t.id));
        return lowestIdForBuffer === this._editor.id;
    }
    _bumpVersion() {
        const filePath = this._editor.getPath();
        if (filePath == null) {
            return;
        }
        this._versions.set(filePath, this._getVersion(filePath) + 1);
    }
    /**
     * Ensure when the document is opened we send notification to the language server so it can load it in and keep track
     * of diagnostics etc.
     */
    didOpen() {
        const filePath = this._editor.getPath();
        if (filePath == null) {
            return;
        } // Not yet saved
        if (!this._isPrimaryAdapter()) {
            return;
        } // Multiple editors, we are not first
        this._connection.didOpenTextDocument({
            textDocument: {
                uri: this.getEditorUri(),
                languageId: this.getLanguageId().toLowerCase(),
                version: this._getVersion(filePath),
                text: this._editor.getText(),
            },
        });
    }
    _getVersion(filePath) {
        return this._versions.get(filePath) || 1;
    }
    /** Called when the {TextEditor} is closed and sends the 'didCloseTextDocument' notification to the connected language server. */
    didClose() {
        if (this._editor.getPath() == null) {
            return;
        } // Not yet saved
        const fileStillOpen = atom.workspace.getTextEditors().find((t) => t.getBuffer() === this._editor.getBuffer());
        if (fileStillOpen) {
            return; // Other windows or editors still have this file open
        }
        this._connection.didCloseTextDocument({ textDocument: { uri: this.getEditorUri() } });
    }
    /** Called just before the {TextEditor} saves and sends the 'willSaveTextDocument' notification to the connected language server. */
    willSave() {
        if (!this._isPrimaryAdapter()) {
            return;
        }
        const uri = this.getEditorUri();
        this._connection.willSaveTextDocument({
            textDocument: { uri },
            reason: languageclient_1.TextDocumentSaveReason.Manual,
        });
    }
    /**
     * Called just before the {TextEditor} saves, sends the 'willSaveWaitUntilTextDocument' request to the connected
     * language server and waits for the response before saving the buffer.
     */
    willSaveWaitUntil() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this._isPrimaryAdapter()) {
                return Promise.resolve();
            }
            const buffer = this._editor.getBuffer();
            const uri = this.getEditorUri();
            const title = this._editor.getLongTitle();
            const applyEditsOrTimeout = Utils.promiseWithTimeout(2500, // 2.5 seconds timeout
            this._connection.willSaveWaitUntilTextDocument({
                textDocument: { uri },
                reason: languageclient_1.TextDocumentSaveReason.Manual,
            }))
                .then((edits) => {
                const cursor = this._editor.getCursorBufferPosition();
                apply_edit_adapter_1.default.applyEdits(buffer, convert_1.default.convertLsTextEdits(edits));
                this._editor.setCursorBufferPosition(cursor);
            })
                .catch((err) => {
                atom.notifications.addError("On-save action failed", {
                    description: `Failed to apply edits to ${title}`,
                    detail: err.message,
                });
                return;
            });
            const withBusySignal = this._reportBusyWhile(`Applying on-save edits for ${title}`, () => applyEditsOrTimeout);
            return withBusySignal || applyEditsOrTimeout;
        });
    }
    /**
     * Called when the {TextEditor} saves and sends the 'didSaveTextDocument' notification to the connected language
     * server. Note: Right now this also sends the `didChangeWatchedFiles` notification as well but that will be sent from
     * elsewhere soon.
     */
    didSave() {
        if (!this._isPrimaryAdapter()) {
            return;
        }
        const uri = this.getEditorUri();
        const didSaveNotification = {
            textDocument: { uri, version: this._getVersion(uri) },
        };
        if (typeof this._documentSync.save === "object" && this._documentSync.save.includeText) {
            didSaveNotification.text = this._editor.getText();
        }
        this._connection.didSaveTextDocument(didSaveNotification);
        if (this._fakeDidChangeWatchedFiles) {
            this._connection.didChangeWatchedFiles({
                changes: [{ uri, type: languageclient_1.FileChangeType.Changed }],
            });
        }
    }
    didRename() {
        if (!this._isPrimaryAdapter()) {
            return;
        }
        const oldUri = this._currentUri;
        this._currentUri = this.getEditorUri();
        if (!oldUri) {
            return; // Didn't previously have a name
        }
        if (this._documentSync.openClose !== false) {
            this._connection.didCloseTextDocument({ textDocument: { uri: oldUri } });
        }
        if (this._fakeDidChangeWatchedFiles) {
            this._connection.didChangeWatchedFiles({
                changes: [
                    { uri: oldUri, type: languageclient_1.FileChangeType.Deleted },
                    { uri: this._currentUri, type: languageclient_1.FileChangeType.Created },
                ],
            });
        }
        // Send an equivalent open event for this editor, which will now use the new
        // file path.
        if (this._documentSync.openClose !== false) {
            this.didOpen();
        }
    }
    /** Public: Obtain the current {TextEditor} path and convert it to a Uri. */
    getEditorUri() {
        return convert_1.default.pathToUri(this._editor.getPath() || "");
    }
}
exports.TextEditorSyncAdapter = TextEditorSyncAdapter;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-sync-adapter.js","sourceRoot":"","sources":["../../../lib/adapters/document-sync-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import Convert from \"../convert\"\nimport {\n  LanguageClientConnection,\n  FileChangeType,\n  TextDocumentSaveReason,\n  TextDocumentSyncKind,\n  TextDocumentSyncOptions,\n  TextDocumentContentChangeEvent,\n  VersionedTextDocumentIdentifier,\n  ServerCapabilities,\n  DidSaveTextDocumentParams,\n} from \"../languageclient\"\nimport ApplyEditAdapter from \"./apply-edit-adapter\"\nimport { CompositeDisposable, Disposable, TextEditor, BufferStoppedChangingEvent, TextChange } from \"atom\"\nimport * as Utils from \"../utils\"\n\n/**\n * Public: Synchronizes the documents between Atom and the language server by notifying each end of changes, opening,\n * closing and other events as well as sending and applying changes either in whole or in part depending on what the\n * language server supports.\n */\nexport default class DocumentSyncAdapter {\n  private _disposable = new CompositeDisposable()\n  public _documentSync: TextDocumentSyncOptions\n  private _editors: WeakMap<TextEditor, TextEditorSyncAdapter> = new WeakMap()\n  private _versions: Map<string, number> = new Map()\n\n  /**\n   * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities\n   * matrix textDocumentSync capability either being Full or Incremental.\n   *\n   * @param serverCapabilities The {ServerCapabilities} of the language server to consider.\n   * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.\n   */\n  public static canAdapt(serverCapabilities: ServerCapabilities): boolean {\n    return this.canAdaptV2(serverCapabilities) || this.canAdaptV3(serverCapabilities)\n  }\n\n  private static canAdaptV2(serverCapabilities: ServerCapabilities): boolean {\n    return (\n      serverCapabilities.textDocumentSync === TextDocumentSyncKind.Incremental ||\n      serverCapabilities.textDocumentSync === TextDocumentSyncKind.Full\n    )\n  }\n\n  private static canAdaptV3(serverCapabilities: ServerCapabilities): boolean {\n    const options = serverCapabilities.textDocumentSync\n    return (\n      options !== null &&\n      typeof options === \"object\" &&\n      (options.change === TextDocumentSyncKind.Incremental || options.change === TextDocumentSyncKind.Full)\n    )\n  }\n\n  /**\n   * Public: Create a new {DocumentSyncAdapter} for the given language server.\n   *\n   * @param _connection A {LanguageClientConnection} to the language server to be kept in sync.\n   * @param documentSync The document syncing options.\n   * @param _editorSelector A predicate function that takes a {TextEditor} and returns a {boolean} indicating whether\n   *   this adapter should care about the contents of the editor.\n   * @param _getLanguageIdFromEditor A function that returns a {string} of `languageId` used for `textDocument/didOpen`\n   *   notification.\n   */\n  constructor(\n    private _connection: LanguageClientConnection,\n    private _editorSelector: (editor: TextEditor) => boolean,\n    documentSync: TextDocumentSyncOptions | TextDocumentSyncKind | undefined,\n    private _reportBusyWhile: Utils.ReportBusyWhile,\n    private _getLanguageIdFromEditor: (editor: TextEditor) => string\n  ) {\n    if (typeof documentSync === \"object\") {\n      this._documentSync = documentSync\n    } else {\n      this._documentSync = {\n        change: documentSync || TextDocumentSyncKind.Full,\n      }\n    }\n    this._disposable.add(atom.textEditors.observe(this.observeTextEditor.bind(this)))\n  }\n\n  /** Dispose this adapter ensuring any resources are freed and events unhooked. */\n  public dispose(): void {\n    this._disposable.dispose()\n  }\n\n  /**\n   * Examine a {TextEditor} and decide if we wish to observe it. If so ensure that we stop observing it when it is\n   * closed or otherwise destroyed.\n   *\n   * @param editor A {TextEditor} to consider for observation.\n   */\n  public observeTextEditor(editor: TextEditor): void {\n    const listener = editor.observeGrammar((_grammar) => this._handleGrammarChange(editor))\n    this._disposable.add(\n      editor.onDidDestroy(() => {\n        this._disposable.remove(listener)\n        listener.dispose()\n      })\n    )\n    this._disposable.add(listener)\n    if (!this._editors.has(editor) && this._editorSelector(editor)) {\n      this._handleNewEditor(editor)\n    }\n  }\n\n  private _handleGrammarChange(editor: TextEditor): void {\n    const sync = this._editors.get(editor)\n    if (sync != null && !this._editorSelector(editor)) {\n      this._editors.delete(editor)\n      this._disposable.remove(sync)\n      sync.didClose()\n      sync.dispose()\n    } else if (sync == null && this._editorSelector(editor)) {\n      this._handleNewEditor(editor)\n    }\n  }\n\n  private _handleNewEditor(editor: TextEditor): void {\n    const sync = new TextEditorSyncAdapter(\n      editor,\n      this._connection,\n      this._documentSync,\n      this._versions,\n      this._reportBusyWhile,\n      this._getLanguageIdFromEditor\n    )\n    this._editors.set(editor, sync)\n    this._disposable.add(sync)\n    this._disposable.add(\n      editor.onDidDestroy(() => {\n        const destroyedSync = this._editors.get(editor)\n        if (destroyedSync) {\n          this._editors.delete(editor)\n          this._disposable.remove(destroyedSync)\n          destroyedSync.dispose()\n        }\n      })\n    )\n  }\n\n  public getEditorSyncAdapter(editor: TextEditor): TextEditorSyncAdapter | undefined {\n    return this._editors.get(editor)\n  }\n}\n\n/** Public: Keep a single {TextEditor} in sync with a given language server. */\nexport class TextEditorSyncAdapter {\n  private _disposable = new CompositeDisposable()\n  private _currentUri: string\n  private _fakeDidChangeWatchedFiles: boolean\n\n  /**\n   * Public: Create a {TextEditorSyncAdapter} in sync with a given language server.\n   *\n   * @param _editor A {TextEditor} to keep in sync.\n   * @param _connection A {LanguageClientConnection} to a language server to keep in sync.\n   * @param _documentSync The document syncing options.\n   */\n  constructor(\n    private _editor: TextEditor,\n    private _connection: LanguageClientConnection,\n    private _documentSync: TextDocumentSyncOptions,\n    private _versions: Map<string, number>,\n    private _reportBusyWhile: Utils.ReportBusyWhile,\n    private _getLanguageIdFromEditor: (editor: TextEditor) => string\n  ) {\n    this._fakeDidChangeWatchedFiles = atom.project.onDidChangeFiles == null\n\n    const changeTracking = this.setupChangeTracking(_documentSync)\n    if (changeTracking != null) {\n      this._disposable.add(changeTracking)\n    }\n\n    // These handlers are attached only if server supports them\n    if (_documentSync.willSave) {\n      this._disposable.add(_editor.getBuffer().onWillSave(this.willSave.bind(this)))\n    }\n    if (_documentSync.willSaveWaitUntil) {\n      this._disposable.add(_editor.getBuffer().onWillSave(this.willSaveWaitUntil.bind(this)))\n    }\n    // Send close notifications unless it's explicitly disabled\n    if (_documentSync.openClose !== false) {\n      this._disposable.add(_editor.onDidDestroy(this.didClose.bind(this)))\n    }\n    this._disposable.add(_editor.onDidSave(this.didSave.bind(this)), _editor.onDidChangePath(this.didRename.bind(this)))\n\n    this._currentUri = this.getEditorUri()\n\n    if (_documentSync.openClose !== false) {\n      this.didOpen()\n    }\n  }\n\n  /** The change tracking disposable listener that will ensure that changes are sent to the language server as appropriate. */\n  public setupChangeTracking(documentSync: TextDocumentSyncOptions): Disposable | null {\n    switch (documentSync.change) {\n      case TextDocumentSyncKind.Full:\n        return this._editor.onDidChange(this.sendFullChanges.bind(this))\n      case TextDocumentSyncKind.Incremental:\n        return this._editor.getBuffer().onDidChangeText(this.sendIncrementalChanges.bind(this))\n    }\n    return null\n  }\n\n  /** Dispose this adapter ensuring any resources are freed and events unhooked. */\n  public dispose(): void {\n    this._disposable.dispose()\n  }\n\n  /** Get the languageId field that will be sent to the language server by simply using the `_getLanguageIdFromEditor`. */\n  public getLanguageId(): string {\n    return this._getLanguageIdFromEditor(this._editor)\n  }\n\n  /**\n   * Public: Create a {VersionedTextDocumentIdentifier} for the document observed by this adapter including both the Uri\n   * and the current Version.\n   */\n  public getVersionedTextDocumentIdentifier(): VersionedTextDocumentIdentifier {\n    return {\n      uri: this.getEditorUri(),\n      version: this._getVersion(this._editor.getPath() || \"\"),\n    }\n  }\n\n  /** Public: Send the entire document to the language server. This is used when operating in Full (1) sync mode. */\n  public sendFullChanges(): void {\n    if (!this._isPrimaryAdapter()) {\n      return\n    } // Multiple editors, we are not first\n\n    this._bumpVersion()\n    this._connection.didChangeTextDocument({\n      textDocument: this.getVersionedTextDocumentIdentifier(),\n      contentChanges: [{ text: this._editor.getText() }],\n    })\n  }\n\n  /**\n   * Public: Send the incremental text changes to the language server. This is used when operating in Incremental (2) sync mode.\n   *\n   * @param event The event fired by Atom to indicate the document has stopped changing including a list of changes\n   *   since the last time this event fired for this text editor. NOTE: The order of changes in the event is guaranteed\n   *   top to bottom. Language server expects this in reverse.\n   */\n  public sendIncrementalChanges(event: BufferStoppedChangingEvent): void {\n    if (event.changes.length > 0) {\n      if (!this._isPrimaryAdapter()) {\n        return\n      } // Multiple editors, we are not first\n\n      this._bumpVersion()\n      this._connection.didChangeTextDocument({\n        textDocument: this.getVersionedTextDocumentIdentifier(),\n        contentChanges: event.changes.map(TextEditorSyncAdapter.textEditToContentChange).reverse(),\n      })\n    }\n  }\n\n  /**\n   * Public: Convert an Atom {TextEditEvent} to a language server {TextDocumentContentChangeEvent} object.\n   *\n   * @param change The Atom {TextEditEvent} to convert.\n   * @returns A {TextDocumentContentChangeEvent} that represents the converted {TextEditEvent}.\n   */\n  public static textEditToContentChange(change: TextChange): TextDocumentContentChangeEvent {\n    return {\n      range: Convert.atomRangeToLSRange(change.oldRange),\n      rangeLength: change.oldText.length,\n      text: change.newText,\n    }\n  }\n\n  private _isPrimaryAdapter(): boolean {\n    const lowestIdForBuffer = Math.min(\n      ...atom.workspace\n        .getTextEditors()\n        .filter((t) => t.getBuffer() === this._editor.getBuffer())\n        .map((t) => t.id)\n    )\n    return lowestIdForBuffer === this._editor.id\n  }\n\n  private _bumpVersion(): void {\n    const filePath = this._editor.getPath()\n    if (filePath == null) {\n      return\n    }\n    this._versions.set(filePath, this._getVersion(filePath) + 1)\n  }\n\n  /**\n   * Ensure when the document is opened we send notification to the language server so it can load it in and keep track\n   * of diagnostics etc.\n   */\n  private didOpen(): void {\n    const filePath = this._editor.getPath()\n    if (filePath == null) {\n      return\n    } // Not yet saved\n\n    if (!this._isPrimaryAdapter()) {\n      return\n    } // Multiple editors, we are not first\n\n    this._connection.didOpenTextDocument({\n      textDocument: {\n        uri: this.getEditorUri(),\n        languageId: this.getLanguageId().toLowerCase(),\n        version: this._getVersion(filePath),\n        text: this._editor.getText(),\n      },\n    })\n  }\n\n  private _getVersion(filePath: string): number {\n    return this._versions.get(filePath) || 1\n  }\n\n  /** Called when the {TextEditor} is closed and sends the 'didCloseTextDocument' notification to the connected language server. */\n  public didClose(): void {\n    if (this._editor.getPath() == null) {\n      return\n    } // Not yet saved\n\n    const fileStillOpen = atom.workspace.getTextEditors().find((t) => t.getBuffer() === this._editor.getBuffer())\n    if (fileStillOpen) {\n      return // Other windows or editors still have this file open\n    }\n\n    this._connection.didCloseTextDocument({ textDocument: { uri: this.getEditorUri() } })\n  }\n\n  /** Called just before the {TextEditor} saves and sends the 'willSaveTextDocument' notification to the connected language server. */\n  public willSave(): void {\n    if (!this._isPrimaryAdapter()) {\n      return\n    }\n\n    const uri = this.getEditorUri()\n    this._connection.willSaveTextDocument({\n      textDocument: { uri },\n      reason: TextDocumentSaveReason.Manual,\n    })\n  }\n\n  /**\n   * Called just before the {TextEditor} saves, sends the 'willSaveWaitUntilTextDocument' request to the connected\n   * language server and waits for the response before saving the buffer.\n   */\n  public async willSaveWaitUntil(): Promise<void> {\n    if (!this._isPrimaryAdapter()) {\n      return Promise.resolve()\n    }\n\n    const buffer = this._editor.getBuffer()\n    const uri = this.getEditorUri()\n    const title = this._editor.getLongTitle()\n\n    const applyEditsOrTimeout = Utils.promiseWithTimeout(\n      2500, // 2.5 seconds timeout\n      this._connection.willSaveWaitUntilTextDocument({\n        textDocument: { uri },\n        reason: TextDocumentSaveReason.Manual,\n      })\n    )\n      .then((edits) => {\n        const cursor = this._editor.getCursorBufferPosition()\n        ApplyEditAdapter.applyEdits(buffer, Convert.convertLsTextEdits(edits))\n        this._editor.setCursorBufferPosition(cursor)\n      })\n      .catch((err) => {\n        atom.notifications.addError(\"On-save action failed\", {\n          description: `Failed to apply edits to ${title}`,\n          detail: err.message,\n        })\n        return\n      })\n\n    const withBusySignal = this._reportBusyWhile(`Applying on-save edits for ${title}`, () => applyEditsOrTimeout)\n    return withBusySignal || applyEditsOrTimeout\n  }\n\n  /**\n   * Called when the {TextEditor} saves and sends the 'didSaveTextDocument' notification to the connected language\n   * server. Note: Right now this also sends the `didChangeWatchedFiles` notification as well but that will be sent from\n   * elsewhere soon.\n   */\n  public didSave(): void {\n    if (!this._isPrimaryAdapter()) {\n      return\n    }\n\n    const uri = this.getEditorUri()\n    const didSaveNotification = {\n      textDocument: { uri, version: this._getVersion(uri) },\n    } as DidSaveTextDocumentParams\n    if (typeof this._documentSync.save === \"object\" && this._documentSync.save.includeText) {\n      didSaveNotification.text = this._editor.getText()\n    }\n    this._connection.didSaveTextDocument(didSaveNotification)\n    if (this._fakeDidChangeWatchedFiles) {\n      this._connection.didChangeWatchedFiles({\n        changes: [{ uri, type: FileChangeType.Changed }],\n      })\n    }\n  }\n\n  public didRename(): void {\n    if (!this._isPrimaryAdapter()) {\n      return\n    }\n\n    const oldUri = this._currentUri\n    this._currentUri = this.getEditorUri()\n    if (!oldUri) {\n      return // Didn't previously have a name\n    }\n\n    if (this._documentSync.openClose !== false) {\n      this._connection.didCloseTextDocument({ textDocument: { uri: oldUri } })\n    }\n\n    if (this._fakeDidChangeWatchedFiles) {\n      this._connection.didChangeWatchedFiles({\n        changes: [\n          { uri: oldUri, type: FileChangeType.Deleted },\n          { uri: this._currentUri, type: FileChangeType.Created },\n        ],\n      })\n    }\n\n    // Send an equivalent open event for this editor, which will now use the new\n    // file path.\n    if (this._documentSync.openClose !== false) {\n      this.didOpen()\n    }\n  }\n\n  /** Public: Obtain the current {TextEditor} path and convert it to a Uri. */\n  public getEditorUri(): string {\n    return Convert.pathToUri(this._editor.getPath() || \"\")\n  }\n}\n"]}