atom-languageclient

import { LanguageClientConnection, TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentContentChangeEvent, VersionedTextDocumentIdentifier, ServerCapabilities } from "../languageclient"; import { Disposable, TextEditor, BufferStoppedChangingEvent, TextChange } from "atom"; import * as Utils from "../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. */ export default class DocumentSyncAdapter { private _connection; private _editorSelector; private _reportBusyWhile; private _getLanguageIdFromEditor; private _disposable; _documentSync: TextDocumentSyncOptions; private _editors; private _versions; /** * 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: ServerCapabilities): boolean; private static canAdaptV2; private static canAdaptV3; /** * 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: LanguageClientConnection, _editorSelector: (editor: TextEditor) => boolean, documentSync: TextDocumentSyncOptions | TextDocumentSyncKind | undefined, _reportBusyWhile: Utils.ReportBusyWhile, _getLanguageIdFromEditor: (editor: TextEditor) => string); /** Dispose this adapter ensuring any resources are freed and events unhooked. */ dispose(): void; /** * 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: TextEditor): void; private _handleGrammarChange; private _handleNewEditor; getEditorSyncAdapter(editor: TextEditor): TextEditorSyncAdapter | undefined; } /** Public: Keep a single {TextEditor} in sync with a given language server. */ export declare class TextEditorSyncAdapter { private _editor; private _connection; private _documentSync; private _versions; private _reportBusyWhile; private _getLanguageIdFromEditor; private _disposable; private _currentUri; private _fakeDidChangeWatchedFiles; /** * 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: TextEditor, _connection: LanguageClientConnection, _documentSync: TextDocumentSyncOptions, _versions: Map<string, number>, _reportBusyWhile: Utils.ReportBusyWhile, _getLanguageIdFromEditor: (editor: TextEditor) => string); /** The change tracking disposable listener that will ensure that changes are sent to the language server as appropriate. */ setupChangeTracking(documentSync: TextDocumentSyncOptions): Disposable | null; /** Dispose this adapter ensuring any resources are freed and events unhooked. */ dispose(): void; /** Get the languageId field that will be sent to the language server by simply using the `_getLanguageIdFromEditor`. */ getLanguageId(): string; /** * Public: Create a {VersionedTextDocumentIdentifier} for the document observed by this adapter including both the Uri * and the current Version. */ getVersionedTextDocumentIdentifier(): VersionedTextDocumentIdentifier; /** Public: Send the entire document to the language server. This is used when operating in Full (1) sync mode. */ sendFullChanges(): void; /** * 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: BufferStoppedChangingEvent): void; /** * 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: TextChange): TextDocumentContentChangeEvent; private _isPrimaryAdapter; private _bumpVersion; /** * 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. */ private didOpen; private _getVersion; /** Called when the {TextEditor} is closed and sends the 'didCloseTextDocument' notification to the connected language server. */ didClose(): void; /** Called just before the {TextEditor} saves and sends the 'willSaveTextDocument' notification to the connected language server. */ willSave(): void; /** * 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(): Promise<void>; /** * 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(): void; didRename(): void; /** Public: Obtain the current {TextEditor} path and convert it to a Uri. */ getEditorUri(): string; }