10108 lines
318 KiB
TypeScript
10108 lines
318 KiB
TypeScript
|
/******************************************************************
|
|||
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|||
|
Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
|
|||
|
*******************************************************************/
|
|||
|
|
|||
|
/// <reference types="node" />
|
|||
|
import cp from 'child_process'
|
|||
|
|
|||
|
declare module 'coc.nvim' {
|
|||
|
// Language server protocol interfaces {{
|
|||
|
export interface Thenable<T> {
|
|||
|
then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => TResult | Thenable<TResult>): Thenable<TResult>
|
|||
|
// eslint-disable-next-line @typescript-eslint/unified-signatures
|
|||
|
then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => void): Thenable<TResult>
|
|||
|
}
|
|||
|
|
|||
|
export interface Disposable {
|
|||
|
/**
|
|||
|
* Dispose this object.
|
|||
|
*/
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export namespace Disposable {
|
|||
|
function create(func: () => void): Disposable
|
|||
|
}
|
|||
|
/**
|
|||
|
* The declaration of a symbol representation as one or many [locations](#Location).
|
|||
|
*/
|
|||
|
export type Declaration = Location | Location[]
|
|||
|
/**
|
|||
|
* Information about where a symbol is declared.
|
|||
|
*
|
|||
|
* Provides additional metadata over normal [location](#Location) declarations, including the range of
|
|||
|
* the declaring symbol.
|
|||
|
*
|
|||
|
* Servers should prefer returning `DeclarationLink` over `Declaration` if supported
|
|||
|
* by the client.
|
|||
|
*/
|
|||
|
export type DeclarationLink = LocationLink
|
|||
|
|
|||
|
export type ProgressToken = number | string
|
|||
|
|
|||
|
export interface WorkDoneProgressBegin {
|
|||
|
kind: 'begin'
|
|||
|
/**
|
|||
|
* Mandatory title of the progress operation. Used to briefly inform about
|
|||
|
* the kind of operation being performed.
|
|||
|
*
|
|||
|
* Examples: "Indexing" or "Linking dependencies".
|
|||
|
*/
|
|||
|
title: string
|
|||
|
/**
|
|||
|
* Controls if a cancel button should show to allow the user to cancel the
|
|||
|
* long running operation. Clients that don't support cancellation are allowed
|
|||
|
* to ignore the setting.
|
|||
|
*/
|
|||
|
cancellable?: boolean
|
|||
|
/**
|
|||
|
* Optional, more detailed associated progress message. Contains
|
|||
|
* complementary information to the `title`.
|
|||
|
*
|
|||
|
* Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
|
|||
|
* If unset, the previous progress message (if any) is still valid.
|
|||
|
*/
|
|||
|
message?: string
|
|||
|
/**
|
|||
|
* Optional progress percentage to display (value 100 is considered 100%).
|
|||
|
* If not provided infinite progress is assumed and clients are allowed
|
|||
|
* to ignore the `percentage` value in subsequent in report notifications.
|
|||
|
*
|
|||
|
* The value should be steadily rising. Clients are free to ignore values
|
|||
|
* that are not following this rule.
|
|||
|
*/
|
|||
|
percentage?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface WorkDoneProgressReport {
|
|||
|
kind: 'report'
|
|||
|
/**
|
|||
|
* Controls enablement state of a cancel button. This property is only valid if a cancel
|
|||
|
* button got requested in the `WorkDoneProgressStart` payload.
|
|||
|
*
|
|||
|
* Clients that don't support cancellation or don't support control the button's
|
|||
|
* enablement state are allowed to ignore the setting.
|
|||
|
*/
|
|||
|
cancellable?: boolean
|
|||
|
/**
|
|||
|
* Optional, more detailed associated progress message. Contains
|
|||
|
* complementary information to the `title`.
|
|||
|
*
|
|||
|
* Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
|
|||
|
* If unset, the previous progress message (if any) is still valid.
|
|||
|
*/
|
|||
|
message?: string
|
|||
|
/**
|
|||
|
* Optional progress percentage to display (value 100 is considered 100%).
|
|||
|
* If not provided infinite progress is assumed and clients are allowed
|
|||
|
* to ignore the `percentage` value in subsequent in report notifications.
|
|||
|
*
|
|||
|
* The value should be steadily rising. Clients are free to ignore values
|
|||
|
* that are not following this rule.
|
|||
|
*/
|
|||
|
percentage?: number
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The file event type
|
|||
|
*/
|
|||
|
export namespace FileChangeType {
|
|||
|
/**
|
|||
|
* The file got created.
|
|||
|
*/
|
|||
|
const Created = 1
|
|||
|
/**
|
|||
|
* The file got changed.
|
|||
|
*/
|
|||
|
const Changed = 2
|
|||
|
/**
|
|||
|
* The file got deleted.
|
|||
|
*/
|
|||
|
const Deleted = 3
|
|||
|
}
|
|||
|
|
|||
|
export type FileChangeType = 1 | 2 | 3
|
|||
|
|
|||
|
/**
|
|||
|
* An event describing a file change.
|
|||
|
*/
|
|||
|
export interface FileEvent {
|
|||
|
/**
|
|||
|
* The file's uri.
|
|||
|
*/
|
|||
|
uri: string
|
|||
|
/**
|
|||
|
* The change type.
|
|||
|
*/
|
|||
|
type: FileChangeType
|
|||
|
}
|
|||
|
|
|||
|
export interface WorkDoneProgressEnd {
|
|||
|
kind: 'end'
|
|||
|
/**
|
|||
|
* Optional, a final message indicating to for example indicate the outcome
|
|||
|
* of the operation.
|
|||
|
*/
|
|||
|
message?: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A literal to identify a text document in the client.
|
|||
|
*/
|
|||
|
export interface TextDocumentIdentifier {
|
|||
|
/**
|
|||
|
* The text document's uri.
|
|||
|
*/
|
|||
|
uri: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A parameter literal used in requests to pass a text document and a position inside that
|
|||
|
* document.
|
|||
|
*/
|
|||
|
export interface TextDocumentPositionParams {
|
|||
|
/**
|
|||
|
* The text document.
|
|||
|
*/
|
|||
|
textDocument: TextDocumentIdentifier
|
|||
|
/**
|
|||
|
* The position inside the text document.
|
|||
|
*/
|
|||
|
position: Position
|
|||
|
}
|
|||
|
|
|||
|
export interface WorkspaceFolder {
|
|||
|
/**
|
|||
|
* The associated URI for this workspace folder.
|
|||
|
*/
|
|||
|
uri: string
|
|||
|
/**
|
|||
|
* The name of the workspace folder. Used to refer to this
|
|||
|
* workspace folder in the user interface.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An event describing a change to a text document.
|
|||
|
*/
|
|||
|
export interface TextDocumentContentChange {
|
|||
|
/**
|
|||
|
* The range of the document that changed.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The new text for the provided range.
|
|||
|
*/
|
|||
|
text: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The workspace folder change event.
|
|||
|
*/
|
|||
|
export interface WorkspaceFoldersChangeEvent {
|
|||
|
/**
|
|||
|
* The array of added workspace folders
|
|||
|
*/
|
|||
|
added: WorkspaceFolder[]
|
|||
|
/**
|
|||
|
* The array of the removed workspace folders
|
|||
|
*/
|
|||
|
removed: WorkspaceFolder[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An event that is fired when a [document](#LinesTextDocument) will be saved.
|
|||
|
*
|
|||
|
* To make modifications to the document before it is being saved, call the
|
|||
|
* [`waitUntil`](#TextDocumentWillSaveEvent.waitUntil)-function with a thenable
|
|||
|
* that resolves to an array of [text edits](#TextEdit).
|
|||
|
*/
|
|||
|
export interface TextDocumentWillSaveEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* The document that will be saved.
|
|||
|
*/
|
|||
|
document: LinesTextDocument
|
|||
|
|
|||
|
/**
|
|||
|
* The reason why save was triggered.
|
|||
|
*/
|
|||
|
reason: 1 | 2 | 3
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A document filter denotes a document by different properties like
|
|||
|
* the [language](#LinesTextDocument.languageId), the [scheme](#Uri.scheme) of
|
|||
|
* its resource, or a glob-pattern that is applied to the [path](#LinesTextDocument.fileName).
|
|||
|
*
|
|||
|
* Glob patterns can have the following syntax:
|
|||
|
* - `*` to match one or more characters in a path segment
|
|||
|
* - `?` to match on one character in a path segment
|
|||
|
* - `**` to match any number of path segments, including none
|
|||
|
* - `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
|
|||
|
* - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
|
|||
|
* - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
|
|||
|
*
|
|||
|
* @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }`
|
|||
|
* @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }`
|
|||
|
*/
|
|||
|
export type DocumentFilter = {
|
|||
|
/** A language id, like `typescript`. */
|
|||
|
language: string
|
|||
|
/** A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */
|
|||
|
scheme?: string
|
|||
|
/** A glob pattern, like `*.{ts,js}`. */
|
|||
|
pattern?: string
|
|||
|
} | {
|
|||
|
/** A language id, like `typescript`. */
|
|||
|
language?: string
|
|||
|
/** A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */
|
|||
|
scheme: string
|
|||
|
/** A glob pattern, like `*.{ts,js}`. */
|
|||
|
pattern?: string
|
|||
|
} | {
|
|||
|
/** A language id, like `typescript`. */
|
|||
|
language?: string
|
|||
|
/** A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */
|
|||
|
scheme?: string
|
|||
|
/** A glob pattern, like `*.{ts,js}`. */
|
|||
|
pattern: string
|
|||
|
}
|
|||
|
/**
|
|||
|
* A document selector is the combination of one or many document filters.
|
|||
|
*
|
|||
|
* @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`;
|
|||
|
*/
|
|||
|
export type DocumentSelector = (string | DocumentFilter)[]
|
|||
|
/**
|
|||
|
* A selection range represents a part of a selection hierarchy. A selection range
|
|||
|
* may have a parent selection range that contains it.
|
|||
|
*/
|
|||
|
export interface SelectionRange {
|
|||
|
/**
|
|||
|
* The [range](#Range) of this selection range.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The parent selection range containing this range. Therefore `parent.range` must contain `this.range`.
|
|||
|
*/
|
|||
|
parent?: SelectionRange
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* MarkedString can be used to render human readable text. It is either a markdown string
|
|||
|
* or a code-block that provides a language and a code snippet. The language identifier
|
|||
|
* is semantically equal to the optional language identifier in fenced code blocks in GitHub
|
|||
|
* issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
|
|||
|
*
|
|||
|
* The pair of a language and a value is an equivalent to markdown:
|
|||
|
* ```${language}
|
|||
|
* ${value}
|
|||
|
* ```
|
|||
|
*
|
|||
|
* Note that markdown strings will be sanitized - that means html will be escaped.
|
|||
|
* @deprecated use MarkupContent instead.
|
|||
|
*/
|
|||
|
export type MarkedString = string | {
|
|||
|
language: string
|
|||
|
value: string
|
|||
|
}
|
|||
|
/**
|
|||
|
* The result of a hover request.
|
|||
|
*/
|
|||
|
export interface Hover {
|
|||
|
/**
|
|||
|
* The hover's content
|
|||
|
*/
|
|||
|
contents: MarkupContent | MarkedString | MarkedString[]
|
|||
|
/**
|
|||
|
* An optional range
|
|||
|
*/
|
|||
|
range?: Range
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The definition of a symbol represented as one or many [locations](#Location).
|
|||
|
* For most programming languages there is only one location at which a symbol is
|
|||
|
* defined.
|
|||
|
*
|
|||
|
* Servers should prefer returning `DefinitionLink` over `Definition` if supported
|
|||
|
* by the client.
|
|||
|
*/
|
|||
|
export type Definition = Location | Location[]
|
|||
|
|
|||
|
/**
|
|||
|
* Information about where a symbol is defined.
|
|||
|
*
|
|||
|
* Provides additional metadata over normal [location](#Location) definitions, including the range of
|
|||
|
* the defining symbol
|
|||
|
*/
|
|||
|
export type DefinitionLink = LocationLink
|
|||
|
|
|||
|
/**
|
|||
|
* How a signature help was triggered.
|
|||
|
*/
|
|||
|
export namespace SignatureHelpTriggerKind {
|
|||
|
/**
|
|||
|
* Signature help was invoked manually by the user or by a command.
|
|||
|
*/
|
|||
|
const Invoked: 1
|
|||
|
/**
|
|||
|
* Signature help was triggered by a trigger character.
|
|||
|
*/
|
|||
|
const TriggerCharacter: 2
|
|||
|
/**
|
|||
|
* Signature help was triggered by the cursor moving or by the document content changing.
|
|||
|
*/
|
|||
|
const ContentChange: 3
|
|||
|
}
|
|||
|
|
|||
|
export type SignatureHelpTriggerKind = 1 | 2 | 3
|
|||
|
|
|||
|
/**
|
|||
|
* Represents the signature of something callable. A signature
|
|||
|
* can have a label, like a function-name, a doc-comment, and
|
|||
|
* a set of parameters.
|
|||
|
*/
|
|||
|
export interface SignatureInformation {
|
|||
|
/**
|
|||
|
* The label of this signature. Will be shown in
|
|||
|
* the UI.
|
|||
|
*/
|
|||
|
label: string
|
|||
|
/**
|
|||
|
* The human-readable doc-comment of this signature. Will be shown
|
|||
|
* in the UI but can be omitted.
|
|||
|
*/
|
|||
|
documentation?: string | MarkupContent
|
|||
|
/**
|
|||
|
* The parameters of this signature.
|
|||
|
*/
|
|||
|
parameters?: ParameterInformation[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a parameter of a callable-signature. A parameter can
|
|||
|
* have a label and a doc-comment.
|
|||
|
*/
|
|||
|
export interface ParameterInformation {
|
|||
|
/**
|
|||
|
* The label of this parameter information.
|
|||
|
*
|
|||
|
* Either a string or an inclusive start and exclusive end offsets within its containing
|
|||
|
* signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
|
|||
|
* string representation as `Position` and `Range` does.
|
|||
|
*
|
|||
|
* *Note*: a label of type string should be a substring of its containing signature label.
|
|||
|
* Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
|
|||
|
*/
|
|||
|
label: string | [number, number]
|
|||
|
/**
|
|||
|
* The human-readable doc-comment of this signature. Will be shown
|
|||
|
* in the UI but can be omitted.
|
|||
|
*/
|
|||
|
documentation?: string | MarkupContent
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Signature help represents the signature of something
|
|||
|
* callable. There can be multiple signature but only one
|
|||
|
* active and only one active parameter.
|
|||
|
*/
|
|||
|
export interface SignatureHelp {
|
|||
|
/**
|
|||
|
* One or more signatures.
|
|||
|
*/
|
|||
|
signatures: SignatureInformation[]
|
|||
|
/**
|
|||
|
* The active signature. Set to `null` if no
|
|||
|
* signatures exist.
|
|||
|
*/
|
|||
|
activeSignature: number | null
|
|||
|
/**
|
|||
|
* The active parameter of the active signature. Set to `null`
|
|||
|
* if the active signature has no parameters.
|
|||
|
*/
|
|||
|
activeParameter: number | null
|
|||
|
}
|
|||
|
/**
|
|||
|
* Additional information about the context in which a signature help request was triggered.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
export interface SignatureHelpContext {
|
|||
|
/**
|
|||
|
* Action that caused signature help to be triggered.
|
|||
|
*/
|
|||
|
triggerKind: SignatureHelpTriggerKind
|
|||
|
/**
|
|||
|
* Character that caused signature help to be triggered.
|
|||
|
*
|
|||
|
* This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`
|
|||
|
*/
|
|||
|
triggerCharacter?: string
|
|||
|
/**
|
|||
|
* `true` if signature help was already showing when it was triggered.
|
|||
|
*
|
|||
|
* Retriggers occur when the signature help is already active and can be caused by actions such as
|
|||
|
* typing a trigger character, a cursor move, or document content changes.
|
|||
|
*/
|
|||
|
isRetrigger: boolean
|
|||
|
/**
|
|||
|
* The currently active `SignatureHelp`.
|
|||
|
*
|
|||
|
* The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on
|
|||
|
* the user navigating through available signatures.
|
|||
|
*/
|
|||
|
activeSignatureHelp?: SignatureHelp
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a folding range.
|
|||
|
*/
|
|||
|
export interface FoldingRange {
|
|||
|
/**
|
|||
|
* The zero-based line number from where the folded range starts.
|
|||
|
*/
|
|||
|
startLine: number
|
|||
|
/**
|
|||
|
* The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.
|
|||
|
*/
|
|||
|
startCharacter?: number
|
|||
|
/**
|
|||
|
* The zero-based line number where the folded range ends.
|
|||
|
*/
|
|||
|
endLine: number
|
|||
|
/**
|
|||
|
* The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.
|
|||
|
*/
|
|||
|
endCharacter?: number
|
|||
|
/**
|
|||
|
* Describes the kind of the folding range such as `comment' or 'region'. The kind
|
|||
|
* is used to categorize folding ranges and used by commands like 'Fold all comments'. See
|
|||
|
* [FoldingRangeKind](#FoldingRangeKind) for an enumeration of standardized kinds.
|
|||
|
*/
|
|||
|
kind?: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A symbol kind.
|
|||
|
*/
|
|||
|
export namespace SymbolKind {
|
|||
|
const File: 1
|
|||
|
const Module: 2
|
|||
|
const Namespace: 3
|
|||
|
const Package: 4
|
|||
|
const Class: 5
|
|||
|
const Method: 6
|
|||
|
const Property: 7
|
|||
|
const Field: 8
|
|||
|
const Constructor: 9
|
|||
|
const Enum: 10
|
|||
|
const Interface: 11
|
|||
|
const Function: 12
|
|||
|
const Variable: 13
|
|||
|
const Constant: 14
|
|||
|
const String: 15
|
|||
|
const Number: 16
|
|||
|
const Boolean: 17
|
|||
|
const Array: 18
|
|||
|
const Object: 19
|
|||
|
const Key: 20
|
|||
|
const Null: 21
|
|||
|
const EnumMember: 22
|
|||
|
const Struct: 23
|
|||
|
const Event: 24
|
|||
|
const Operator: 25
|
|||
|
const TypeParameter: 26
|
|||
|
}
|
|||
|
|
|||
|
export type SymbolKind = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26
|
|||
|
|
|||
|
/**
|
|||
|
* Represents information about programming constructs like variables, classes,
|
|||
|
* interfaces etc.
|
|||
|
*/
|
|||
|
export interface SymbolInformation {
|
|||
|
/**
|
|||
|
* The name of this symbol.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* The kind of this symbol.
|
|||
|
*/
|
|||
|
kind: SymbolKind
|
|||
|
/**
|
|||
|
* Indicates if this symbol is deprecated.
|
|||
|
*/
|
|||
|
deprecated?: boolean
|
|||
|
/**
|
|||
|
* The location of this symbol. The location's range is used by a tool
|
|||
|
* to reveal the location in the editor. If the symbol is selected in the
|
|||
|
* tool the range's start information is used to position the cursor. So
|
|||
|
* the range usually spans more than the actual symbol's name and does
|
|||
|
* normally include thinks like visibility modifiers.
|
|||
|
*
|
|||
|
* The range doesn't have to denote a node range in the sense of a abstract
|
|||
|
* syntax tree. It can therefore not be used to re-construct a hierarchy of
|
|||
|
* the symbols.
|
|||
|
*/
|
|||
|
location: Location
|
|||
|
/**
|
|||
|
* The name of the symbol containing this symbol. This information is for
|
|||
|
* user interface purposes (e.g. to render a qualifier in the user interface
|
|||
|
* if necessary). It can't be used to re-infer a hierarchy for the document
|
|||
|
* symbols.
|
|||
|
*/
|
|||
|
containerName?: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents programming constructs like variables, classes, interfaces etc.
|
|||
|
* that appear in a document. Document symbols can be hierarchical and they
|
|||
|
* have two ranges: one that encloses its definition and one that points to
|
|||
|
* its most interesting range, e.g. the range of an identifier.
|
|||
|
*/
|
|||
|
export interface DocumentSymbol {
|
|||
|
/**
|
|||
|
* The name of this symbol. Will be displayed in the user interface and therefore must not be
|
|||
|
* an empty string or a string only consisting of white spaces.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* More detail for this symbol, e.g the signature of a function.
|
|||
|
*/
|
|||
|
detail?: string
|
|||
|
/**
|
|||
|
* The kind of this symbol.
|
|||
|
*/
|
|||
|
kind: SymbolKind
|
|||
|
/**
|
|||
|
* Indicates if this symbol is deprecated.
|
|||
|
*/
|
|||
|
deprecated?: boolean
|
|||
|
/**
|
|||
|
* The range enclosing this symbol not including leading/trailing whitespace but everything else
|
|||
|
* like comments. This information is typically used to determine if the the clients cursor is
|
|||
|
* inside the symbol to reveal in the symbol in the UI.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The range that should be selected and revealed when this symbol is being picked, e.g the name of a function.
|
|||
|
* Must be contained by the the `range`.
|
|||
|
*/
|
|||
|
selectionRange: Range
|
|||
|
/**
|
|||
|
* Children of this symbol, e.g. properties of a class.
|
|||
|
*/
|
|||
|
children?: DocumentSymbol[]
|
|||
|
}
|
|||
|
|
|||
|
export interface FormattingOptions {
|
|||
|
/**
|
|||
|
* If indentation is based on spaces (`insertSpaces` = true), the number of spaces that make an indent.
|
|||
|
*/
|
|||
|
tabSize: number
|
|||
|
/**
|
|||
|
* Is indentation based on spaces?
|
|||
|
*/
|
|||
|
insertSpaces: boolean
|
|||
|
/**
|
|||
|
* Trim trailing whitespaces on a line.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
trimTrailingWhitespace?: boolean
|
|||
|
/**
|
|||
|
* Insert a newline character at the end of the file if one does not exist.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
insertFinalNewline?: boolean
|
|||
|
/**
|
|||
|
* Trim all newlines after the final newline at the end of the file.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
trimFinalNewlines?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Contains additional diagnostic information about the context in which
|
|||
|
* a [code action](#CodeActionProvider.provideCodeActions) is run.
|
|||
|
*/
|
|||
|
export interface CodeActionContext {
|
|||
|
/**
|
|||
|
* An array of diagnostics known on the client side overlapping the range provided to the
|
|||
|
* `textDocument/codeAction` request. They are provided so that the server knows which
|
|||
|
* errors are currently presented to the user for the given range. There is no guarantee
|
|||
|
* that these accurately reflect the error state of the resource. The primary parameter
|
|||
|
* to compute code actions is the provided range.
|
|||
|
*/
|
|||
|
diagnostics: Diagnostic[]
|
|||
|
/**
|
|||
|
* Requested kind of actions to return.
|
|||
|
*
|
|||
|
* Actions not of this kind are filtered out by the client before being shown. So servers
|
|||
|
* can omit computing them.
|
|||
|
*/
|
|||
|
only?: string[]
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/**
|
|||
|
* A document highlight kind.
|
|||
|
*/
|
|||
|
export namespace DocumentHighlightKind {
|
|||
|
/**
|
|||
|
* A textual occurrence.
|
|||
|
*/
|
|||
|
const Text: 1
|
|||
|
/**
|
|||
|
* Read-access of a symbol, like reading a variable.
|
|||
|
*/
|
|||
|
const Read: 2
|
|||
|
/**
|
|||
|
* Write-access of a symbol, like writing to a variable.
|
|||
|
*/
|
|||
|
const Write: 3
|
|||
|
}
|
|||
|
|
|||
|
export type DocumentHighlightKind = 1 | 2 | 3
|
|||
|
/**
|
|||
|
* A document highlight is a range inside a text document which deserves
|
|||
|
* special attention. Usually a document highlight is visualized by changing
|
|||
|
* the background color of its range.
|
|||
|
*/
|
|||
|
export interface DocumentHighlight {
|
|||
|
/**
|
|||
|
* The range this highlight applies to.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The highlight kind, default is [text](#DocumentHighlightKind.Text).
|
|||
|
*/
|
|||
|
kind?: DocumentHighlightKind
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A document link is a range in a text document that links to an internal or external resource, like another
|
|||
|
* text document or a web site.
|
|||
|
*/
|
|||
|
export interface DocumentLink {
|
|||
|
/**
|
|||
|
* The range this link applies to.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The uri this link points to.
|
|||
|
*/
|
|||
|
target?: string
|
|||
|
/**
|
|||
|
* The tooltip text when you hover over this link.
|
|||
|
*
|
|||
|
* If a tooltip is provided, is will be displayed in a string that includes instructions on how to
|
|||
|
* trigger the link, such as `{0} (ctrl + click)`. The specific instructions vary depending on OS,
|
|||
|
* user settings, and localization.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
tooltip?: string
|
|||
|
/**
|
|||
|
* A data entry field that is preserved on a document link between a
|
|||
|
* DocumentLinkRequest and a DocumentLinkResolveRequest.
|
|||
|
*/
|
|||
|
data?: any
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a color in RGBA space.
|
|||
|
*/
|
|||
|
export interface Color {
|
|||
|
/**
|
|||
|
* The red component of this color in the range [0-1].
|
|||
|
*/
|
|||
|
readonly red: number
|
|||
|
/**
|
|||
|
* The green component of this color in the range [0-1].
|
|||
|
*/
|
|||
|
readonly green: number
|
|||
|
/**
|
|||
|
* The blue component of this color in the range [0-1].
|
|||
|
*/
|
|||
|
readonly blue: number
|
|||
|
/**
|
|||
|
* The alpha component of this color in the range [0-1].
|
|||
|
*/
|
|||
|
readonly alpha: number
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a color range from a document.
|
|||
|
*/
|
|||
|
export interface ColorInformation {
|
|||
|
/**
|
|||
|
* The range in the document where this color appears.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The actual color value for this color range.
|
|||
|
*/
|
|||
|
color: Color
|
|||
|
}
|
|||
|
|
|||
|
export interface ColorPresentation {
|
|||
|
/**
|
|||
|
* The label of this color presentation. It will be shown on the color
|
|||
|
* picker header. By default this is also the text that is inserted when selecting
|
|||
|
* this color presentation.
|
|||
|
*/
|
|||
|
label: string
|
|||
|
/**
|
|||
|
* An [edit](#TextEdit) which is applied to a document when selecting
|
|||
|
* this presentation for the color. When `falsy` the [label](#ColorPresentation.label)
|
|||
|
* is used.
|
|||
|
*/
|
|||
|
textEdit?: TextEdit
|
|||
|
/**
|
|||
|
* An optional array of additional [text edits](#TextEdit) that are applied when
|
|||
|
* selecting this color presentation. Edits must not overlap with the main [edit](#ColorPresentation.textEdit) nor with themselves.
|
|||
|
*/
|
|||
|
additionalTextEdits?: TextEdit[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A code lens represents a [command](#Command) that should be shown along with
|
|||
|
* source text, like the number of references, a way to run tests, etc.
|
|||
|
*
|
|||
|
* A code lens is _unresolved_ when no command is associated to it. For performance
|
|||
|
* reasons the creation of a code lens and resolving should be done to two stages.
|
|||
|
*/
|
|||
|
export interface CodeLens {
|
|||
|
/**
|
|||
|
* The range in which this code lens is valid. Should only span a single line.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The command this code lens represents.
|
|||
|
*/
|
|||
|
command?: Command
|
|||
|
/**
|
|||
|
* An data entry field that is preserved on a code lens item between
|
|||
|
* a [CodeLensRequest](#CodeLensRequest) and a [CodeLensResolveRequest]
|
|||
|
* (#CodeLensResolveRequest)
|
|||
|
*/
|
|||
|
data?: any
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents the connection of two locations. Provides additional metadata over normal [locations](#Location),
|
|||
|
* including an origin range.
|
|||
|
*/
|
|||
|
export interface LocationLink {
|
|||
|
/**
|
|||
|
* Span of the origin of this link.
|
|||
|
*
|
|||
|
* Used as the underlined span for mouse definition hover. Defaults to the word range at
|
|||
|
* the definition position.
|
|||
|
*/
|
|||
|
originSelectionRange?: Range
|
|||
|
/**
|
|||
|
* The target resource identifier of this link.
|
|||
|
*/
|
|||
|
targetUri: string
|
|||
|
/**
|
|||
|
* The full target range of this link. If the target for example is a symbol then target range is the
|
|||
|
* range enclosing this symbol not including leading/trailing whitespace but everything else
|
|||
|
* like comments. This information is typically used to highlight the range in the editor.
|
|||
|
*/
|
|||
|
targetRange: Range
|
|||
|
/**
|
|||
|
* The range that should be selected and revealed when this link is being followed, e.g the name of a function.
|
|||
|
* Must be contained by the the `targetRange`. See also `DocumentSymbol#range`
|
|||
|
*/
|
|||
|
targetSelectionRange: Range
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The LocationLink namespace provides helper functions to work with
|
|||
|
* [LocationLink](#LocationLink) literals.
|
|||
|
*/
|
|||
|
export namespace LocationLink {
|
|||
|
/**
|
|||
|
* Creates a LocationLink literal.
|
|||
|
* @param targetUri The definition's uri.
|
|||
|
* @param targetRange The full range of the definition.
|
|||
|
* @param targetSelectionRange The span of the symbol definition at the target.
|
|||
|
* @param originSelectionRange The span of the symbol being defined in the originating source file.
|
|||
|
*/
|
|||
|
function create(targetUri: string, targetRange: Range, targetSelectionRange: Range, originSelectionRange?: Range): LocationLink
|
|||
|
/**
|
|||
|
* Checks whether the given literal conforms to the [LocationLink](#LocationLink) interface.
|
|||
|
*/
|
|||
|
function is(value: any): value is LocationLink
|
|||
|
}
|
|||
|
|
|||
|
export type MarkupKind = 'plaintext' | 'markdown'
|
|||
|
|
|||
|
/**
|
|||
|
* Describes the content type that a client supports in various
|
|||
|
* result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
|
|||
|
*
|
|||
|
* Please note that `MarkupKinds` must not start with a `$`. This kinds
|
|||
|
* are reserved for internal usage.
|
|||
|
*/
|
|||
|
export namespace MarkupKind {
|
|||
|
/**
|
|||
|
* Plain text is supported as a content format
|
|||
|
*/
|
|||
|
const PlainText: 'plaintext'
|
|||
|
/**
|
|||
|
* Markdown is supported as a content format
|
|||
|
*/
|
|||
|
const Markdown: 'markdown'
|
|||
|
}
|
|||
|
/**
|
|||
|
* A `MarkupContent` literal represents a string value which content is interpreted base on its
|
|||
|
* kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds.
|
|||
|
*
|
|||
|
* If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
|
|||
|
* See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
|
|||
|
*
|
|||
|
* Here is an example how such a string can be constructed using JavaScript / TypeScript:
|
|||
|
* ```ts
|
|||
|
* let markdown: MarkdownContent = {
|
|||
|
* kind: MarkupKind.Markdown,
|
|||
|
* value: [
|
|||
|
* '# Header',
|
|||
|
* 'Some text',
|
|||
|
* '```typescript',
|
|||
|
* 'someCode();',
|
|||
|
* '```'
|
|||
|
* ].join('\n')
|
|||
|
* };
|
|||
|
* ```
|
|||
|
*
|
|||
|
* *Please Note* that clients might sanitize the return markdown. A client could decide to
|
|||
|
* remove HTML from the markdown to avoid script execution.
|
|||
|
*/
|
|||
|
export interface MarkupContent {
|
|||
|
/**
|
|||
|
* The type of the Markup
|
|||
|
*/
|
|||
|
kind: MarkupKind
|
|||
|
/**
|
|||
|
* The content itself
|
|||
|
*/
|
|||
|
value: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The kind of a completion entry.
|
|||
|
*/
|
|||
|
export namespace CompletionItemKind {
|
|||
|
const Text: 1
|
|||
|
const Method: 2
|
|||
|
const Function: 3
|
|||
|
const Constructor: 4
|
|||
|
const Field: 5
|
|||
|
const Variable: 6
|
|||
|
const Class: 7
|
|||
|
const Interface: 8
|
|||
|
const Module: 9
|
|||
|
const Property: 10
|
|||
|
const Unit: 11
|
|||
|
const Value: 12
|
|||
|
const Enum: 13
|
|||
|
const Keyword: 14
|
|||
|
const Snippet: 15
|
|||
|
const Color: 16
|
|||
|
const File: 17
|
|||
|
const Reference: 18
|
|||
|
const Folder: 19
|
|||
|
const EnumMember: 20
|
|||
|
const Constant: 21
|
|||
|
const Struct: 22
|
|||
|
const Event: 23
|
|||
|
const Operator: 24
|
|||
|
const TypeParameter: 25
|
|||
|
}
|
|||
|
|
|||
|
export type CompletionItemKind = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25
|
|||
|
|
|||
|
/**
|
|||
|
* Defines whether the insert text in a completion item should be interpreted as
|
|||
|
* plain text or a snippet.
|
|||
|
*/
|
|||
|
export namespace InsertTextFormat {
|
|||
|
/**
|
|||
|
* The primary text to be inserted is treated as a plain string.
|
|||
|
*/
|
|||
|
const PlainText: 1
|
|||
|
/**
|
|||
|
* The primary text to be inserted is treated as a snippet.
|
|||
|
*
|
|||
|
* A snippet can define tab stops and placeholders with `$1`, `$2`
|
|||
|
* and `${3:foo}`. `$0` defines the final tab stop, it defaults to
|
|||
|
* the end of the snippet. Placeholders with equal identifiers are linked,
|
|||
|
* that is typing in one will update others too.
|
|||
|
*
|
|||
|
* See also: https://github.com/microsoft/vscode/blob/main/src/vs/editor/contrib/snippet/snippet.md
|
|||
|
*/
|
|||
|
const Snippet: 2
|
|||
|
}
|
|||
|
export type InsertTextFormat = 1 | 2
|
|||
|
|
|||
|
/**
|
|||
|
* A completion item represents a text snippet that is
|
|||
|
* proposed to complete text that is being typed.
|
|||
|
*/
|
|||
|
export interface CompletionItem {
|
|||
|
/**
|
|||
|
* The label of this completion item. By default
|
|||
|
* also the text that is inserted when selecting
|
|||
|
* this completion.
|
|||
|
*/
|
|||
|
label: string
|
|||
|
/**
|
|||
|
* The kind of this completion item. Based of the kind
|
|||
|
* an icon is chosen by the editor.
|
|||
|
*/
|
|||
|
kind?: CompletionItemKind
|
|||
|
/**
|
|||
|
* Tags for this completion item.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
tags?: number[]
|
|||
|
/**
|
|||
|
* A human-readable string with additional information
|
|||
|
* about this item, like type or symbol information.
|
|||
|
*/
|
|||
|
detail?: string
|
|||
|
/**
|
|||
|
* A human-readable string that represents a doc-comment.
|
|||
|
*/
|
|||
|
documentation?: string | MarkupContent
|
|||
|
/**
|
|||
|
* Indicates if this item is deprecated.
|
|||
|
* @deprecated Use `tags` instead.
|
|||
|
*/
|
|||
|
deprecated?: boolean
|
|||
|
/**
|
|||
|
* Select this item when showing.
|
|||
|
*
|
|||
|
* *Note* that only one completion item can be selected and that the
|
|||
|
* tool / client decides which item that is. The rule is that the *first*
|
|||
|
* item of those that match best is selected.
|
|||
|
*/
|
|||
|
preselect?: boolean
|
|||
|
/**
|
|||
|
* A string that should be used when comparing this item
|
|||
|
* with other items. When `falsy` the [label](#CompletionItem.label)
|
|||
|
* is used.
|
|||
|
*/
|
|||
|
sortText?: string
|
|||
|
/**
|
|||
|
* A string that should be used when filtering a set of
|
|||
|
* completion items. When `falsy` the [label](#CompletionItem.label)
|
|||
|
* is used.
|
|||
|
*/
|
|||
|
filterText?: string
|
|||
|
/**
|
|||
|
* A string that should be inserted into a document when selecting
|
|||
|
* this completion. When `falsy` the [label](#CompletionItem.label)
|
|||
|
* is used.
|
|||
|
*
|
|||
|
* The `insertText` is subject to interpretation by the client side.
|
|||
|
* Some tools might not take the string literally. For example
|
|||
|
* VS Code when code complete is requested in this example `con<cursor position>`
|
|||
|
* and a completion item with an `insertText` of `console` is provided it
|
|||
|
* will only insert `sole`. Therefore it is recommended to use `textEdit` instead
|
|||
|
* since it avoids additional client side interpretation.
|
|||
|
*/
|
|||
|
insertText?: string
|
|||
|
/**
|
|||
|
* The format of the insert text. The format applies to both the `insertText` property
|
|||
|
* and the `newText` property of a provided `textEdit`. If omitted defaults to
|
|||
|
* `InsertTextFormat.PlainText`.
|
|||
|
*/
|
|||
|
insertTextFormat?: InsertTextFormat
|
|||
|
/**
|
|||
|
* An [edit](#TextEdit) which is applied to a document when selecting
|
|||
|
* this completion. When an edit is provided the value of
|
|||
|
* [insertText](#CompletionItem.insertText) is ignored.
|
|||
|
*
|
|||
|
* *Note:* The text edit's range must be a [single line] and it must contain the position
|
|||
|
* at which completion has been requested.
|
|||
|
*/
|
|||
|
textEdit?: TextEdit
|
|||
|
/**
|
|||
|
* An optional array of additional [text edits](#TextEdit) that are applied when
|
|||
|
* selecting this completion. Edits must not overlap (including the same insert position)
|
|||
|
* with the main [edit](#CompletionItem.textEdit) nor with themselves.
|
|||
|
*
|
|||
|
* Additional text edits should be used to change text unrelated to the current cursor position
|
|||
|
* (for example adding an import statement at the top of the file if the completion item will
|
|||
|
* insert an unqualified type).
|
|||
|
*/
|
|||
|
additionalTextEdits?: TextEdit[]
|
|||
|
/**
|
|||
|
* An optional set of characters that when pressed while this completion is active will accept it first and
|
|||
|
* then type that character. *Note* that all commit characters should have `length=1` and that superfluous
|
|||
|
* characters will be ignored.
|
|||
|
*/
|
|||
|
commitCharacters?: string[]
|
|||
|
/**
|
|||
|
* An optional [command](#Command) that is executed *after* inserting this completion. *Note* that
|
|||
|
* additional modifications to the current document should be described with the
|
|||
|
* [additionalTextEdits](#CompletionItem.additionalTextEdits)-property.
|
|||
|
*/
|
|||
|
command?: Command
|
|||
|
/**
|
|||
|
* An data entry field that is preserved on a completion item between
|
|||
|
* a [CompletionRequest](#CompletionRequest) and a [CompletionResolveRequest]
|
|||
|
* (#CompletionResolveRequest)
|
|||
|
*/
|
|||
|
data?: any
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a collection of [completion items](#CompletionItem) to be presented
|
|||
|
* in the editor.
|
|||
|
*/
|
|||
|
export interface CompletionList {
|
|||
|
/**
|
|||
|
* This list it not complete. Further typing results in recomputing this list.
|
|||
|
*/
|
|||
|
isIncomplete: boolean
|
|||
|
/**
|
|||
|
* The completion items.
|
|||
|
*/
|
|||
|
items: CompletionItem[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* How a completion was triggered
|
|||
|
*/
|
|||
|
export namespace CompletionTriggerKind {
|
|||
|
/**
|
|||
|
* Completion was triggered by typing an identifier (24x7 code
|
|||
|
* complete), manual invocation (e.g Ctrl+Space) or via API.
|
|||
|
*/
|
|||
|
const Invoked: 1
|
|||
|
/**
|
|||
|
* Completion was triggered by a trigger character specified by
|
|||
|
* the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
|
|||
|
*/
|
|||
|
const TriggerCharacter: 2
|
|||
|
/**
|
|||
|
* Completion was re-triggered as current completion list is incomplete
|
|||
|
*/
|
|||
|
const TriggerForIncompleteCompletions: 3
|
|||
|
}
|
|||
|
|
|||
|
export type CompletionTriggerKind = 1 | 2 | 3
|
|||
|
|
|||
|
/**
|
|||
|
* Contains additional information about the context in which a completion request is triggered.
|
|||
|
*/
|
|||
|
export interface CompletionContext {
|
|||
|
/**
|
|||
|
* How the completion was triggered.
|
|||
|
*/
|
|||
|
triggerKind: CompletionTriggerKind,
|
|||
|
/**
|
|||
|
* The trigger character (a single character) that has trigger code complete.
|
|||
|
* Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
|
|||
|
*/
|
|||
|
triggerCharacter?: string
|
|||
|
|
|||
|
option?: CompleteOption
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a reference to a command. Provides a title which
|
|||
|
* will be used to represent a command in the UI and, optionally,
|
|||
|
* an array of arguments which will be passed to the command handler
|
|||
|
* function when invoked.
|
|||
|
*/
|
|||
|
export interface Command {
|
|||
|
/**
|
|||
|
* Title of the command, like `save`.
|
|||
|
*/
|
|||
|
title: string
|
|||
|
/**
|
|||
|
* The identifier of the actual command handler.
|
|||
|
*/
|
|||
|
command: string
|
|||
|
/**
|
|||
|
* Arguments that the command handler should be
|
|||
|
* invoked with.
|
|||
|
*/
|
|||
|
arguments?: any[]
|
|||
|
}
|
|||
|
|
|||
|
export interface TextDocumentEdit {
|
|||
|
/**
|
|||
|
* The text document to change.
|
|||
|
*/
|
|||
|
textDocument: {
|
|||
|
uri: string
|
|||
|
version: number | null
|
|||
|
}
|
|||
|
/**
|
|||
|
* The edits to be applied.
|
|||
|
*/
|
|||
|
edits: TextEdit[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A workspace edit represents changes to many resources managed in the workspace. The edit
|
|||
|
* should either provide `changes` or `documentChanges`. If documentChanges are present
|
|||
|
* they are preferred over `changes` if the client can handle versioned document edits.
|
|||
|
*/
|
|||
|
export interface WorkspaceEdit {
|
|||
|
/**
|
|||
|
* Holds changes to existing resources.
|
|||
|
*/
|
|||
|
changes?: {
|
|||
|
[uri: string]: TextEdit[]
|
|||
|
}
|
|||
|
/**
|
|||
|
* Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes
|
|||
|
* are either an array of `TextDocumentEdit`s to express changes to n different text documents
|
|||
|
* where each text document edit addresses a specific version of a text document. Or it can contain
|
|||
|
* above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations.
|
|||
|
*
|
|||
|
* Whether a client supports versioned document edits is expressed via
|
|||
|
* `workspace.workspaceEdit.documentChanges` client capability.
|
|||
|
*
|
|||
|
* If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then
|
|||
|
* only plain `TextEdit`s using the `changes` property are supported.
|
|||
|
*/
|
|||
|
documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[]
|
|||
|
}
|
|||
|
|
|||
|
interface ResourceOperation {
|
|||
|
kind: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Delete file options
|
|||
|
*/
|
|||
|
export interface DeleteFileOptions {
|
|||
|
/**
|
|||
|
* Delete the content recursively if a folder is denoted.
|
|||
|
*/
|
|||
|
recursive?: boolean
|
|||
|
/**
|
|||
|
* Ignore the operation if the file doesn't exist.
|
|||
|
*/
|
|||
|
ignoreIfNotExists?: boolean
|
|||
|
}
|
|||
|
/**
|
|||
|
* Delete file operation
|
|||
|
*/
|
|||
|
export interface DeleteFile extends ResourceOperation {
|
|||
|
/**
|
|||
|
* A delete
|
|||
|
*/
|
|||
|
kind: 'delete'
|
|||
|
/**
|
|||
|
* The file to delete.
|
|||
|
*/
|
|||
|
uri: string
|
|||
|
/**
|
|||
|
* Delete options.
|
|||
|
*/
|
|||
|
options?: DeleteFileOptions
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Options to create a file.
|
|||
|
*/
|
|||
|
export interface CreateFileOptions {
|
|||
|
/**
|
|||
|
* Overwrite existing file. Overwrite wins over `ignoreIfExists`
|
|||
|
*/
|
|||
|
overwrite?: boolean
|
|||
|
/**
|
|||
|
* Ignore if exists.
|
|||
|
*/
|
|||
|
ignoreIfExists?: boolean
|
|||
|
}
|
|||
|
/**
|
|||
|
* Create file operation.
|
|||
|
*/
|
|||
|
export interface CreateFile extends ResourceOperation {
|
|||
|
/**
|
|||
|
* A create
|
|||
|
*/
|
|||
|
kind: 'create'
|
|||
|
/**
|
|||
|
* The resource to create.
|
|||
|
*/
|
|||
|
uri: string
|
|||
|
/**
|
|||
|
* Additional options
|
|||
|
*/
|
|||
|
options?: CreateFileOptions
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Rename file options
|
|||
|
*/
|
|||
|
export interface RenameFileOptions {
|
|||
|
/**
|
|||
|
* Overwrite target if existing. Overwrite wins over `ignoreIfExists`
|
|||
|
*/
|
|||
|
overwrite?: boolean
|
|||
|
/**
|
|||
|
* Ignores if target exists.
|
|||
|
*/
|
|||
|
ignoreIfExists?: boolean
|
|||
|
}
|
|||
|
/**
|
|||
|
* Rename file operation
|
|||
|
*/
|
|||
|
export interface RenameFile extends ResourceOperation {
|
|||
|
/**
|
|||
|
* A rename
|
|||
|
*/
|
|||
|
kind: 'rename'
|
|||
|
/**
|
|||
|
* The old (existing) location.
|
|||
|
*/
|
|||
|
oldUri: string
|
|||
|
/**
|
|||
|
* The new location.
|
|||
|
*/
|
|||
|
newUri: string
|
|||
|
/**
|
|||
|
* Rename options.
|
|||
|
*/
|
|||
|
options?: RenameFileOptions
|
|||
|
}
|
|||
|
/**
|
|||
|
* Represents a related message and source code location for a diagnostic. This should be
|
|||
|
* used to point to code locations that cause or related to a diagnostics, e.g when duplicating
|
|||
|
* a symbol in a scope.
|
|||
|
*/
|
|||
|
export interface DiagnosticRelatedInformation {
|
|||
|
/**
|
|||
|
* The location of this related diagnostic information.
|
|||
|
*/
|
|||
|
location: Location
|
|||
|
/**
|
|||
|
* The message of this related diagnostic information.
|
|||
|
*/
|
|||
|
message: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The diagnostic's severity.
|
|||
|
*/
|
|||
|
export namespace DiagnosticSeverity {
|
|||
|
/**
|
|||
|
* Reports an error.
|
|||
|
*/
|
|||
|
const Error: 1
|
|||
|
/**
|
|||
|
* Reports a warning.
|
|||
|
*/
|
|||
|
const Warning: 2
|
|||
|
/**
|
|||
|
* Reports an information.
|
|||
|
*/
|
|||
|
const Information: 3
|
|||
|
/**
|
|||
|
* Reports a hint.
|
|||
|
*/
|
|||
|
const Hint: 4
|
|||
|
}
|
|||
|
|
|||
|
export type DiagnosticSeverity = 1 | 2 | 3 | 4
|
|||
|
|
|||
|
/**
|
|||
|
* The diagnostic tags.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
export namespace DiagnosticTag {
|
|||
|
/**
|
|||
|
* Unused or unnecessary code.
|
|||
|
*
|
|||
|
* Clients are allowed to render diagnostics with this tag faded out instead of having
|
|||
|
* an error squiggle.
|
|||
|
*/
|
|||
|
const Unnecessary: 1
|
|||
|
/**
|
|||
|
* Deprecated or obsolete code.
|
|||
|
*
|
|||
|
* Clients are allowed to rendered diagnostics with this tag strike through.
|
|||
|
*/
|
|||
|
const Deprecated: 2
|
|||
|
}
|
|||
|
|
|||
|
export type DiagnosticTag = 1 | 2
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a diagnostic, such as a compiler error or warning. Diagnostic objects
|
|||
|
* are only valid in the scope of a resource.
|
|||
|
*/
|
|||
|
export interface Diagnostic {
|
|||
|
/**
|
|||
|
* The range at which the message applies
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The diagnostic's severity. Can be omitted. If omitted it is up to the
|
|||
|
* client to interpret diagnostics as error, warning, info or hint.
|
|||
|
*/
|
|||
|
severity?: DiagnosticSeverity
|
|||
|
/**
|
|||
|
* The diagnostic's code, which usually appear in the user interface.
|
|||
|
*/
|
|||
|
code?: number | string
|
|||
|
/**
|
|||
|
* A human-readable string describing the source of this
|
|||
|
* diagnostic, e.g. 'typescript' or 'super lint'. It usually
|
|||
|
* appears in the user interface.
|
|||
|
*/
|
|||
|
source?: string
|
|||
|
/**
|
|||
|
* The diagnostic's message. It usually appears in the user interface
|
|||
|
*/
|
|||
|
message: string
|
|||
|
/**
|
|||
|
* Additional metadata about the diagnostic.
|
|||
|
*/
|
|||
|
tags?: DiagnosticTag[]
|
|||
|
/**
|
|||
|
* An array of related diagnostic information, e.g. when symbol-names within
|
|||
|
* a scope collide all definitions can be marked via this property.
|
|||
|
*/
|
|||
|
relatedInformation?: DiagnosticRelatedInformation[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The Diagnostic namespace provides helper functions to work with
|
|||
|
* [Diagnostic](#Diagnostic) literals.
|
|||
|
*/
|
|||
|
export namespace Diagnostic {
|
|||
|
/**
|
|||
|
* Creates a new Diagnostic literal.
|
|||
|
*/
|
|||
|
function create(range: Range, message: string, severity?: DiagnosticSeverity, code?: number | string, source?: string, relatedInformation?: DiagnosticRelatedInformation[]): Diagnostic
|
|||
|
/**
|
|||
|
* Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface.
|
|||
|
*/
|
|||
|
function is(value: any): value is Diagnostic
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A code action represents a change that can be performed in code, e.g. to fix a problem or
|
|||
|
* to refactor code.
|
|||
|
*
|
|||
|
* A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed.
|
|||
|
*/
|
|||
|
export interface CodeAction {
|
|||
|
/**
|
|||
|
* A short, human-readable, title for this code action.
|
|||
|
*/
|
|||
|
title: string
|
|||
|
/**
|
|||
|
* The kind of the code action.
|
|||
|
*
|
|||
|
* Used to filter code actions.
|
|||
|
*/
|
|||
|
kind?: CodeActionKind
|
|||
|
/**
|
|||
|
* The diagnostics that this code action resolves.
|
|||
|
*/
|
|||
|
diagnostics?: Diagnostic[]
|
|||
|
/**
|
|||
|
* Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted
|
|||
|
* by keybindings.
|
|||
|
*
|
|||
|
* A quick fix should be marked preferred if it properly addresses the underlying error.
|
|||
|
* A refactoring should be marked preferred if it is the most reasonable choice of actions to take.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
isPreferred?: boolean
|
|||
|
/**
|
|||
|
* The workspace edit this code action performs.
|
|||
|
*/
|
|||
|
edit?: WorkspaceEdit
|
|||
|
/**
|
|||
|
* A command this code action executes. If a code action
|
|||
|
* provides a edit and a command, first the edit is
|
|||
|
* executed and then the command.
|
|||
|
*/
|
|||
|
command?: Command
|
|||
|
/**
|
|||
|
* Id of client that provide codeAction.
|
|||
|
*/
|
|||
|
clientId?: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The kind of a code action.
|
|||
|
*
|
|||
|
* Kinds are a hierarchical list of identifiers separated by `.`, e.g. `"refactor.extract.function"`.
|
|||
|
*
|
|||
|
* The set of kinds is open and client needs to announce the kinds it supports to the server during
|
|||
|
* initialization.
|
|||
|
*/
|
|||
|
export type CodeActionKind = string
|
|||
|
/**
|
|||
|
* A set of predefined code action kinds
|
|||
|
*/
|
|||
|
export namespace CodeActionKind {
|
|||
|
/**
|
|||
|
* Empty kind.
|
|||
|
*/
|
|||
|
const Empty: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for quickfix actions: 'quickfix'
|
|||
|
*/
|
|||
|
const QuickFix: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for refactoring actions: 'refactor'
|
|||
|
*/
|
|||
|
const Refactor: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for refactoring extraction actions: 'refactor.extract'
|
|||
|
*
|
|||
|
* Example extract actions:
|
|||
|
*
|
|||
|
* - Extract method
|
|||
|
* - Extract function
|
|||
|
* - Extract variable
|
|||
|
* - Extract interface from class
|
|||
|
* - ...
|
|||
|
*/
|
|||
|
const RefactorExtract: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for refactoring inline actions: 'refactor.inline'
|
|||
|
*
|
|||
|
* Example inline actions:
|
|||
|
*
|
|||
|
* - Inline function
|
|||
|
* - Inline variable
|
|||
|
* - Inline constant
|
|||
|
* - ...
|
|||
|
*/
|
|||
|
const RefactorInline: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for refactoring rewrite actions: 'refactor.rewrite'
|
|||
|
*
|
|||
|
* Example rewrite actions:
|
|||
|
*
|
|||
|
* - Convert JavaScript function to class
|
|||
|
* - Add or remove parameter
|
|||
|
* - Encapsulate field
|
|||
|
* - Make method static
|
|||
|
* - Move method to base class
|
|||
|
* - ...
|
|||
|
*/
|
|||
|
const RefactorRewrite: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for source actions: `source`
|
|||
|
*
|
|||
|
* Source code actions apply to the entire file.
|
|||
|
*/
|
|||
|
const Source: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for an organize imports source action: `source.organizeImports`
|
|||
|
*/
|
|||
|
const SourceOrganizeImports: CodeActionKind
|
|||
|
/**
|
|||
|
* Base kind for auto-fix source actions: `source.fixAll`.
|
|||
|
*
|
|||
|
* Fix all actions automatically fix errors that have a clear fix that do not require user input.
|
|||
|
* They should not suppress errors or perform unsafe fixes such as generating new types or classes.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
const SourceFixAll: CodeActionKind
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Position in a text document expressed as zero-based line and character offset.
|
|||
|
* The offsets are based on a UTF-16 string representation. So a string of the form
|
|||
|
* `a𐐀b` the character offset of the character `a` is 0, the character offset of `𐐀`
|
|||
|
* is 1 and the character offset of b is 3 since `𐐀` is represented using two code
|
|||
|
* units in UTF-16.
|
|||
|
*
|
|||
|
* Positions are line end character agnostic. So you can not specify a position that
|
|||
|
* denotes `\r|\n` or `\n|` where `|` represents the character offset.
|
|||
|
*/
|
|||
|
export interface Position {
|
|||
|
/**
|
|||
|
* Line position in a document (zero-based).
|
|||
|
* If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
|
|||
|
* If a line number is negative, it defaults to 0.
|
|||
|
*/
|
|||
|
line: number
|
|||
|
/**
|
|||
|
* Character offset on a line in a document (zero-based). Assuming that the line is
|
|||
|
* represented as a string, the `character` value represents the gap between the
|
|||
|
* `character` and `character + 1`.
|
|||
|
*
|
|||
|
* If the character value is greater than the line length it defaults back to the
|
|||
|
* line length.
|
|||
|
* If a line number is negative, it defaults to 0.
|
|||
|
*/
|
|||
|
character: number
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The Position namespace provides helper functions to work with
|
|||
|
* [Position](#Position) literals.
|
|||
|
*/
|
|||
|
export namespace Position {
|
|||
|
/**
|
|||
|
* Creates a new Position literal from the given line and character.
|
|||
|
* @param line The position's line.
|
|||
|
* @param character The position's character.
|
|||
|
*/
|
|||
|
function create(line: number, character: number): Position
|
|||
|
/**
|
|||
|
* Checks whether the given liternal conforms to the [Position](#Position) interface.
|
|||
|
*/
|
|||
|
function is(value: any): value is Position
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a typed event.
|
|||
|
*
|
|||
|
* A function that represents an event to which you subscribe by calling it with
|
|||
|
* a listener function as argument.
|
|||
|
*
|
|||
|
* @example
|
|||
|
* item.onDidChange(function(event) { console.log("Event happened: " + event); });
|
|||
|
*/
|
|||
|
export interface Event<T> {
|
|||
|
|
|||
|
/**
|
|||
|
* A function that represents an event to which you subscribe by calling it with
|
|||
|
* a listener function as argument.
|
|||
|
*
|
|||
|
* @param listener The listener function will be called when the event happens.
|
|||
|
* @param thisArgs The `this`-argument which will be used when calling the event listener.
|
|||
|
* @param disposables An array to which a [disposable](#Disposable) will be added.
|
|||
|
* @return A disposable which unsubscribes the event listener.
|
|||
|
*/
|
|||
|
(listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]): Disposable
|
|||
|
}
|
|||
|
|
|||
|
export namespace Event {
|
|||
|
const None: Event<any>
|
|||
|
}
|
|||
|
|
|||
|
export interface EmitterOptions {
|
|||
|
onFirstListenerAdd?: Function
|
|||
|
onLastListenerRemove?: Function
|
|||
|
}
|
|||
|
|
|||
|
export class Emitter<T> {
|
|||
|
constructor(_options?: EmitterOptions | undefined)
|
|||
|
/**
|
|||
|
* For the public to allow to subscribe
|
|||
|
* to events from this Emitter
|
|||
|
*/
|
|||
|
get event(): Event<T>
|
|||
|
/**
|
|||
|
* To be kept private to fire an event to
|
|||
|
* subscribers
|
|||
|
*/
|
|||
|
fire(event: T): any
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a location inside a resource, such as a line
|
|||
|
* inside a text file.
|
|||
|
*/
|
|||
|
export interface Location {
|
|||
|
uri: string
|
|||
|
range: Range
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The Location namespace provides helper functions to work with
|
|||
|
* [Location](#Location) literals.
|
|||
|
*/
|
|||
|
export namespace Location {
|
|||
|
/**
|
|||
|
* Creates a Location literal.
|
|||
|
* @param uri The location's uri.
|
|||
|
* @param range The location's range.
|
|||
|
*/
|
|||
|
function create(uri: string, range: Range): Location
|
|||
|
/**
|
|||
|
* Checks whether the given literal conforms to the [Location](#Location) interface.
|
|||
|
*/
|
|||
|
function is(value: any): value is Location
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A range in a text document expressed as (zero-based) start and end positions.
|
|||
|
*
|
|||
|
* If you want to specify a range that contains a line including the line ending
|
|||
|
* character(s) then use an end position denoting the start of the next line.
|
|||
|
* For example:
|
|||
|
* ```ts
|
|||
|
* {
|
|||
|
* start: { line: 5, character: 23 }
|
|||
|
* end : { line 6, character : 0 }
|
|||
|
* }
|
|||
|
* ```
|
|||
|
*/
|
|||
|
export interface Range {
|
|||
|
/**
|
|||
|
* The range's start position
|
|||
|
*/
|
|||
|
start: Position
|
|||
|
/**
|
|||
|
* The range's end position.
|
|||
|
*/
|
|||
|
end: Position
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The Range namespace provides helper functions to work with
|
|||
|
* [Range](#Range) literals.
|
|||
|
*/
|
|||
|
export namespace Range {
|
|||
|
/**
|
|||
|
* Create a new Range liternal.
|
|||
|
* @param start The range's start position.
|
|||
|
* @param end The range's end position.
|
|||
|
*/
|
|||
|
function create(start: Position, end: Position): Range
|
|||
|
/**
|
|||
|
* Create a new Range liternal.
|
|||
|
* @param startLine The start line number.
|
|||
|
* @param startCharacter The start character.
|
|||
|
* @param endLine The end line number.
|
|||
|
* @param endCharacter The end character.
|
|||
|
*/
|
|||
|
function create(startLine: number, startCharacter: number, endLine: number, endCharacter: number): Range
|
|||
|
/**
|
|||
|
* Checks whether the given literal conforms to the [Range](#Range) interface.
|
|||
|
*/
|
|||
|
function is(value: any): value is Range
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A text edit applicable to a text document.
|
|||
|
*/
|
|||
|
export interface TextEdit {
|
|||
|
/**
|
|||
|
* The range of the text document to be manipulated. To insert
|
|||
|
* text into a document create a range where start === end.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The string to be inserted. For delete operations use an
|
|||
|
* empty string.
|
|||
|
*/
|
|||
|
newText: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The TextEdit namespace provides helper function to create replace,
|
|||
|
* insert and delete edits more easily.
|
|||
|
*/
|
|||
|
export namespace TextEdit {
|
|||
|
/**
|
|||
|
* Creates a replace text edit.
|
|||
|
* @param range The range of text to be replaced.
|
|||
|
* @param newText The new text.
|
|||
|
*/
|
|||
|
function replace(range: Range, newText: string): TextEdit
|
|||
|
/**
|
|||
|
* Creates a insert text edit.
|
|||
|
* @param position The position to insert the text at.
|
|||
|
* @param newText The text to be inserted.
|
|||
|
*/
|
|||
|
function insert(position: Position, newText: string): TextEdit
|
|||
|
/**
|
|||
|
* Creates a delete text edit.
|
|||
|
* @param range The range of text to be deleted.
|
|||
|
*/
|
|||
|
function del(range: Range): TextEdit
|
|||
|
function is(value: any): value is TextEdit
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Defines a CancellationToken. This interface is not
|
|||
|
* intended to be implemented. A CancellationToken must
|
|||
|
* be created via a CancellationTokenSource.
|
|||
|
*/
|
|||
|
export interface CancellationToken {
|
|||
|
/**
|
|||
|
* Is `true` when the token has been cancelled, `false` otherwise.
|
|||
|
*/
|
|||
|
readonly isCancellationRequested: boolean
|
|||
|
/**
|
|||
|
* An [event](#Event) which fires upon cancellation.
|
|||
|
*/
|
|||
|
readonly onCancellationRequested: Event<any>
|
|||
|
}
|
|||
|
|
|||
|
export namespace CancellationToken {
|
|||
|
const None: CancellationToken
|
|||
|
const Cancelled: CancellationToken
|
|||
|
function is(value: any): value is CancellationToken
|
|||
|
}
|
|||
|
|
|||
|
export class CancellationTokenSource {
|
|||
|
get token(): CancellationToken
|
|||
|
cancel(): void
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a line of text, such as a line of source code.
|
|||
|
*
|
|||
|
* TextLine objects are __immutable__. When a {@link LinesTextDocument document} changes,
|
|||
|
* previously retrieved lines will not represent the latest state.
|
|||
|
*/
|
|||
|
export interface TextLine {
|
|||
|
/**
|
|||
|
* The zero-based line number.
|
|||
|
*/
|
|||
|
readonly lineNumber: number
|
|||
|
|
|||
|
/**
|
|||
|
* The text of this line without the line separator characters.
|
|||
|
*/
|
|||
|
readonly text: string
|
|||
|
|
|||
|
/**
|
|||
|
* The range this line covers without the line separator characters.
|
|||
|
*/
|
|||
|
readonly range: Range
|
|||
|
|
|||
|
/**
|
|||
|
* The range this line covers with the line separator characters.
|
|||
|
*/
|
|||
|
readonly rangeIncludingLineBreak: Range
|
|||
|
|
|||
|
/**
|
|||
|
* The offset of the first character which is not a whitespace character as defined
|
|||
|
* by `/\s/`. **Note** that if a line is all whitespace the length of the line is returned.
|
|||
|
*/
|
|||
|
readonly firstNonWhitespaceCharacterIndex: number
|
|||
|
|
|||
|
/**
|
|||
|
* Whether this line is whitespace only, shorthand
|
|||
|
* for {@link TextLine.firstNonWhitespaceCharacterIndex} === {@link TextLine.text TextLine.text.length}.
|
|||
|
*/
|
|||
|
readonly isEmptyOrWhitespace: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A simple text document. Not to be implemented. The document keeps the content
|
|||
|
* as string.
|
|||
|
*/
|
|||
|
export interface TextDocument {
|
|||
|
/**
|
|||
|
* The associated URI for this document. Most documents have the __file__-scheme, indicating that they
|
|||
|
* represent files on disk. However, some documents may have other schemes indicating that they are not
|
|||
|
* available on disk.
|
|||
|
*
|
|||
|
* @readonly
|
|||
|
*/
|
|||
|
readonly uri: string
|
|||
|
/**
|
|||
|
* The identifier of the language associated with this document.
|
|||
|
*
|
|||
|
* @readonly
|
|||
|
*/
|
|||
|
readonly languageId: string
|
|||
|
/**
|
|||
|
* The version number of this document (it will increase after each
|
|||
|
* change, including undo/redo).
|
|||
|
*
|
|||
|
* @readonly
|
|||
|
*/
|
|||
|
readonly version: number
|
|||
|
/**
|
|||
|
* Get the text of this document. A substring can be retrieved by
|
|||
|
* providing a range.
|
|||
|
*
|
|||
|
* @param range (optional) An range within the document to return.
|
|||
|
* If no range is passed, the full content is returned.
|
|||
|
* Invalid range positions are adjusted as described in [Position.line](#Position.line)
|
|||
|
* and [Position.character](#Position.character).
|
|||
|
* If the start range position is greater than the end range position,
|
|||
|
* then the effect of getText is as if the two positions were swapped.
|
|||
|
|
|||
|
* @return The text of this document or a substring of the text if a
|
|||
|
* range is provided.
|
|||
|
*/
|
|||
|
getText(range?: Range): string
|
|||
|
/**
|
|||
|
* Converts a zero-based offset to a position.
|
|||
|
*
|
|||
|
* @param offset A zero-based offset.
|
|||
|
* @return A valid [position](#Position).
|
|||
|
*/
|
|||
|
positionAt(offset: number): Position
|
|||
|
/**
|
|||
|
* Converts the position to a zero-based offset.
|
|||
|
* Invalid positions are adjusted as described in [Position.line](#Position.line)
|
|||
|
* and [Position.character](#Position.character).
|
|||
|
*
|
|||
|
* @param position A position.
|
|||
|
* @return A valid zero-based offset.
|
|||
|
*/
|
|||
|
offsetAt(position: Position): number
|
|||
|
/**
|
|||
|
* The number of lines in this document.
|
|||
|
*
|
|||
|
* @readonly
|
|||
|
*/
|
|||
|
readonly lineCount: number
|
|||
|
}
|
|||
|
|
|||
|
export interface LinesTextDocument extends TextDocument {
|
|||
|
/**
|
|||
|
* Total length of TextDocument.
|
|||
|
*/
|
|||
|
readonly length: number
|
|||
|
/**
|
|||
|
* End position of TextDocument.
|
|||
|
*/
|
|||
|
readonly end: Position
|
|||
|
/**
|
|||
|
* 'eol' option of related buffer. When enabled additional `\n` will be
|
|||
|
* added to the end of document content
|
|||
|
*/
|
|||
|
readonly rol: boolean
|
|||
|
/**
|
|||
|
* Lines of TextDocument.
|
|||
|
*/
|
|||
|
readonly lines: ReadonlyArray<string>
|
|||
|
/**
|
|||
|
* Returns a text line denoted by the line number. Note
|
|||
|
* that the returned object is *not* live and changes to the
|
|||
|
* document are not reflected.
|
|||
|
*
|
|||
|
* @param line or position
|
|||
|
* @return A {@link TextLine line}.
|
|||
|
*/
|
|||
|
lineAt(lineOrPos: number | Position): TextLine
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface SemanticTokensLegend {
|
|||
|
/**
|
|||
|
* The token types a server uses.
|
|||
|
*/
|
|||
|
tokenTypes: string[]
|
|||
|
/**
|
|||
|
* The token modifiers a server uses.
|
|||
|
*/
|
|||
|
tokenModifiers: string[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface SemanticTokens {
|
|||
|
/**
|
|||
|
* An optional result id. If provided and clients support delta updating
|
|||
|
* the client will include the result id in the next semantic token request.
|
|||
|
* A server can then instead of computing all semantic tokens again simply
|
|||
|
* send a delta.
|
|||
|
*/
|
|||
|
resultId?: string
|
|||
|
/**
|
|||
|
* The actual tokens.
|
|||
|
*/
|
|||
|
data: number[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface SemanticTokensEdit {
|
|||
|
/**
|
|||
|
* The start offset of the edit.
|
|||
|
*/
|
|||
|
start: number
|
|||
|
/**
|
|||
|
* The count of elements to remove.
|
|||
|
*/
|
|||
|
deleteCount: number
|
|||
|
/**
|
|||
|
* The elements to insert.
|
|||
|
*/
|
|||
|
data?: number[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface SemanticTokensDelta {
|
|||
|
readonly resultId?: string
|
|||
|
/**
|
|||
|
* The semantic token edits to transform a previous result into a new result.
|
|||
|
*/
|
|||
|
edits: SemanticTokensEdit[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The result of a linked editing range request.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface LinkedEditingRanges {
|
|||
|
/**
|
|||
|
* A list of ranges that can be edited together. The ranges must have
|
|||
|
* identical length and contain identical text content. The ranges cannot overlap.
|
|||
|
*/
|
|||
|
ranges: Range[]
|
|||
|
/**
|
|||
|
* An optional word pattern (regular expression) that describes valid contents for
|
|||
|
* the given ranges. If no pattern is provided, the client configuration's word
|
|||
|
* pattern will be used.
|
|||
|
*/
|
|||
|
wordPattern?: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents programming constructs like functions or constructors in the context
|
|||
|
* of call hierarchy.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface CallHierarchyItem {
|
|||
|
/**
|
|||
|
* The name of this item.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* The kind of this item.
|
|||
|
*/
|
|||
|
kind: SymbolKind
|
|||
|
/**
|
|||
|
* Tags for this item.
|
|||
|
*/
|
|||
|
tags?: number[]
|
|||
|
/**
|
|||
|
* More detail for this item, e.g. the signature of a function.
|
|||
|
*/
|
|||
|
detail?: string
|
|||
|
/**
|
|||
|
* The resource identifier of this item.
|
|||
|
*/
|
|||
|
uri: string
|
|||
|
/**
|
|||
|
* The range enclosing this symbol not including leading/trailing whitespace but everything else, e.g. comments and code.
|
|||
|
*/
|
|||
|
range: Range
|
|||
|
/**
|
|||
|
* The range that should be selected and revealed when this symbol is being picked, e.g. the name of a function.
|
|||
|
* Must be contained by the [`range`](#CallHierarchyItem.range).
|
|||
|
*/
|
|||
|
selectionRange: Range
|
|||
|
/**
|
|||
|
* A data entry field that is preserved between a call hierarchy prepare and
|
|||
|
* incoming calls or outgoing calls requests.
|
|||
|
*/
|
|||
|
data?: unknown
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents an incoming call, e.g. a caller of a method or constructor.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface CallHierarchyIncomingCall {
|
|||
|
/**
|
|||
|
* The item that makes the call.
|
|||
|
*/
|
|||
|
from: CallHierarchyItem
|
|||
|
/**
|
|||
|
* The ranges at which the calls appear. This is relative to the caller
|
|||
|
* denoted by [`this.from`](#CallHierarchyIncomingCall.from).
|
|||
|
*/
|
|||
|
fromRanges: Range[]
|
|||
|
}
|
|||
|
/**
|
|||
|
* Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface CallHierarchyOutgoingCall {
|
|||
|
/**
|
|||
|
* The item that is called.
|
|||
|
*/
|
|||
|
to: CallHierarchyItem
|
|||
|
/**
|
|||
|
* The range at which this item is called. This is the range relative to the caller, e.g the item
|
|||
|
* passed to [`provideCallHierarchyOutgoingCalls`](#CallHierarchyItemProvider.provideCallHierarchyOutgoingCalls)
|
|||
|
* and not [`this.to`](#CallHierarchyOutgoingCall.to).
|
|||
|
*/
|
|||
|
fromRanges: Range[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Moniker uniqueness level to define scope of the moniker.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export namespace UniquenessLevel {
|
|||
|
/**
|
|||
|
* The moniker is only unique inside a document
|
|||
|
*/
|
|||
|
export const document = 'document'
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker is unique inside a project for which a dump got created
|
|||
|
*/
|
|||
|
export const project = 'project'
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker is unique inside the group to which a project belongs
|
|||
|
*/
|
|||
|
export const group = 'group'
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker is unique inside the moniker scheme.
|
|||
|
*/
|
|||
|
export const scheme = 'scheme'
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker is globally unique
|
|||
|
*/
|
|||
|
export const global = 'global'
|
|||
|
}
|
|||
|
|
|||
|
export type UniquenessLevel = 'document' | 'project' | 'group' | 'scheme' | 'global'
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker kind.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export enum MonikerKind {
|
|||
|
/**
|
|||
|
* The moniker represent a symbol that is imported into a project
|
|||
|
*/
|
|||
|
import = 'import',
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker represents a symbol that is exported from a project
|
|||
|
*/
|
|||
|
export = 'export',
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker represents a symbol that is local to a project (e.g. a local
|
|||
|
* variable of a function, a class not visible outside the project, ...)
|
|||
|
*/
|
|||
|
local = 'local'
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Moniker definition to match LSIF 0.5 moniker definition.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface Moniker {
|
|||
|
/**
|
|||
|
* The scheme of the moniker. For example tsc or .Net
|
|||
|
*/
|
|||
|
scheme: string
|
|||
|
|
|||
|
/**
|
|||
|
* The identifier of the moniker. The value is opaque in LSIF however
|
|||
|
* schema owners are allowed to define the structure if they want.
|
|||
|
*/
|
|||
|
identifier: string
|
|||
|
|
|||
|
/**
|
|||
|
* The scope in which the moniker is unique
|
|||
|
*/
|
|||
|
unique: UniquenessLevel
|
|||
|
|
|||
|
/**
|
|||
|
* The moniker kind if known.
|
|||
|
*/
|
|||
|
kind?: MonikerKind
|
|||
|
}
|
|||
|
|
|||
|
export type InlayHintKind = 1 | 2
|
|||
|
|
|||
|
/**
|
|||
|
* An inlay hint label part allows for interactive and composite labels
|
|||
|
* of inlay hints.
|
|||
|
*
|
|||
|
* @since 3.17.0
|
|||
|
* @proposed
|
|||
|
*/
|
|||
|
export interface InlayHintLabelPart {
|
|||
|
|
|||
|
/**
|
|||
|
* The value of this label part.
|
|||
|
*/
|
|||
|
value: string
|
|||
|
|
|||
|
/**
|
|||
|
* The tooltip text when you hover over this label part. Depending on
|
|||
|
* the client capability `inlayHint.resolveSupport` clients might resolve
|
|||
|
* this property late using the resolve request.
|
|||
|
*/
|
|||
|
tooltip?: string | MarkupContent
|
|||
|
|
|||
|
/**
|
|||
|
* An optional source code location that represents this
|
|||
|
* label part.
|
|||
|
*
|
|||
|
* The editor will use this location for the hover and for code navigation
|
|||
|
* features: This part will become a clickable link that resolves to the
|
|||
|
* definition of the symbol at the given location (not necessarily the
|
|||
|
* location itself), it shows the hover that shows at the given location,
|
|||
|
* and it shows a context menu with further code navigation commands.
|
|||
|
*
|
|||
|
* Depending on the client capability `inlayHint.resolveSupport` clients
|
|||
|
* might resolve this property late using the resolve request.
|
|||
|
*/
|
|||
|
location?: Location
|
|||
|
|
|||
|
/**
|
|||
|
* An optional command for this label part.
|
|||
|
*
|
|||
|
* Depending on the client capability `inlayHint.resolveSupport` clients
|
|||
|
* might resolve this property late using the resolve request.
|
|||
|
*/
|
|||
|
command?: Command
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Inlay hint information.
|
|||
|
*
|
|||
|
* @since 3.17.0
|
|||
|
* @proposed
|
|||
|
*/
|
|||
|
export interface InlayHint {
|
|||
|
|
|||
|
/**
|
|||
|
* The position of this hint.
|
|||
|
*/
|
|||
|
position: Position
|
|||
|
|
|||
|
/**
|
|||
|
* The label of this hint. A human readable string or an array of
|
|||
|
* InlayHintLabelPart label parts.
|
|||
|
*
|
|||
|
* *Note* that neither the string nor the label part can be empty.
|
|||
|
*/
|
|||
|
label: string | InlayHintLabelPart[]
|
|||
|
|
|||
|
/**
|
|||
|
* The kind of this hint. Can be omitted in which case the client
|
|||
|
* should fall back to a reasonable default.
|
|||
|
*/
|
|||
|
kind?: InlayHintKind
|
|||
|
|
|||
|
/**
|
|||
|
* Optional text edits that are performed when accepting this inlay hint.
|
|||
|
*
|
|||
|
* *Note* that edits are expected to change the document so that the inlay
|
|||
|
* hint (or its nearest variant) is now part of the document and the inlay
|
|||
|
* hint itself is now obsolete.
|
|||
|
*/
|
|||
|
textEdits?: TextEdit[]
|
|||
|
|
|||
|
/**
|
|||
|
* The tooltip text when you hover over this item.
|
|||
|
*/
|
|||
|
tooltip?: string | MarkupContent
|
|||
|
|
|||
|
/**
|
|||
|
* Render padding before the hint.
|
|||
|
*
|
|||
|
* Note: Padding should use the editor's background color, not the
|
|||
|
* background color of the hint itself. That means padding can be used
|
|||
|
* to visually align/separate an inlay hint.
|
|||
|
*/
|
|||
|
paddingLeft?: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Render padding after the hint.
|
|||
|
*
|
|||
|
* Note: Padding should use the editor's background color, not the
|
|||
|
* background color of the hint itself. That means padding can be used
|
|||
|
* to visually align/separate an inlay hint.
|
|||
|
*/
|
|||
|
paddingRight?: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* A data entry field that is preserved on a inlay hint between
|
|||
|
* a `textDocument/inlayHint` and a `inlayHint/resolve` request.
|
|||
|
*/
|
|||
|
data?: any
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// nvim interfaces {{
|
|||
|
type VimValue =
|
|||
|
| number
|
|||
|
| boolean
|
|||
|
| string
|
|||
|
| number[]
|
|||
|
| { [key: string]: any }
|
|||
|
|
|||
|
// see `:h nvim_set_client_info()` for details.
|
|||
|
export interface VimClientInfo {
|
|||
|
name: string
|
|||
|
version: {
|
|||
|
major?: number
|
|||
|
minor?: number
|
|||
|
patch?: number
|
|||
|
prerelease?: string
|
|||
|
commit?: string
|
|||
|
}
|
|||
|
type: 'remote' | 'embedder' | 'host'
|
|||
|
methods?: {
|
|||
|
[index: string]: any
|
|||
|
}
|
|||
|
attributes?: {
|
|||
|
[index: string]: any
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
export interface UiAttachOptions {
|
|||
|
rgb?: boolean
|
|||
|
ext_popupmenu?: boolean
|
|||
|
ext_tabline?: boolean
|
|||
|
ext_wildmenu?: boolean
|
|||
|
ext_cmdline?: boolean
|
|||
|
ext_linegrid?: boolean
|
|||
|
ext_hlstate?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface ChanInfo {
|
|||
|
id: number
|
|||
|
stream: 'stdio' | 'stderr' | 'socket' | 'job'
|
|||
|
mode: 'bytes' | 'terminal' | 'rpc'
|
|||
|
pty?: number
|
|||
|
buffer?: number
|
|||
|
client?: VimClientInfo
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Returned by nvim_get_commands api.
|
|||
|
*/
|
|||
|
export interface VimCommandDescription {
|
|||
|
name: string
|
|||
|
bang: boolean
|
|||
|
bar: boolean
|
|||
|
register: boolean
|
|||
|
definition: string
|
|||
|
count?: number | null
|
|||
|
script_id: number
|
|||
|
complete?: string
|
|||
|
nargs?: string
|
|||
|
range?: string
|
|||
|
complete_arg?: string
|
|||
|
}
|
|||
|
|
|||
|
export interface NvimFloatOptions {
|
|||
|
standalone?: boolean
|
|||
|
focusable?: boolean
|
|||
|
relative?: 'editor' | 'cursor' | 'win'
|
|||
|
anchor?: 'NW' | 'NE' | 'SW' | 'SE'
|
|||
|
height: number
|
|||
|
width: number
|
|||
|
row: number
|
|||
|
col: number
|
|||
|
}
|
|||
|
|
|||
|
export interface ExtmarkOptions {
|
|||
|
id?: number
|
|||
|
// 0-based inclusive.
|
|||
|
end_line?: number
|
|||
|
// 0-based exclusive.
|
|||
|
end_col?: number
|
|||
|
// name of the highlight group used to highlight this mark.
|
|||
|
hl_group?: string
|
|||
|
hl_mode?: 'replace' | 'combine' | 'blend'
|
|||
|
hl_eol?: boolean
|
|||
|
// A list of [text, highlight] tuples
|
|||
|
virt_text?: [string, string | string[]][]
|
|||
|
virt_text_pos?: 'eol' | 'overlay' | 'right_align'
|
|||
|
virt_text_win_col?: number
|
|||
|
virt_text_hide?: boolean
|
|||
|
virt_lines?: [string, string | string[]][][]
|
|||
|
virt_lines_above?: boolean
|
|||
|
virt_lines_leftcol?: boolean
|
|||
|
right_gravity?: boolean
|
|||
|
end_right_gravity?: boolean
|
|||
|
priority?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface ExtmarkDetails {
|
|||
|
end_col: number
|
|||
|
end_row: number
|
|||
|
priority: number
|
|||
|
hl_group?: string
|
|||
|
virt_text?: [string, string][]
|
|||
|
virt_lines?: [string, string | string][][]
|
|||
|
}
|
|||
|
|
|||
|
export interface NvimProc {
|
|||
|
ppid: number
|
|||
|
name: string
|
|||
|
pid: number
|
|||
|
}
|
|||
|
|
|||
|
export interface SignPlaceOption {
|
|||
|
id?: number
|
|||
|
group?: string
|
|||
|
name: string
|
|||
|
lnum: number
|
|||
|
priority?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface SignUnplaceOption {
|
|||
|
group?: string
|
|||
|
id?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface SignPlacedOption {
|
|||
|
/**
|
|||
|
* Use '*' for all group, default to '' as unnamed group.
|
|||
|
*/
|
|||
|
group?: string
|
|||
|
id?: number
|
|||
|
lnum?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface SignItem {
|
|||
|
group: string
|
|||
|
id: number
|
|||
|
lnum: number
|
|||
|
name: string
|
|||
|
priority: number
|
|||
|
}
|
|||
|
|
|||
|
export interface HighlightItem {
|
|||
|
hlGroup: string
|
|||
|
/**
|
|||
|
* 0 based
|
|||
|
*/
|
|||
|
lnum: number
|
|||
|
/**
|
|||
|
* 0 based
|
|||
|
*/
|
|||
|
colStart: number
|
|||
|
/**
|
|||
|
* 0 based
|
|||
|
*/
|
|||
|
colEnd: number
|
|||
|
}
|
|||
|
|
|||
|
export interface ExtendedHighlightItem extends HighlightItem {
|
|||
|
combine?: boolean
|
|||
|
start_incl?: boolean
|
|||
|
end_incl?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface HighlightOption {
|
|||
|
/**
|
|||
|
* 0 based start line, default to 0.
|
|||
|
*/
|
|||
|
start?: number
|
|||
|
/**
|
|||
|
* 0 based end line, default to 0.
|
|||
|
*/
|
|||
|
end?: number
|
|||
|
/**
|
|||
|
* Default to 0 on vim8, 4096 on neovim
|
|||
|
*/
|
|||
|
priority?: number
|
|||
|
/**
|
|||
|
* Buffer changedtick to match.
|
|||
|
*/
|
|||
|
changedtick?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface BufferKeymapOption {
|
|||
|
nowait?: boolean
|
|||
|
silent?: boolean
|
|||
|
script?: boolean
|
|||
|
expr?: boolean
|
|||
|
unique?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface BufferHighlight {
|
|||
|
/**
|
|||
|
* Name of the highlight group to use
|
|||
|
*/
|
|||
|
hlGroup?: string
|
|||
|
/**
|
|||
|
* Namespace to use or -1 for ungrouped highlight
|
|||
|
*/
|
|||
|
srcId?: number
|
|||
|
/**
|
|||
|
* Line to highlight (zero-indexed)
|
|||
|
*/
|
|||
|
line?: number
|
|||
|
/**
|
|||
|
* Start of (byte-indexed) column range to highlight
|
|||
|
*/
|
|||
|
colStart?: number
|
|||
|
/**
|
|||
|
* End of (byte-indexed) column range to highlight, or -1 to highlight to end of line
|
|||
|
*/
|
|||
|
colEnd?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface BufferClearHighlight {
|
|||
|
srcId?: number
|
|||
|
lineStart?: number
|
|||
|
lineEnd?: number
|
|||
|
}
|
|||
|
|
|||
|
interface BaseApi<T> {
|
|||
|
/**
|
|||
|
* unique identify number
|
|||
|
*/
|
|||
|
id: number
|
|||
|
|
|||
|
/**
|
|||
|
* Check if same by compare id.
|
|||
|
*/
|
|||
|
equals(other: T): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Request to vim, name need to be nvim_ prefixed and supported by vim.
|
|||
|
*
|
|||
|
* @param {string} name - nvim function name
|
|||
|
* @param {VimValue[]} args
|
|||
|
* @returns {Promise<VimValue>}
|
|||
|
*/
|
|||
|
request(name: string, args?: VimValue[]): Promise<any>
|
|||
|
|
|||
|
/**
|
|||
|
* Send notification to vim, name need to be nvim_ prefixed and supported
|
|||
|
* by vim
|
|||
|
*/
|
|||
|
notify(name: string, args?: VimValue[]): void
|
|||
|
|
|||
|
/**
|
|||
|
* Retrieves scoped variable, returns null when value doesn't exist.
|
|||
|
*/
|
|||
|
getVar(name: string): Promise<VimValue | null>
|
|||
|
|
|||
|
/**
|
|||
|
* Set scoped variable by request.
|
|||
|
*
|
|||
|
* @param {string} name
|
|||
|
* @param {VimValue} value
|
|||
|
* @returns {Promise<void>}
|
|||
|
*/
|
|||
|
setVar(name: string, value: VimValue): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Set scoped variable by notification.
|
|||
|
*/
|
|||
|
setVar(name: string, value: VimValue, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Delete scoped variable by notification.
|
|||
|
*/
|
|||
|
deleteVar(name: string): void
|
|||
|
|
|||
|
/**
|
|||
|
* Retrieves a scoped option, doesn't exist for tabpage.
|
|||
|
*/
|
|||
|
getOption(name: string): Promise<VimValue>
|
|||
|
|
|||
|
/**
|
|||
|
* Set scoped option by request, doesn't exist for tabpage.
|
|||
|
*/
|
|||
|
setOption(name: string, value: VimValue): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Set scoped variable by notification, doesn't exist for tabpage.
|
|||
|
*/
|
|||
|
setOption(name: string, value: VimValue, isNotify: true): void
|
|||
|
}
|
|||
|
|
|||
|
export interface Neovim extends BaseApi<Neovim> {
|
|||
|
|
|||
|
/**
|
|||
|
* Echo error message to vim and log error stack.
|
|||
|
*/
|
|||
|
echoError(msg: unknown): void
|
|||
|
|
|||
|
/**
|
|||
|
* Check if `nvim_` function exists.
|
|||
|
*/
|
|||
|
hasFunction(name: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Get channelid used by coc.nvim.
|
|||
|
*/
|
|||
|
channelId: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Create buffer instance by id.
|
|||
|
*/
|
|||
|
createBuffer(id: number): Buffer
|
|||
|
|
|||
|
/**
|
|||
|
* Create window instance by id.
|
|||
|
*/
|
|||
|
createWindow(id: number): Window
|
|||
|
|
|||
|
/**
|
|||
|
* Create tabpage instance by id.
|
|||
|
*/
|
|||
|
createTabpage(id: number): Tabpage
|
|||
|
|
|||
|
/**
|
|||
|
* Stop send subsequent notifications.
|
|||
|
* This method **must** be paired with `nvim.resumeNotification` in a sync manner.
|
|||
|
*/
|
|||
|
pauseNotification(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Send paused notifications by nvim_call_atomic request
|
|||
|
*
|
|||
|
* @param {boolean} redrawVim Redraw vim on vim8 to update the screen
|
|||
|
*
|
|||
|
* **Note**: avoid call async function between pauseNotification and
|
|||
|
* resumeNotification.
|
|||
|
*/
|
|||
|
resumeNotification(redrawVim?: boolean): Promise<[VimValue[], [string, number, string] | null]>
|
|||
|
|
|||
|
/**
|
|||
|
* Send paused notifications by nvim_call_atomic notification
|
|||
|
*
|
|||
|
* @param {boolean} redrawVim Redraw vim to update the screen
|
|||
|
* @param {true} notify
|
|||
|
* @returns {void}
|
|||
|
*/
|
|||
|
resumeNotification(redrawVim: boolean, notify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Send redraw command to vim, does nothing on neovim since it's not necessary on most cases.
|
|||
|
*/
|
|||
|
redrawVim(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Get list of current buffers.
|
|||
|
*/
|
|||
|
buffers: Promise<Buffer[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Get current buffer.
|
|||
|
*/
|
|||
|
buffer: Promise<Buffer>
|
|||
|
|
|||
|
/**
|
|||
|
* Set current buffer
|
|||
|
*/
|
|||
|
setBuffer(buffer: Buffer): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get list of current tabpages.
|
|||
|
*/
|
|||
|
tabpages: Promise<Tabpage[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Get current tabpage.
|
|||
|
*/
|
|||
|
tabpage: Promise<Tabpage>
|
|||
|
|
|||
|
/**
|
|||
|
* Set current tabpage
|
|||
|
*/
|
|||
|
setTabpage(tabpage: Tabpage): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get list of current windows.
|
|||
|
*/
|
|||
|
windows: Promise<Window[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Get current window.
|
|||
|
*/
|
|||
|
window: Promise<Window>
|
|||
|
|
|||
|
/**
|
|||
|
* Set current window.
|
|||
|
*/
|
|||
|
setWindow(window: Window): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get information of all channels,
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
chans: Promise<ChanInfo[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Get information of channel by id,
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getChanInfo(id: number): Promise<ChanInfo>
|
|||
|
|
|||
|
/**
|
|||
|
* Creates a new namespace, or gets an existing one.
|
|||
|
* `:h nvim_create_namespace()`
|
|||
|
*/
|
|||
|
createNamespace(name?: string): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets existing, non-anonymous namespaces.
|
|||
|
*
|
|||
|
* @return dict that maps from names to namespace ids.
|
|||
|
*/
|
|||
|
namespaces: Promise<{ [name: string]: number }>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets a map of global (non-buffer-local) Ex commands.
|
|||
|
*
|
|||
|
* @return Map of maps describing commands.
|
|||
|
*/
|
|||
|
getCommands(opt?: { builtin: boolean }): Promise<{ [name: string]: VimCommandDescription }>
|
|||
|
|
|||
|
/**
|
|||
|
* Get list of all runtime paths
|
|||
|
*/
|
|||
|
runtimePaths: Promise<string[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Set global working directory.
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
setDirectory(dir: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get current line.
|
|||
|
*/
|
|||
|
line: Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Creates a new, empty, unnamed buffer.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
createNewBuffer(listed?: boolean, scratch?: boolean): Promise<Buffer>
|
|||
|
|
|||
|
/**
|
|||
|
* Create float window of neovim.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only, use high level api provided by window
|
|||
|
* module is recommended.
|
|||
|
*/
|
|||
|
openFloatWindow(buffer: Buffer, enter: boolean, options: NvimFloatOptions): Promise<Window>
|
|||
|
|
|||
|
/**
|
|||
|
* Set current line.
|
|||
|
*/
|
|||
|
setLine(line: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets a list of global (non-buffer-local) |mapping| definitions.
|
|||
|
* `:h nvim_get_keymap`
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getKeymap(mode: string): Promise<object[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets the current mode. |mode()| "blocking" is true if Nvim is waiting for input.
|
|||
|
*
|
|||
|
* **Note:** blocking would always be false when used with vim.
|
|||
|
*/
|
|||
|
mode: Promise<{ mode: string; blocking: boolean }>
|
|||
|
|
|||
|
/**
|
|||
|
* Returns a map of color names and RGB values.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
colorMap(): Promise<{ [name: string]: number }>
|
|||
|
|
|||
|
/**
|
|||
|
* Returns the 24-bit RGB value of a |nvim_get_color_map()| color name or
|
|||
|
* "#rrggbb" hexadecimal string.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getColorByName(name: string): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets a highlight definition by id. |hlID()|
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getHighlight(nameOrId: string | number, isRgb?: boolean): Promise<object>
|
|||
|
|
|||
|
/**
|
|||
|
* Get a highlight by name, return rgb by default.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getHighlightByName(name: string, isRgb?: boolean): Promise<object>
|
|||
|
|
|||
|
/**
|
|||
|
* Get a highlight by id, return rgb by default.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getHighlightById(id: number, isRgb?: boolean): Promise<object>
|
|||
|
|
|||
|
/**
|
|||
|
* Delete current line in buffer.
|
|||
|
*/
|
|||
|
deleteCurrentLine(): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Evaluates a VimL expression (:help expression). Dictionaries
|
|||
|
* and Lists are recursively expanded. On VimL error: Returns a
|
|||
|
* generic error; v:errmsg is not updated.
|
|||
|
*
|
|||
|
*/
|
|||
|
eval(expr: string): Promise<VimValue>
|
|||
|
|
|||
|
/**
|
|||
|
* Executes lua, it's possible neovim client does not support this
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
lua(code: string, args?: VimValue[]): Promise<object>
|
|||
|
|
|||
|
/**
|
|||
|
* Calls a VimL |Dictionary-function| with the given arguments.
|
|||
|
*/
|
|||
|
callDictFunction(dict: object | string, fname: string, args: VimValue | VimValue[]): Promise<object>
|
|||
|
|
|||
|
/**
|
|||
|
* Call a vim function.
|
|||
|
*
|
|||
|
* @param {string} fname - function name
|
|||
|
* @param {VimValue | VimValue[]} args
|
|||
|
* @returns {Promise<any>}
|
|||
|
*/
|
|||
|
call(fname: string, args?: VimValue | VimValue[]): Promise<any>
|
|||
|
|
|||
|
/**
|
|||
|
* Call a vim function by notification.
|
|||
|
*/
|
|||
|
call(fname: string, args: VimValue | VimValue[], isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Call a vim function with timer of timeout 0.
|
|||
|
*
|
|||
|
* @param {string} fname - function name
|
|||
|
* @param {VimValue | VimValue[]} args
|
|||
|
* @returns {Promise<any>}
|
|||
|
*/
|
|||
|
callTimer(fname: string, args?: VimValue | VimValue[]): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Call a vim function with timer of timeout 0 by notification.
|
|||
|
*/
|
|||
|
callTimer(fname: string, args: VimValue | VimValue[], isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Call async vim function that accept callback as argument
|
|||
|
* by using notifications.
|
|||
|
*/
|
|||
|
callAsync(fname: string, args?: VimValue | VimValue[]): Promise<unknown>
|
|||
|
|
|||
|
/**
|
|||
|
* Calls many API methods atomically.
|
|||
|
*/
|
|||
|
callAtomic(calls: [string, VimValue[]][]): Promise<[any[], any[] | null]>
|
|||
|
|
|||
|
/**
|
|||
|
* Executes an ex-command by request.
|
|||
|
*/
|
|||
|
command(arg: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Executes an ex-command by notification.
|
|||
|
*/
|
|||
|
command(arg: string, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Runs a command and returns output.
|
|||
|
*
|
|||
|
* @deprecated Use exec() instead.
|
|||
|
*/
|
|||
|
commandOutput(arg: string): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Executes Vimscript (multiline block of Ex-commands), like
|
|||
|
* anonymous |:source|
|
|||
|
*/
|
|||
|
exec(src: string, output?: boolean): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets a v: variable.
|
|||
|
*/
|
|||
|
getVvar(name: string): Promise<VimValue>
|
|||
|
|
|||
|
/**
|
|||
|
* `:h nvim_feedkeys`
|
|||
|
*/
|
|||
|
feedKeys(keys: string, mode: string, escapeCsi: boolean): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Queues raw user-input. Unlike |nvim_feedkeys()|, this uses a
|
|||
|
* low-level input buffer and the call is non-blocking (input is
|
|||
|
* processed asynchronously by the eventloop).
|
|||
|
*
|
|||
|
* On execution error: does not fail, but updates v:errmsg.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
input(keys: string): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Parse a VimL Expression.
|
|||
|
*/
|
|||
|
parseExpression(expr: string, flags: string, highlight: boolean): Promise<object>
|
|||
|
|
|||
|
/**
|
|||
|
* Get process info, neovim only.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getProc(pid: number): Promise<NvimProc>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets the immediate children of process `pid`.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getProcChildren(pid: number): Promise<NvimProc[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Replaces terminal codes and |keycodes| (<CR>, <Esc>, ...)
|
|||
|
* in a string with the internal representation.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
replaceTermcodes(str: string, fromPart: boolean, doIt: boolean, special: boolean): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets width(display cells) of string.
|
|||
|
*/
|
|||
|
strWidth(str: string): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets a list of dictionaries representing attached UIs.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
uis: Promise<any[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Subscribe to nvim event broadcasts.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
subscribe(event: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Unsubscribe to nvim event broadcasts
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
unsubscribe(event: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Activates UI events on the channel.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
uiAttach(width: number, height: number, options: UiAttachOptions): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* `:h nvim_ui_try_resize`
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
uiTryResize(width: number, height: number): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Deactivates UI events on the channel.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
uiDetach(): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Quit vim.
|
|||
|
*/
|
|||
|
quit(): Promise<void>
|
|||
|
}
|
|||
|
|
|||
|
export interface Buffer extends BaseApi<Buffer> {
|
|||
|
id: number
|
|||
|
|
|||
|
/** Total number of lines in buffer */
|
|||
|
length: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Get lines of buffer.
|
|||
|
*/
|
|||
|
lines: Promise<string[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Get changedtick of buffer.
|
|||
|
*/
|
|||
|
changedtick: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Add buffer keymap by notification.
|
|||
|
*/
|
|||
|
setKeymap(mode: string, lhs: string, rhs: string, opts?: BufferKeymapOption): void
|
|||
|
|
|||
|
/**
|
|||
|
* Removes an ext mark by notification.
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @param {number} ns_id - Namespace id
|
|||
|
* @param {number} id - Extmark id
|
|||
|
*/
|
|||
|
deleteExtMark(ns_id: number, id: number): void
|
|||
|
|
|||
|
/**
|
|||
|
* Gets the position (0-indexed) of an extmark.
|
|||
|
*
|
|||
|
* @param {number} ns_id - Namespace id
|
|||
|
* @param {number} id - Extmark id
|
|||
|
* @param {Object} opts - Optional parameters.
|
|||
|
* @returns {Promise<[] | [number, number] | [number, number, ExtmarkDetails]>}
|
|||
|
*/
|
|||
|
getExtMarkById(ns_id: number, id: number, opts?: {
|
|||
|
details?: boolean
|
|||
|
}): Promise<[] | [number, number] | [number, number, ExtmarkDetails]>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets extmarks in "traversal order" from a |charwise| region defined by
|
|||
|
* buffer positions (inclusive, 0-indexed |api-indexing|).
|
|||
|
*
|
|||
|
* Region can be given as (row,col) tuples, or valid extmark ids (whose
|
|||
|
* positions define the bounds). 0 and -1 are understood as (0,0) and (-1,-1)
|
|||
|
* respectively, thus the following are equivalent:
|
|||
|
*
|
|||
|
* nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
|
|||
|
* nvim_buf_get_extmarks(0, my_ns, [0,0], [-1,-1], {})
|
|||
|
*
|
|||
|
* @param {number} ns_id - Namespace id
|
|||
|
* @param {[number, number] | number} start
|
|||
|
* @param {[number, number] | number} end
|
|||
|
* @param {Object} opts
|
|||
|
* @returns {Promise<[number, number, number, ExtmarkDetails?][]>}
|
|||
|
*/
|
|||
|
getExtMarks(ns_id: number, start: [number, number] | number, end: [number, number] | number, opts?: {
|
|||
|
details?: boolean
|
|||
|
limit?: number
|
|||
|
}): Promise<[number, number, number, ExtmarkDetails?][]>
|
|||
|
|
|||
|
/**
|
|||
|
* Creates or updates an extmark by notification, `:h nvim_buf_set_extmark`.
|
|||
|
*
|
|||
|
* @param {number} ns_id
|
|||
|
* @param {number} line
|
|||
|
* @param {number} col
|
|||
|
* @param {ExtmarkOptions} opts
|
|||
|
* @returns {void}
|
|||
|
*/
|
|||
|
setExtMark(ns_id: number, line: number, col: number, opts?: ExtmarkOptions): void
|
|||
|
|
|||
|
/**
|
|||
|
* Add sign to buffer by notification.
|
|||
|
*
|
|||
|
* @param {SignPlaceOption} sign
|
|||
|
*/
|
|||
|
placeSign(sign: SignPlaceOption): void
|
|||
|
|
|||
|
/**
|
|||
|
* Unplace signs by notification
|
|||
|
*/
|
|||
|
unplaceSign(opts: SignUnplaceOption): void
|
|||
|
|
|||
|
/**
|
|||
|
* Get signs by group name or id and lnum.
|
|||
|
*
|
|||
|
* @param {SignPlacedOption} opts
|
|||
|
*/
|
|||
|
getSigns(opts: SignPlacedOption): Promise<SignItem[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Get highlight items by namespace (end inclusive).
|
|||
|
*
|
|||
|
* @param {string} ns Namespace key or id.
|
|||
|
* @param {number} start 0 based line number, default to 0.
|
|||
|
* @param {number} end 0 based line number, default to -1.
|
|||
|
*/
|
|||
|
getHighlights(ns: string, start?: number, end?: number): Promise<HighlightItem[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Update namespaced highlights in range by notification.
|
|||
|
* Priority default to 0 on vim and 4096 on neovim.
|
|||
|
* Note: timer used for whole buffer highlights for better performance.
|
|||
|
*
|
|||
|
* @param {string} ns Namespace key.
|
|||
|
* @param {HighlightItem[]} highlights Highlight items.
|
|||
|
* @param {HighlightOption} opts Highlight options.
|
|||
|
*/
|
|||
|
updateHighlights(ns: string, highlights: ExtendedHighlightItem[], opts?: HighlightOption): void
|
|||
|
|
|||
|
/**
|
|||
|
* Gets a map of buffer-local |user-commands|.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
getCommands(options?: {}): Promise<Object>
|
|||
|
|
|||
|
/**
|
|||
|
* Get lines of buffer, get all lines by default.
|
|||
|
*/
|
|||
|
getLines(opts?: { start: number, end: number, strictIndexing?: boolean }): Promise<string[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Set lines of buffer given indices use request.
|
|||
|
*/
|
|||
|
setLines(lines: string[], opts?: { start: number, end: number, strictIndexing?: boolean }): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Set lines of buffer given indices use notification.
|
|||
|
*/
|
|||
|
setLines(lines: string[], opts: { start: number, end: number, strictIndexing?: boolean }, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Set virtual text for a line
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @deprecated Use `setExtMark()` instead.
|
|||
|
* @param {number} src_id - Source group to use or 0 to use a new group, or -1
|
|||
|
* @param {number} line - Line to annotate with virtual text (zero-indexed)
|
|||
|
* @param {Chunk[]} chunks - List with [text, hl_group]
|
|||
|
* @param {[index} opts
|
|||
|
* @returns {Promise<number>}
|
|||
|
*/
|
|||
|
setVirtualText(src_id: number, line: number, chunks: [string, string][], opts?: { [index: string]: any }): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Append a string or list of lines to end of buffer
|
|||
|
*/
|
|||
|
append(lines: string[] | string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get buffer name.
|
|||
|
*/
|
|||
|
name: Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Set buffer name.
|
|||
|
*/
|
|||
|
setName(name: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Check if buffer valid.
|
|||
|
*/
|
|||
|
valid: Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Get mark position given mark name
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
mark(name: string): Promise<[number, number]>
|
|||
|
|
|||
|
/**
|
|||
|
* Gets a list of buffer-local |mapping| definitions.
|
|||
|
*
|
|||
|
* @return Array of maparg()-like dictionaries describing mappings.
|
|||
|
* The "buffer" key holds the associated buffer handle.
|
|||
|
*/
|
|||
|
getKeymap(mode: string): Promise<object[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Check if buffer loaded.
|
|||
|
*/
|
|||
|
loaded: Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Returns the byte offset for a line.
|
|||
|
*
|
|||
|
* Line 1 (index=0) has offset 0. UTF-8 bytes are counted. EOL is
|
|||
|
* one byte. 'fileformat' and 'fileencoding' are ignored. The
|
|||
|
* line index just after the last line gives the total byte-count
|
|||
|
* of the buffer. A final EOL byte is counted if it would be
|
|||
|
* written, see 'eol'.
|
|||
|
*
|
|||
|
* Unlike |line2byte()|, throws error for out-of-bounds indexing.
|
|||
|
* Returns -1 for unloaded buffer.
|
|||
|
*
|
|||
|
* @return {Number} Integer byte offset, or -1 for unloaded buffer.
|
|||
|
*/
|
|||
|
getOffset(index: number): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Adds a highlight to buffer, checkout |nvim_buf_add_highlight|.
|
|||
|
*
|
|||
|
* Note: when `srcId = 0`, request is made for new `srcId`, otherwire, use notification.
|
|||
|
* Note: `hlGroup` as empty string is not supported.
|
|||
|
*
|
|||
|
* @deprecated use `highlightRanges()` instead.
|
|||
|
*/
|
|||
|
addHighlight(opts: BufferHighlight): Promise<number | null>
|
|||
|
|
|||
|
/**
|
|||
|
* Clear highlights of specified lins.
|
|||
|
*
|
|||
|
* @deprecated use clearNamespace() instead.
|
|||
|
*/
|
|||
|
clearHighlight(args?: BufferClearHighlight)
|
|||
|
|
|||
|
/**
|
|||
|
* Add highlight to ranges by notification, works on both vim & neovim.
|
|||
|
*
|
|||
|
* Works on neovim and `workspace.isVim && workspace.env.textprop` is true
|
|||
|
*
|
|||
|
* @param {string | number} srcId Unique key or namespace number.
|
|||
|
* @param {string} hlGroup Highlight group.
|
|||
|
* @param {Range[]} ranges List of highlight ranges
|
|||
|
*/
|
|||
|
highlightRanges(srcId: string | number, hlGroup: string, ranges: Range[]): void
|
|||
|
|
|||
|
/**
|
|||
|
* Clear namespace by id or name by notification, works on both vim & neovim.
|
|||
|
*
|
|||
|
* Works on neovim and `workspace.isVim && workspace.env.textprop` is true
|
|||
|
*
|
|||
|
* @param key Unique key or namespace number, use -1 for all namespaces
|
|||
|
* @param lineStart Start of line, 0 based, default to 0.
|
|||
|
* @param lineEnd End of line, 0 based, default to -1.
|
|||
|
*/
|
|||
|
clearNamespace(key: number | string, lineStart?: number, lineEnd?: number)
|
|||
|
}
|
|||
|
|
|||
|
export interface Window extends BaseApi<Window> {
|
|||
|
/**
|
|||
|
* The windowid that not change within a Vim session
|
|||
|
*/
|
|||
|
id: number
|
|||
|
|
|||
|
/**
|
|||
|
* Buffer in window.
|
|||
|
*/
|
|||
|
buffer: Promise<Buffer>
|
|||
|
|
|||
|
/**
|
|||
|
* Tabpage contains window.
|
|||
|
*/
|
|||
|
tabpage: Promise<Tabpage>
|
|||
|
|
|||
|
/**
|
|||
|
* Cursor position as [line, col], 1 based.
|
|||
|
*/
|
|||
|
cursor: Promise<[number, number]>
|
|||
|
|
|||
|
/**
|
|||
|
* Window height.
|
|||
|
*/
|
|||
|
height: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Window width.
|
|||
|
*/
|
|||
|
width: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Set cursor position by request.
|
|||
|
*/
|
|||
|
setCursor(pos: [number, number]): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Set cursor position by notification.
|
|||
|
*/
|
|||
|
setCursor(pos: [number, number], isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Set height
|
|||
|
*/
|
|||
|
setHeight(height: number): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Set height by notification.
|
|||
|
*/
|
|||
|
setHeight(height: number, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Set width.
|
|||
|
*/
|
|||
|
setWidth(width: number): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Set width by notification.
|
|||
|
*/
|
|||
|
setWidth(width: number, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Get window position, not work with vim8's popup.
|
|||
|
*/
|
|||
|
position: Promise<[number, number]>
|
|||
|
|
|||
|
/** 0-indexed, on-screen window position(row) in display cells. */
|
|||
|
row: Promise<number>
|
|||
|
|
|||
|
/** 0-indexed, on-screen window position(col) in display cells. */
|
|||
|
col: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Check if window valid.
|
|||
|
*/
|
|||
|
valid: Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Get window number, throws for invalid window.
|
|||
|
*/
|
|||
|
number: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Config float window with options.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
setConfig(options: NvimFloatOptions): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Config float window with options by send notification.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*/
|
|||
|
setConfig(options: NvimFloatOptions, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Gets window configuration.
|
|||
|
*
|
|||
|
* **Note:** works on neovim only.
|
|||
|
*
|
|||
|
* @returns Map defining the window configuration, see |nvim_open_win()|
|
|||
|
*/
|
|||
|
getConfig(): Promise<NvimFloatOptions>
|
|||
|
|
|||
|
/**
|
|||
|
* Close window by send request.
|
|||
|
*/
|
|||
|
close(force: boolean): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Close window by send notification.
|
|||
|
*/
|
|||
|
close(force: boolean, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Add highlight to ranges by request (matchaddpos is used)
|
|||
|
*
|
|||
|
* @return {Promise<number[]>} match ids.
|
|||
|
*/
|
|||
|
highlightRanges(hlGroup: string, ranges: Range[], priority?: number): Promise<number[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Add highlight to ranges by notification (matchaddpos is used)
|
|||
|
*/
|
|||
|
highlightRanges(hlGroup: string, ranges: Range[], priority: number, isNotify: true): void
|
|||
|
|
|||
|
/**
|
|||
|
* Clear match of highlight group by send notification.
|
|||
|
*/
|
|||
|
clearMatchGroup(hlGroup: string): void
|
|||
|
|
|||
|
/**
|
|||
|
* Clear match of match ids by send notification.
|
|||
|
*/
|
|||
|
clearMatches(ids: number[]): void
|
|||
|
}
|
|||
|
|
|||
|
export interface Tabpage extends BaseApi<Tabpage> {
|
|||
|
/**
|
|||
|
* tabpage number.
|
|||
|
*/
|
|||
|
number: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Is current tabpage valid.
|
|||
|
*/
|
|||
|
valid: Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Returns all windows of tabpage.
|
|||
|
*/
|
|||
|
windows: Promise<Window[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Current window of tabpage.
|
|||
|
*/
|
|||
|
window: Promise<Window>
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// vscode-uri {{
|
|||
|
export interface UriComponents {
|
|||
|
scheme: string
|
|||
|
authority: string
|
|||
|
path: string
|
|||
|
query: string
|
|||
|
fragment: string
|
|||
|
}
|
|||
|
/**
|
|||
|
* Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
|
|||
|
* This class is a simple parser which creates the basic component parts
|
|||
|
* (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
|
|||
|
* and encoding.
|
|||
|
*
|
|||
|
* ```txt
|
|||
|
* foo://example.com:8042/over/there?name=ferret#nose
|
|||
|
* \_/ \______________/\_________/ \_________/ \__/
|
|||
|
* | | | | |
|
|||
|
* scheme authority path query fragment
|
|||
|
* | _____________________|__
|
|||
|
* / \ / \
|
|||
|
* urn:example:animal:ferret:nose
|
|||
|
* ```
|
|||
|
*/
|
|||
|
export class Uri implements UriComponents {
|
|||
|
static isUri(thing: any): thing is Uri
|
|||
|
/**
|
|||
|
* scheme is the 'http' part of 'http://www.msft.com/some/path?query#fragment'.
|
|||
|
* The part before the first colon.
|
|||
|
*/
|
|||
|
readonly scheme: string
|
|||
|
/**
|
|||
|
* authority is the 'www.msft.com' part of 'http://www.msft.com/some/path?query#fragment'.
|
|||
|
* The part between the first double slashes and the next slash.
|
|||
|
*/
|
|||
|
readonly authority: string
|
|||
|
/**
|
|||
|
* path is the '/some/path' part of 'http://www.msft.com/some/path?query#fragment'.
|
|||
|
*/
|
|||
|
readonly path: string
|
|||
|
/**
|
|||
|
* query is the 'query' part of 'http://www.msft.com/some/path?query#fragment'.
|
|||
|
*/
|
|||
|
readonly query: string
|
|||
|
/**
|
|||
|
* fragment is the 'fragment' part of 'http://www.msft.com/some/path?query#fragment'.
|
|||
|
*/
|
|||
|
readonly fragment: string
|
|||
|
/**
|
|||
|
* @internal
|
|||
|
*/
|
|||
|
protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean)
|
|||
|
/**
|
|||
|
* @internal
|
|||
|
*/
|
|||
|
protected constructor(components: UriComponents)
|
|||
|
/**
|
|||
|
* Returns a string representing the corresponding file system path of this URI.
|
|||
|
* Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
|
|||
|
* platform specific path separator.
|
|||
|
*
|
|||
|
* * Will *not* validate the path for invalid characters and semantics.
|
|||
|
* * Will *not* look at the scheme of this URI.
|
|||
|
* * The result shall *not* be used for display purposes but for accessing a file on disk.
|
|||
|
*
|
|||
|
*
|
|||
|
* The *difference* to `URI#path` is the use of the platform specific separator and the handling
|
|||
|
* of UNC paths. See the below sample of a file-uri with an authority (UNC path).
|
|||
|
*
|
|||
|
* ```ts
|
|||
|
const u = URI.parse('file://server/c$/folder/file.txt')
|
|||
|
u.authority === 'server'
|
|||
|
u.path === '/shares/c$/file.txt'
|
|||
|
u.fsPath === '\\server\c$\folder\file.txt'
|
|||
|
```
|
|||
|
*
|
|||
|
* Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
|
|||
|
* namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
|
|||
|
* with URIs that represent files on disk (`file` scheme).
|
|||
|
*/
|
|||
|
readonly fsPath: string
|
|||
|
with(change: {
|
|||
|
scheme?: string
|
|||
|
authority?: string | null
|
|||
|
path?: string | null
|
|||
|
query?: string | null
|
|||
|
fragment?: string | null
|
|||
|
}): Uri
|
|||
|
/**
|
|||
|
* Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,
|
|||
|
* `file:///usr/home`, or `scheme:with/path`.
|
|||
|
*
|
|||
|
* @param value A string which represents an URI (see `URI#toString`).
|
|||
|
*/
|
|||
|
static parse(value: string, _strict?: boolean): Uri
|
|||
|
/**
|
|||
|
* Creates a new URI from a file system path, e.g. `c:\my\files`,
|
|||
|
* `/usr/home`, or `\\server\share\some\path`.
|
|||
|
*
|
|||
|
* The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
|
|||
|
* as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
|
|||
|
* `URI.parse('file://' + path)` because the path might contain characters that are
|
|||
|
* interpreted (# and ?). See the following sample:
|
|||
|
* ```ts
|
|||
|
const good = URI.file('/coding/c#/project1');
|
|||
|
good.scheme === 'file';
|
|||
|
good.path === '/coding/c#/project1';
|
|||
|
good.fragment === '';
|
|||
|
const bad = URI.parse('file://' + '/coding/c#/project1');
|
|||
|
bad.scheme === 'file';
|
|||
|
bad.path === '/coding/c'; // path is now broken
|
|||
|
bad.fragment === '/project1';
|
|||
|
```
|
|||
|
*
|
|||
|
* @param path A file system path (see `URI#fsPath`)
|
|||
|
*/
|
|||
|
static file(path: string): Uri
|
|||
|
static from(components: {
|
|||
|
scheme: string
|
|||
|
authority?: string
|
|||
|
path?: string
|
|||
|
query?: string
|
|||
|
fragment?: string
|
|||
|
}): Uri
|
|||
|
/**
|
|||
|
* Creates a string representation for this URI. It's guaranteed that calling
|
|||
|
* `URI.parse` with the result of this function creates an URI which is equal
|
|||
|
* to this URI.
|
|||
|
*
|
|||
|
* * The result shall *not* be used for display purposes but for externalization or transport.
|
|||
|
* * The result will be encoded using the percentage encoding and encoding happens mostly
|
|||
|
* ignore the scheme-specific encoding rules.
|
|||
|
*
|
|||
|
* @param skipEncoding Do not encode the result, default is `false`
|
|||
|
*/
|
|||
|
toString(skipEncoding?: boolean): string
|
|||
|
toJSON(): UriComponents
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// vim interfaces {{
|
|||
|
/**
|
|||
|
* See `:h complete-items`
|
|||
|
*/
|
|||
|
export interface VimCompleteItem {
|
|||
|
word: string
|
|||
|
abbr?: string
|
|||
|
menu?: string
|
|||
|
info?: string
|
|||
|
kind?: string
|
|||
|
icase?: number
|
|||
|
equal?: number
|
|||
|
dup?: number
|
|||
|
empty?: number
|
|||
|
user_data?: string
|
|||
|
}
|
|||
|
|
|||
|
export interface LocationListItem {
|
|||
|
bufnr: number
|
|||
|
lnum: number
|
|||
|
end_lnum: number
|
|||
|
col: number
|
|||
|
end_col: number
|
|||
|
text: string
|
|||
|
type: string
|
|||
|
}
|
|||
|
|
|||
|
export interface QuickfixItem {
|
|||
|
uri?: string
|
|||
|
module?: string
|
|||
|
range?: Range
|
|||
|
text?: string
|
|||
|
type?: string
|
|||
|
filename?: string
|
|||
|
bufnr?: number
|
|||
|
lnum?: number
|
|||
|
end_lnum?: number
|
|||
|
col?: number
|
|||
|
end_col?: number
|
|||
|
valid?: boolean
|
|||
|
nr?: number
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// provider interfaces {{
|
|||
|
/**
|
|||
|
* A provider result represents the values a provider, like the [`HoverProvider`](#HoverProvider),
|
|||
|
* may return. For once this is the actual result type `T`, like `Hover`, or a thenable that resolves
|
|||
|
* to that type `T`. In addition, `null` and `undefined` can be returned - either directly or from a
|
|||
|
* thenable.
|
|||
|
*
|
|||
|
* The snippets below are all valid implementations of the [`HoverProvider`](#HoverProvider):
|
|||
|
*
|
|||
|
* ```ts
|
|||
|
* let a: HoverProvider = {
|
|||
|
* provideHover(doc, pos, token): ProviderResult<Hover> {
|
|||
|
* return new Hover('Hello World')
|
|||
|
* }
|
|||
|
* }
|
|||
|
*
|
|||
|
* let b: HoverProvider = {
|
|||
|
* provideHover(doc, pos, token): ProviderResult<Hover> {
|
|||
|
* return new Promise(resolve => {
|
|||
|
* resolve(new Hover('Hello World'))
|
|||
|
* })
|
|||
|
* }
|
|||
|
* }
|
|||
|
*
|
|||
|
* let c: HoverProvider = {
|
|||
|
* provideHover(doc, pos, token): ProviderResult<Hover> {
|
|||
|
* return; // undefined
|
|||
|
* }
|
|||
|
* }
|
|||
|
* ```
|
|||
|
*/
|
|||
|
export type ProviderResult<T> =
|
|||
|
| T
|
|||
|
| undefined
|
|||
|
| null
|
|||
|
| Thenable<T | undefined | null>
|
|||
|
|
|||
|
/**
|
|||
|
* Supported provider names.
|
|||
|
*/
|
|||
|
export type ProviderName = 'rename' | 'onTypeEdit' | 'documentLink' | 'documentColor'
|
|||
|
| 'foldingRange' | 'format' | 'codeAction' | 'workspaceSymbols' | 'formatRange' | 'formatOnType'
|
|||
|
| 'hover' | 'signature' | 'documentSymbol' | 'documentHighlight' | 'definition'
|
|||
|
| 'declaration' | 'typeDefinition' | 'reference' | 'implementation'
|
|||
|
| 'codeLens' | 'selectionRange' | 'callHierarchy' | 'semanticTokens' | 'linkedEditing'
|
|||
|
|
|||
|
/**
|
|||
|
* The completion item provider interface defines the contract between extensions and
|
|||
|
* [IntelliSense](https://code.visualstudio.com/docs/editor/intellisense).
|
|||
|
*
|
|||
|
* Providers can delay the computation of the [`detail`](#CompletionItem.detail)
|
|||
|
* and [`documentation`](#CompletionItem.documentation) properties by implementing the
|
|||
|
* [`resolveCompletionItem`](#CompletionItemProvider.resolveCompletionItem)-function. However, properties that
|
|||
|
* are needed for the initial sorting and filtering, like `sortText`, `filterText`, `insertText`, and `range`, must
|
|||
|
* not be changed during resolve.
|
|||
|
*
|
|||
|
* Providers are asked for completions either explicitly by a user gesture or -depending on the configuration-
|
|||
|
* implicitly when typing words or trigger characters.
|
|||
|
*/
|
|||
|
export interface CompletionItemProvider {
|
|||
|
/**
|
|||
|
* Provide completion items for the given position and document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @param context How the completion was triggered.
|
|||
|
*
|
|||
|
* @return An array of completions, a [completion list](#CompletionList), or a thenable that resolves to either.
|
|||
|
* The lack of a result can be signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideCompletionItems(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken,
|
|||
|
context?: CompletionContext
|
|||
|
): ProviderResult<CompletionItem[] | CompletionList>
|
|||
|
|
|||
|
/**
|
|||
|
* Given a completion item fill in more data, like [doc-comment](#CompletionItem.documentation)
|
|||
|
* or [details](#CompletionItem.detail).
|
|||
|
*
|
|||
|
* The editor will only resolve a completion item once.
|
|||
|
*
|
|||
|
* @param item A completion item currently active in the UI.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return The resolved completion item or a thenable that resolves to of such. It is OK to return the given
|
|||
|
* `item`. When no result is returned, the given `item` will be used.
|
|||
|
*/
|
|||
|
resolveCompletionItem?(
|
|||
|
item: CompletionItem,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<CompletionItem>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The hover provider interface defines the contract between extensions and
|
|||
|
* the [hover](https://code.visualstudio.com/docs/editor/intellisense)-feature.
|
|||
|
*/
|
|||
|
export interface HoverProvider {
|
|||
|
/**
|
|||
|
* Provide a hover for the given position and document. Multiple hovers at the same
|
|||
|
* position will be merged by the editor. A hover can have a range which defaults
|
|||
|
* to the word range at the position when omitted.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A hover or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideHover(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Hover>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The definition provider interface defines the contract between extensions and
|
|||
|
* the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
|
|||
|
* and peek definition features.
|
|||
|
*/
|
|||
|
export interface DefinitionProvider {
|
|||
|
/**
|
|||
|
* Provide the definition of the symbol at the given position and document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A definition or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideDefinition(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The definition provider interface defines the contract between extensions and
|
|||
|
* the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
|
|||
|
* and peek definition features.
|
|||
|
*/
|
|||
|
export interface DeclarationProvider {
|
|||
|
/**
|
|||
|
* Provide the declaration of the symbol at the given position and document.
|
|||
|
*/
|
|||
|
provideDeclaration(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The signature help provider interface defines the contract between extensions and
|
|||
|
* the [parameter hints](https://code.visualstudio.com/docs/editor/intellisense)-feature.
|
|||
|
*/
|
|||
|
export interface SignatureHelpProvider {
|
|||
|
/**
|
|||
|
* Provide help for the signature at the given position and document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return Signature help or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideSignatureHelp(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken,
|
|||
|
context: SignatureHelpContext
|
|||
|
): ProviderResult<SignatureHelp>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The type definition provider defines the contract between extensions and
|
|||
|
* the go to type definition feature.
|
|||
|
*/
|
|||
|
export interface TypeDefinitionProvider {
|
|||
|
/**
|
|||
|
* Provide the type definition of the symbol at the given position and document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A definition or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideTypeDefinition(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Value-object that contains additional information when
|
|||
|
* requesting references.
|
|||
|
*/
|
|||
|
export interface ReferenceContext {
|
|||
|
/**
|
|||
|
* Include the declaration of the current symbol.
|
|||
|
*/
|
|||
|
includeDeclaration: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The reference provider interface defines the contract between extensions and
|
|||
|
* the [find references](https://code.visualstudio.com/docs/editor/editingevolved#_peek)-feature.
|
|||
|
*/
|
|||
|
export interface ReferenceProvider {
|
|||
|
/**
|
|||
|
* Provide a set of project-wide references for the given position and document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param context
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of locations or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideReferences(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
context: ReferenceContext,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Location[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Folding context (for future use)
|
|||
|
*/
|
|||
|
export interface FoldingContext {}
|
|||
|
|
|||
|
/**
|
|||
|
* The folding range provider interface defines the contract between extensions and
|
|||
|
* [Folding](https://code.visualstudio.com/docs/editor/codebasics#_folding) in the editor.
|
|||
|
*/
|
|||
|
export interface FoldingRangeProvider {
|
|||
|
/**
|
|||
|
* Returns a list of folding ranges or null and undefined if the provider
|
|||
|
* does not want to participate or was cancelled.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param context Additional context information (for future use)
|
|||
|
* @param token A cancellation token.
|
|||
|
*/
|
|||
|
provideFoldingRanges(
|
|||
|
document: LinesTextDocument,
|
|||
|
context: FoldingContext,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<FoldingRange[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document symbol provider interface defines the contract between extensions and
|
|||
|
* the [go to symbol](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-symbol)-feature.
|
|||
|
*/
|
|||
|
export interface DocumentSymbolProvider {
|
|||
|
/**
|
|||
|
* Provide symbol information for the given document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of document highlights or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideDocumentSymbols(
|
|||
|
document: LinesTextDocument,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<SymbolInformation[] | DocumentSymbol[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The implementation provider interface defines the contract between extensions and
|
|||
|
* the go to implementation feature.
|
|||
|
*/
|
|||
|
export interface ImplementationProvider {
|
|||
|
/**
|
|||
|
* Provide the implementations of the symbol at the given position and document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A definition or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideImplementation(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The workspace symbol provider interface defines the contract between extensions and
|
|||
|
* the [symbol search](https://code.visualstudio.com/docs/editor/editingevolved#_open-symbol-by-name)-feature.
|
|||
|
*/
|
|||
|
export interface WorkspaceSymbolProvider {
|
|||
|
/**
|
|||
|
* Project-wide search for a symbol matching the given query string. It is up to the provider
|
|||
|
* how to search given the query string, like substring, indexOf etc. To improve performance implementors can
|
|||
|
* skip the [location](#SymbolInformation.location) of symbols and implement `resolveWorkspaceSymbol` to do that
|
|||
|
* later.
|
|||
|
*
|
|||
|
* The `query`-parameter should be interpreted in a *relaxed way* as the editor will apply its own highlighting
|
|||
|
* and scoring on the results. A good rule of thumb is to match case-insensitive and to simply check that the
|
|||
|
* characters of *query* appear in their order in a candidate symbol. Don't use prefix, substring, or similar
|
|||
|
* strict matching.
|
|||
|
*
|
|||
|
* @param query A non-empty query string.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of document highlights or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideWorkspaceSymbols(
|
|||
|
query: string,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<SymbolInformation[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Given a symbol fill in its [location](#SymbolInformation.location). This method is called whenever a symbol
|
|||
|
* is selected in the UI. Providers can implement this method and return incomplete symbols from
|
|||
|
* [`provideWorkspaceSymbols`](#WorkspaceSymbolProvider.provideWorkspaceSymbols) which often helps to improve
|
|||
|
* performance.
|
|||
|
*
|
|||
|
* @param symbol The symbol that is to be resolved. Guaranteed to be an instance of an object returned from an
|
|||
|
* earlier call to `provideWorkspaceSymbols`.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return The resolved symbol or a thenable that resolves to that. When no result is returned,
|
|||
|
* the given `symbol` is used.
|
|||
|
*/
|
|||
|
resolveWorkspaceSymbol?(
|
|||
|
symbol: SymbolInformation,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<SymbolInformation>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The rename provider interface defines the contract between extensions and
|
|||
|
* the [rename](https://code.visualstudio.com/docs/editor/editingevolved#_rename-symbol)-feature.
|
|||
|
*/
|
|||
|
export interface RenameProvider {
|
|||
|
/**
|
|||
|
* Provide an edit that describes changes that have to be made to one
|
|||
|
* or many resources to rename a symbol to a different name.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param newName The new name of the symbol. If the given name is not valid, the provider must return a rejected promise.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A workspace edit or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideRenameEdits(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
newName: string,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<WorkspaceEdit>
|
|||
|
|
|||
|
/**
|
|||
|
* Optional function for resolving and validating a position *before* running rename. The result can
|
|||
|
* be a range or a range and a placeholder text. The placeholder text should be the identifier of the symbol
|
|||
|
* which is being renamed - when omitted the text in the returned range is used.
|
|||
|
*
|
|||
|
* @param document The document in which rename will be invoked.
|
|||
|
* @param position The position at which rename will be invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return The range or range and placeholder text of the identifier that is to be renamed. The lack of a result can signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
prepareRename?(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Range | { range: Range; placeholder: string }>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document formatting provider interface defines the contract between extensions and
|
|||
|
* the formatting-feature.
|
|||
|
*/
|
|||
|
export interface DocumentFormattingEditProvider {
|
|||
|
/**
|
|||
|
* Provide formatting edits for a whole document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param options Options controlling formatting.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A set of text edits or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideDocumentFormattingEdits(
|
|||
|
document: LinesTextDocument,
|
|||
|
options: FormattingOptions,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<TextEdit[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document formatting provider interface defines the contract between extensions and
|
|||
|
* the formatting-feature.
|
|||
|
*/
|
|||
|
export interface DocumentRangeFormattingEditProvider {
|
|||
|
/**
|
|||
|
* Provide formatting edits for a range in a document.
|
|||
|
*
|
|||
|
* The given range is a hint and providers can decide to format a smaller
|
|||
|
* or larger range. Often this is done by adjusting the start and end
|
|||
|
* of the range to full syntax nodes.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param range The range which should be formatted.
|
|||
|
* @param options Options controlling formatting.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A set of text edits or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideDocumentRangeFormattingEdits(
|
|||
|
document: LinesTextDocument,
|
|||
|
range: Range,
|
|||
|
options: FormattingOptions,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<TextEdit[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The code action interface defines the contract between extensions and
|
|||
|
* the [light bulb](https://code.visualstudio.com/docs/editor/editingevolved#_code-action) feature.
|
|||
|
*
|
|||
|
* A code action can be any command that is [known](#commands.getCommands) to the system.
|
|||
|
*/
|
|||
|
export interface CodeActionProvider<T extends CodeAction = CodeAction> {
|
|||
|
/**
|
|||
|
* Provide commands for the given document and range.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param range The selector or range for which the command was invoked. This will always be a selection if
|
|||
|
* there is a currently active editor.
|
|||
|
* @param context Context carrying additional information.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of commands, quick fixes, or refactorings or a thenable of such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideCodeActions(
|
|||
|
document: LinesTextDocument,
|
|||
|
range: Range,
|
|||
|
context: CodeActionContext,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<(Command | CodeAction)[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Given a code action fill in its [`edit`](#CodeAction.edit)-property. Changes to
|
|||
|
* all other properties, like title, are ignored. A code action that has an edit
|
|||
|
* will not be resolved.
|
|||
|
*
|
|||
|
* @param codeAction A code action.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return The resolved code action or a thenable that resolves to such. It is OK to return the given
|
|||
|
* `item`. When no result is returned, the given `item` will be used.
|
|||
|
*/
|
|||
|
resolveCodeAction?(codeAction: T, token: CancellationToken): ProviderResult<T>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Metadata about the type of code actions that a [CodeActionProvider](#CodeActionProvider) providers
|
|||
|
*/
|
|||
|
export interface CodeActionProviderMetadata {
|
|||
|
/**
|
|||
|
* [CodeActionKinds](#CodeActionKind) that this provider may return.
|
|||
|
*
|
|||
|
* The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the provider
|
|||
|
* may list our every specific kind they provide, such as `CodeActionKind.Refactor.Extract.append('function`)`
|
|||
|
*/
|
|||
|
readonly providedCodeActionKinds?: ReadonlyArray<string>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document highlight provider interface defines the contract between extensions and
|
|||
|
* the word-highlight-feature.
|
|||
|
*/
|
|||
|
export interface DocumentHighlightProvider {
|
|||
|
|
|||
|
/**
|
|||
|
* Provide a set of document highlights, like all occurrences of a variable or
|
|||
|
* all exit-points of a function.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of document highlights or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideDocumentHighlights(
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<DocumentHighlight[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document link provider defines the contract between extensions and feature of showing
|
|||
|
* links in the editor.
|
|||
|
*/
|
|||
|
export interface DocumentLinkProvider {
|
|||
|
|
|||
|
/**
|
|||
|
* Provide links for the given document. Note that the editor ships with a default provider that detects
|
|||
|
* `http(s)` and `file` links.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of [document links](#DocumentLink) or a thenable that resolves to such. The lack of a result
|
|||
|
* can be signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideDocumentLinks(document: LinesTextDocument, token: CancellationToken): ProviderResult<DocumentLink[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Given a link fill in its [target](#DocumentLink.target). This method is called when an incomplete
|
|||
|
* link is selected in the UI. Providers can implement this method and return incomple links
|
|||
|
* (without target) from the [`provideDocumentLinks`](#DocumentLinkProvider.provideDocumentLinks) method which
|
|||
|
* often helps to improve performance.
|
|||
|
*
|
|||
|
* @param link The link that is to be resolved.
|
|||
|
* @param token A cancellation token.
|
|||
|
*/
|
|||
|
resolveDocumentLink?(link: DocumentLink, token: CancellationToken): ProviderResult<DocumentLink>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A code lens provider adds [commands](#Command) to source text. The commands will be shown
|
|||
|
* as dedicated horizontal lines in between the source text.
|
|||
|
*/
|
|||
|
export interface CodeLensProvider {
|
|||
|
|
|||
|
/**
|
|||
|
* Compute a list of [lenses](#CodeLens). This call should return as fast as possible and if
|
|||
|
* computing the commands is expensive implementors should only return code lens objects with the
|
|||
|
* range set and implement [resolve](#CodeLensProvider.resolveCodeLens).
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of code lenses or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideCodeLenses(document: LinesTextDocument, token: CancellationToken): ProviderResult<CodeLens[]>
|
|||
|
|
|||
|
/**
|
|||
|
* This function will be called for each visible code lens, usually when scrolling and after
|
|||
|
* calls to [compute](#CodeLensProvider.provideCodeLenses)-lenses.
|
|||
|
*
|
|||
|
* @param codeLens code lens that must be resolved.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return The given, resolved code lens or thenable that resolves to such.
|
|||
|
*/
|
|||
|
resolveCodeLens?(codeLens: CodeLens, token: CancellationToken): ProviderResult<CodeLens>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document formatting provider interface defines the contract between extensions and
|
|||
|
* the formatting-feature.
|
|||
|
*/
|
|||
|
export interface OnTypeFormattingEditProvider {
|
|||
|
|
|||
|
/**
|
|||
|
* Provide formatting edits after a character has been typed.
|
|||
|
*
|
|||
|
* The given position and character should hint to the provider
|
|||
|
* what range the position to expand to, like find the matching `{`
|
|||
|
* when `}` has been entered.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param ch The character that has been typed.
|
|||
|
* @param options Options controlling formatting.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A set of text edits or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideOnTypeFormattingEdits(document: LinesTextDocument, position: Position, ch: string, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document color provider defines the contract between extensions and feature of
|
|||
|
* picking and modifying colors in the editor.
|
|||
|
*/
|
|||
|
export interface DocumentColorProvider {
|
|||
|
|
|||
|
/**
|
|||
|
* Provide colors for the given document.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of [color information](#ColorInformation) or a thenable that resolves to such. The lack of a result
|
|||
|
* can be signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideDocumentColors(document: LinesTextDocument, token: CancellationToken): ProviderResult<ColorInformation[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Provide [representations](#ColorPresentation) for a color.
|
|||
|
*
|
|||
|
* @param color The color to show and insert.
|
|||
|
* @param context A context object with additional information
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of color presentations or a thenable that resolves to such. The lack of a result
|
|||
|
* can be signaled by returning `undefined`, `null`, or an empty array.
|
|||
|
*/
|
|||
|
provideColorPresentations(color: Color, context: { document: LinesTextDocument; range: Range }, token: CancellationToken): ProviderResult<ColorPresentation[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface TextDocumentContentProvider {
|
|||
|
|
|||
|
/**
|
|||
|
* An event to signal a resource has changed.
|
|||
|
*/
|
|||
|
onDidChange?: Event<Uri>
|
|||
|
|
|||
|
/**
|
|||
|
* Provide textual content for a given uri.
|
|||
|
*
|
|||
|
* The editor will use the returned string-content to create a readonly
|
|||
|
* [document](#LinesTextDocument). Resources allocated should be released when
|
|||
|
* the corresponding document has been [closed](#workspace.onDidCloseTextDocument).
|
|||
|
*
|
|||
|
* @param uri An uri which scheme matches the scheme this provider was [registered](#workspace.registerTextDocumentContentProvider) for.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A string or a thenable that resolves to such.
|
|||
|
*/
|
|||
|
provideTextDocumentContent(uri: Uri, token: CancellationToken): ProviderResult<string>
|
|||
|
}
|
|||
|
|
|||
|
export interface SelectionRangeProvider {
|
|||
|
/**
|
|||
|
* Provide selection ranges starting at a given position. The first range must [contain](#Range.contains)
|
|||
|
* position and subsequent ranges must contain the previous range.
|
|||
|
*/
|
|||
|
provideSelectionRanges(document: LinesTextDocument, positions: Position[], token: CancellationToken): ProviderResult<SelectionRange[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The call hierarchy provider interface describes the contract between extensions
|
|||
|
* and the call hierarchy feature which allows to browse calls and caller of function,
|
|||
|
* methods, constructor etc.
|
|||
|
*/
|
|||
|
export interface CallHierarchyProvider {
|
|||
|
|
|||
|
/**
|
|||
|
* Bootstraps call hierarchy by returning the item that is denoted by the given document
|
|||
|
* and position. This item will be used as entry into the call graph. Providers should
|
|||
|
* return `undefined` or `null` when there is no item at the given location.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param position The position at which the command was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @returns A call hierarchy item or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
prepareCallHierarchy(document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<CallHierarchyItem | CallHierarchyItem[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Provide all incoming calls for an item, e.g all callers for a method. In graph terms this describes directed
|
|||
|
* and annotated edges inside the call graph, e.g the given item is the starting node and the result is the nodes
|
|||
|
* that can be reached.
|
|||
|
*
|
|||
|
* @param item The hierarchy item for which incoming calls should be computed.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @returns A set of incoming calls or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideCallHierarchyIncomingCalls(item: CallHierarchyItem, token: CancellationToken): ProviderResult<CallHierarchyIncomingCall[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Provide all outgoing calls for an item, e.g call calls to functions, methods, or constructors from the given item. In
|
|||
|
* graph terms this describes directed and annotated edges inside the call graph, e.g the given item is the starting
|
|||
|
* node and the result is the nodes that can be reached.
|
|||
|
*
|
|||
|
* @param item The hierarchy item for which outgoing calls should be computed.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @returns A set of outgoing calls or a thenable that resolves to such. The lack of a result can be
|
|||
|
* signaled by returning `undefined` or `null`.
|
|||
|
*/
|
|||
|
provideCallHierarchyOutgoingCalls(item: CallHierarchyItem, token: CancellationToken): ProviderResult<CallHierarchyOutgoingCall[]>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document semantic tokens provider interface defines the contract between extensions and
|
|||
|
* semantic tokens.
|
|||
|
*/
|
|||
|
export interface DocumentSemanticTokensProvider {
|
|||
|
/**
|
|||
|
* An optional event to signal that the semantic tokens from this provider have changed.
|
|||
|
*/
|
|||
|
// TODO: SemantiTokens
|
|||
|
onDidChangeSemanticTokens?: Event<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Tokens in a file are represented as an array of integers. The position of each token is expressed relative to
|
|||
|
* the token before it, because most tokens remain stable relative to each other when edits are made in a file.
|
|||
|
*
|
|||
|
* ---
|
|||
|
* In short, each token takes 5 integers to represent, so a specific token `i` in the file consists of the following array indices:
|
|||
|
*
|
|||
|
* - at index `5*i` - `deltaLine`: token line number, relative to the previous token
|
|||
|
* - at index `5*i+1` - `deltaStart`: token start character, relative to the previous token (relative to 0 or the previous token's start if they are on the same line)
|
|||
|
* - at index `5*i+2` - `length`: the length of the token. A token cannot be multiline.
|
|||
|
* - at index `5*i+3` - `tokenType`: will be looked up in `SemanticTokensLegend.tokenTypes`. We currently ask that `tokenType` < 65536.
|
|||
|
* - at index `5*i+4` - `tokenModifiers`: each set bit will be looked up in `SemanticTokensLegend.tokenModifiers`
|
|||
|
*
|
|||
|
* ---
|
|||
|
* ### How to encode tokens
|
|||
|
*
|
|||
|
* Here is an example for encoding a file with 3 tokens in a uint32 array:
|
|||
|
* ```
|
|||
|
* { line: 2, startChar: 5, length: 3, tokenType: "property", tokenModifiers: ["private", "static"] },
|
|||
|
* { line: 2, startChar: 10, length: 4, tokenType: "type", tokenModifiers: [] },
|
|||
|
* { line: 5, startChar: 2, length: 7, tokenType: "class", tokenModifiers: [] }
|
|||
|
* ```
|
|||
|
*
|
|||
|
* 1. First of all, a legend must be devised. This legend must be provided up-front and capture all possible token types.
|
|||
|
* For this example, we will choose the following legend which must be passed in when registering the provider:
|
|||
|
* ```
|
|||
|
* tokenTypes: ['property', 'type', 'class'],
|
|||
|
* tokenModifiers: ['private', 'static']
|
|||
|
* ```
|
|||
|
*
|
|||
|
* 2. The first transformation step is to encode `tokenType` and `tokenModifiers` as integers using the legend. Token types are looked
|
|||
|
* up by index, so a `tokenType` value of `1` means `tokenTypes[1]`. Multiple token modifiers can be set by using bit flags,
|
|||
|
* so a `tokenModifier` value of `3` is first viewed as binary `0b00000011`, which means `[tokenModifiers[0], tokenModifiers[1]]` because
|
|||
|
* bits 0 and 1 are set. Using this legend, the tokens now are:
|
|||
|
* ```
|
|||
|
* { line: 2, startChar: 5, length: 3, tokenType: 0, tokenModifiers: 3 },
|
|||
|
* { line: 2, startChar: 10, length: 4, tokenType: 1, tokenModifiers: 0 },
|
|||
|
* { line: 5, startChar: 2, length: 7, tokenType: 2, tokenModifiers: 0 }
|
|||
|
* ```
|
|||
|
*
|
|||
|
* 3. The next step is to represent each token relative to the previous token in the file. In this case, the second token
|
|||
|
* is on the same line as the first token, so the `startChar` of the second token is made relative to the `startChar`
|
|||
|
* of the first token, so it will be `10 - 5`. The third token is on a different line than the second token, so the
|
|||
|
* `startChar` of the third token will not be altered:
|
|||
|
* ```
|
|||
|
* { deltaLine: 2, deltaStartChar: 5, length: 3, tokenType: 0, tokenModifiers: 3 },
|
|||
|
* { deltaLine: 0, deltaStartChar: 5, length: 4, tokenType: 1, tokenModifiers: 0 },
|
|||
|
* { deltaLine: 3, deltaStartChar: 2, length: 7, tokenType: 2, tokenModifiers: 0 }
|
|||
|
* ```
|
|||
|
*
|
|||
|
* 4. Finally, the last step is to inline each of the 5 fields for a token in a single array, which is a memory friendly representation:
|
|||
|
* ```
|
|||
|
* // 1st token, 2nd token, 3rd token
|
|||
|
* [ 2,5,3,0,3, 0,5,4,1,0, 3,2,7,2,0 ]
|
|||
|
* ```
|
|||
|
*
|
|||
|
* @see [SemanticTokensBuilder](#SemanticTokensBuilder) for a helper to encode tokens as integers.
|
|||
|
* *NOTE*: When doing edits, it is possible that multiple edits occur until VS Code decides to invoke the semantic tokens provider.
|
|||
|
* *NOTE*: If the provider cannot temporarily compute semantic tokens, it can indicate this by throwing an error with the message 'Busy'.
|
|||
|
*/
|
|||
|
provideDocumentSemanticTokens(document: LinesTextDocument, token: CancellationToken): ProviderResult<SemanticTokens>
|
|||
|
|
|||
|
/**
|
|||
|
* Instead of always returning all the tokens in a file, it is possible for a `DocumentSemanticTokensProvider` to implement
|
|||
|
* this method (`provideDocumentSemanticTokensEdits`) and then return incremental updates to the previously provided semantic tokens.
|
|||
|
*
|
|||
|
* ---
|
|||
|
* ### How tokens change when the document changes
|
|||
|
*
|
|||
|
* Suppose that `provideDocumentSemanticTokens` has previously returned the following semantic tokens:
|
|||
|
* ```
|
|||
|
* // 1st token, 2nd token, 3rd token
|
|||
|
* [ 2,5,3,0,3, 0,5,4,1,0, 3,2,7,2,0 ]
|
|||
|
* ```
|
|||
|
*
|
|||
|
* Also suppose that after some edits, the new semantic tokens in a file are:
|
|||
|
* ```
|
|||
|
* // 1st token, 2nd token, 3rd token
|
|||
|
* [ 3,5,3,0,3, 0,5,4,1,0, 3,2,7,2,0 ]
|
|||
|
* ```
|
|||
|
* It is possible to express these new tokens in terms of an edit applied to the previous tokens:
|
|||
|
* ```
|
|||
|
* [ 2,5,3,0,3, 0,5,4,1,0, 3,2,7,2,0 ] // old tokens
|
|||
|
* [ 3,5,3,0,3, 0,5,4,1,0, 3,2,7,2,0 ] // new tokens
|
|||
|
*
|
|||
|
* edit: { start: 0, deleteCount: 1, data: [3] } // replace integer at offset 0 with 3
|
|||
|
* ```
|
|||
|
*
|
|||
|
* *NOTE*: If the provider cannot compute `SemanticTokensEdits`, it can "give up" and return all the tokens in the document again.
|
|||
|
* *NOTE*: All edits in `SemanticTokensEdits` contain indices in the old integers array, so they all refer to the previous result state.
|
|||
|
*/
|
|||
|
provideDocumentSemanticTokensEdits?(document: LinesTextDocument, previousResultId: string, token: CancellationToken): ProviderResult<SemanticTokens | SemanticTokensDelta>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The document range semantic tokens provider interface defines the contract between extensions and
|
|||
|
* semantic tokens.
|
|||
|
*/
|
|||
|
export interface DocumentRangeSemanticTokensProvider {
|
|||
|
/**
|
|||
|
* @see [provideDocumentSemanticTokens](#DocumentSemanticTokensProvider.provideDocumentSemanticTokens).
|
|||
|
*/
|
|||
|
provideDocumentRangeSemanticTokens(document: LinesTextDocument, range: Range, token: CancellationToken): ProviderResult<SemanticTokens>
|
|||
|
}
|
|||
|
|
|||
|
export interface LinkedEditingRangeProvider {
|
|||
|
/**
|
|||
|
* For a given position in a document, returns the range of the symbol at the position and all ranges
|
|||
|
* that have the same content. A change to one of the ranges can be applied to all other ranges if the new content
|
|||
|
* is valid. An optional word pattern can be returned with the result to describe valid contents.
|
|||
|
* If no result-specific word pattern is provided, the word pattern from the language configuration is used.
|
|||
|
*
|
|||
|
* @param document The document in which the provider was invoked.
|
|||
|
* @param position The position at which the provider was invoked.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return A list of ranges that can be edited together
|
|||
|
*/
|
|||
|
provideLinkedEditingRanges(document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<LinkedEditingRanges>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The inlay hints provider interface defines the contract between extensions and
|
|||
|
* the inlay hints feature.
|
|||
|
*/
|
|||
|
export interface InlayHintsProvider<T extends InlayHint = InlayHint> {
|
|||
|
|
|||
|
/**
|
|||
|
* An optional event to signal that inlay hints from this provider have changed.
|
|||
|
*/
|
|||
|
onDidChangeInlayHints?: Event<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Provide inlay hints for the given range and document.
|
|||
|
*
|
|||
|
* *Note* that inlay hints that are not {@link Range.contains contained} by the given range are ignored.
|
|||
|
*
|
|||
|
* @param document The document in which the command was invoked.
|
|||
|
* @param range The range for which inlay hints should be computed.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return An array of inlay hints or a thenable that resolves to such.
|
|||
|
*/
|
|||
|
provideInlayHints(document: TextDocument, range: Range, token: CancellationToken): ProviderResult<T[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Given an inlay hint fill in {@link InlayHint.tooltip tooltip}, {@link InlayHint.textEdits text edits},
|
|||
|
* or complete label {@link InlayHintLabelPart parts}.
|
|||
|
*
|
|||
|
* *Note* that the editor will resolve an inlay hint at most once.
|
|||
|
*
|
|||
|
* @param hint An inlay hint.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return The resolved inlay hint or a thenable that resolves to such. It is OK to return the given `item`. When no result is returned, the given `item` will be used.
|
|||
|
*/
|
|||
|
resolveInlayHint?(hint: T, token: CancellationToken): ProviderResult<T>
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// Classes {{
|
|||
|
/**
|
|||
|
* A semantic tokens builder can help with creating a `SemanticTokens` instance
|
|||
|
* which contains delta encoded semantic tokens.
|
|||
|
*/
|
|||
|
export class SemanticTokensBuilder {
|
|||
|
constructor(legend?: SemanticTokensLegend)
|
|||
|
|
|||
|
/**
|
|||
|
* Add another token.
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @param line The token start line number (absolute value).
|
|||
|
* @param char The token start character (absolute value).
|
|||
|
* @param length The token length in characters.
|
|||
|
* @param tokenType The encoded token type.
|
|||
|
* @param tokenModifiers The encoded token modifiers.
|
|||
|
*/
|
|||
|
push(line: number, char: number, length: number, tokenType: number, tokenModifiers?: number): void
|
|||
|
/**
|
|||
|
* Add another token. Use only when providing a legend.
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @param range The range of the token. Must be single-line.
|
|||
|
* @param tokenType The token type.
|
|||
|
* @param tokenModifiers The token modifiers.
|
|||
|
*/
|
|||
|
push(range: Range, tokenType: string, tokenModifiers?: string[]): void
|
|||
|
|
|||
|
/**
|
|||
|
* Finish and create a `SemanticTokens` instance.
|
|||
|
*
|
|||
|
* @public
|
|||
|
*/
|
|||
|
build(resultId?: string): SemanticTokens
|
|||
|
}
|
|||
|
|
|||
|
export interface Document {
|
|||
|
readonly buffer: Buffer
|
|||
|
/**
|
|||
|
* Document is attached to vim.
|
|||
|
*/
|
|||
|
readonly attached: boolean
|
|||
|
/**
|
|||
|
* Is command line document.
|
|||
|
*/
|
|||
|
readonly isCommandLine: boolean
|
|||
|
/**
|
|||
|
* `buftype` option of buffer.
|
|||
|
*/
|
|||
|
readonly buftype: string
|
|||
|
/**
|
|||
|
* Text document that synchronized.
|
|||
|
*/
|
|||
|
readonly textDocument: LinesTextDocument
|
|||
|
/**
|
|||
|
* Fired when document change.
|
|||
|
*/
|
|||
|
readonly onDocumentChange: Event<DidChangeTextDocumentParams>
|
|||
|
/**
|
|||
|
* Get current buffer changedtick.
|
|||
|
*/
|
|||
|
readonly changedtick: number
|
|||
|
/**
|
|||
|
* Scheme of document.
|
|||
|
*/
|
|||
|
readonly schema: string
|
|||
|
/**
|
|||
|
* Line count of current buffer.
|
|||
|
*/
|
|||
|
readonly lineCount: number
|
|||
|
/**
|
|||
|
* Window ID when buffer create, could be -1 when no window associated.
|
|||
|
*/
|
|||
|
readonly winid: number
|
|||
|
/**
|
|||
|
* Returns if current document is opended with previewwindow
|
|||
|
*/
|
|||
|
readonly previewwindow: boolean
|
|||
|
/**
|
|||
|
* Check if document changed after last synchronize
|
|||
|
*/
|
|||
|
readonly dirty: boolean
|
|||
|
/**
|
|||
|
* Buffer number
|
|||
|
*/
|
|||
|
readonly bufnr: number
|
|||
|
/**
|
|||
|
* Content of textDocument.
|
|||
|
*/
|
|||
|
readonly content: string
|
|||
|
/**
|
|||
|
* Converted filetype.
|
|||
|
*/
|
|||
|
readonly filetype: string
|
|||
|
/**
|
|||
|
* Main filetype of buffer, first part when buffer filetype contains dots.
|
|||
|
* Same as filetype most of the time.
|
|||
|
*/
|
|||
|
readonly languageId: string
|
|||
|
readonly uri: string
|
|||
|
readonly version: number
|
|||
|
/**
|
|||
|
* Apply text edits to document. `nvim_buf_set_text()` is used when possible
|
|||
|
*
|
|||
|
* @param {TextEdit[]} edits
|
|||
|
* @param {boolean} joinUndo - Join further changes with the previous undo block by `:undojoin`.
|
|||
|
* @param {boolean | Position} move - Move the cursor when true or from custom position.
|
|||
|
* @returns {Promise<void>}
|
|||
|
*/
|
|||
|
applyEdits(edits: TextEdit[], joinUndo?: boolean, move?: boolean | Position): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Change individual lines.
|
|||
|
*
|
|||
|
* @param {[number, string][]} lines
|
|||
|
* @returns {void}
|
|||
|
*/
|
|||
|
changeLines(lines: [number, string][]): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get offset from lnum & col
|
|||
|
*/
|
|||
|
getOffset(lnum: number, col: number): number
|
|||
|
|
|||
|
/**
|
|||
|
* Check string is word.
|
|||
|
*/
|
|||
|
isWord(word: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Word range at position.
|
|||
|
*
|
|||
|
* @param {Position} position
|
|||
|
* @param {string} extraChars Extra characters that should be keyword.
|
|||
|
* @param {boolean} current Use current lines instead of textDocument, default to true.
|
|||
|
* @returns {Range | null}
|
|||
|
*/
|
|||
|
getWordRangeAtPosition(position: Position, extraChars?: string, current?: boolean): Range | null
|
|||
|
|
|||
|
/**
|
|||
|
* Get ranges of word in textDocument.
|
|||
|
*/
|
|||
|
getSymbolRanges(word: string): Range[]
|
|||
|
|
|||
|
/**
|
|||
|
* Get line for buffer
|
|||
|
*
|
|||
|
* @param {number} line 0 based line index.
|
|||
|
* @param {boolean} current Use textDocument lines when false, default to true.
|
|||
|
* @returns {string}
|
|||
|
*/
|
|||
|
getline(line: number, current?: boolean): string
|
|||
|
|
|||
|
/**
|
|||
|
* Get range of current lines, zero indexed, end exclude.
|
|||
|
*/
|
|||
|
getLines(start?: number, end?: number): string[]
|
|||
|
|
|||
|
/**
|
|||
|
* Get variable value by key, defined by `b:coc_{key}`
|
|||
|
*/
|
|||
|
getVar<T>(key: string, defaultValue?: T): T
|
|||
|
|
|||
|
/**
|
|||
|
* Get position from lnum & col
|
|||
|
*/
|
|||
|
getPosition(lnum: number, col: number): Position
|
|||
|
|
|||
|
/**
|
|||
|
* Adjust col with new valid character before position.
|
|||
|
*/
|
|||
|
fixStartcol(position: Position, valids: string[]): number
|
|||
|
|
|||
|
/**
|
|||
|
* Get current content text.
|
|||
|
*/
|
|||
|
getDocumentContent(): string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a {@link TextEditor text editor}'s {@link TextEditor.options options}.
|
|||
|
*/
|
|||
|
export interface TextEditorOptions {
|
|||
|
/**
|
|||
|
* The size in spaces a tab takes. This is used for two purposes:
|
|||
|
* - the rendering width of a tab character;
|
|||
|
* - the number of spaces to insert when {@link TextEditorOptions.insertSpaces insertSpaces} is true.
|
|||
|
*
|
|||
|
* When getting a text editor's options, this property will always be a number (resolved).
|
|||
|
*/
|
|||
|
tabSize: number
|
|||
|
/**
|
|||
|
* When pressing Tab insert {@link TextEditorOptions.tabSize n} spaces.
|
|||
|
* When getting a text editor's options, this property will always be a boolean (resolved).
|
|||
|
*/
|
|||
|
insertSpaces: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents an editor that is attached to a {@link TextDocument document}.
|
|||
|
*/
|
|||
|
export interface TextEditor {
|
|||
|
/**
|
|||
|
* The tabpagenr of current editor.
|
|||
|
*/
|
|||
|
readonly tabpagenr: number
|
|||
|
/**
|
|||
|
* The window id of current editor.
|
|||
|
*/
|
|||
|
readonly winid: number
|
|||
|
/**
|
|||
|
* The window number of current editor.
|
|||
|
*/
|
|||
|
readonly winnr: number
|
|||
|
/**
|
|||
|
* The document associated with this text editor. The document will be the same for the entire lifetime of this text editor.
|
|||
|
*/
|
|||
|
readonly document: Document
|
|||
|
/**
|
|||
|
* The current visible ranges in the editor (vertically).
|
|||
|
* This accounts only for vertical scrolling, and not for horizontal scrolling.
|
|||
|
*/
|
|||
|
readonly visibleRanges: readonly Range[]
|
|||
|
/**
|
|||
|
* Text editor options.
|
|||
|
*/
|
|||
|
readonly options: TextEditorOptions
|
|||
|
}
|
|||
|
|
|||
|
export interface FloatWinConfig {
|
|||
|
maxHeight?: number
|
|||
|
maxWidth?: number
|
|||
|
preferTop?: boolean
|
|||
|
autoHide?: boolean
|
|||
|
offsetX?: number
|
|||
|
title?: string
|
|||
|
border?: number[]
|
|||
|
cursorline?: boolean
|
|||
|
close?: boolean
|
|||
|
highlight?: string
|
|||
|
borderhighlight?: string
|
|||
|
modes?: string[]
|
|||
|
shadow?: boolean
|
|||
|
winblend?: number
|
|||
|
focusable?: boolean
|
|||
|
excludeImages?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface Documentation {
|
|||
|
/**
|
|||
|
* Filetype used for highlight, markdown is supported.
|
|||
|
*/
|
|||
|
filetype: string
|
|||
|
/**
|
|||
|
* Content of document.
|
|||
|
*/
|
|||
|
content: string
|
|||
|
/**
|
|||
|
* Byte offset (0 based) that should be undelined.
|
|||
|
*/
|
|||
|
active?: [number, number]
|
|||
|
highlights?: HighlightItem[]
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Float window factory for create float around current cursor, works on vim and neovim.
|
|||
|
* Use `workspace.floatSupported` to check if float could work.
|
|||
|
*
|
|||
|
* Float windows are automatic reused and hidden on specific events including:
|
|||
|
* - BufEnter
|
|||
|
* - InsertEnter
|
|||
|
* - InsertLeave
|
|||
|
* - MenuPopupChanged
|
|||
|
* - CursorMoved
|
|||
|
* - CursorMovedI
|
|||
|
*/
|
|||
|
export class FloatFactory implements Disposable {
|
|||
|
get bufnr(): number | undefined
|
|||
|
get buffer(): Buffer | null
|
|||
|
get window(): Window | null
|
|||
|
activated(): Promise<boolean>
|
|||
|
|
|||
|
constructor(nvim: Neovim)
|
|||
|
|
|||
|
/**
|
|||
|
* Show documentations in float window/popup around cursor.
|
|||
|
* Window and buffer are reused when possible.
|
|||
|
* Window is closed automatically on change buffer, InsertEnter, CursorMoved and CursorMovedI.
|
|||
|
*
|
|||
|
* @param docs List of documentations.
|
|||
|
* @param config Configuration for floating window/popup.
|
|||
|
*/
|
|||
|
show(docs: Documentation[], config?: FloatWinConfig): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Close float window.
|
|||
|
*/
|
|||
|
close(): void
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/**
|
|||
|
* A file glob pattern to match file paths against. This can either be a glob pattern string
|
|||
|
* (like `**/*.{ts,js}` or `*.{ts,js}`) or a {@link RelativePattern relative pattern}.
|
|||
|
*
|
|||
|
* Glob patterns can have the following syntax:
|
|||
|
* * `*` to match one or more characters in a path segment
|
|||
|
* * `?` to match on one character in a path segment
|
|||
|
* * `**` to match any number of path segments, including none
|
|||
|
* * `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
|
|||
|
* * `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
|
|||
|
* * `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
|
|||
|
*
|
|||
|
* Note: a backslash (`\`) is not valid within a glob pattern. If you have an existing file
|
|||
|
* path to match against, consider to use the {@link RelativePattern relative pattern} support
|
|||
|
* that takes care of converting any backslash into slash. Otherwise, make sure to convert
|
|||
|
* any backslash to slash when creating the glob pattern.
|
|||
|
*/
|
|||
|
export type GlobPattern = string | RelativePattern
|
|||
|
|
|||
|
/**
|
|||
|
* A relative pattern is a helper to construct glob patterns that are matched
|
|||
|
* relatively to a base file path. The base path can either be an absolute file
|
|||
|
* path as string or uri or a {@link WorkspaceFolder workspace folder}, which is the
|
|||
|
* preferred way of creating the relative pattern.
|
|||
|
*/
|
|||
|
export class RelativePattern {
|
|||
|
|
|||
|
/**
|
|||
|
* A base file path to which this pattern will be matched against relatively.
|
|||
|
*/
|
|||
|
baseUri: Uri
|
|||
|
|
|||
|
/**
|
|||
|
* A file glob pattern like `*.{ts,js}` that will be matched on file paths
|
|||
|
* relative to the base path.
|
|||
|
*
|
|||
|
* Example: Given a base of `/home/work/folder` and a file path of `/home/work/folder/index.js`,
|
|||
|
* the file glob pattern will match on `index.js`.
|
|||
|
*/
|
|||
|
pattern: string
|
|||
|
|
|||
|
/**
|
|||
|
* Creates a new relative pattern object with a base file path and pattern to match. This pattern
|
|||
|
* will be matched on file paths relative to the base.
|
|||
|
*
|
|||
|
* Example:
|
|||
|
* ```ts
|
|||
|
* const folder = vscode.workspace.workspaceFolders?.[0];
|
|||
|
* if (folder) {
|
|||
|
*
|
|||
|
* // Match any TypeScript file in the root of this workspace folder
|
|||
|
* const pattern1 = new vscode.RelativePattern(folder, '*.ts');
|
|||
|
*
|
|||
|
* // Match any TypeScript file in `someFolder` inside this workspace folder
|
|||
|
* const pattern2 = new vscode.RelativePattern(folder, 'someFolder/*.ts');
|
|||
|
* }
|
|||
|
* ```
|
|||
|
*
|
|||
|
* @param base A base to which this pattern will be matched against relatively. It is recommended
|
|||
|
* to pass in a {@link WorkspaceFolder workspace folder} if the pattern should match inside the workspace.
|
|||
|
* Otherwise, a uri or string should only be used if the pattern is for a file path outside the workspace.
|
|||
|
* @param pattern A file glob pattern like `*.{ts,js}` that will be matched on paths relative to the base.
|
|||
|
*/
|
|||
|
constructor(base: WorkspaceFolder | Uri | string, pattern: string)
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Build buffer with lines and highlights
|
|||
|
*/
|
|||
|
export class Highlighter {
|
|||
|
constructor(srcId?: number)
|
|||
|
/**
|
|||
|
* Add a line with highlight group.
|
|||
|
*/
|
|||
|
addLine(line: string, hlGroup?: string): void
|
|||
|
/**
|
|||
|
* Add lines without highlights.
|
|||
|
*/
|
|||
|
addLines(lines: string[]): void
|
|||
|
/**
|
|||
|
* Add text with highlight.
|
|||
|
*/
|
|||
|
addText(text: string, hlGroup?: string): void
|
|||
|
/**
|
|||
|
* Get line count
|
|||
|
*/
|
|||
|
get length(): number
|
|||
|
/**
|
|||
|
* Render lines to buffer at specified range.
|
|||
|
* Since notifications is used, use `nvim.pauseNotification` & `nvim.resumeNotification`
|
|||
|
* when you need to wait for the request finish.
|
|||
|
*
|
|||
|
* @param {Buffer} buffer
|
|||
|
* @param {number} start
|
|||
|
* @param {number} end
|
|||
|
* @returns {void}
|
|||
|
*/
|
|||
|
render(buffer: Buffer, start?: number, end?: number): void
|
|||
|
}
|
|||
|
|
|||
|
export interface ListConfiguration {
|
|||
|
get<T>(key: string, defaultValue?: T): T
|
|||
|
previousKey(): string
|
|||
|
nextKey(): string
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface ListActionOptions {
|
|||
|
/**
|
|||
|
* No prompt stop and window switch when invoked.
|
|||
|
*/
|
|||
|
persist?: boolean
|
|||
|
/**
|
|||
|
* Reload list after action invoked.
|
|||
|
*/
|
|||
|
reload?: boolean
|
|||
|
/**
|
|||
|
* Support multiple items as execute argument.
|
|||
|
*/
|
|||
|
parallel?: boolean
|
|||
|
/**
|
|||
|
* Tab positioned list should be persisted (no window switch) on action invoke.
|
|||
|
*/
|
|||
|
tabPersist?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface CommandTaskOption {
|
|||
|
/**
|
|||
|
* Command to run.
|
|||
|
*/
|
|||
|
cmd: string
|
|||
|
/**
|
|||
|
* Arguments of command.
|
|||
|
*/
|
|||
|
args: string[]
|
|||
|
/**
|
|||
|
* Current working directory.
|
|||
|
*/
|
|||
|
cwd?: string
|
|||
|
env?: NodeJS.ProcessEnv
|
|||
|
/**
|
|||
|
* Runs for each line, return undefined for invalid item.
|
|||
|
*/
|
|||
|
onLine: (line: string) => ListItem | undefined
|
|||
|
}
|
|||
|
|
|||
|
export abstract class BasicList implements IList {
|
|||
|
/**
|
|||
|
* Unique name, must be provided by implementation class.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* Default action name invoked by <cr> by default, must be provided by implementation class.
|
|||
|
*/
|
|||
|
defaultAction: string
|
|||
|
/**
|
|||
|
* Registered actions.
|
|||
|
*/
|
|||
|
readonly actions: ListAction[]
|
|||
|
/**
|
|||
|
* Arguments configuration of list.
|
|||
|
*/
|
|||
|
options: ListArgument[]
|
|||
|
protected nvim: Neovim
|
|||
|
protected disposables: Disposable[]
|
|||
|
protected config: ListConfiguration
|
|||
|
constructor(nvim: Neovim)
|
|||
|
/**
|
|||
|
* Should align columns when true.
|
|||
|
*/
|
|||
|
get alignColumns(): boolean
|
|||
|
get hlGroup(): string
|
|||
|
get previewHeight(): string
|
|||
|
get splitRight(): boolean
|
|||
|
/**
|
|||
|
* Parse argument string array for argument object from `this.options`.
|
|||
|
* Could be used inside `this.loadItems()`
|
|||
|
*/
|
|||
|
protected parseArguments(args: string[]): { [key: string]: string | boolean }
|
|||
|
/**
|
|||
|
* Get configurations of current list
|
|||
|
*/
|
|||
|
protected getConfig(): WorkspaceConfiguration
|
|||
|
/**
|
|||
|
* Add an action
|
|||
|
*/
|
|||
|
protected addAction(name: string, fn: (item: ListItem, context: ListContext) => ProviderResult<void>, options?: ListActionOptions): void
|
|||
|
/**
|
|||
|
* Add action that support multiple selection.
|
|||
|
*/
|
|||
|
protected addMultipleAction(name: string, fn: (item: ListItem[], context: ListContext) => ProviderResult<void>, options?: ListActionOptions): void
|
|||
|
/**
|
|||
|
* Create task from command task option.
|
|||
|
*/
|
|||
|
protected createCommandTask(opt: CommandTaskOption): ListTask
|
|||
|
/**
|
|||
|
* Add location related actions, should be called in constructor.
|
|||
|
*/
|
|||
|
protected addLocationActions(): void
|
|||
|
protected convertLocation(location: Location | LocationWithLine | string): Promise<Location>
|
|||
|
/**
|
|||
|
* Jump to location
|
|||
|
*
|
|||
|
* @method
|
|||
|
*/
|
|||
|
protected jumpTo(location: Location | LocationWithLine | string, command?: string): Promise<void>
|
|||
|
/**
|
|||
|
* Preview location.
|
|||
|
*
|
|||
|
* @method
|
|||
|
*/
|
|||
|
protected previewLocation(location: Location, context: ListContext): Promise<void>
|
|||
|
/**
|
|||
|
* Preview lines.
|
|||
|
*
|
|||
|
* @method
|
|||
|
*/
|
|||
|
protected preview(options: PreviewOptions, context: ListContext): Promise<void>
|
|||
|
/**
|
|||
|
* Use for syntax highlights, invoked after buffer loaded.
|
|||
|
*/
|
|||
|
doHighlight(): void
|
|||
|
/**
|
|||
|
* Invoked for listItems or listTask, could throw error when failed to load.
|
|||
|
*/
|
|||
|
abstract loadItems(context: ListContext, token?: CancellationToken): Promise<ListItem[] | ListTask | null | undefined>
|
|||
|
}
|
|||
|
|
|||
|
export class Mutex {
|
|||
|
/**
|
|||
|
* Returns true when task is running.
|
|||
|
*/
|
|||
|
get busy(): boolean
|
|||
|
/**
|
|||
|
* Resolved release function that must be called after task finish.
|
|||
|
*/
|
|||
|
acquire(): Promise<() => void>
|
|||
|
/**
|
|||
|
* Captrue the async task function that ensures to be executed one by one.
|
|||
|
*/
|
|||
|
use<T>(f: () => Promise<T>): Promise<T>
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// functions {{
|
|||
|
|
|||
|
export interface AnsiItem {
|
|||
|
foreground?: string
|
|||
|
background?: string
|
|||
|
bold?: boolean
|
|||
|
italic?: boolean
|
|||
|
underline?: boolean
|
|||
|
text: string
|
|||
|
}
|
|||
|
|
|||
|
export interface ParsedUrlQueryInput {
|
|||
|
[key: string]: unknown
|
|||
|
}
|
|||
|
|
|||
|
export interface FetchOptions {
|
|||
|
/**
|
|||
|
* Default to 'GET'
|
|||
|
*/
|
|||
|
method?: string
|
|||
|
/**
|
|||
|
* Default no timeout
|
|||
|
*/
|
|||
|
timeout?: number
|
|||
|
/**
|
|||
|
* Always return buffer instead of parsed response.
|
|||
|
*/
|
|||
|
buffer?: boolean
|
|||
|
/**
|
|||
|
* Data send to server.
|
|||
|
*/
|
|||
|
data?: string | { [key: string]: any } | Buffer
|
|||
|
/**
|
|||
|
* Plain object added as query of url
|
|||
|
*/
|
|||
|
query?: ParsedUrlQueryInput
|
|||
|
headers?: any
|
|||
|
/**
|
|||
|
* User for http basic auth, should use with password
|
|||
|
*/
|
|||
|
user?: string
|
|||
|
/**
|
|||
|
* Password for http basic auth, should use with user
|
|||
|
*/
|
|||
|
password?: string
|
|||
|
}
|
|||
|
|
|||
|
export interface DownloadOptions extends Omit<FetchOptions, 'buffer'> {
|
|||
|
/**
|
|||
|
* Folder that contains downloaded file or extracted files by untar or unzip
|
|||
|
*/
|
|||
|
dest: string
|
|||
|
/**
|
|||
|
* Remove the specified number of leading path elements for *untar* only, default to `1`.
|
|||
|
*/
|
|||
|
strip?: number
|
|||
|
/**
|
|||
|
* If true, use untar for `.tar.gz` filename
|
|||
|
*/
|
|||
|
extract?: boolean | 'untar' | 'unzip'
|
|||
|
onProgress?: (percent: string) => void
|
|||
|
}
|
|||
|
|
|||
|
export type ResponseResult = string | Buffer | {
|
|||
|
[name: string]: any
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Parse ansi result from string contains ansi characters.
|
|||
|
*/
|
|||
|
export function ansiparse(str: string): AnsiItem[]
|
|||
|
|
|||
|
/**
|
|||
|
* Send request to server for response, supports:
|
|||
|
*
|
|||
|
* - Send json data and parse json response.
|
|||
|
* - Throw error for failed response statusCode.
|
|||
|
* - Timeout support (no timeout by default).
|
|||
|
* - Send buffer (as data) and receive data (as response).
|
|||
|
* - Proxy support from user configuration & environment.
|
|||
|
* - Redirect support, limited to 3.
|
|||
|
* - Support of gzip & deflate response content.
|
|||
|
*
|
|||
|
* @return Parsed object if response content type is application/json, text if content type starts with `text/`
|
|||
|
*/
|
|||
|
export function fetch(url: string, options?: FetchOptions, token?: CancellationToken): Promise<ResponseResult>
|
|||
|
|
|||
|
/**
|
|||
|
* Download file from url, with optional untar/unzip support.
|
|||
|
*
|
|||
|
* Note: you may need to set `strip` to 0 when using untar as extract method.
|
|||
|
*
|
|||
|
* @param {string} url
|
|||
|
* @param {DownloadOptions} options contains dest folder and optional onProgress callback
|
|||
|
*/
|
|||
|
export function download(url: string, options: DownloadOptions, token?: CancellationToken): Promise<string>
|
|||
|
|
|||
|
interface ExecOptions {
|
|||
|
cwd?: string
|
|||
|
env?: NodeJS.ProcessEnv
|
|||
|
shell?: string
|
|||
|
timeout?: number
|
|||
|
maxBuffer?: number
|
|||
|
killSignal?: string
|
|||
|
uid?: number
|
|||
|
gid?: number
|
|||
|
windowsHide?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Dispose all disposables.
|
|||
|
*/
|
|||
|
export function disposeAll(disposables: Disposable[]): void
|
|||
|
|
|||
|
/**
|
|||
|
* Concurrent run async functions with limit support.
|
|||
|
*/
|
|||
|
export function concurrent<T>(arr: T[], fn: (val: T) => Promise<void>, limit?: number): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Create promise resolved after ms milliseconds.
|
|||
|
*/
|
|||
|
export function wait(ms: number): Promise<any>
|
|||
|
|
|||
|
/**
|
|||
|
* Run command with `child_process.exec`
|
|||
|
*/
|
|||
|
export function runCommand(cmd: string, opts?: ExecOptions, timeout?: number): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Check if process with pid is running
|
|||
|
*/
|
|||
|
export function isRunning(pid: number): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Check if command is executable.
|
|||
|
*/
|
|||
|
export function executable(command: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Watch single file for change, the filepath needs to be exists file.
|
|||
|
*
|
|||
|
* @param filepath Full path of file.
|
|||
|
* @param onChange Handler on file change detected.
|
|||
|
*/
|
|||
|
export function watchFile(filepath: string, onChange: () => void): Disposable
|
|||
|
// }}
|
|||
|
|
|||
|
// commands module {{
|
|||
|
export interface CommandItem {
|
|||
|
id: string
|
|||
|
internal?: boolean
|
|||
|
execute(...args: any[]): any
|
|||
|
}
|
|||
|
/**
|
|||
|
* Namespace for dealing with commands of coc.nvim
|
|||
|
*/
|
|||
|
export namespace commands {
|
|||
|
/**
|
|||
|
* Registered commands.
|
|||
|
*/
|
|||
|
export const commandList: CommandItem[]
|
|||
|
|
|||
|
/**
|
|||
|
* Execute specified command.
|
|||
|
*
|
|||
|
* @deprecated use `executeCommand()` instead.
|
|||
|
*/
|
|||
|
export function execute(command: { name: string, arguments?: any[] }): void
|
|||
|
|
|||
|
/**
|
|||
|
* Check if command is registered.
|
|||
|
*
|
|||
|
* @param id Unique id of command.
|
|||
|
*/
|
|||
|
export function has(id: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Registers a command that can be invoked via a keyboard shortcut,
|
|||
|
* a menu item, an action, or directly.
|
|||
|
*
|
|||
|
* Registering a command with an existing command identifier twice
|
|||
|
* will cause an error.
|
|||
|
*
|
|||
|
* @param command A unique identifier for the command.
|
|||
|
* @param impl A command handler function.
|
|||
|
* @param thisArg The `this` context used when invoking the handler function.
|
|||
|
* @return Disposable which unregisters this command on disposal.
|
|||
|
*/
|
|||
|
export function registerCommand(id: string, impl: (...args: any[]) => void, thisArg?: any, internal?: boolean): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Executes the command denoted by the given command identifier.
|
|||
|
*
|
|||
|
* * *Note 1:* When executing an editor command not all types are allowed to
|
|||
|
* be passed as arguments. Allowed are the primitive types `string`, `boolean`,
|
|||
|
* `number`, `undefined`, and `null`, as well as [`Position`](#Position), [`Range`](#Range), [`URI`](#URI) and [`Location`](#Location).
|
|||
|
* * *Note 2:* There are no restrictions when executing commands that have been contributed
|
|||
|
* by extensions.
|
|||
|
*
|
|||
|
* @param command Identifier of the command to execute.
|
|||
|
* @param rest Parameters passed to the command function.
|
|||
|
* @return A promise that resolves to the returned value of the given command. `undefined` when
|
|||
|
* the command handler function doesn't return anything.
|
|||
|
*/
|
|||
|
export function executeCommand<T>(command: string, ...rest: any[]): Promise<T>
|
|||
|
|
|||
|
/**
|
|||
|
* Open uri with external tool, use `open` on mac, use `xdg-open` on linux.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'vscode.open', uri: string | Uri): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Reload current buffer by `:edit` command.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'workbench.action.reloadWindow'): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Insert snippet at range of current buffer.
|
|||
|
*
|
|||
|
* @param edit Contains snippet text and range to replace.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.insertSnippet', edit: TextEdit, ultisnip?: UltiSnippetOption): Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Invoke specified code action.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.doCodeAction', action: CodeAction): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Trigger coc.nvim's completion at current cursor position.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.triggerSuggest'): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Trigger signature help at current cursor position.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.triggerParameterHints'): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Add ranges to cursors session for multiple cursors.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.addRanges', ranges: Range[]): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Restart coc.nvim service by `:CocRestart` command.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.restart'): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Show locations by location list or vim's quickfix list.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.showReferences', filepath: string | undefined, position: Position | undefined, locations: Location[]): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Invoke rename action at position of specified uri.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.rename', uri: string, position: Position): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Run format action for current buffer.
|
|||
|
*/
|
|||
|
export function executeCommand(command: 'editor.action.format'): Promise<void>
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// events module {{
|
|||
|
type EventResult = void | Promise<void>
|
|||
|
type MoveEvents = 'CursorMoved' | 'CursorMovedI' | 'CursorHold' | 'CursorHoldI'
|
|||
|
type BufEvents = 'BufHidden' | 'BufEnter' | 'BufWritePost'
|
|||
|
| 'InsertLeave' | 'TermOpen' | 'InsertEnter'
|
|||
|
| 'BufCreate' | 'BufUnload' | 'BufWritePre' | 'Enter'
|
|||
|
type EmptyEvents = 'FocusGained' | 'FocusLost' | 'InsertSnippet'
|
|||
|
type InsertChangeEvents = 'TextChangedP' | 'TextChangedI'
|
|||
|
type TaskEvents = 'TaskExit' | 'TaskStderr' | 'TaskStdout'
|
|||
|
type WindowEvents = 'WinLeave' | 'WinEnter'
|
|||
|
type AllEvents = BufEvents | EmptyEvents | MoveEvents | TaskEvents | WindowEvents | InsertChangeEvents | 'CompleteDone' | 'TextChanged' | 'MenuPopupChanged' | 'InsertCharPre' | 'FileType' | 'BufWinEnter' | 'BufWinLeave' | 'VimResized' | 'DirChanged' | 'OptionSet' | 'Command' | 'BufReadCmd' | 'GlobalChange' | 'InputChar' | 'WinLeave' | 'MenuInput' | 'PromptInsert' | 'FloatBtnClick' | 'InsertSnippet' | 'PromptKeyPress'
|
|||
|
type OptionValue = string | number | boolean
|
|||
|
type PromptWidowKeys = 'C-j' | 'C-k' | 'C-n' | 'C-p' | 'up' | 'down'
|
|||
|
|
|||
|
export interface CursorPosition {
|
|||
|
readonly bufnr: number
|
|||
|
readonly lnum: number
|
|||
|
readonly col: number
|
|||
|
readonly insert: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface InsertChange {
|
|||
|
/**
|
|||
|
* 1 based line number
|
|||
|
*/
|
|||
|
readonly lnum: number
|
|||
|
/**
|
|||
|
* 1 based column number
|
|||
|
*/
|
|||
|
readonly col: number
|
|||
|
/**
|
|||
|
* Text before cursor.
|
|||
|
*/
|
|||
|
readonly pre: string
|
|||
|
/**
|
|||
|
* Insert character that cause change of this time.
|
|||
|
*/
|
|||
|
readonly insertChar: string | undefined
|
|||
|
readonly changedtick: number
|
|||
|
}
|
|||
|
|
|||
|
export interface PopupChangeEvent {
|
|||
|
readonly completed_item: VimCompleteItem
|
|||
|
readonly height: number
|
|||
|
readonly width: number
|
|||
|
readonly row: number
|
|||
|
readonly col: number
|
|||
|
readonly size: number
|
|||
|
readonly scrollbar: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Used for listen to events send from vim.
|
|||
|
*/
|
|||
|
export namespace events {
|
|||
|
/**
|
|||
|
* Latest cursor position.
|
|||
|
*/
|
|||
|
export const cursor: Readonly<CursorPosition>
|
|||
|
/**
|
|||
|
* Latest pum position, is true when pum positioned above current line.
|
|||
|
*/
|
|||
|
export const pumAlignTop: boolean
|
|||
|
/**
|
|||
|
* Insert mode detected by latest events.
|
|||
|
*/
|
|||
|
export const insertMode: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Popup menu is visible.
|
|||
|
*/
|
|||
|
export const pumvisible: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Wait for any of event in events to fire, resolve undefined when timeout or CancellationToken requested.
|
|||
|
* @param events Event names to wait.
|
|||
|
* @param timeoutOrToken Timeout in miniseconds or CancellationToken.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function race(events: AllEvents[], timeoutOrToken?: number | CancellationToken): Promise<{ name: AllEvents, args: unknown[] } | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Attach handler to buffer events.
|
|||
|
*/
|
|||
|
export function on(event: BufEvents, handler: (bufnr: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Attach handler to mouse move events.
|
|||
|
*/
|
|||
|
export function on(event: MoveEvents, handler: (bufnr: number, cursor: [number, number]) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Attach handler to TextChangedI or TextChangedP.
|
|||
|
*/
|
|||
|
export function on(event: InsertChangeEvents, handler: (bufnr: number, info: InsertChange) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Attach handler to window event.
|
|||
|
*/
|
|||
|
export function on(event: WindowEvents, handler: (winid: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Attach handler to float button click.
|
|||
|
*/
|
|||
|
export function on(event: 'FloatBtnClick', handler: (bufnr: number, index: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Attach handler to keypress in prompt window.
|
|||
|
* Key could only be 'C-j', 'C-k', 'C-n', 'C-p', 'up' and 'down'
|
|||
|
*/
|
|||
|
export function on(event: 'PromptKeyPress', handler: (bufnr: number, key: PromptWidowKeys) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Fired on vim's TextChanged event.
|
|||
|
*/
|
|||
|
export function on(event: 'TextChanged', handler: (bufnr: number, changedtick: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'TaskExit', handler: (id: string, code: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'TaskStderr' | 'TaskStdout', handler: (id: string, lines: string[]) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Fired on vim's BufReadCmd event.
|
|||
|
*/
|
|||
|
export function on(event: 'BufReadCmd', handler: (scheme: string, fullpath: string) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
/**
|
|||
|
* Fired on vim's VimResized event.
|
|||
|
*/
|
|||
|
export function on(event: 'VimResized', handler: (columns: number, lines: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'MenuPopupChanged', handler: (event: PopupChangeEvent, cursorline: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'CompleteDone', handler: (item: VimCompleteItem) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'InsertCharPre', handler: (character: string) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'FileType', handler: (filetype: string, bufnr: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'BufWinEnter' | 'BufWinLeave', handler: (bufnr: number, winid: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'DirChanged', handler: (cwd: string) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'OptionSet' | 'GlobalChange', handler: (option: string, oldVal: OptionValue, newVal: OptionValue) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'InputChar', handler: (session: string, character: string, mode: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'PromptInsert', handler: (value: string, bufnr: number) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
export function on(event: 'Command', handler: (name: string) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Fired after user insert character and made change to the buffer.
|
|||
|
* Fired after TextChangedI & TextChangedP event.
|
|||
|
*/
|
|||
|
export function on(event: 'TextInsert', handler: (bufnr: number, info: InsertChange, character: string) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
|
|||
|
export function on(event: EmptyEvents, handler: () => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
|
|||
|
export function on(event: AllEvents[], handler: (...args: unknown[]) => EventResult, thisArg?: any, disposables?: Disposable[]): Disposable
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// file events {{
|
|||
|
/**
|
|||
|
* An event that is fired after files are created.
|
|||
|
*/
|
|||
|
export interface FileCreateEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* The files that got created.
|
|||
|
*/
|
|||
|
readonly files: ReadonlyArray<Uri>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An event that is fired when files are going to be created.
|
|||
|
*
|
|||
|
* To make modifications to the workspace before the files are created,
|
|||
|
* call the [`waitUntil](#FileWillCreateEvent.waitUntil)-function with a
|
|||
|
* thenable that resolves to a [workspace edit](#WorkspaceEdit).
|
|||
|
*/
|
|||
|
export interface FileWillCreateEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* A cancellation token.
|
|||
|
*/
|
|||
|
readonly token: CancellationToken
|
|||
|
|
|||
|
/**
|
|||
|
* The files that are going to be created.
|
|||
|
*/
|
|||
|
readonly files: ReadonlyArray<Uri>
|
|||
|
|
|||
|
/**
|
|||
|
* Allows to pause the event and to apply a [workspace edit](#WorkspaceEdit).
|
|||
|
*
|
|||
|
* *Note:* This function can only be called during event dispatch and not
|
|||
|
* in an asynchronous manner:
|
|||
|
*
|
|||
|
* ```ts
|
|||
|
* workspace.onWillCreateFiles(event => {
|
|||
|
* // async, will *throw* an error
|
|||
|
* setTimeout(() => event.waitUntil(promise));
|
|||
|
*
|
|||
|
* // sync, OK
|
|||
|
* event.waitUntil(promise);
|
|||
|
* })
|
|||
|
* ```
|
|||
|
*
|
|||
|
* @param thenable A thenable that delays saving.
|
|||
|
*/
|
|||
|
waitUntil(thenable: Thenable<WorkspaceEdit | any>): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An event that is fired when files are going to be deleted.
|
|||
|
*
|
|||
|
* To make modifications to the workspace before the files are deleted,
|
|||
|
* call the [`waitUntil](#FileWillCreateEvent.waitUntil)-function with a
|
|||
|
* thenable that resolves to a [workspace edit](#WorkspaceEdit).
|
|||
|
*/
|
|||
|
export interface FileWillDeleteEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* The files that are going to be deleted.
|
|||
|
*/
|
|||
|
readonly files: ReadonlyArray<Uri>
|
|||
|
|
|||
|
/**
|
|||
|
* Allows to pause the event and to apply a [workspace edit](#WorkspaceEdit).
|
|||
|
*
|
|||
|
* *Note:* This function can only be called during event dispatch and not
|
|||
|
* in an asynchronous manner:
|
|||
|
*
|
|||
|
* ```ts
|
|||
|
* workspace.onWillCreateFiles(event => {
|
|||
|
* // async, will *throw* an error
|
|||
|
* setTimeout(() => event.waitUntil(promise));
|
|||
|
*
|
|||
|
* // sync, OK
|
|||
|
* event.waitUntil(promise);
|
|||
|
* })
|
|||
|
* ```
|
|||
|
*
|
|||
|
* @param thenable A thenable that delays saving.
|
|||
|
*/
|
|||
|
waitUntil(thenable: Thenable<WorkspaceEdit | any>): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An event that is fired after files are deleted.
|
|||
|
*/
|
|||
|
export interface FileDeleteEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* The files that got deleted.
|
|||
|
*/
|
|||
|
readonly files: ReadonlyArray<Uri>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An event that is fired after files are renamed.
|
|||
|
*/
|
|||
|
export interface FileRenameEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* The files that got renamed.
|
|||
|
*/
|
|||
|
readonly files: ReadonlyArray<{ oldUri: Uri, newUri: Uri }>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An event that is fired when files are going to be renamed.
|
|||
|
*
|
|||
|
* To make modifications to the workspace before the files are renamed,
|
|||
|
* call the [`waitUntil](#FileWillCreateEvent.waitUntil)-function with a
|
|||
|
* thenable that resolves to a [workspace edit](#WorkspaceEdit).
|
|||
|
*/
|
|||
|
export interface FileWillRenameEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* The files that are going to be renamed.
|
|||
|
*/
|
|||
|
readonly files: ReadonlyArray<{ oldUri: Uri, newUri: Uri }>
|
|||
|
|
|||
|
/**
|
|||
|
* Allows to pause the event and to apply a [workspace edit](#WorkspaceEdit).
|
|||
|
*
|
|||
|
* *Note:* This function can only be called during event dispatch and not
|
|||
|
* in an asynchronous manner:
|
|||
|
*
|
|||
|
* ```ts
|
|||
|
* workspace.onWillCreateFiles(event => {
|
|||
|
* // async, will *throw* an error
|
|||
|
* setTimeout(() => event.waitUntil(promise));
|
|||
|
*
|
|||
|
* // sync, OK
|
|||
|
* event.waitUntil(promise);
|
|||
|
* })
|
|||
|
* ```
|
|||
|
*
|
|||
|
* @param thenable A thenable that delays saving.
|
|||
|
*/
|
|||
|
waitUntil(thenable: Thenable<WorkspaceEdit | any>): void
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// languages module {{
|
|||
|
export interface DocumentSymbolProviderMetadata {
|
|||
|
/**
|
|||
|
* A human-readable string that is shown when multiple outlines trees show for one document.
|
|||
|
*/
|
|||
|
label?: string
|
|||
|
}
|
|||
|
|
|||
|
export namespace languages {
|
|||
|
/**
|
|||
|
* Create a diagnostics collection.
|
|||
|
*
|
|||
|
* @param name The [name](#DiagnosticCollection.name) of the collection.
|
|||
|
* @return A new diagnostic collection.
|
|||
|
*/
|
|||
|
export function createDiagnosticCollection(name?: string): DiagnosticCollection
|
|||
|
|
|||
|
/**
|
|||
|
* Register a formatting provider that works on type. The provider is active when the user enables the setting `coc.preferences.formatOnType`.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their [score](#languages.match) and the best-matching provider is used. Failure
|
|||
|
* of the selected provider will cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider An on type formatting edit provider.
|
|||
|
* @param triggerCharacters Trigger character that should trigger format on type.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerOnTypeFormattingEditProvider(selector: DocumentSelector, provider: OnTypeFormattingEditProvider, triggerCharacters: string[]): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a completion provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their [score](#languages.match) and groups of equal score are sequentially asked for
|
|||
|
* completion items. The process stops when one or many providers of a group return a
|
|||
|
* result. A failing provider (rejected promise or exception) will not fail the whole
|
|||
|
* operation.
|
|||
|
*
|
|||
|
* A completion item provider can be associated with a set of `triggerCharacters`. When trigger
|
|||
|
* characters are being typed, completions are requested but only from providers that registered
|
|||
|
* the typed character. Because of that trigger characters should be different than [word characters](#LanguageConfiguration.wordPattern),
|
|||
|
* a common trigger character is `.` to trigger member completions.
|
|||
|
*
|
|||
|
* @param name Name of completion source.
|
|||
|
* @param shortcut Shortcut used in completion menu.
|
|||
|
* @param selector Document selector of created completion source.
|
|||
|
* @param provider A completion provider.
|
|||
|
* @param triggerCharacters Trigger completion when the user types one of the characters.
|
|||
|
* @param priority Higher priority would shown first.
|
|||
|
* @param allCommitCharacters Commit characters of completion source.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerCompletionItemProvider(name: string, shortcut: string, selector: DocumentSelector | null, provider: CompletionItemProvider, triggerCharacters?: string[], priority?: number, allCommitCharacters?: string[]): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a code action provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A code action provider.
|
|||
|
* @param clientId Optional id of language client.
|
|||
|
* @param codeActionKinds Optional supported code action kinds.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerCodeActionProvider(selector: DocumentSelector, provider: CodeActionProvider, clientId: string | undefined, codeActionKinds?: string[]): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a hover provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A hover provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerHoverProvider(selector: DocumentSelector, provider: HoverProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a selection range provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A selection range provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerSelectionRangeProvider(selector: DocumentSelector, provider: SelectionRangeProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a signature help provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their [score](#languages.match) and called sequentially until a provider returns a
|
|||
|
* valid result.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A signature help provider.
|
|||
|
* @param triggerCharacters Trigger signature help when the user types one of the characters, like `,` or `(`.
|
|||
|
* @param metadata Information about the provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerSignatureHelpProvider(selector: DocumentSelector, provider: SignatureHelpProvider, triggerCharacters?: string[]): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a document symbol provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers only first provider
|
|||
|
* are asked for result.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A document symbol provider.
|
|||
|
* @param metadata Optional meta data.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentSymbolProvider(selector: DocumentSelector, provider: DocumentSymbolProvider, metadata?: DocumentSymbolProviderMetadata): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a folding range provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers only first provider
|
|||
|
* are asked for result.
|
|||
|
*
|
|||
|
* A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A folding range provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerFoldingRangeProvider(selector: DocumentSelector, provider: FoldingRangeProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a document highlight provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their [score](#languages.match) and groups sequentially asked for document highlights.
|
|||
|
* The process stops when a provider returns a `non-falsy` or `non-failure` result.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A document highlight provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentHighlightProvider(selector: DocumentSelector, provider: any): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a code lens provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A code lens provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerCodeLensProvider(selector: DocumentSelector, provider: CodeLensProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a document link provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A document link provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentLinkProvider(selector: DocumentSelector, provider: DocumentLinkProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a color provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A color provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentColorProvider(selector: DocumentSelector, provider: DocumentColorProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a definition provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A definition provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDefinitionProvider(selector: DocumentSelector, provider: DefinitionProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a declaration provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A declaration provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDeclarationProvider(selector: DocumentSelector, provider: DeclarationProvider): Disposable
|
|||
|
|
|||
|
|
|||
|
/**
|
|||
|
* Register a type definition provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A type definition provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerTypeDefinitionProvider(selector: DocumentSelector, provider: TypeDefinitionProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register an implementation provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider An implementation provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerImplementationProvider(selector: DocumentSelector, provider: ImplementationProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a reference provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A reference provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerReferencesProvider(selector: DocumentSelector, provider: ReferenceProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a rename provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their [score](#workspace.match) and asked in sequence. The first provider producing a result
|
|||
|
* defines the result of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A rename provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerRenameProvider(selector: DocumentSelector, provider: RenameProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a workspace symbol provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered. In that case providers are asked in parallel and
|
|||
|
* the results are merged. A failing provider (rejected promise or exception) will not cause
|
|||
|
* a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param provider A workspace symbol provider.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerWorkspaceSymbolProvider(provider: WorkspaceSymbolProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a formatting provider for a document.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their priority. Failure of the selected provider will cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A document formatting edit provider.
|
|||
|
* @param priority default to 0.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentFormatProvider(selector: DocumentSelector, provider: DocumentFormattingEditProvider, priority?: number): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a formatting provider for a document range.
|
|||
|
*
|
|||
|
* *Note:* A document range provider is also a [document formatter](#DocumentFormattingEditProvider)
|
|||
|
* which means there is no need to [register](#languages.registerDocumentFormattingEditProvider) a document
|
|||
|
* formatter when also registering a range provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case provider with highest priority is used.
|
|||
|
* Failure of the selected provider will cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A document range formatting edit provider.
|
|||
|
* @param priority default to 0.
|
|||
|
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentRangeFormatProvider(selector: DocumentSelector, provider: DocumentRangeFormattingEditProvider, priority?: number): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a call hierarchy provider.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A call hierarchy provider.
|
|||
|
* @return A {@link Disposable} that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerCallHierarchyProvider(selector: DocumentSelector, provider: CallHierarchyProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a semantic tokens provider for a whole document.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their {@link languages.match score} and the best-matching provider is used. Failure
|
|||
|
* of the selected provider will cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A document semantic tokens provider.
|
|||
|
* @return A {@link Disposable} that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentSemanticTokensProvider(selector: DocumentSelector, provider: DocumentSemanticTokensProvider, legend: SemanticTokensLegend): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a semantic tokens provider for a document range.
|
|||
|
*
|
|||
|
* *Note:* If a document has both a `DocumentSemanticTokensProvider` and a `DocumentRangeSemanticTokensProvider`,
|
|||
|
* the range provider will be invoked only initially, for the time in which the full document provider takes
|
|||
|
* to resolve the first request. Once the full document provider resolves the first request, the semantic tokens
|
|||
|
* provided via the range provider will be discarded and from that point forward, only the document provider
|
|||
|
* will be used.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their {@link languages.match score} and the best-matching provider is used. Failure
|
|||
|
* of the selected provider will cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A document range semantic tokens provider.
|
|||
|
* @return A {@link Disposable} that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerDocumentRangeSemanticTokensProvider(selector: DocumentSelector, provider: DocumentRangeSemanticTokensProvider, legend: SemanticTokensLegend): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a linked editing range provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are sorted
|
|||
|
* by their {@link languages.match score} and the best-matching provider that has a result is used. Failure
|
|||
|
* of the selected provider will cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider A linked editing range provider.
|
|||
|
* @return A {@link Disposable} that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerLinkedEditingRangeProvider(selector: DocumentSelector, provider: LinkedEditingRangeProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register a inlay hints provider.
|
|||
|
*
|
|||
|
* Multiple providers can be registered for a language. In that case providers are asked in
|
|||
|
* parallel and the results are merged. A failing provider (rejected promise or exception) will
|
|||
|
* not cause a failure of the whole operation.
|
|||
|
*
|
|||
|
* @param selector A selector that defines the documents this provider is applicable to.
|
|||
|
* @param provider An inlay hints provider.
|
|||
|
* @return A {@link Disposable} that unregisters this provider when being disposed.
|
|||
|
*/
|
|||
|
export function registerInlayHintsProvider(selector: DocumentSelector, provider: InlayHintsProvider): Disposable
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// services module {{
|
|||
|
export enum ServiceStat {
|
|||
|
Initial,
|
|||
|
Starting,
|
|||
|
StartFailed,
|
|||
|
Running,
|
|||
|
Stopping,
|
|||
|
Stopped,
|
|||
|
}
|
|||
|
|
|||
|
export interface IServiceProvider {
|
|||
|
// unique service id
|
|||
|
id: string
|
|||
|
name: string
|
|||
|
client?: LanguageClient
|
|||
|
selector: DocumentSelector
|
|||
|
// current state
|
|||
|
state: ServiceStat
|
|||
|
start(): Promise<void>
|
|||
|
dispose(): void
|
|||
|
stop(): Promise<void> | void
|
|||
|
restart(): Promise<void> | void
|
|||
|
onServiceReady: Event<void>
|
|||
|
}
|
|||
|
|
|||
|
export namespace services {
|
|||
|
/**
|
|||
|
* Register languageClient as service provider.
|
|||
|
*/
|
|||
|
export function registLanguageClient(client: LanguageClient): Disposable
|
|||
|
/**
|
|||
|
* Register service, nothing happens when `service.id` already exists.
|
|||
|
*/
|
|||
|
export function regist(service: IServiceProvider): Disposable
|
|||
|
/**
|
|||
|
* Get service by id.
|
|||
|
*/
|
|||
|
export function getService(id: string): IServiceProvider
|
|||
|
/**
|
|||
|
* Stop service by id.
|
|||
|
*/
|
|||
|
export function stop(id: string): Promise<void>
|
|||
|
/**
|
|||
|
* Stop running service or start stopped service.
|
|||
|
*/
|
|||
|
export function toggle(id: string): Promise<void>
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// sources module {{
|
|||
|
/**
|
|||
|
* Source options to create source that could respect configuration from `coc.source.{name}`
|
|||
|
*/
|
|||
|
export type SourceConfig = Omit<ISource, 'shortcut' | 'priority' | 'triggerOnly' | 'triggerCharacters' | 'triggerPatterns' | 'enable' | 'filetypes' | 'disableSyntaxes'>
|
|||
|
|
|||
|
export interface SourceStat {
|
|||
|
name: string
|
|||
|
priority: number
|
|||
|
triggerCharacters: string[]
|
|||
|
type: 'native' | 'remote' | 'service'
|
|||
|
shortcut: string
|
|||
|
filepath: string
|
|||
|
disabled: boolean
|
|||
|
filetypes: string[]
|
|||
|
}
|
|||
|
|
|||
|
export enum SourceType {
|
|||
|
Native,
|
|||
|
Remote,
|
|||
|
Service,
|
|||
|
}
|
|||
|
|
|||
|
export interface CompleteResult {
|
|||
|
items: VimCompleteItem[]
|
|||
|
isIncomplete?: boolean
|
|||
|
startcol?: number
|
|||
|
source?: string
|
|||
|
priority?: number
|
|||
|
}
|
|||
|
|
|||
|
// option on complete & should_complete
|
|||
|
export interface CompleteOption {
|
|||
|
/**
|
|||
|
* Current buffer number.
|
|||
|
*/
|
|||
|
readonly bufnr: number
|
|||
|
/**
|
|||
|
* Current line.
|
|||
|
*/
|
|||
|
readonly line: string
|
|||
|
/**
|
|||
|
* Column to start completion, determined by iskeyword options of buffer.
|
|||
|
*/
|
|||
|
readonly col: number
|
|||
|
/**
|
|||
|
* Input text.
|
|||
|
*/
|
|||
|
readonly input: string
|
|||
|
readonly filetype: string
|
|||
|
readonly filepath: string
|
|||
|
/**
|
|||
|
* Word under cursor.
|
|||
|
*/
|
|||
|
readonly word: string
|
|||
|
/**
|
|||
|
* Trigger character, could be empty string.
|
|||
|
*/
|
|||
|
readonly triggerCharacter: string
|
|||
|
/**
|
|||
|
* Col of cursor, 1 based.
|
|||
|
*/
|
|||
|
readonly colnr: number
|
|||
|
readonly linenr: number
|
|||
|
readonly synname: string
|
|||
|
/**
|
|||
|
* Black list words specified by user.
|
|||
|
*/
|
|||
|
readonly blacklist: string[]
|
|||
|
/**
|
|||
|
* Buffer changetick
|
|||
|
*/
|
|||
|
readonly changedtick: number
|
|||
|
/**
|
|||
|
* Is trigger for in complete completion.
|
|||
|
*/
|
|||
|
readonly triggerForInComplete?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface ISource {
|
|||
|
/**
|
|||
|
* Identifier name
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* @deprecated use documentSelector instead.
|
|||
|
*/
|
|||
|
filetypes?: string[]
|
|||
|
/**
|
|||
|
* Filters of document.
|
|||
|
*/
|
|||
|
documentSelector?: DocumentSelector
|
|||
|
enable?: boolean
|
|||
|
shortcut?: string
|
|||
|
priority?: number
|
|||
|
sourceType?: SourceType
|
|||
|
/**
|
|||
|
* Should only be used when completion is triggered, requirs `triggerPatterns` or `triggerCharacters` defined.
|
|||
|
*/
|
|||
|
triggerOnly?: boolean
|
|||
|
triggerCharacters?: string[]
|
|||
|
// regex to detect trigger completion, ignored when triggerCharacters exists.
|
|||
|
triggerPatterns?: RegExp[]
|
|||
|
disableSyntaxes?: string[]
|
|||
|
filepath?: string
|
|||
|
// should the first character always match
|
|||
|
firstMatch?: boolean
|
|||
|
refresh?(): Promise<void>
|
|||
|
/**
|
|||
|
* For disable/enable
|
|||
|
*/
|
|||
|
toggle?(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Triggered on BufEnter, used for cache normally
|
|||
|
*/
|
|||
|
onEnter?(bufnr: number): void
|
|||
|
|
|||
|
/**
|
|||
|
* Check if this source should doComplete
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @param {CompleteOption} opt
|
|||
|
* @returns {Promise<boolean> }
|
|||
|
*/
|
|||
|
shouldComplete?(opt: CompleteOption): Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Run completion
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @param {CompleteOption} opt
|
|||
|
* @param {CancellationToken} token
|
|||
|
* @returns {Promise<CompleteResult | null>}
|
|||
|
*/
|
|||
|
doComplete(opt: CompleteOption, token: CancellationToken): ProviderResult<CompleteResult>
|
|||
|
|
|||
|
/**
|
|||
|
* Action for complete item on complete item selected
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @param {VimCompleteItem} item
|
|||
|
* @param {CancellationToken} token
|
|||
|
* @returns {Promise<void>}
|
|||
|
*/
|
|||
|
onCompleteResolve?(item: VimCompleteItem, token: CancellationToken): ProviderResult<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Action for complete item on complete done
|
|||
|
*
|
|||
|
* @public
|
|||
|
* @param {VimCompleteItem} item
|
|||
|
* @returns {Promise<void>}
|
|||
|
*/
|
|||
|
onCompleteDone?(item: VimCompleteItem, opt: CompleteOption): ProviderResult<void>
|
|||
|
|
|||
|
shouldCommit?(item: VimCompleteItem, character: string): boolean
|
|||
|
}
|
|||
|
|
|||
|
export namespace sources {
|
|||
|
/**
|
|||
|
* Names of registered sources.
|
|||
|
*/
|
|||
|
export const names: ReadonlyArray<string>
|
|||
|
export const sources: ReadonlyArray<ISource>
|
|||
|
/**
|
|||
|
* Check if source exists by name.
|
|||
|
*/
|
|||
|
export function has(name: string): boolean
|
|||
|
/**
|
|||
|
* Get source by name.
|
|||
|
*/
|
|||
|
export function getSource(name: string): ISource | null
|
|||
|
|
|||
|
/**
|
|||
|
* Add source to sources list.
|
|||
|
*
|
|||
|
* Note: Use `sources.createSource()` for regist new source is recommended for
|
|||
|
* user configuration support.
|
|||
|
*/
|
|||
|
export function addSource(source: ISource): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Create source by source config, configurations starts with `coc.source.{name}`
|
|||
|
* are automatically supported.
|
|||
|
*
|
|||
|
* `name` and `doComplete()` must be provided in config.
|
|||
|
*/
|
|||
|
export function createSource(config: SourceConfig): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Get list of all source stats.
|
|||
|
*/
|
|||
|
export function sourceStats(): SourceStat[]
|
|||
|
|
|||
|
/**
|
|||
|
* Call refresh for _name_ source or all sources.
|
|||
|
*/
|
|||
|
export function refresh(name?: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Toggle state of _name_ source.
|
|||
|
*/
|
|||
|
export function toggleSource(name: string): void
|
|||
|
|
|||
|
/**
|
|||
|
* Remove source by name.
|
|||
|
*/
|
|||
|
export function removeSource(name: string): void
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// TreeView related {{
|
|||
|
export interface TreeItemLabel {
|
|||
|
label: string
|
|||
|
highlights?: [number, number][]
|
|||
|
}
|
|||
|
|
|||
|
export interface TreeItemIcon {
|
|||
|
text: string
|
|||
|
hlGroup: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Collapsible state of the tree item
|
|||
|
*/
|
|||
|
export enum TreeItemCollapsibleState {
|
|||
|
/**
|
|||
|
* Determines an item can be neither collapsed nor expanded. Implies it has no children.
|
|||
|
*/
|
|||
|
None = 0,
|
|||
|
/**
|
|||
|
* Determines an item is collapsed
|
|||
|
*/
|
|||
|
Collapsed = 1,
|
|||
|
/**
|
|||
|
* Determines an item is expanded
|
|||
|
*/
|
|||
|
Expanded = 2
|
|||
|
}
|
|||
|
|
|||
|
export class TreeItem {
|
|||
|
/**
|
|||
|
* A human-readable string describing this item. When `falsy`, it is derived from {@link TreeItem.resourceUri resourceUri}.
|
|||
|
*/
|
|||
|
label?: string | TreeItemLabel
|
|||
|
|
|||
|
/**
|
|||
|
* Description rendered less prominently after label.
|
|||
|
*/
|
|||
|
description?: string
|
|||
|
|
|||
|
/**
|
|||
|
* The icon path or {@link ThemeIcon} for the tree item.
|
|||
|
* When `falsy`, {@link ThemeIcon.Folder Folder Theme Icon} is assigned, if item is collapsible otherwise {@link ThemeIcon.File File Theme Icon}.
|
|||
|
* When a file or folder {@link ThemeIcon} is specified, icon is derived from the current file icon theme for the specified theme icon using {@link TreeItem.resourceUri resourceUri} (if provided).
|
|||
|
*/
|
|||
|
icon?: TreeItemIcon
|
|||
|
|
|||
|
/**
|
|||
|
* Optional id for the tree item that has to be unique across tree. The id is used to preserve the selection and expansion state of the tree item.
|
|||
|
*
|
|||
|
* If not provided, an id is generated using the tree item's resourceUri when exists. **Note** that when labels change, ids will change and that selection and expansion state cannot be kept stable anymore.
|
|||
|
*/
|
|||
|
id?: string
|
|||
|
|
|||
|
/**
|
|||
|
* The {@link Uri} of the resource representing this item.
|
|||
|
*
|
|||
|
* Will be used to derive the {@link TreeItem.label label}, when it is not provided.
|
|||
|
* Will be used to derive the icon from current file icon theme, when {@link TreeItem.iconPath iconPath} has {@link ThemeIcon} value.
|
|||
|
*/
|
|||
|
resourceUri?: Uri
|
|||
|
|
|||
|
/**
|
|||
|
* The tooltip text when you hover over this item.
|
|||
|
*/
|
|||
|
tooltip?: string | MarkupContent
|
|||
|
|
|||
|
/**
|
|||
|
* The {@link Command} that should be executed when the tree item is selected.
|
|||
|
*
|
|||
|
* Please use `vscode.open` or `vscode.diff` as command IDs when the tree item is opening
|
|||
|
* something in the editor. Using these commands ensures that the resulting editor will
|
|||
|
* appear consistent with how other built-in trees open editors.
|
|||
|
*/
|
|||
|
command?: Command
|
|||
|
|
|||
|
/**
|
|||
|
* {@link TreeItemCollapsibleState} of the tree item.
|
|||
|
*/
|
|||
|
collapsibleState?: TreeItemCollapsibleState
|
|||
|
|
|||
|
/**
|
|||
|
* @param label A human-readable string describing this item
|
|||
|
* @param collapsibleState {@link TreeItemCollapsibleState} of the tree item. Default is {@link TreeItemCollapsibleState.None}
|
|||
|
*/
|
|||
|
constructor(label: string | TreeItemLabel, collapsibleState?: TreeItemCollapsibleState)
|
|||
|
|
|||
|
/**
|
|||
|
* @param resourceUri The {@link Uri} of the resource representing this item.
|
|||
|
* @param collapsibleState {@link TreeItemCollapsibleState} of the tree item. Default is {@link TreeItemCollapsibleState.None}
|
|||
|
*/
|
|||
|
constructor(resourceUri: Uri, collapsibleState?: TreeItemCollapsibleState)
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Action resolved by {@link TreeDataProvider}
|
|||
|
*/
|
|||
|
export interface TreeItemAction<T> {
|
|||
|
/**
|
|||
|
* Label text in menu.
|
|||
|
*/
|
|||
|
title: string
|
|||
|
handler: (item: T) => ProviderResult<void>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Options for creating a {@link TreeView}
|
|||
|
*/
|
|||
|
export interface TreeViewOptions<T> {
|
|||
|
/**
|
|||
|
* bufhidden option for TreeView, default to 'wipe'
|
|||
|
*/
|
|||
|
bufhidden?: 'hide' | 'unload' | 'delete' | 'wipe'
|
|||
|
/**
|
|||
|
* Fixed width for window, default to true
|
|||
|
*/
|
|||
|
winfixwidth?: boolean
|
|||
|
/**
|
|||
|
* Enable filter feature, default to false
|
|||
|
*/
|
|||
|
enableFilter?: boolean
|
|||
|
/**
|
|||
|
* Disable indent of leaves without children, default to false
|
|||
|
*/
|
|||
|
disableLeafIndent?: boolean
|
|||
|
/**
|
|||
|
* A data provider that provides tree data.
|
|||
|
*/
|
|||
|
treeDataProvider: TreeDataProvider<T>
|
|||
|
/**
|
|||
|
* Whether the tree supports multi-select. When the tree supports multi-select and a command is executed from the tree,
|
|||
|
* the first argument to the command is the tree item that the command was executed on and the second argument is an
|
|||
|
* array containing all selected tree items.
|
|||
|
*/
|
|||
|
canSelectMany?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The event that is fired when an element in the {@link TreeView} is expanded or collapsed
|
|||
|
*/
|
|||
|
export interface TreeViewExpansionEvent<T> {
|
|||
|
|
|||
|
/**
|
|||
|
* Element that is expanded or collapsed.
|
|||
|
*/
|
|||
|
readonly element: T
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The event that is fired when there is a change in {@link TreeView.selection tree view's selection}
|
|||
|
*/
|
|||
|
export interface TreeViewSelectionChangeEvent<T> {
|
|||
|
|
|||
|
/**
|
|||
|
* Selected elements.
|
|||
|
*/
|
|||
|
readonly selection: T[]
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* The event that is fired when there is a change in {@link TreeView.visible tree view's visibility}
|
|||
|
*/
|
|||
|
export interface TreeViewVisibilityChangeEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* `true` if the {@link TreeView tree view} is visible otherwise `false`.
|
|||
|
*/
|
|||
|
readonly visible: boolean
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents a Tree view
|
|||
|
*/
|
|||
|
export interface TreeView<T> extends Disposable {
|
|||
|
|
|||
|
/**
|
|||
|
* Event that is fired when an element is expanded
|
|||
|
*/
|
|||
|
readonly onDidExpandElement: Event<TreeViewExpansionEvent<T>>
|
|||
|
|
|||
|
/**
|
|||
|
* Event that is fired when an element is collapsed
|
|||
|
*/
|
|||
|
readonly onDidCollapseElement: Event<TreeViewExpansionEvent<T>>
|
|||
|
|
|||
|
/**
|
|||
|
* Currently selected elements.
|
|||
|
*/
|
|||
|
readonly selection: T[]
|
|||
|
|
|||
|
/**
|
|||
|
* Event that is fired when the {@link TreeView.selection selection} has changed
|
|||
|
*/
|
|||
|
readonly onDidChangeSelection: Event<TreeViewSelectionChangeEvent<T>>
|
|||
|
|
|||
|
/**
|
|||
|
* Event that is fired when {@link TreeView.visible visibility} has changed
|
|||
|
*/
|
|||
|
readonly onDidChangeVisibility: Event<TreeViewVisibilityChangeEvent>
|
|||
|
|
|||
|
/**
|
|||
|
* `true` if the {@link TreeView tree view} is visible otherwise `false`.
|
|||
|
*
|
|||
|
* **NOTE:** is `true` when TreeView visible on other tab.
|
|||
|
*/
|
|||
|
readonly visible: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Window id used by TreeView.
|
|||
|
*/
|
|||
|
readonly windowId: number | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* An optional human-readable message that will be rendered in the view.
|
|||
|
* Setting the message to null, undefined, or empty string will remove the message from the view.
|
|||
|
*/
|
|||
|
message?: string
|
|||
|
|
|||
|
/**
|
|||
|
* The tree view title is initially taken from viewId of TreeView
|
|||
|
* Changes to the title property will be properly reflected in the UI in the title of the view.
|
|||
|
*/
|
|||
|
title?: string
|
|||
|
|
|||
|
/**
|
|||
|
* An optional human-readable description which is rendered less prominently in the title of the view.
|
|||
|
* Setting the title description to null, undefined, or empty string will remove the description from the view.
|
|||
|
*/
|
|||
|
description?: string
|
|||
|
|
|||
|
/**
|
|||
|
* Reveals the given element in the tree view.
|
|||
|
* If the tree view is not visible then the tree view is shown and element is revealed.
|
|||
|
*
|
|||
|
* By default revealed element is selected.
|
|||
|
* In order to not to select, set the option `select` to `false`.
|
|||
|
* In order to focus, set the option `focus` to `true`.
|
|||
|
* In order to expand the revealed element, set the option `expand` to `true`. To expand recursively set `expand` to the number of levels to expand.
|
|||
|
* **NOTE:** You can expand only to 3 levels maximum.
|
|||
|
*
|
|||
|
* **NOTE:** The {@link TreeDataProvider} that the `TreeView` {@link window.createTreeView is registered with} with must implement {@link TreeDataProvider.getParent getParent} method to access this API.
|
|||
|
*/
|
|||
|
reveal(element: T, options?: { select?: boolean, focus?: boolean, expand?: boolean | number }): Thenable<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Create tree view in new window.
|
|||
|
*
|
|||
|
* **NOTE:** TreeView with same viewId in current tab would be disposed.
|
|||
|
*
|
|||
|
* @param splitCommand The command to open TreeView window, default to 'belowright 30vs'
|
|||
|
* @return `true` if window shown.
|
|||
|
*/
|
|||
|
show(splitCommand?: string): Promise<boolean>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A data provider that provides tree data
|
|||
|
*/
|
|||
|
export interface TreeDataProvider<T> {
|
|||
|
/**
|
|||
|
* An optional event to signal that an element or root has changed.
|
|||
|
* This will trigger the view to update the changed element/root and its children recursively (if shown).
|
|||
|
* To signal that root has changed, do not pass any argument or pass `undefined` or `null`.
|
|||
|
*/
|
|||
|
onDidChangeTreeData?: Event<T | undefined | null | void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get {@link TreeItem} representation of the `element`
|
|||
|
*
|
|||
|
* @param element The element for which {@link TreeItem} representation is asked for.
|
|||
|
* @return {@link TreeItem} representation of the element
|
|||
|
*/
|
|||
|
getTreeItem(element: T): TreeItem | Thenable<TreeItem>
|
|||
|
|
|||
|
/**
|
|||
|
* Get the children of `element` or root if no element is passed.
|
|||
|
*
|
|||
|
* @param element The element from which the provider gets children. Can be `undefined`.
|
|||
|
* @return Children of `element` or root if no element is passed.
|
|||
|
*/
|
|||
|
getChildren(element?: T): ProviderResult<T[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Optional method to return the parent of `element`.
|
|||
|
* Return `null` or `undefined` if `element` is a child of root.
|
|||
|
*
|
|||
|
* **NOTE:** This method should be implemented in order to access {@link TreeView.reveal reveal} API.
|
|||
|
*
|
|||
|
* @param element The element for which the parent has to be returned.
|
|||
|
* @return Parent of `element`.
|
|||
|
*/
|
|||
|
getParent?(element: T): ProviderResult<T>
|
|||
|
|
|||
|
/**
|
|||
|
* Called on hover to resolve the {@link TreeItem.tooltip TreeItem} property if it is undefined.
|
|||
|
* Called on tree item click/open to resolve the {@link TreeItem.command TreeItem} property if it is undefined.
|
|||
|
* Only properties that were undefined can be resolved in `resolveTreeItem`.
|
|||
|
* Functionality may be expanded later to include being called to resolve other missing
|
|||
|
* properties on selection and/or on open.
|
|||
|
*
|
|||
|
* Will only ever be called once per TreeItem.
|
|||
|
*
|
|||
|
* onDidChangeTreeData should not be triggered from within resolveTreeItem.
|
|||
|
*
|
|||
|
* *Note* that this function is called when tree items are already showing in the UI.
|
|||
|
* Because of that, no property that changes the presentation (label, description, etc.)
|
|||
|
* can be changed.
|
|||
|
*
|
|||
|
* @param item Undefined properties of `item` should be set then `item` should be returned.
|
|||
|
* @param element The object associated with the TreeItem.
|
|||
|
* @param token A cancellation token.
|
|||
|
* @return The resolved tree item or a thenable that resolves to such. It is OK to return the given
|
|||
|
* `item`. When no result is returned, the given `item` will be used.
|
|||
|
*/
|
|||
|
resolveTreeItem?(item: TreeItem, element: T, token: CancellationToken): ProviderResult<TreeItem>
|
|||
|
|
|||
|
/**
|
|||
|
* Called with current element to resolve actions.
|
|||
|
* Called when user press 'actions' key.
|
|||
|
*
|
|||
|
* @param item Resolved item.
|
|||
|
* @param element The object under cursor.
|
|||
|
*/
|
|||
|
resolveActions?(item: TreeItem, element: T): ProviderResult<TreeItemAction<T>[]>
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// workspace module {{
|
|||
|
/**
|
|||
|
* An event describing the change in Configuration
|
|||
|
*/
|
|||
|
export interface ConfigurationChangeEvent {
|
|||
|
|
|||
|
/**
|
|||
|
* Returns `true` if the given section for the given resource (if provided) is affected.
|
|||
|
*
|
|||
|
* @param section Configuration name, supports _dotted_ names.
|
|||
|
* @param resource A resource URI.
|
|||
|
* @return `true` if the given section for the given resource (if provided) is affected.
|
|||
|
*/
|
|||
|
affectsConfiguration(section: string, resource?: string): boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface WillSaveEvent extends TextDocumentWillSaveEvent {
|
|||
|
/**
|
|||
|
* Allows to pause the event loop and to apply [pre-save-edits](#TextEdit).
|
|||
|
* Edits of subsequent calls to this function will be applied in order. The
|
|||
|
* edits will be *ignored* if concurrent modifications of the document happened.
|
|||
|
*
|
|||
|
* *Note:* This function can only be called during event dispatch and not
|
|||
|
* in an asynchronous manner:
|
|||
|
*
|
|||
|
* ```ts
|
|||
|
* workspace.onWillSaveTextDocument(event => {
|
|||
|
* // async, will *throw* an error
|
|||
|
* setTimeout(() => event.waitUntil(promise));
|
|||
|
*
|
|||
|
* // sync, OK
|
|||
|
* event.waitUntil(promise);
|
|||
|
* })
|
|||
|
* ```
|
|||
|
*
|
|||
|
* @param thenable A thenable that resolves to [pre-save-edits](#TextEdit).
|
|||
|
*/
|
|||
|
waitUntil(thenable: Thenable<TextEdit[] | any>): void
|
|||
|
}
|
|||
|
|
|||
|
export interface KeymapOption {
|
|||
|
/**
|
|||
|
* Use request instead of notify, default true
|
|||
|
*/
|
|||
|
sync: boolean
|
|||
|
/**
|
|||
|
* Cancel completion before invoke callback, default true
|
|||
|
*/
|
|||
|
cancel: boolean
|
|||
|
/**
|
|||
|
* Use <silent> for keymap, default false
|
|||
|
*/
|
|||
|
silent: boolean
|
|||
|
/**
|
|||
|
* Enable repeat support for repeat.vim, default false
|
|||
|
*/
|
|||
|
repeat: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface DidChangeTextDocumentParams {
|
|||
|
/**
|
|||
|
* The document that did change. The version number points
|
|||
|
* to the version after all provided content changes have
|
|||
|
* been applied.
|
|||
|
*/
|
|||
|
readonly textDocument: {
|
|||
|
version: number
|
|||
|
uri: string
|
|||
|
}
|
|||
|
/**
|
|||
|
* The actual content changes. The content changes describe single state changes
|
|||
|
* to the document. So if there are two content changes c1 (at array index 0) and
|
|||
|
* c2 (at array index 1) for a document in state S then c1 moves the document from
|
|||
|
* S to S' and c2 from S' to S''. So c1 is computed on the state S and c2 is computed
|
|||
|
* on the state S'.
|
|||
|
*/
|
|||
|
readonly contentChanges: ReadonlyArray<TextDocumentContentChange>
|
|||
|
/**
|
|||
|
* Buffer number of document.
|
|||
|
*/
|
|||
|
readonly bufnr: number
|
|||
|
/**
|
|||
|
* Original content before change
|
|||
|
*/
|
|||
|
readonly original: string
|
|||
|
/**
|
|||
|
* Original lines before change
|
|||
|
*/
|
|||
|
readonly originalLines: ReadonlyArray<string>
|
|||
|
}
|
|||
|
|
|||
|
export interface EditerState {
|
|||
|
document: LinesTextDocument
|
|||
|
position: Position
|
|||
|
}
|
|||
|
|
|||
|
export type MapMode = 'n' | 'i' | 'v' | 'x' | 's' | 'o'
|
|||
|
|
|||
|
export interface Autocmd {
|
|||
|
/**
|
|||
|
* Vim event or event set.
|
|||
|
*/
|
|||
|
event: string | string[]
|
|||
|
/**
|
|||
|
* Callback functions that called with evaled arguments.
|
|||
|
*/
|
|||
|
callback: Function
|
|||
|
/**
|
|||
|
* Match pattern, default to `*`.
|
|||
|
*/
|
|||
|
pattern?: string
|
|||
|
/**
|
|||
|
* Vim expression that eval to arguments of callback, default to `[]`
|
|||
|
*/
|
|||
|
arglist?: string[]
|
|||
|
/**
|
|||
|
* Use request when `true`, use notification by default.
|
|||
|
*/
|
|||
|
request?: boolean
|
|||
|
/**
|
|||
|
* `this` of callback.
|
|||
|
*/
|
|||
|
thisArg?: any
|
|||
|
}
|
|||
|
|
|||
|
export interface Env {
|
|||
|
/**
|
|||
|
* |completeopt| option of (neo)vim.
|
|||
|
*/
|
|||
|
readonly completeOpt: string
|
|||
|
/**
|
|||
|
* |runtimepath| option of (neo)vim.
|
|||
|
*/
|
|||
|
readonly runtimepath: string
|
|||
|
/**
|
|||
|
* |guicursor| option of (neo)vim
|
|||
|
*/
|
|||
|
readonly guicursor: string
|
|||
|
/**
|
|||
|
* Could use float window on neovim, always false on vim.
|
|||
|
*/
|
|||
|
readonly floating: boolean
|
|||
|
/**
|
|||
|
* |sign_place()| and |sign_unplace()| can be used when true.
|
|||
|
*/
|
|||
|
readonly sign: boolean
|
|||
|
/**
|
|||
|
* Root directory of extensions.
|
|||
|
*/
|
|||
|
readonly extensionRoot: string
|
|||
|
/**
|
|||
|
* Process id of (neo)vim.
|
|||
|
*/
|
|||
|
readonly pid: number
|
|||
|
/**
|
|||
|
* Total columns of screen.
|
|||
|
*/
|
|||
|
readonly columns: number
|
|||
|
/**
|
|||
|
* Total lines of screen.
|
|||
|
*/
|
|||
|
readonly lines: number
|
|||
|
/**
|
|||
|
* Is true when |CompleteChanged| event is supported.
|
|||
|
*/
|
|||
|
readonly pumevent: boolean
|
|||
|
/**
|
|||
|
* |cmdheight| option of (neo)vim.
|
|||
|
*/
|
|||
|
readonly cmdheight: number
|
|||
|
/**
|
|||
|
* Value of |g:coc_filetype_map|
|
|||
|
*/
|
|||
|
readonly filetypeMap: { [index: string]: string }
|
|||
|
/**
|
|||
|
* Is true when not using neovim.
|
|||
|
*/
|
|||
|
readonly isVim: boolean
|
|||
|
/**
|
|||
|
* Is cygvim when true.
|
|||
|
*/
|
|||
|
readonly isCygwin: boolean
|
|||
|
/**
|
|||
|
* Is macvim when true.
|
|||
|
*/
|
|||
|
readonly isMacvim: boolean
|
|||
|
/**
|
|||
|
* Is true when iTerm.app is used on mac.
|
|||
|
*/
|
|||
|
readonly isiTerm: boolean
|
|||
|
/**
|
|||
|
* version of (neo)vim, on vim it's like: 8020750, on neoivm it's like: 0.5.0
|
|||
|
*/
|
|||
|
readonly version: string
|
|||
|
/**
|
|||
|
* |v:progpath| value, could be empty.
|
|||
|
*/
|
|||
|
readonly progpath: string
|
|||
|
/**
|
|||
|
* Is true when dialog feature is supported, which need vim >= 8.2.750 or neovim >= 0.4.0
|
|||
|
*/
|
|||
|
readonly dialog: boolean
|
|||
|
/**
|
|||
|
* Is true when vim's textprop is supported.
|
|||
|
*/
|
|||
|
readonly textprop: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Store & retrieve most recent used items.
|
|||
|
*/
|
|||
|
export interface Mru {
|
|||
|
/**
|
|||
|
* Load iems from mru file
|
|||
|
*/
|
|||
|
|
|||
|
load(): Promise<string[]>
|
|||
|
/**
|
|||
|
* Add item to mru file.
|
|||
|
*/
|
|||
|
add(item: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Remove item from mru file.
|
|||
|
*/
|
|||
|
|
|||
|
remove(item: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Remove the data file.
|
|||
|
*/
|
|||
|
clean(): Promise<void>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Option to create task that runs in (neo)vim.
|
|||
|
*/
|
|||
|
export interface TaskOptions {
|
|||
|
/**
|
|||
|
* The command to run, without arguments
|
|||
|
*/
|
|||
|
cmd: string
|
|||
|
/**
|
|||
|
* Arguments of command.
|
|||
|
*/
|
|||
|
args?: string[]
|
|||
|
/**
|
|||
|
* Current working directory of the task, Default to current vim's cwd.
|
|||
|
*/
|
|||
|
cwd?: string
|
|||
|
/**
|
|||
|
* Additional environment key-value pairs.
|
|||
|
*/
|
|||
|
env?: { [key: string]: string }
|
|||
|
/**
|
|||
|
* Use pty when true.
|
|||
|
*/
|
|||
|
pty?: boolean
|
|||
|
/**
|
|||
|
* Detach child process when true.
|
|||
|
*/
|
|||
|
detach?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Controls long running task started by (neo)vim.
|
|||
|
* Useful to keep the task running after CocRestart.
|
|||
|
*/
|
|||
|
export interface Task extends Disposable {
|
|||
|
/**
|
|||
|
* Fired on task exit with exit code.
|
|||
|
*/
|
|||
|
onExit: Event<number>
|
|||
|
/**
|
|||
|
* Fired with lines on stdout received.
|
|||
|
*/
|
|||
|
onStdout: Event<string[]>
|
|||
|
/**
|
|||
|
* Fired with lines on stderr received.
|
|||
|
*/
|
|||
|
onStderr: Event<string[]>
|
|||
|
/**
|
|||
|
* Start task, task will be restarted when already running.
|
|||
|
*
|
|||
|
* @param {TaskOptions} opts
|
|||
|
* @returns {Promise<boolean>}
|
|||
|
*/
|
|||
|
start(opts: TaskOptions): Promise<boolean>
|
|||
|
/**
|
|||
|
* Stop task by SIGTERM or SIGKILL
|
|||
|
*/
|
|||
|
stop(): Promise<void>
|
|||
|
/**
|
|||
|
* Check if the task is running.
|
|||
|
*/
|
|||
|
running: Promise<boolean>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A simple json database.
|
|||
|
*/
|
|||
|
export interface JsonDB {
|
|||
|
filepath: string
|
|||
|
/**
|
|||
|
* Get data by key.
|
|||
|
*
|
|||
|
* @param {string} key unique key allows dot notation.
|
|||
|
* @returns {any}
|
|||
|
*/
|
|||
|
fetch(key: string): any
|
|||
|
/**
|
|||
|
* Check if key exists
|
|||
|
*
|
|||
|
* @param {string} key unique key allows dot notation.
|
|||
|
*/
|
|||
|
exists(key: string): boolean
|
|||
|
/**
|
|||
|
* Delete data by key
|
|||
|
*
|
|||
|
* @param {string} key unique key allows dot notation.
|
|||
|
*/
|
|||
|
delete(key: string): void
|
|||
|
/**
|
|||
|
* Save data with key
|
|||
|
*/
|
|||
|
push(key: string, data: number | null | boolean | string | { [index: string]: any }): void
|
|||
|
/**
|
|||
|
* Empty db file.
|
|||
|
*/
|
|||
|
clear(): void
|
|||
|
/**
|
|||
|
* Remove db file.
|
|||
|
*/
|
|||
|
destroy(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface RenameEvent {
|
|||
|
oldUri: Uri
|
|||
|
newUri: Uri
|
|||
|
}
|
|||
|
|
|||
|
export interface FileSystemWatcher {
|
|||
|
readonly ignoreCreateEvents: boolean
|
|||
|
readonly ignoreChangeEvents: boolean
|
|||
|
readonly ignoreDeleteEvents: boolean
|
|||
|
readonly onDidCreate: Event<Uri>
|
|||
|
readonly onDidChange: Event<Uri>
|
|||
|
readonly onDidDelete: Event<Uri>
|
|||
|
readonly onDidRename: Event<RenameEvent>
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface ConfigurationInspect<T> {
|
|||
|
key: string
|
|||
|
defaultValue?: T
|
|||
|
globalValue?: T
|
|||
|
workspaceValue?: T
|
|||
|
}
|
|||
|
|
|||
|
export interface WorkspaceConfiguration {
|
|||
|
/**
|
|||
|
* Return a value from this configuration.
|
|||
|
*
|
|||
|
* @param section Configuration name, supports _dotted_ names.
|
|||
|
* @return The value `section` denotes or `undefined`.
|
|||
|
*/
|
|||
|
get<T>(section: string): T | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* Return a value from this configuration.
|
|||
|
*
|
|||
|
* @param section Configuration name, supports _dotted_ names.
|
|||
|
* @param defaultValue A value should be returned when no value could be found, is `undefined`.
|
|||
|
* @return The value `section` denotes or the default.
|
|||
|
*/
|
|||
|
get<T>(section: string, defaultValue: T): T
|
|||
|
|
|||
|
/**
|
|||
|
* Check if this configuration has a certain value.
|
|||
|
*
|
|||
|
* @param section Configuration name, supports _dotted_ names.
|
|||
|
* @return `true` if the section doesn't resolve to `undefined`.
|
|||
|
*/
|
|||
|
has(section: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Retrieve all information about a configuration setting. A configuration value
|
|||
|
* often consists of a *default* value, a global or installation-wide value,
|
|||
|
* a workspace-specific value
|
|||
|
*
|
|||
|
* *Note:* The configuration name must denote a leaf in the configuration tree
|
|||
|
* (`editor.fontSize` vs `editor`) otherwise no result is returned.
|
|||
|
*
|
|||
|
* @param section Configuration name, supports _dotted_ names.
|
|||
|
* @return Information about a configuration setting or `undefined`.
|
|||
|
*/
|
|||
|
inspect<T>(section: string): ConfigurationInspect<T> | undefined
|
|||
|
/**
|
|||
|
* Update a configuration value. The updated configuration values are persisted.
|
|||
|
*
|
|||
|
*
|
|||
|
* @param section Configuration name, supports _dotted_ names.
|
|||
|
* @param value The new value.
|
|||
|
* @param isUser if true, always update user configuration
|
|||
|
*/
|
|||
|
update(section: string, value: any, isUser?: boolean): void
|
|||
|
|
|||
|
/**
|
|||
|
* Readable dictionary that backs this configuration.
|
|||
|
*/
|
|||
|
readonly [key: string]: any
|
|||
|
}
|
|||
|
|
|||
|
export interface BufferSyncItem {
|
|||
|
/**
|
|||
|
* Called on buffer unload.
|
|||
|
*/
|
|||
|
dispose: () => void
|
|||
|
/**
|
|||
|
* Called on buffer content change.
|
|||
|
*/
|
|||
|
onChange?(e: DidChangeTextDocumentParams): void
|
|||
|
/**
|
|||
|
* Called on TextChangedI & TextChanged events.
|
|||
|
*/
|
|||
|
onTextChange?(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface BufferSync<T extends BufferSyncItem> {
|
|||
|
/**
|
|||
|
* Current items.
|
|||
|
*/
|
|||
|
readonly items: Iterable<T>
|
|||
|
/**
|
|||
|
* Get created item by uri
|
|||
|
*/
|
|||
|
getItem(uri: string): T | undefined
|
|||
|
/**
|
|||
|
* Get created item by bufnr
|
|||
|
*/
|
|||
|
getItem(bufnr: number): T | undefined
|
|||
|
dispose: () => void
|
|||
|
}
|
|||
|
|
|||
|
export namespace workspace {
|
|||
|
export const nvim: Neovim
|
|||
|
/**
|
|||
|
* Current buffer number, could be wrong since vim could not send autocmd as expected.
|
|||
|
*
|
|||
|
* @deprecated will be removed in the feature.
|
|||
|
*/
|
|||
|
export const bufnr: number
|
|||
|
/**
|
|||
|
* Current document.
|
|||
|
*/
|
|||
|
export const document: Promise<Document>
|
|||
|
/**
|
|||
|
* Environments or current (neo)vim.
|
|||
|
*/
|
|||
|
export const env: Env
|
|||
|
/**
|
|||
|
* Float window or popup can work.
|
|||
|
*/
|
|||
|
export const floatSupported: boolean
|
|||
|
/**
|
|||
|
* Current working directory of vim.
|
|||
|
*/
|
|||
|
export const cwd: string
|
|||
|
/**
|
|||
|
* Current workspace root.
|
|||
|
*/
|
|||
|
export const root: string
|
|||
|
/**
|
|||
|
* @deprecated aliased to root.
|
|||
|
*/
|
|||
|
export const rootPath: string
|
|||
|
/**
|
|||
|
* Not neovim when true.
|
|||
|
*/
|
|||
|
export const isVim: boolean
|
|||
|
/**
|
|||
|
* Is neovim when true.
|
|||
|
*/
|
|||
|
export const isNvim: boolean
|
|||
|
/**
|
|||
|
* All filetypes of loaded documents.
|
|||
|
*/
|
|||
|
export const filetypes: ReadonlySet<string>
|
|||
|
/**
|
|||
|
* All languageIds of loaded documents.
|
|||
|
*/
|
|||
|
export const languageIds: ReadonlySet<string>
|
|||
|
/**
|
|||
|
* Root directory of coc.nvim
|
|||
|
*/
|
|||
|
export const pluginRoot: string
|
|||
|
/**
|
|||
|
* Current `&completeopt` of vim, may not correct.
|
|||
|
*/
|
|||
|
export const completeOpt: string
|
|||
|
/**
|
|||
|
* Exists channel names.
|
|||
|
*/
|
|||
|
export const channelNames: ReadonlyArray<string>
|
|||
|
/**
|
|||
|
* Loaded documents that attached.
|
|||
|
*/
|
|||
|
export const documents: ReadonlyArray<Document>
|
|||
|
/**
|
|||
|
* Current document array.
|
|||
|
*/
|
|||
|
export const textDocuments: ReadonlyArray<LinesTextDocument>
|
|||
|
/**
|
|||
|
* Current workspace folders.
|
|||
|
*/
|
|||
|
export const workspaceFolders: ReadonlyArray<WorkspaceFolder>
|
|||
|
/**
|
|||
|
* Directory paths of workspaceFolders.
|
|||
|
*/
|
|||
|
export const folderPaths: ReadonlyArray<string>
|
|||
|
/**
|
|||
|
* Current workspace folder, could be null when vim started from user's home.
|
|||
|
*
|
|||
|
* @deprecated
|
|||
|
*/
|
|||
|
export const workspaceFolder: WorkspaceFolder | null
|
|||
|
export const onDidCreateFiles: Event<FileCreateEvent>
|
|||
|
export const onDidRenameFiles: Event<FileRenameEvent>
|
|||
|
export const onDidDeleteFiles: Event<FileDeleteEvent>
|
|||
|
export const onWillCreateFiles: Event<FileWillCreateEvent>
|
|||
|
export const onWillRenameFiles: Event<FileWillRenameEvent>
|
|||
|
export const onWillDeleteFiles: Event<FileWillDeleteEvent>
|
|||
|
/**
|
|||
|
* Event fired on workspace folder change.
|
|||
|
*/
|
|||
|
export const onDidChangeWorkspaceFolders: Event<WorkspaceFoldersChangeEvent>
|
|||
|
/**
|
|||
|
* Event fired after document create.
|
|||
|
*/
|
|||
|
export const onDidOpenTextDocument: Event<LinesTextDocument & { bufnr: number }>
|
|||
|
/**
|
|||
|
* Event fired after document unload.
|
|||
|
*/
|
|||
|
export const onDidCloseTextDocument: Event<LinesTextDocument & { bufnr: number }>
|
|||
|
/**
|
|||
|
* Event fired on document change.
|
|||
|
*/
|
|||
|
export const onDidChangeTextDocument: Event<DidChangeTextDocumentParams>
|
|||
|
/**
|
|||
|
* Event fired before document save.
|
|||
|
*/
|
|||
|
export const onWillSaveTextDocument: Event<WillSaveEvent>
|
|||
|
/**
|
|||
|
* Event fired after document save.
|
|||
|
*/
|
|||
|
export const onDidSaveTextDocument: Event<LinesTextDocument>
|
|||
|
|
|||
|
/**
|
|||
|
* Event fired on configuration change. Configuration change could by many
|
|||
|
* reasons, including:
|
|||
|
*
|
|||
|
* - Changes detected from `coc-settings.json`.
|
|||
|
* - Change to document that using another configuration file.
|
|||
|
* - Configuration change by call update API of WorkspaceConfiguration.
|
|||
|
*/
|
|||
|
export const onDidChangeConfiguration: Event<ConfigurationChangeEvent>
|
|||
|
|
|||
|
/**
|
|||
|
* Fired when vim's runtimepath change detected.
|
|||
|
*/
|
|||
|
export const onDidRuntimePathChange: Event<ReadonlyArray<string>>
|
|||
|
|
|||
|
/**
|
|||
|
* Returns a path that is relative to the workspace folder or folders.
|
|||
|
*
|
|||
|
* When there are no {@link workspace.workspaceFolders workspace folders} or when the path
|
|||
|
* is not contained in them, the input is returned.
|
|||
|
*
|
|||
|
* @param pathOrUri A path or uri. When a uri is given its {@link Uri.fsPath fsPath} is used.
|
|||
|
* @param includeWorkspaceFolder When `true` and when the given path is contained inside a
|
|||
|
* workspace folder the name of the workspace is prepended. Defaults to `true` when there are
|
|||
|
* multiple workspace folders and `false` otherwise.
|
|||
|
* @return A path relative to the root or the input.
|
|||
|
*/
|
|||
|
export function asRelativePath(pathOrUri: string | Uri, includeWorkspaceFolder?: boolean): string
|
|||
|
|
|||
|
/**
|
|||
|
* Opens a document. Will return early if this document is already open. Otherwise
|
|||
|
* the document is loaded and the {@link workspace.onDidOpenTextDocument didOpen}-event fires.
|
|||
|
*
|
|||
|
* The document is denoted by an {@link Uri}. Depending on the {@link Uri.scheme scheme} the
|
|||
|
* following rules apply:
|
|||
|
* * `file`-scheme: Open a file on disk (`openTextDocument(Uri.file(path))`). Will be rejected if the file
|
|||
|
* does not exist or cannot be loaded.
|
|||
|
* * `untitled`-scheme: Open a blank untitled file with associated path (`openTextDocument(Uri.file(path).with({ scheme: 'untitled' }))`).
|
|||
|
* The language will be derived from the file name.
|
|||
|
* * For all other schemes contributed {@link TextDocumentContentProvider text document content providers} and
|
|||
|
* {@link FileSystemProvider file system providers} are consulted.
|
|||
|
*
|
|||
|
* *Note* that the lifecycle of the returned document is owned by the editor and not by the extension. That means an
|
|||
|
* {@linkcode workspace.onDidCloseTextDocument onDidClose}-event can occur at any time after opening it.
|
|||
|
*
|
|||
|
* @param uri Identifies the resource to open.
|
|||
|
* @return A promise that resolves to a {@link Document document}.
|
|||
|
*/
|
|||
|
export function openTextDocument(uri: Uri): Thenable<Document>
|
|||
|
|
|||
|
/**
|
|||
|
* A short-hand for `openTextDocument(Uri.file(fileName))`.
|
|||
|
*
|
|||
|
* @see {@link openTextDocument}
|
|||
|
* @param fileName A name of a file on disk.
|
|||
|
* @return A promise that resolves to a {@link Document document}.
|
|||
|
*/
|
|||
|
export function openTextDocument(fileName: string): Thenable<Document>
|
|||
|
|
|||
|
/**
|
|||
|
* Create new namespace id by name.
|
|||
|
*
|
|||
|
* @deprecated Latest neovim requires namespace created by neoivm.
|
|||
|
*/
|
|||
|
export function createNameSpace(name: string): number
|
|||
|
|
|||
|
/**
|
|||
|
* Like vim's has(), but for version check only.
|
|||
|
* Check patch on neovim and check nvim on vim would return false.
|
|||
|
*
|
|||
|
* For example:
|
|||
|
* - has('nvim-0.6.0')
|
|||
|
* - has('patch-7.4.248')
|
|||
|
*/
|
|||
|
export function has(feature: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Register autocmd on vim.
|
|||
|
*
|
|||
|
* Note: avoid request autocmd when possible since vim could be blocked
|
|||
|
* forever when request triggered during request.
|
|||
|
*/
|
|||
|
export function registerAutocmd(autocmd: Autocmd): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Watch for vim's global option change.
|
|||
|
*/
|
|||
|
export function watchOption(key: string, callback: (oldValue: any, newValue: any) => Thenable<void> | void, disposables?: Disposable[]): void
|
|||
|
|
|||
|
/**
|
|||
|
* Watch for vim's global variable change, works on neovim only.
|
|||
|
*/
|
|||
|
export function watchGlobal(key: string, callback?: (oldValue: any, newValue: any) => Thenable<void> | void, disposables?: Disposable[]): void
|
|||
|
|
|||
|
/**
|
|||
|
* Check if selector match document.
|
|||
|
*/
|
|||
|
export function match(selector: DocumentSelector, document: LinesTextDocument): number
|
|||
|
|
|||
|
/**
|
|||
|
* Findup from filename or filenames from current filepath or root.
|
|||
|
*
|
|||
|
* @return fullpath of file or null when not found.
|
|||
|
*/
|
|||
|
export function findUp(filename: string | string[]): Promise<string | null>
|
|||
|
|
|||
|
/**
|
|||
|
* Get possible watchman binary path.
|
|||
|
*/
|
|||
|
export function getWatchmanPath(): string | null
|
|||
|
|
|||
|
/**
|
|||
|
* Get configuration by section and optional resource uri.
|
|||
|
*/
|
|||
|
export function getConfiguration(section?: string, resource?: string): WorkspaceConfiguration
|
|||
|
|
|||
|
/**
|
|||
|
* Get created document by uri or bufnr.
|
|||
|
*/
|
|||
|
export function getDocument(uri: number | string): Document
|
|||
|
|
|||
|
/**
|
|||
|
* Apply WorkspaceEdit.
|
|||
|
*/
|
|||
|
export function applyEdit(edit: WorkspaceEdit): Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Convert location to quickfix item.
|
|||
|
*/
|
|||
|
export function getQuickfixItem(loc: Location | LocationLink, text?: string, type?: string, module?: string): Promise<QuickfixItem>
|
|||
|
|
|||
|
/**
|
|||
|
* Convert locations to quickfix list.
|
|||
|
*/
|
|||
|
export function getQuickfixList(locations: Location[]): Promise<ReadonlyArray<QuickfixItem>>
|
|||
|
|
|||
|
/**
|
|||
|
* Populate locations to UI.
|
|||
|
*/
|
|||
|
export function showLocations(locations: Location[]): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get content of line by uri and line.
|
|||
|
*/
|
|||
|
export function getLine(uri: string, line: number): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Get WorkspaceFolder of uri
|
|||
|
*/
|
|||
|
export function getWorkspaceFolder(uri: string): WorkspaceFolder | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* Get content from buffer or file by uri.
|
|||
|
*/
|
|||
|
export function readFile(uri: string): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Get current document and position.
|
|||
|
*/
|
|||
|
export function getCurrentState(): Promise<EditerState>
|
|||
|
|
|||
|
/**
|
|||
|
* Get format options of uri or current buffer.
|
|||
|
*/
|
|||
|
export function getFormatOptions(uri?: string): Promise<FormattingOptions>
|
|||
|
|
|||
|
/**
|
|||
|
* Jump to location.
|
|||
|
*/
|
|||
|
export function jumpTo(uri: string, position?: Position | null, openCommand?: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Create a file in vim and disk
|
|||
|
*/
|
|||
|
export function createFile(filepath: string, opts?: CreateFileOptions): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Load uri as document, buffer would be invisible if not loaded.
|
|||
|
*/
|
|||
|
export function loadFile(uri: string): Promise<Document>
|
|||
|
|
|||
|
/**
|
|||
|
* Load the files that not loaded
|
|||
|
*/
|
|||
|
export function loadFiles(uris: string[]): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Rename file in vim and disk
|
|||
|
*/
|
|||
|
export function renameFile(oldPath: string, newPath: string, opts?: RenameFileOptions): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Delete file from vim and disk.
|
|||
|
*/
|
|||
|
export function deleteFile(filepath: string, opts?: DeleteFileOptions): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Open resource by uri
|
|||
|
*/
|
|||
|
export function openResource(uri: string): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Resolve full path of module from yarn or npm global directory.
|
|||
|
*/
|
|||
|
export function resolveModule(name: string): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Run nodejs command
|
|||
|
*/
|
|||
|
export function runCommand(cmd: string, cwd?: string, timeout?: number): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Expand filepath with `~` and/or environment placeholders
|
|||
|
*/
|
|||
|
export function expand(filepath: string): string
|
|||
|
|
|||
|
/**
|
|||
|
* Call a function by use notifications, useful for functions like |input| that could block vim.
|
|||
|
*/
|
|||
|
export function callAsync<T>(method: string, args: any[]): Promise<T>
|
|||
|
|
|||
|
/**
|
|||
|
* registerTextDocumentContentProvider
|
|||
|
*/
|
|||
|
export function registerTextDocumentContentProvider(scheme: string, provider: TextDocumentContentProvider): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register unique keymap uses `<Plug>(coc-{key})` as lhs
|
|||
|
* Throw error when {key} already exists.
|
|||
|
*
|
|||
|
* @param {MapMode[]} modes - array of 'n' | 'i' | 'v' | 'x' | 's' | 'o'
|
|||
|
* @param {string} key - unique name
|
|||
|
* @param {Function} fn - callback function
|
|||
|
* @param {Partial} opts
|
|||
|
* @returns {Disposable}
|
|||
|
*/
|
|||
|
export function registerKeymap(modes: MapMode[], key: string, fn: () => ProviderResult<any>, opts?: Partial<KeymapOption>): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register expr key-mapping.
|
|||
|
*/
|
|||
|
export function registerExprKeymap(mode: 'i' | 'n' | 'v' | 's' | 'x', key: string, fn: () => ProviderResult<string>, buffer?: boolean): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register local key-mapping.
|
|||
|
*/
|
|||
|
export function registerLocalKeymap(mode: 'n' | 'v' | 's' | 'x', key: string, fn: () => ProviderResult<any>, notify?: boolean): Disposable
|
|||
|
|
|||
|
/**
|
|||
|
* Register for buffer sync objects, created item should be disposable
|
|||
|
* and provide optional `onChange` which called when document change.
|
|||
|
*
|
|||
|
* The document is always attached and not command line buffer.
|
|||
|
*
|
|||
|
* @param create Called for each attached document and on document create.
|
|||
|
* @returns Disposable
|
|||
|
*/
|
|||
|
export function registerBufferSync<T extends BufferSyncItem>(create: (doc: Document) => T | undefined): BufferSync<T>
|
|||
|
|
|||
|
/**
|
|||
|
* Create a FileSystemWatcher instance, when watchman doesn't exist, the
|
|||
|
* returned FileSystemWatcher can still be used, but not work at all.
|
|||
|
*/
|
|||
|
export function createFileSystemWatcher(globPattern: string, ignoreCreate?: boolean, ignoreChange?: boolean, ignoreDelete?: boolean): FileSystemWatcher
|
|||
|
/**
|
|||
|
* Find files across all {@link workspace.workspaceFolders workspace folders} in the workspace.
|
|||
|
*
|
|||
|
* @example
|
|||
|
* findFiles('**/*.js', '**/node_modules/**', 10)
|
|||
|
*
|
|||
|
* @param include A {@link GlobPattern glob pattern} that defines the files to search for. The glob pattern
|
|||
|
* will be matched against the file paths of resulting matches relative to their workspace.
|
|||
|
* Use a {@link RelativePattern relative pattern} to restrict the search results to a {@link WorkspaceFolder workspace folder}.
|
|||
|
* @param exclude A {@link GlobPattern glob pattern} that defines files and folders to exclude. The glob pattern
|
|||
|
* will be matched against the file paths of resulting matches relative to their workspace. When `undefined` or`null`,
|
|||
|
* no excludes will apply.
|
|||
|
* @param maxResults An upper-bound for the result.
|
|||
|
* @param token A token that can be used to signal cancellation to the underlying search engine.
|
|||
|
* @return A thenable that resolves to an array of resource identifiers. Will return no results if no
|
|||
|
* {@link workspace.workspaceFolders workspace folders} are opened.
|
|||
|
*/
|
|||
|
export function findFiles(include: GlobPattern, exclude?: GlobPattern | null, maxResults?: number, token?: CancellationToken): Thenable<Uri[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Create persistence Mru instance.
|
|||
|
*/
|
|||
|
export function createMru(name: string): Mru
|
|||
|
|
|||
|
/**
|
|||
|
* Create Task instance that runs in (neo)vim, no shell.
|
|||
|
*
|
|||
|
* @param id Unique id string, like `TSC`
|
|||
|
*/
|
|||
|
export function createTask(id: string): Task
|
|||
|
|
|||
|
/**
|
|||
|
* Create DB instance at extension root.
|
|||
|
*/
|
|||
|
export function createDatabase(name: string): JsonDB
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// window module {{
|
|||
|
/**
|
|||
|
* Represents how a terminal exited.
|
|||
|
*/
|
|||
|
export interface TerminalExitStatus {
|
|||
|
/**
|
|||
|
* The exit code that a terminal exited with, it can have the following values:
|
|||
|
* - Zero: the terminal process or custom execution succeeded.
|
|||
|
* - Non-zero: the terminal process or custom execution failed.
|
|||
|
* - `undefined`: the user forcibly closed the terminal or a custom execution exited
|
|||
|
* without providing an exit code.
|
|||
|
*/
|
|||
|
readonly code: number | undefined
|
|||
|
}
|
|||
|
|
|||
|
export interface TerminalOptions {
|
|||
|
/**
|
|||
|
* A human-readable string which will be used to represent the terminal in the UI.
|
|||
|
*/
|
|||
|
name?: string
|
|||
|
|
|||
|
/**
|
|||
|
* A path to a custom shell executable to be used in the terminal.
|
|||
|
*/
|
|||
|
shellPath?: string
|
|||
|
|
|||
|
/**
|
|||
|
* Args for the custom shell executable, this does not work on Windows (see #8429)
|
|||
|
*/
|
|||
|
shellArgs?: string[]
|
|||
|
|
|||
|
/**
|
|||
|
* A path or URI for the current working directory to be used for the terminal.
|
|||
|
*/
|
|||
|
cwd?: string
|
|||
|
|
|||
|
/**
|
|||
|
* Object with environment variables that will be added to the VS Code process.
|
|||
|
*/
|
|||
|
env?: { [key: string]: string | null }
|
|||
|
|
|||
|
/**
|
|||
|
* Whether the terminal process environment should be exactly as provided in
|
|||
|
* `TerminalOptions.env`. When this is false (default), the environment will be based on the
|
|||
|
* window's environment and also apply configured platform settings like
|
|||
|
* `terminal.integrated.windows.env` on top. When this is true, the complete environment
|
|||
|
* must be provided as nothing will be inherited from the process or any configuration.
|
|||
|
* Neovim only.
|
|||
|
*/
|
|||
|
strictEnv?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An individual terminal instance within the integrated terminal.
|
|||
|
*/
|
|||
|
export interface Terminal {
|
|||
|
|
|||
|
/**
|
|||
|
* The bufnr of terminal buffer.
|
|||
|
*/
|
|||
|
readonly bufnr: number
|
|||
|
|
|||
|
/**
|
|||
|
* The name of the terminal.
|
|||
|
*/
|
|||
|
readonly name: string
|
|||
|
|
|||
|
/**
|
|||
|
* The process ID of the shell process.
|
|||
|
*/
|
|||
|
readonly processId: Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* The exit status of the terminal, this will be undefined while the terminal is active.
|
|||
|
*
|
|||
|
* **Example:** Show a notification with the exit code when the terminal exits with a
|
|||
|
* non-zero exit code.
|
|||
|
* ```typescript
|
|||
|
* window.onDidCloseTerminal(t => {
|
|||
|
* if (t.exitStatus && t.exitStatus.code) {
|
|||
|
* vscode.window.showInformationMessage(`Exit code: ${t.exitStatus.code}`);
|
|||
|
* }
|
|||
|
* });
|
|||
|
* ```
|
|||
|
*/
|
|||
|
readonly exitStatus: TerminalExitStatus | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* Send text to the terminal. The text is written to the stdin of the underlying pty process
|
|||
|
* (shell) of the terminal.
|
|||
|
*
|
|||
|
* @param text The text to send.
|
|||
|
* @param addNewLine Whether to add a new line to the text being sent, this is normally
|
|||
|
* required to run a command in the terminal. The character(s) added are \n or \r\n
|
|||
|
* depending on the platform. This defaults to `true`.
|
|||
|
*/
|
|||
|
sendText(text: string, addNewLine?: boolean): void
|
|||
|
|
|||
|
/**
|
|||
|
* Show the terminal panel and reveal this terminal in the UI, return false when failed.
|
|||
|
*
|
|||
|
* @param preserveFocus When `true` the terminal will not take focus.
|
|||
|
*/
|
|||
|
show(preserveFocus?: boolean): Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Hide the terminal panel if this terminal is currently showing.
|
|||
|
*/
|
|||
|
hide(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Dispose and free associated resources.
|
|||
|
*/
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Option for create status item.
|
|||
|
*/
|
|||
|
export interface StatusItemOption {
|
|||
|
progress?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Status item that included in `g:coc_status`
|
|||
|
*/
|
|||
|
export interface StatusBarItem {
|
|||
|
/**
|
|||
|
* The priority of this item. Higher value means the item should
|
|||
|
* be shown more to the left.
|
|||
|
*/
|
|||
|
readonly priority: number
|
|||
|
|
|||
|
isProgress: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* The text to show for the entry. You can embed icons in the text by leveraging the syntax:
|
|||
|
*
|
|||
|
* `My text $(icon-name) contains icons like $(icon-name) this one.`
|
|||
|
*
|
|||
|
* Where the icon-name is taken from the [octicon](https://octicons.github.com) icon set, e.g.
|
|||
|
* `light-bulb`, `thumbsup`, `zap` etc.
|
|||
|
*/
|
|||
|
text: string
|
|||
|
|
|||
|
/**
|
|||
|
* Shows the entry in the status bar.
|
|||
|
*/
|
|||
|
show(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Hide the entry in the status bar.
|
|||
|
*/
|
|||
|
hide(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Dispose and free associated resources. Call
|
|||
|
* [hide](#StatusBarItem.hide).
|
|||
|
*/
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Value-object describing where and how progress should show.
|
|||
|
*/
|
|||
|
export interface ProgressOptions {
|
|||
|
|
|||
|
/**
|
|||
|
* A human-readable string which will be used to describe the
|
|||
|
* operation.
|
|||
|
*/
|
|||
|
title?: string
|
|||
|
|
|||
|
/**
|
|||
|
* Controls if a cancel button should show to allow the user to
|
|||
|
* cancel the long running operation.
|
|||
|
*/
|
|||
|
cancellable?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Defines a generalized way of reporting progress updates.
|
|||
|
*/
|
|||
|
export interface Progress<T> {
|
|||
|
|
|||
|
/**
|
|||
|
* Report a progress update.
|
|||
|
*
|
|||
|
* @param value A progress item, like a message and/or an
|
|||
|
* report on how much work finished
|
|||
|
*/
|
|||
|
report(value: T): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents an action that is shown with an information, warning, or
|
|||
|
* error message.
|
|||
|
*
|
|||
|
* @see [showInformationMessage](#window.showInformationMessage)
|
|||
|
* @see [showWarningMessage](#window.showWarningMessage)
|
|||
|
* @see [showErrorMessage](#window.showErrorMessage)
|
|||
|
*/
|
|||
|
export interface MessageItem {
|
|||
|
|
|||
|
/**
|
|||
|
* A short title like 'Retry', 'Open Log' etc.
|
|||
|
*/
|
|||
|
title: string
|
|||
|
|
|||
|
/**
|
|||
|
* A hint for modal dialogs that the item should be triggered
|
|||
|
* when the user cancels the dialog (e.g. by pressing the ESC
|
|||
|
* key).
|
|||
|
*
|
|||
|
* Note: this option is ignored for non-modal messages.
|
|||
|
* Note: not used by coc.nvim for now.
|
|||
|
*/
|
|||
|
isCloseAffordance?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface DialogButton {
|
|||
|
/**
|
|||
|
* Use by callback, should >= 0
|
|||
|
*/
|
|||
|
index: number
|
|||
|
text: string
|
|||
|
/**
|
|||
|
* Not shown when true
|
|||
|
*/
|
|||
|
disabled?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface DialogConfig {
|
|||
|
/**
|
|||
|
* Content shown in window.
|
|||
|
*/
|
|||
|
content: string
|
|||
|
/**
|
|||
|
* Optional title text.
|
|||
|
*/
|
|||
|
title?: string
|
|||
|
/**
|
|||
|
* show close button, default to true when not specified.
|
|||
|
*/
|
|||
|
close?: boolean
|
|||
|
/**
|
|||
|
* highlight group for dialog window, default to `"dialog.floatHighlight"` or 'CocFlating'
|
|||
|
*/
|
|||
|
highlight?: string
|
|||
|
/**
|
|||
|
* highlight items of content.
|
|||
|
*/
|
|||
|
highlights?: ReadonlyArray<HighlightItem>
|
|||
|
/**
|
|||
|
* highlight groups for border, default to `"dialog.borderhighlight"` or 'CocFlating'
|
|||
|
*/
|
|||
|
borderhighlight?: string
|
|||
|
/**
|
|||
|
* Buttons as bottom of dialog.
|
|||
|
*/
|
|||
|
buttons?: DialogButton[]
|
|||
|
/**
|
|||
|
* index is -1 for window close without button click
|
|||
|
*/
|
|||
|
callback?: (index: number) => void
|
|||
|
}
|
|||
|
|
|||
|
export type NotificationKind = 'error' | 'info' | 'warning' | 'progress'
|
|||
|
|
|||
|
export interface NotificationConfig {
|
|||
|
kind?: NotificationKind
|
|||
|
|
|||
|
content?: string
|
|||
|
/**
|
|||
|
* Optional title text.
|
|||
|
*/
|
|||
|
title?: string
|
|||
|
/**
|
|||
|
* Buttons as bottom of dialog.
|
|||
|
*/
|
|||
|
buttons?: DialogButton[]
|
|||
|
/**
|
|||
|
* index is -1 for window close without button click
|
|||
|
*/
|
|||
|
callback?: (index: number) => void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Options to configure the behavior of the quick pick UI.
|
|||
|
*/
|
|||
|
export interface QuickPickOptions {
|
|||
|
|
|||
|
/**
|
|||
|
* An optional string that represents the title of the quick pick.
|
|||
|
*/
|
|||
|
title?: string
|
|||
|
|
|||
|
/**
|
|||
|
* An optional flag to include the description when filtering the picks.
|
|||
|
*/
|
|||
|
matchOnDescription?: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* An optional flag to make the picker accept multiple selections, if true the result is an array of picks.
|
|||
|
*/
|
|||
|
canPickMany?: boolean
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents an item that can be selected from
|
|||
|
* a list of items.
|
|||
|
*/
|
|||
|
export interface QuickPickItem {
|
|||
|
/**
|
|||
|
* A human-readable string which is rendered prominent
|
|||
|
*/
|
|||
|
label: string
|
|||
|
/**
|
|||
|
* A human-readable string which is rendered less prominent in the same line
|
|||
|
*/
|
|||
|
description?: string
|
|||
|
/**
|
|||
|
* Optional flag indicating if this item is picked initially.
|
|||
|
*/
|
|||
|
picked?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface QuickPickConfig<T extends QuickPickItem> {
|
|||
|
/**
|
|||
|
* An optional title.
|
|||
|
*/
|
|||
|
title?: string
|
|||
|
/**
|
|||
|
* Items to pick from.
|
|||
|
*/
|
|||
|
items: readonly T[]
|
|||
|
/**
|
|||
|
* Initial value of the filter text.
|
|||
|
*/
|
|||
|
value?: string
|
|||
|
/**
|
|||
|
* If multiple items can be selected at the same time. Defaults to false.
|
|||
|
*/
|
|||
|
canSelectMany?: boolean
|
|||
|
/**
|
|||
|
* Max height of list window.
|
|||
|
*/
|
|||
|
maxHeight?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface QuickPick<T extends QuickPickItem> {
|
|||
|
/**
|
|||
|
* An optional title.
|
|||
|
*/
|
|||
|
title: string | undefined
|
|||
|
/**
|
|||
|
* If the UI should show a progress indicator. Defaults to false.
|
|||
|
*
|
|||
|
* Change this to true, e.g., while loading more data or validating
|
|||
|
* user input.
|
|||
|
*/
|
|||
|
loading: boolean
|
|||
|
/**
|
|||
|
* Items to pick from. This can be read and updated by the extension.
|
|||
|
*/
|
|||
|
items: readonly T[]
|
|||
|
/**
|
|||
|
* Active items. This can be read and updated by the extension.
|
|||
|
*/
|
|||
|
activeItems: readonly T[]
|
|||
|
/**
|
|||
|
* If the filter text should also be matched against the description of the items. Defaults to false.
|
|||
|
*/
|
|||
|
matchOnDescription: boolean
|
|||
|
/**
|
|||
|
* Current input value
|
|||
|
*/
|
|||
|
readonly value: string
|
|||
|
/**
|
|||
|
* An event signaling when QuickPick closed, fired with selected items or null when canceled.
|
|||
|
*/
|
|||
|
readonly onDidFinish: Event<T[] | null>
|
|||
|
/**
|
|||
|
* An event signaling when the value of the filter text has changed.
|
|||
|
*/
|
|||
|
readonly onDidChangeValue: Event<string>
|
|||
|
/**
|
|||
|
* An event signaling when the selected items have changed.
|
|||
|
*/
|
|||
|
readonly onDidChangeSelection: Event<readonly T[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ScreenPosition {
|
|||
|
row: number
|
|||
|
col: number
|
|||
|
}
|
|||
|
|
|||
|
export type MsgTypes = 'error' | 'warning' | 'more'
|
|||
|
|
|||
|
export interface OpenTerminalOption {
|
|||
|
/**
|
|||
|
* Cwd of terminal, default to result of |getcwd()|
|
|||
|
*/
|
|||
|
cwd?: string
|
|||
|
/**
|
|||
|
* Close terminal on job finish, default to true.
|
|||
|
*/
|
|||
|
autoclose?: boolean
|
|||
|
/**
|
|||
|
* Keep focus current window, default to false.
|
|||
|
*/
|
|||
|
keepfocus?: boolean
|
|||
|
/**
|
|||
|
* Position of terminal window, default to 'right'.
|
|||
|
*/
|
|||
|
position?: 'bottom' | 'right'
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An output channel is a container for readonly textual information.
|
|||
|
*
|
|||
|
* To get an instance of an `OutputChannel` use
|
|||
|
* [createOutputChannel](#window.createOutputChannel).
|
|||
|
*/
|
|||
|
export interface OutputChannel {
|
|||
|
|
|||
|
/**
|
|||
|
* The human-readable name of this output channel.
|
|||
|
*/
|
|||
|
readonly name: string
|
|||
|
|
|||
|
readonly content: string
|
|||
|
/**
|
|||
|
* Append the given value to the channel.
|
|||
|
*
|
|||
|
* @param value A string, falsy values will not be printed.
|
|||
|
*/
|
|||
|
append(value: string): void
|
|||
|
|
|||
|
/**
|
|||
|
* Append the given value and a line feed character
|
|||
|
* to the channel.
|
|||
|
*
|
|||
|
* @param value A string, falsy values will be printed.
|
|||
|
*/
|
|||
|
appendLine(value: string): void
|
|||
|
|
|||
|
/**
|
|||
|
* Removes output from the channel. Latest `keep` lines will be remained.
|
|||
|
*/
|
|||
|
clear(keep?: number): void
|
|||
|
|
|||
|
/**
|
|||
|
* Reveal this channel in the UI.
|
|||
|
*
|
|||
|
* @param preserveFocus When `true` the channel will not take focus.
|
|||
|
*/
|
|||
|
show(preserveFocus?: boolean): void
|
|||
|
|
|||
|
/**
|
|||
|
* Hide this channel from the UI.
|
|||
|
*/
|
|||
|
hide(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Dispose and free associated resources.
|
|||
|
*/
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface TerminalResult {
|
|||
|
bufnr: number
|
|||
|
success: boolean
|
|||
|
content?: string
|
|||
|
}
|
|||
|
|
|||
|
export interface Dialog {
|
|||
|
/**
|
|||
|
* Buffer number of dialog.
|
|||
|
*/
|
|||
|
bufnr: number
|
|||
|
/**
|
|||
|
* Window id of dialog.
|
|||
|
*/
|
|||
|
winid: Promise<number | null>
|
|||
|
dispose: () => void
|
|||
|
}
|
|||
|
|
|||
|
export type HighlightItemDef = [string, number, number, number, number?, number?, number?]
|
|||
|
|
|||
|
export interface HighlightDiff {
|
|||
|
remove: number[]
|
|||
|
removeMarkers: number[]
|
|||
|
add: HighlightItemDef[]
|
|||
|
}
|
|||
|
|
|||
|
export interface MenuItem {
|
|||
|
text: string
|
|||
|
disabled?: boolean | { reason: string }
|
|||
|
}
|
|||
|
|
|||
|
export interface MenuOption {
|
|||
|
/**
|
|||
|
* Title in menu window.
|
|||
|
*/
|
|||
|
title?: string,
|
|||
|
/**
|
|||
|
* Content in menu window as normal text.
|
|||
|
*/
|
|||
|
content?: string
|
|||
|
/**
|
|||
|
* Create and highlight shortcut characters.
|
|||
|
*/
|
|||
|
shortcuts?: boolean
|
|||
|
/**
|
|||
|
* Position of menu, default to 'cursor'
|
|||
|
*/
|
|||
|
position?: 'center' | 'cursor'
|
|||
|
}
|
|||
|
|
|||
|
export interface InputOptions {
|
|||
|
/**
|
|||
|
* Position to show input, default to 'cursor'
|
|||
|
*/
|
|||
|
position?: 'cursor' | 'center'
|
|||
|
/**
|
|||
|
* Margin top editor when position is 'center'
|
|||
|
*/
|
|||
|
marginTop?: number
|
|||
|
/**
|
|||
|
* Border highlight of float window/popup, configuration `dialog.borderhighlight` used as default.
|
|||
|
*/
|
|||
|
borderhighlight?: string
|
|||
|
/**
|
|||
|
* Create key-mappings for quickpick list.
|
|||
|
*/
|
|||
|
list?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface InputPreference extends InputOptions {
|
|||
|
/**
|
|||
|
* Top, right, bottom, left border existence, default to [1,1,1,1]
|
|||
|
*/
|
|||
|
border?: [0 | 1, 0 | 1, 0 | 1, 0 | 1]
|
|||
|
/**
|
|||
|
* Rounded border, default to true, configuration `dialog.rounded` used as default.
|
|||
|
*/
|
|||
|
rounded?: boolean
|
|||
|
/**
|
|||
|
* Minimal window width, `g:coc_prompt_win_width` or 32 used as default.
|
|||
|
*/
|
|||
|
minWidth?: number
|
|||
|
/**
|
|||
|
* Maximum window width, configuration `dialog.maxWidth` used as default.
|
|||
|
*/
|
|||
|
maxWidth?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface InputDimension {
|
|||
|
readonly width: number
|
|||
|
readonly height: number
|
|||
|
/**
|
|||
|
* 0 based screen row
|
|||
|
*/
|
|||
|
readonly row: number
|
|||
|
/**
|
|||
|
* O based screen col
|
|||
|
*/
|
|||
|
readonly col: number
|
|||
|
}
|
|||
|
|
|||
|
export interface InputBox {
|
|||
|
/**
|
|||
|
* Change or get title of input box.
|
|||
|
*/
|
|||
|
title: string
|
|||
|
/**
|
|||
|
* Change or get loading state of input box.
|
|||
|
*/
|
|||
|
loading: boolean
|
|||
|
/**
|
|||
|
* Change or get borderhighlight of input box.
|
|||
|
*/
|
|||
|
borderhighlight: string
|
|||
|
/**
|
|||
|
* Dimension of float window/popup
|
|||
|
*/
|
|||
|
readonly dimension: InputDimension
|
|||
|
/**
|
|||
|
* Buffer number of float window/popup
|
|||
|
*/
|
|||
|
readonly bufnr: number
|
|||
|
/**
|
|||
|
* An event signaling when the value has changed.
|
|||
|
*/
|
|||
|
readonly onDidChange: Event<string>
|
|||
|
/**
|
|||
|
* An event signaling input finished, emit input value or null when canceled.
|
|||
|
*/
|
|||
|
readonly onDidFinish: Event<string | null>
|
|||
|
}
|
|||
|
|
|||
|
export namespace window {
|
|||
|
/**
|
|||
|
* The currently active editor or `undefined`. The active editor is the one
|
|||
|
* that currently has focus or, when none has focus, the one that has changed
|
|||
|
* input most recently.
|
|||
|
*/
|
|||
|
export const activeTextEditor: TextEditor | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* The currently visible editors or an empty array.
|
|||
|
*/
|
|||
|
export const visibleTextEditors: readonly TextEditor[]
|
|||
|
|
|||
|
/**
|
|||
|
* An {@link Event} which fires when the {@link window.activeTextEditor active editor}
|
|||
|
* has changed. *Note* that the event also fires when the active editor changes
|
|||
|
* to `undefined`.
|
|||
|
*/
|
|||
|
export const onDidChangeActiveTextEditor: Event<TextEditor | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* An {@link Event} which fires when the array of {@link window.visibleTextEditors visible editors}
|
|||
|
* has changed.
|
|||
|
*/
|
|||
|
export const onDidChangeVisibleTextEditors: Event<readonly TextEditor[]>
|
|||
|
|
|||
|
/**
|
|||
|
* The currently opened terminals or an empty array.
|
|||
|
*/
|
|||
|
export const terminals: readonly Terminal[]
|
|||
|
/**
|
|||
|
* onDidChangeTerminalState doesn't exist since we can't detect window resize on vim.
|
|||
|
*/
|
|||
|
/**
|
|||
|
* Event fired after terminal created, only fired with Terminal that
|
|||
|
* created by `window.createTerminal`
|
|||
|
*/
|
|||
|
export const onDidOpenTerminal: Event<Terminal>
|
|||
|
/**
|
|||
|
* Event fired on terminal close, only fired with Terminal that created by
|
|||
|
* `window.createTerminal`
|
|||
|
*/
|
|||
|
export const onDidCloseTerminal: Event<Terminal>
|
|||
|
/**
|
|||
|
* Creates a {@link Terminal} with a backing shell process.
|
|||
|
* The terminal is created by (neo)vim.
|
|||
|
*
|
|||
|
* @param options A TerminalOptions object describing the characteristics of the new terminal.
|
|||
|
* @return A new Terminal.
|
|||
|
* @throws When running in an environment where a new process cannot be started.
|
|||
|
*/
|
|||
|
export function createTerminal(opts: TerminalOptions): Promise<Terminal>
|
|||
|
|
|||
|
/**
|
|||
|
* Reveal message with message type.
|
|||
|
*
|
|||
|
* @deprecated Use `window.showErrorMessage`, `window.showWarningMessage` and `window.showInformationMessage` instead.
|
|||
|
* @param msg Message text to show.
|
|||
|
* @param messageType Type of message, could be `error` `warning` and `more`, default to `more`
|
|||
|
*/
|
|||
|
export function showMessage(msg: string, messageType?: MsgTypes): void
|
|||
|
|
|||
|
/**
|
|||
|
* Run command in vim terminal for result
|
|||
|
*
|
|||
|
* @param cmd Command to run.
|
|||
|
* @param cwd Cwd of terminal, default to result of |getcwd()|.
|
|||
|
*/
|
|||
|
export function runTerminalCommand(cmd: string, cwd?: string, keepfocus?: boolean): Promise<TerminalResult>
|
|||
|
|
|||
|
/**
|
|||
|
* Open terminal window.
|
|||
|
*
|
|||
|
* @param cmd Command to run.
|
|||
|
* @param opts Terminal option.
|
|||
|
* @returns buffer number of terminal.
|
|||
|
*/
|
|||
|
export function openTerminal(cmd: string, opts?: OpenTerminalOption): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Show quickpick for single item, use `window.menuPick` for menu at current current position.
|
|||
|
* Use `window.showPickerDialog()` for multiple selection.
|
|||
|
*
|
|||
|
* @param items Label list.
|
|||
|
* @param placeholder Prompt text, default to 'choose by number'.
|
|||
|
* @returns Index of selected item, or -1 when canceled.
|
|||
|
*/
|
|||
|
export function showQuickpick(items: string[], placeholder?: string): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Shows a selection list allowing multiple selections.
|
|||
|
* Throw error when 'workspace.env.dialog' is not true.
|
|||
|
*
|
|||
|
* @param items An array of strings, or a promise that resolves to an array of strings.
|
|||
|
* @param options Configures the behavior of the selection list.
|
|||
|
* @param token A token that can be used to signal cancellation.
|
|||
|
* @return A promise that resolves to the selected items or `undefined`.
|
|||
|
*/
|
|||
|
export function showQuickPick(items: readonly string[] | Thenable<readonly string[]>, options: QuickPickOptions & { canPickMany: true }, token?: CancellationToken): Thenable<string[] | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Shows a selection list.
|
|||
|
* Throw error when 'workspace.env.dialog' is not true.
|
|||
|
*
|
|||
|
* @param items An array of strings, or a promise that resolves to an array of strings.
|
|||
|
* @param options Configures the behavior of the selection list.
|
|||
|
* @param token A token that can be used to signal cancellation.
|
|||
|
* @return A promise that resolves to the selection or `undefined`.
|
|||
|
*/
|
|||
|
export function showQuickPick(items: readonly string[] | Thenable<readonly string[]>, options?: QuickPickOptions, token?: CancellationToken): Thenable<string | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Shows a selection list allowing multiple selections.
|
|||
|
* Throw error when 'workspace.env.dialog' is not true.
|
|||
|
*
|
|||
|
* @param items An array of items, or a promise that resolves to an array of items.
|
|||
|
* @param options Configures the behavior of the selection list.
|
|||
|
* @param token A token that can be used to signal cancellation.
|
|||
|
* @return A promise that resolves to the selected items or `undefined`.
|
|||
|
*/
|
|||
|
export function showQuickPick<T extends QuickPickItem>(items: readonly T[] | Thenable<readonly T[]>, options: QuickPickOptions & { canPickMany: true }, token?: CancellationToken): Thenable<T[] | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Shows a selection list.
|
|||
|
* Throw error when `workspace.env.dialog` not true.
|
|||
|
*
|
|||
|
* @param items An array of items, or a promise that resolves to an array of items.
|
|||
|
* @param options Configures the behavior of the selection list.
|
|||
|
* @param token A token that can be used to signal cancellation.
|
|||
|
* @return A promise that resolves to the selected item or `undefined`.
|
|||
|
*/
|
|||
|
export function showQuickPick<T extends QuickPickItem>(items: readonly T[] | Thenable<readonly T[]>, options?: QuickPickOptions, token?: CancellationToken): Thenable<T | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Show menu picker at current cursor position, |inputlist()| is used as fallback.
|
|||
|
* Throw error when `workspace.env.dialog` not true.
|
|||
|
*
|
|||
|
* @param items Array of texts or menu items.
|
|||
|
* @param title Optional title of float/popup window.
|
|||
|
* @param token A token that can be used to signal cancellation.
|
|||
|
* @returns Selected index (0 based), -1 when canceled.
|
|||
|
*/
|
|||
|
export function showMenuPicker(items: string[] | MenuItem[], option?: MenuOption | string, token?: CancellationToken): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Prompt user for confirm, a float/popup window would be used when possible,
|
|||
|
* use vim's |confirm()| function as callback.
|
|||
|
*
|
|||
|
* @param title The prompt text.
|
|||
|
* @returns Result of confirm.
|
|||
|
*/
|
|||
|
export function showPrompt(title: string): Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Show dialog window at the center of screen.
|
|||
|
* Note that the dialog would always be closed after button click.
|
|||
|
* Throw error when `workspace.env.dialog` not true.
|
|||
|
*
|
|||
|
* @param config Dialog configuration.
|
|||
|
* @returns Dialog or null when dialog can't work.
|
|||
|
*/
|
|||
|
export function showDialog(config: DialogConfig): Promise<Dialog | null>
|
|||
|
|
|||
|
/**
|
|||
|
* Request input from user, `input()` is used when `window.env.dialog` not true.
|
|||
|
*
|
|||
|
* @param title Title text of prompt window.
|
|||
|
* @param defaultValue Default value of input, empty text by default.
|
|||
|
* @param {InputOptions} option for input window, other preferences are read from user configuration.
|
|||
|
*/
|
|||
|
export function requestInput(title: string, defaultValue?: string, option?: InputOptions): Promise<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Creates and show a {@link InputBox} to let the user enter some text input.
|
|||
|
* Throw error when `workspace.env.dialog` not true.
|
|||
|
*
|
|||
|
* @return A new {@link InputBox}.
|
|||
|
*/
|
|||
|
export function createInputBox(title: string, defaultValue: string | undefined, option: InputPreference): Promise<InputBox>
|
|||
|
|
|||
|
/**
|
|||
|
* Creates and show a {@link QuickPick} to let the user pick an item or items from a
|
|||
|
* list of items of type T.
|
|||
|
* Throw error when `workspace.env.dialog` not true.
|
|||
|
*
|
|||
|
* Note that in many cases the more convenient {@link window.showQuickPick}
|
|||
|
* is easier to use. {@link window.createQuickPick} should be used
|
|||
|
* when {@link window.showQuickPick} does not offer the required flexibility.
|
|||
|
*
|
|||
|
* @return A new {@link QuickPick}.
|
|||
|
*/
|
|||
|
export function createQuickPick<T extends QuickPickItem>(config: QuickPickConfig<T>): Promise<QuickPick<T>>
|
|||
|
|
|||
|
/**
|
|||
|
* Create statusbar item that would be included in `g:coc_status`.
|
|||
|
*
|
|||
|
* @param priority Higher priority item would be shown right.
|
|||
|
* @param option
|
|||
|
* @return A new status bar item.
|
|||
|
*/
|
|||
|
export function createStatusBarItem(priority?: number, option?: StatusItemOption): StatusBarItem
|
|||
|
|
|||
|
/**
|
|||
|
* Open local config file
|
|||
|
*/
|
|||
|
export function openLocalConfig(): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Create a new output channel
|
|||
|
*
|
|||
|
* @param name Unique name of output channel.
|
|||
|
* @returns A new output channel.
|
|||
|
*/
|
|||
|
export function createOutputChannel(name: string): OutputChannel
|
|||
|
|
|||
|
/**
|
|||
|
* Create a {@link TreeView} instance, call `show()` method to render.
|
|||
|
*
|
|||
|
* @param viewId Id of the view, used as title of TreeView when title doesn't exist.
|
|||
|
* @param options Options for creating the {@link TreeView}
|
|||
|
* @returns a {@link TreeView}.
|
|||
|
*/
|
|||
|
export function createTreeView<T>(viewId: string, options: TreeViewOptions<T>): TreeView<T>
|
|||
|
|
|||
|
/**
|
|||
|
* Reveal buffer of output channel.
|
|||
|
*
|
|||
|
* @param name Name of output channel.
|
|||
|
* @param preserveFocus Preserve window focus when true.
|
|||
|
*/
|
|||
|
export function showOutputChannel(name: string, preserveFocus: boolean): void
|
|||
|
|
|||
|
/**
|
|||
|
* Echo lines at the bottom of vim.
|
|||
|
*
|
|||
|
* @param lines Line list.
|
|||
|
* @param truncate Truncate the lines to avoid 'press enter to continue' when true
|
|||
|
*/
|
|||
|
export function echoLines(lines: string[], truncate?: boolean): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get current cursor position (line, character both 0 based).
|
|||
|
*
|
|||
|
* @returns Cursor position.
|
|||
|
*/
|
|||
|
export function getCursorPosition(): Promise<Position>
|
|||
|
|
|||
|
/**
|
|||
|
* Move cursor to position (line, character both 0 based).
|
|||
|
*
|
|||
|
* @param position LSP position.
|
|||
|
*/
|
|||
|
export function moveTo(position: Position): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get current cursor character offset in document,
|
|||
|
* length of line break would always be 1.
|
|||
|
*
|
|||
|
* @returns Character offset.
|
|||
|
*/
|
|||
|
export function getOffset(): Promise<number>
|
|||
|
|
|||
|
/**
|
|||
|
* Get screen position of current cursor(relative to editor),
|
|||
|
* both `row` and `col` are 0 based.
|
|||
|
*
|
|||
|
* @returns Cursor screen position.
|
|||
|
*/
|
|||
|
export function getCursorScreenPosition(): Promise<ScreenPosition>
|
|||
|
|
|||
|
/**
|
|||
|
* Show multiple picker at center of screen.
|
|||
|
* Use `workspace.env.dialog` to check if dialog could work.
|
|||
|
*
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @param title Title of picker dialog.
|
|||
|
* @param token A token that can be used to signal cancellation.
|
|||
|
* @return A promise that resolves to the selected items or `undefined`.
|
|||
|
*/
|
|||
|
export function showPickerDialog(items: string[], title: string, token?: CancellationToken): Promise<string[] | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Show multiple picker at center of screen.
|
|||
|
* Use `workspace.env.dialog` to check if dialog could work.
|
|||
|
*
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @param title Title of picker dialog.
|
|||
|
* @param token A token that can be used to signal cancellation.
|
|||
|
* @return A promise that resolves to the selected items or `undefined`.
|
|||
|
*/
|
|||
|
export function showPickerDialog<T extends QuickPickItem>(items: T[], title: string, token?: CancellationToken): Promise<T[] | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Show an information message to users. Optionally provide an array of items which will be presented as
|
|||
|
* clickable buttons.
|
|||
|
*
|
|||
|
* @param message The message to show.
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @return Promise that resolves to the selected item or `undefined` when being dismissed.
|
|||
|
*/
|
|||
|
export function showInformationMessage(message: string, ...items: string[]): Promise<string | undefined>
|
|||
|
/**
|
|||
|
* Show an information message to users. Optionally provide an array of items which will be presented as
|
|||
|
* clickable buttons.
|
|||
|
*
|
|||
|
* @param message The message to show.
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @return Promise that resolves to the selected item or `undefined` when being dismissed.
|
|||
|
*/
|
|||
|
export function showInformationMessage<T extends MessageItem>(message: string, ...items: T[]): Promise<T | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Show an warning message to users. Optionally provide an array of items which will be presented as
|
|||
|
* clickable buttons.
|
|||
|
*
|
|||
|
* @param message The message to show.
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @return Promise that resolves to the selected item or `undefined` when being dismissed.
|
|||
|
*/
|
|||
|
export function showWarningMessage(message: string, ...items: string[]): Promise<string | undefined>
|
|||
|
/**
|
|||
|
* Show an warning message to users. Optionally provide an array of items which will be presented as
|
|||
|
* clickable buttons.
|
|||
|
*
|
|||
|
* @param message The message to show.
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @return Promise that resolves to the selected item or `undefined` when being dismissed.
|
|||
|
*/
|
|||
|
export function showWarningMessage<T extends MessageItem>(message: string, ...items: T[]): Promise<T | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Show an error message to users. Optionally provide an array of items which will be presented as
|
|||
|
* clickable buttons.
|
|||
|
*
|
|||
|
* @param message The message to show.
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @return Promise that resolves to the selected item or `undefined` when being dismissed.
|
|||
|
*/
|
|||
|
export function showErrorMessage(message: string, ...items: string[]): Promise<string | undefined>
|
|||
|
/**
|
|||
|
* Show an error message to users. Optionally provide an array of items which will be presented as
|
|||
|
* clickable buttons.
|
|||
|
*
|
|||
|
* @param message The message to show.
|
|||
|
* @param items A set of items that will be rendered as actions in the message.
|
|||
|
* @return Promise that resolves to the selected item or `undefined` when being dismissed.
|
|||
|
*/
|
|||
|
export function showErrorMessage<T extends MessageItem>(message: string, ...items: T[]): Promise<T | undefined>
|
|||
|
|
|||
|
/**
|
|||
|
* Show notification window at bottom right of screen.
|
|||
|
*/
|
|||
|
export function showNotification(config: NotificationConfig): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Show progress in the editor. Progress is shown while running the given callback
|
|||
|
* and while the promise it returned isn't resolved nor rejected.
|
|||
|
*
|
|||
|
* @param task A callback returning a promise. Progress state can be reported with
|
|||
|
* the provided [progress](#Progress)-object.
|
|||
|
*
|
|||
|
* To report discrete progress, use `increment` to indicate how much work has been completed. Each call with
|
|||
|
* a `increment` value will be summed up and reflected as overall progress until 100% is reached (a value of
|
|||
|
* e.g. `10` accounts for `10%` of work done).
|
|||
|
*
|
|||
|
* To monitor if the operation has been cancelled by the user, use the provided [`CancellationToken`](#CancellationToken).
|
|||
|
*
|
|||
|
* @return The thenable the task-callback returned.
|
|||
|
*/
|
|||
|
export function withProgress<R>(options: ProgressOptions, task: (progress: Progress<{
|
|||
|
message?: string
|
|||
|
increment?: number
|
|||
|
}>, token: CancellationToken) => Thenable<R>): Promise<R>
|
|||
|
|
|||
|
/**
|
|||
|
* Get selected range for current document
|
|||
|
*/
|
|||
|
export function getSelectedRange(visualmode: string): Promise<Range | null>
|
|||
|
|
|||
|
/**
|
|||
|
* Visual select range of current document
|
|||
|
*/
|
|||
|
export function selectRange(range: Range): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Get diff between new highlight items and current highlights requested from vim
|
|||
|
*
|
|||
|
* @param {number} bufnr - Buffer number
|
|||
|
* @param {string} ns - Highlight namespace
|
|||
|
* @param {HighlightItem[]} items - Highlight items
|
|||
|
* @param {[number, number] | undefined} - region 0 based start line and end line (end exclusive)
|
|||
|
* @param {CancellationToken} token - CancellationToken
|
|||
|
* @returns {Promise<HighlightDiff>}
|
|||
|
*/
|
|||
|
export function diffHighlights(bufnr: number, ns: string, items: ExtendedHighlightItem[], region?: [number, number] | undefined, token?: CancellationToken): Promise<HighlightDiff | null>
|
|||
|
|
|||
|
/**
|
|||
|
* Apply highlight diffs, normally used with `window.diffHighlights`
|
|||
|
*
|
|||
|
* Timer is used to add highlights when there're too many highlight items to add,
|
|||
|
* the highlight process won't be finished on that case.
|
|||
|
*
|
|||
|
* @param {number} bufnr - Buffer name
|
|||
|
* @param {string} ns - Namespace
|
|||
|
* @param {number} priority
|
|||
|
* @param {HighlightDiff} diff
|
|||
|
* @param {boolean} notify - Use notification, default false.
|
|||
|
* @returns {Promise<void>}
|
|||
|
*/
|
|||
|
export function applyDiffHighlights(bufnr: number, ns: string, priority: number, diff: HighlightDiff, notify?: boolean): Promise<void>
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// extensions module {{
|
|||
|
export interface Logger {
|
|||
|
readonly category: string
|
|||
|
readonly level: string
|
|||
|
log(...args: any[]): void
|
|||
|
trace(message: any, ...args: any[]): void
|
|||
|
debug(message: any, ...args: any[]): void
|
|||
|
info(message: any, ...args: any[]): void
|
|||
|
warn(message: any, ...args: any[]): void
|
|||
|
error(message: any, ...args: any[]): void
|
|||
|
fatal(message: any, ...args: any[]): void
|
|||
|
mark(message: any, ...args: any[]): void
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A memento represents a storage utility. It can store and retrieve
|
|||
|
* values.
|
|||
|
*/
|
|||
|
export interface Memento {
|
|||
|
|
|||
|
/**
|
|||
|
* Return a value.
|
|||
|
*
|
|||
|
* @param key A string.
|
|||
|
* @return The stored value or `undefined`.
|
|||
|
*/
|
|||
|
get<T>(key: string): T | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* Return a value.
|
|||
|
*
|
|||
|
* @param key A string.
|
|||
|
* @param defaultValue A value that should be returned when there is no
|
|||
|
* value (`undefined`) with the given key.
|
|||
|
* @return The stored value or the defaultValue.
|
|||
|
*/
|
|||
|
get<T>(key: string, defaultValue: T): T
|
|||
|
|
|||
|
/**
|
|||
|
* Store a value. The value must be JSON-stringifyable.
|
|||
|
*
|
|||
|
* @param key A string.
|
|||
|
* @param value A value. MUST not contain cyclic references.
|
|||
|
*/
|
|||
|
update(key: string, value: any): Promise<void>
|
|||
|
}
|
|||
|
|
|||
|
export type ExtensionState = 'disabled' | 'loaded' | 'activated' | 'unknown'
|
|||
|
|
|||
|
export enum ExtensionType {
|
|||
|
Global,
|
|||
|
Local,
|
|||
|
SingleFile,
|
|||
|
Internal
|
|||
|
}
|
|||
|
|
|||
|
export interface ExtensionJson {
|
|||
|
name: string
|
|||
|
main?: string
|
|||
|
engines: {
|
|||
|
[key: string]: string
|
|||
|
}
|
|||
|
version?: string
|
|||
|
[key: string]: any
|
|||
|
}
|
|||
|
|
|||
|
export interface ExtensionInfo {
|
|||
|
id: string
|
|||
|
version: string
|
|||
|
description: string
|
|||
|
root: string
|
|||
|
exotic: boolean
|
|||
|
uri?: string
|
|||
|
state: ExtensionState
|
|||
|
isLocal: boolean
|
|||
|
packageJSON: Readonly<ExtensionJson>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Represents an extension.
|
|||
|
*
|
|||
|
* To get an instance of an `Extension` use [getExtension](#extensions.getExtension).
|
|||
|
*/
|
|||
|
export interface Extension<T> {
|
|||
|
|
|||
|
/**
|
|||
|
* The canonical extension identifier in the form of: `publisher.name`.
|
|||
|
*/
|
|||
|
readonly id: string
|
|||
|
|
|||
|
/**
|
|||
|
* The absolute file path of the directory containing this extension.
|
|||
|
*/
|
|||
|
readonly extensionPath: string
|
|||
|
|
|||
|
/**
|
|||
|
* `true` if the extension has been activated.
|
|||
|
*/
|
|||
|
readonly isActive: boolean
|
|||
|
|
|||
|
/**
|
|||
|
* The parsed contents of the extension's package.json.
|
|||
|
*/
|
|||
|
readonly packageJSON: any
|
|||
|
|
|||
|
/**
|
|||
|
* The public API exported by this extension. It is an invalid action
|
|||
|
* to access this field before this extension has been activated.
|
|||
|
*/
|
|||
|
readonly exports: T
|
|||
|
|
|||
|
/**
|
|||
|
* Activates this extension and returns its public API.
|
|||
|
*
|
|||
|
* @return A promise that will resolve when this extension has been activated.
|
|||
|
*/
|
|||
|
activate(): Promise<T>
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* An extension context is a collection of utilities private to an
|
|||
|
* extension.
|
|||
|
*
|
|||
|
* An instance of an `ExtensionContext` is provided as the first
|
|||
|
* parameter to the `activate`-call of an extension.
|
|||
|
*/
|
|||
|
export interface ExtensionContext {
|
|||
|
|
|||
|
/**
|
|||
|
* An array to which disposables can be added. When this
|
|||
|
* extension is deactivated the disposables will be disposed.
|
|||
|
*/
|
|||
|
subscriptions: Disposable[]
|
|||
|
|
|||
|
/**
|
|||
|
* The absolute file path of the directory containing the extension.
|
|||
|
*/
|
|||
|
extensionPath: string
|
|||
|
|
|||
|
/**
|
|||
|
* Get the absolute path of a resource contained in the extension.
|
|||
|
*
|
|||
|
* @param relativePath A relative path to a resource contained in the extension.
|
|||
|
* @return The absolute path of the resource.
|
|||
|
*/
|
|||
|
asAbsolutePath(relativePath: string): string
|
|||
|
|
|||
|
/**
|
|||
|
* The absolute directory path for extension to download persist data.
|
|||
|
* The directory might not exist.
|
|||
|
*/
|
|||
|
storagePath: string
|
|||
|
|
|||
|
/**
|
|||
|
* A memento object that stores state in the context
|
|||
|
* of the currently opened [workspace](#workspace.workspaceFolders).
|
|||
|
*/
|
|||
|
workspaceState: Memento
|
|||
|
|
|||
|
/**
|
|||
|
* A memento object that stores state independent
|
|||
|
* of the current opened [workspace](#workspace.workspaceFolders).
|
|||
|
*/
|
|||
|
globalState: Memento
|
|||
|
|
|||
|
logger: Logger
|
|||
|
}
|
|||
|
|
|||
|
export type ExtensionApi = {
|
|||
|
[index: string]: any
|
|||
|
} | void | null | undefined
|
|||
|
|
|||
|
export interface PropertyScheme {
|
|||
|
type: string
|
|||
|
default: any
|
|||
|
description: string
|
|||
|
enum?: string[]
|
|||
|
items?: any
|
|||
|
[key: string]: any
|
|||
|
}
|
|||
|
|
|||
|
export namespace extensions {
|
|||
|
/**
|
|||
|
* Fired on extension loaded, extension not activated yet.
|
|||
|
*/
|
|||
|
export const onDidLoadExtension: Event<Extension<ExtensionApi>>
|
|||
|
|
|||
|
/**
|
|||
|
* Fired on extension activated.
|
|||
|
*/
|
|||
|
export const onDidActiveExtension: Event<Extension<ExtensionApi>>
|
|||
|
|
|||
|
/**
|
|||
|
* Fired with extension id on extension unload.
|
|||
|
*/
|
|||
|
export const onDidUnloadExtension: Event<string>
|
|||
|
|
|||
|
/**
|
|||
|
* Get all loaded extensions, without disabled extensions, extension may not activated.
|
|||
|
*/
|
|||
|
export const all: ReadonlyArray<Extension<ExtensionApi>>
|
|||
|
|
|||
|
/**
|
|||
|
* Get state of specific extension.
|
|||
|
*/
|
|||
|
export function getExtensionState(id: string): ExtensionState
|
|||
|
|
|||
|
/**
|
|||
|
* Get state of all extensions, including disabled extensions.
|
|||
|
*/
|
|||
|
export function getExtensionStates(): Promise<ExtensionInfo[]>
|
|||
|
|
|||
|
/**
|
|||
|
* Check if extension is activated.
|
|||
|
*/
|
|||
|
export function isActivated(id: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Dynamic add custom json schemes without using package.json.
|
|||
|
*/
|
|||
|
export function addSchemeProperty(key: string, def: PropertyScheme): void
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// listManager module {{
|
|||
|
export interface LocationWithLine {
|
|||
|
uri: string
|
|||
|
/**
|
|||
|
* Match text of line.
|
|||
|
*/
|
|||
|
line: string
|
|||
|
/**
|
|||
|
* Highlight text in line.
|
|||
|
*/
|
|||
|
text?: string
|
|||
|
}
|
|||
|
|
|||
|
export interface AnsiHighlight {
|
|||
|
/**
|
|||
|
* Byte indexes, 0 based.
|
|||
|
*/
|
|||
|
span: [number, number]
|
|||
|
hlGroup: string
|
|||
|
}
|
|||
|
|
|||
|
export interface ListItem {
|
|||
|
label: string
|
|||
|
preselect?: boolean
|
|||
|
filterText?: string
|
|||
|
/**
|
|||
|
* A string that should be used when comparing this item
|
|||
|
* with other items, only used for fuzzy filter.
|
|||
|
*/
|
|||
|
sortText?: string
|
|||
|
location?: Location | LocationWithLine | string
|
|||
|
data?: any
|
|||
|
ansiHighlights?: AnsiHighlight[]
|
|||
|
resolved?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface ListHighlights {
|
|||
|
/**
|
|||
|
* Byte indexes list, 0 based.
|
|||
|
*/
|
|||
|
spans: [number, number][]
|
|||
|
/**
|
|||
|
* `CocListSearch` is used when it not exist.
|
|||
|
*/
|
|||
|
hlGroup?: string
|
|||
|
}
|
|||
|
|
|||
|
export type ListMode = 'normal' | 'insert'
|
|||
|
|
|||
|
export type ListMatcher = 'strict' | 'fuzzy' | 'regex'
|
|||
|
|
|||
|
export interface ListOptions {
|
|||
|
position: string
|
|||
|
reverse: boolean
|
|||
|
input: string
|
|||
|
ignorecase: boolean
|
|||
|
interactive: boolean
|
|||
|
sort: boolean
|
|||
|
mode: ListMode
|
|||
|
matcher: ListMatcher
|
|||
|
autoPreview: boolean
|
|||
|
numberSelect: boolean
|
|||
|
noQuit: boolean
|
|||
|
first: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface ListContext {
|
|||
|
/**
|
|||
|
* Input on list activated.
|
|||
|
*/
|
|||
|
input: string
|
|||
|
/**
|
|||
|
* Current work directory on activated.
|
|||
|
*/
|
|||
|
cwd: string
|
|||
|
/**
|
|||
|
* Options of list.
|
|||
|
*/
|
|||
|
options: ListOptions
|
|||
|
/**
|
|||
|
* Arguments passed to list.
|
|||
|
*/
|
|||
|
args: string[]
|
|||
|
/**
|
|||
|
* Original window on list invoke.
|
|||
|
*/
|
|||
|
window: Window
|
|||
|
/**
|
|||
|
* Original buffer on list invoke.
|
|||
|
*/
|
|||
|
buffer: Buffer
|
|||
|
listWindow: Window | null
|
|||
|
}
|
|||
|
|
|||
|
export interface ListAction {
|
|||
|
/**
|
|||
|
* Action name
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* Should persist list window on invoke.
|
|||
|
*/
|
|||
|
persist?: boolean
|
|||
|
/**
|
|||
|
* Should reload list after invoke.
|
|||
|
*/
|
|||
|
reload?: boolean
|
|||
|
/**
|
|||
|
* Inovke all selected items in parallel.
|
|||
|
*/
|
|||
|
parallel?: boolean
|
|||
|
/**
|
|||
|
* Support handle multiple items at once.
|
|||
|
*/
|
|||
|
multiple?: boolean
|
|||
|
/**
|
|||
|
* Tab positioned list should be persisted (no window switch) on action invoke.
|
|||
|
*/
|
|||
|
tabPersist?: boolean
|
|||
|
/**
|
|||
|
* Item is array of selected items when multiple is true.
|
|||
|
*/
|
|||
|
execute: (item: ListItem | ListItem[], context: ListContext) => ProviderResult<void>
|
|||
|
}
|
|||
|
|
|||
|
export interface MultipleListAction extends Omit<ListAction, 'execute'> {
|
|||
|
multiple: true
|
|||
|
execute: (item: ListItem[], context: ListContext) => ProviderResult<void>
|
|||
|
}
|
|||
|
|
|||
|
export interface ListTask {
|
|||
|
on(event: 'data', callback: (item: ListItem) => void): void
|
|||
|
on(event: 'end', callback: () => void): void
|
|||
|
on(event: 'error', callback: (msg: string | Error) => void): void
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface ListArgument {
|
|||
|
key?: string
|
|||
|
hasValue?: boolean
|
|||
|
name: string
|
|||
|
description: string
|
|||
|
}
|
|||
|
|
|||
|
export interface IList {
|
|||
|
/**
|
|||
|
* Unique name of list.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* Default action name.
|
|||
|
*/
|
|||
|
defaultAction: string
|
|||
|
/**
|
|||
|
* Action list.
|
|||
|
*/
|
|||
|
actions: ListAction[]
|
|||
|
/**
|
|||
|
* Load list items.
|
|||
|
*/
|
|||
|
loadItems(context: ListContext, token: CancellationToken): Promise<ListItem[] | ListTask | null | undefined>
|
|||
|
/**
|
|||
|
* Should be true when interactive is supported.
|
|||
|
*/
|
|||
|
interactive?: boolean
|
|||
|
/**
|
|||
|
* Description of list.
|
|||
|
*/
|
|||
|
description?: string
|
|||
|
/**
|
|||
|
* Detail description, shown in help.
|
|||
|
*/
|
|||
|
detail?: string
|
|||
|
/**
|
|||
|
* Options supported by list.
|
|||
|
*/
|
|||
|
options?: ListArgument[]
|
|||
|
/**
|
|||
|
* Resolve list item.
|
|||
|
*/
|
|||
|
resolveItem?(item: ListItem): Promise<ListItem | null>
|
|||
|
/**
|
|||
|
* Highlight buffer by vim's syntax commands.
|
|||
|
*/
|
|||
|
doHighlight?(): void
|
|||
|
/**
|
|||
|
* Called on list unregistered.
|
|||
|
*/
|
|||
|
dispose?(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface PreviewOptions {
|
|||
|
bufname?: string
|
|||
|
lines: string[]
|
|||
|
filetype: string
|
|||
|
lnum?: number
|
|||
|
range?: Range
|
|||
|
/**
|
|||
|
* @deprecated not used
|
|||
|
*/
|
|||
|
sketch?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export namespace listManager {
|
|||
|
/**
|
|||
|
* Registered list names set.
|
|||
|
*/
|
|||
|
export const names: ReadonlyArray<string>
|
|||
|
/**
|
|||
|
* Register list, list session can be created by `CocList [name]` after registered.
|
|||
|
*/
|
|||
|
export function registerList(list: IList): Disposable
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// snippetManager module {{
|
|||
|
export interface SnippetSession {
|
|||
|
isActive: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface UltiSnippetOption {
|
|||
|
regex?: string
|
|||
|
context?: string
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A snippet string is a template which allows to insert text
|
|||
|
* and to control the editor cursor when insertion happens.
|
|||
|
*
|
|||
|
* A snippet can define tab stops and placeholders with `$1`, `$2`
|
|||
|
* and `${3:foo}`. `$0` defines the final tab stop, it defaults to
|
|||
|
* the end of the snippet. Variables are defined with `$name` and
|
|||
|
* `${name:default value}`. The full snippet syntax is documented
|
|||
|
* [here](https://code.visualstudio.com/docs/editor/userdefinedsnippets#_creating-your-own-snippets).
|
|||
|
*/
|
|||
|
export class SnippetString {
|
|||
|
/**
|
|||
|
* The snippet string.
|
|||
|
*/
|
|||
|
value: string
|
|||
|
|
|||
|
constructor(
|
|||
|
/**
|
|||
|
* The default snippet string.
|
|||
|
*/
|
|||
|
value?: string
|
|||
|
)
|
|||
|
|
|||
|
/**
|
|||
|
* Builder-function that appends the given string to
|
|||
|
* the {@link SnippetString.value `value`} of this snippet string.
|
|||
|
*
|
|||
|
* @param string A value to append 'as given'. The string will be escaped.
|
|||
|
* @return This snippet string.
|
|||
|
*/
|
|||
|
appendText(string: string): SnippetString
|
|||
|
|
|||
|
/**
|
|||
|
* Builder-function that appends a tabstop (`$1`, `$2` etc) to
|
|||
|
* the {@link SnippetString.value `value`} of this snippet string.
|
|||
|
*
|
|||
|
* @param number The number of this tabstop, defaults to an auto-increment
|
|||
|
* value starting at 1.
|
|||
|
* @return This snippet string.
|
|||
|
*/
|
|||
|
appendTabstop(number?: number): SnippetString
|
|||
|
|
|||
|
/**
|
|||
|
* Builder-function that appends a placeholder (`${1:value}`) to
|
|||
|
* the {@link SnippetString.value `value`} of this snippet string.
|
|||
|
*
|
|||
|
* @param value The value of this placeholder - either a string or a function
|
|||
|
* with which a nested snippet can be created.
|
|||
|
* @param number The number of this tabstop, defaults to an auto-increment
|
|||
|
* value starting at 1.
|
|||
|
* @return This snippet string.
|
|||
|
*/
|
|||
|
appendPlaceholder(value: string | ((snippet: SnippetString) => any), number?: number): SnippetString
|
|||
|
|
|||
|
/**
|
|||
|
* Builder-function that appends a choice (`${1|a,b,c|}`) to
|
|||
|
* the {@link SnippetString.value `value`} of this snippet string.
|
|||
|
*
|
|||
|
* @param values The values for choices - the array of strings
|
|||
|
* @param number The number of this tabstop, defaults to an auto-increment
|
|||
|
* value starting at 1.
|
|||
|
* @return This snippet string.
|
|||
|
*/
|
|||
|
appendChoice(values: string[], number?: number): SnippetString
|
|||
|
|
|||
|
/**
|
|||
|
* Builder-function that appends a variable (`${VAR}`) to
|
|||
|
* the {@link SnippetString.value `value`} of this snippet string.
|
|||
|
*
|
|||
|
* @param name The name of the variable - excluding the `$`.
|
|||
|
* @param defaultValue The default value which is used when the variable name cannot
|
|||
|
* be resolved - either a string or a function with which a nested snippet can be created.
|
|||
|
* @return This snippet string.
|
|||
|
*/
|
|||
|
appendVariable(name: string, defaultValue: string | ((snippet: SnippetString) => any)): SnippetString
|
|||
|
}
|
|||
|
/**
|
|||
|
* Manage snippet sessions.
|
|||
|
*/
|
|||
|
export namespace snippetManager {
|
|||
|
/**
|
|||
|
* Get snippet session by bufnr.
|
|||
|
*/
|
|||
|
export function getSession(bufnr: number): SnippetSession | undefined
|
|||
|
/**
|
|||
|
* Resolve snippet string to text.
|
|||
|
*/
|
|||
|
export function resolveSnippet(body: string, ultisnip?: UltiSnippetOption): Promise<string>
|
|||
|
/**
|
|||
|
* Insert snippet at current buffer.
|
|||
|
*
|
|||
|
* @param {string} snippet Textmate snippet string.
|
|||
|
* @param {boolean} select Not select first placeholder when false, default `true`.
|
|||
|
* @param {Range} range Repalce range, insert to current cursor position when undefined.
|
|||
|
* @returns {Promise<boolean>} true when insert success.
|
|||
|
*/
|
|||
|
export function insertSnippet(snippet: string | SnippetString, select?: boolean, range?: Range, ultisnip?: boolean): Promise<boolean>
|
|||
|
|
|||
|
/**
|
|||
|
* Jump to next placeholder, only works when snippet session activated.
|
|||
|
*/
|
|||
|
export function nextPlaceholder(): Promise<void>
|
|||
|
/**
|
|||
|
* Jump to previous placeholder, only works when snippet session activated.
|
|||
|
*/
|
|||
|
export function previousPlaceholder(): Promise<void>
|
|||
|
/**
|
|||
|
* Cancel snippet session of current buffer, does nothing when no session activated.
|
|||
|
*/
|
|||
|
export function cancel(): void
|
|||
|
/**
|
|||
|
* Check if snippet activated for bufnr.
|
|||
|
*/
|
|||
|
export function isActivated(bufnr: number): boolean
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// diagnosticManager module {{
|
|||
|
export interface DiagnosticItem {
|
|||
|
file: string
|
|||
|
lnum: number
|
|||
|
col: number
|
|||
|
source: string
|
|||
|
code: string | number
|
|||
|
message: string
|
|||
|
severity: string
|
|||
|
level: number
|
|||
|
location: Location
|
|||
|
}
|
|||
|
|
|||
|
export enum DiagnosticKind {
|
|||
|
Syntax,
|
|||
|
Semantic,
|
|||
|
Suggestion,
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A diagnostics collection is a container that manages a set of
|
|||
|
* [diagnostics](#Diagnostic). Diagnostics are always scopes to a
|
|||
|
* diagnostics collection and a resource.
|
|||
|
*
|
|||
|
* To get an instance of a `DiagnosticCollection` use
|
|||
|
* [createDiagnosticCollection](#languages.createDiagnosticCollection).
|
|||
|
*/
|
|||
|
export interface DiagnosticCollection {
|
|||
|
|
|||
|
/**
|
|||
|
* The name of this diagnostic collection, for instance `typescript`. Every diagnostic
|
|||
|
* from this collection will be associated with this name. Also, the task framework uses this
|
|||
|
* name when defining [problem matchers](https://code.visualstudio.com/docs/editor/tasks#_defining-a-problem-matcher).
|
|||
|
*/
|
|||
|
readonly name: string
|
|||
|
|
|||
|
/**
|
|||
|
* Assign diagnostics for given resource. Will replace
|
|||
|
* existing diagnostics for that resource.
|
|||
|
*
|
|||
|
* @param uri A resource identifier.
|
|||
|
* @param diagnostics Array of diagnostics or `undefined`
|
|||
|
*/
|
|||
|
set(uri: string, diagnostics: Diagnostic[] | null): void
|
|||
|
/**
|
|||
|
* Replace all entries in this collection.
|
|||
|
*
|
|||
|
* Diagnostics of multiple tuples of the same uri will be merged, e.g
|
|||
|
* `[[file1, [d1]], [file1, [d2]]]` is equivalent to `[[file1, [d1, d2]]]`.
|
|||
|
* If a diagnostics item is `undefined` as in `[file1, undefined]`
|
|||
|
* all previous but not subsequent diagnostics are removed.
|
|||
|
*
|
|||
|
* @param entries An array of tuples, like `[[file1, [d1, d2]], [file2, [d3, d4, d5]]]`, or `undefined`.
|
|||
|
*/
|
|||
|
set(entries: [string, Diagnostic[] | null][] | string, diagnostics?: Diagnostic[]): void
|
|||
|
|
|||
|
/**
|
|||
|
* Remove all diagnostics from this collection that belong
|
|||
|
* to the provided `uri`. The same as `#set(uri, undefined)`.
|
|||
|
*
|
|||
|
* @param uri A resource identifier.
|
|||
|
*/
|
|||
|
delete(uri: string): void
|
|||
|
|
|||
|
/**
|
|||
|
* Remove all diagnostics from this collection. The same
|
|||
|
* as calling `#set(undefined)`
|
|||
|
*/
|
|||
|
clear(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Iterate over each entry in this collection.
|
|||
|
*
|
|||
|
* @param callback Function to execute for each entry.
|
|||
|
* @param thisArg The `this` context used when invoking the handler function.
|
|||
|
*/
|
|||
|
forEach(callback: (uri: string, diagnostics: Diagnostic[], collection: DiagnosticCollection) => any, thisArg?: any): void
|
|||
|
|
|||
|
/**
|
|||
|
* Get the diagnostics for a given resource. *Note* that you cannot
|
|||
|
* modify the diagnostics-array returned from this call.
|
|||
|
*
|
|||
|
* @param uri A resource identifier.
|
|||
|
* @returns An immutable array of [diagnostics](#Diagnostic) or `undefined`.
|
|||
|
*/
|
|||
|
get(uri: string): Diagnostic[] | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* Check if this collection contains diagnostics for a
|
|||
|
* given resource.
|
|||
|
*
|
|||
|
* @param uri A resource identifier.
|
|||
|
* @returns `true` if this collection has diagnostic for the given resource.
|
|||
|
*/
|
|||
|
has(uri: string): boolean
|
|||
|
|
|||
|
/**
|
|||
|
* Dispose and free associated resources. Calls
|
|||
|
* [clear](#DiagnosticCollection.clear).
|
|||
|
*/
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface DiagnosticEventParams {
|
|||
|
bufnr: number
|
|||
|
uri: string
|
|||
|
diagnostics: ReadonlyArray<Diagnostic>
|
|||
|
}
|
|||
|
|
|||
|
export namespace diagnosticManager {
|
|||
|
|
|||
|
export const onDidRefresh: Event<DiagnosticEventParams>
|
|||
|
/**
|
|||
|
* Create collection by name
|
|||
|
*/
|
|||
|
export function create(name: string): DiagnosticCollection
|
|||
|
|
|||
|
/**
|
|||
|
* Get readonly diagnostics for uri
|
|||
|
*/
|
|||
|
export function getDiagnostics(uri: string): { [collection: string]: Diagnostic[] }
|
|||
|
|
|||
|
/**
|
|||
|
* Get readonly diagnostics by document and range.
|
|||
|
*/
|
|||
|
export function getDiagnosticsInRange(doc: TextDocumentIdentifier, range: Range): ReadonlyArray<Diagnostic>
|
|||
|
/**
|
|||
|
* Get all sorted diagnostics
|
|||
|
*/
|
|||
|
export function getDiagnosticList(): Promise<ReadonlyArray<DiagnosticItem>>
|
|||
|
|
|||
|
/**
|
|||
|
* All diagnostics at current cursor position.
|
|||
|
*/
|
|||
|
export function getCurrentDiagnostics(): Promise<ReadonlyArray<Diagnostic>>
|
|||
|
|
|||
|
/**
|
|||
|
* Get diagnostic collection.
|
|||
|
*/
|
|||
|
export function getCollectionByName(name: string): DiagnosticCollection
|
|||
|
}
|
|||
|
// }}
|
|||
|
|
|||
|
// language client {{
|
|||
|
/**
|
|||
|
* An action to be performed when the connection is producing errors.
|
|||
|
*/
|
|||
|
export enum ErrorAction {
|
|||
|
/**
|
|||
|
* Continue running the server.
|
|||
|
*/
|
|||
|
Continue = 1,
|
|||
|
/**
|
|||
|
* Shutdown the server.
|
|||
|
*/
|
|||
|
Shutdown = 2
|
|||
|
}
|
|||
|
/**
|
|||
|
* An action to be performed when the connection to a server got closed.
|
|||
|
*/
|
|||
|
export enum CloseAction {
|
|||
|
/**
|
|||
|
* Don't restart the server. The connection stays closed.
|
|||
|
*/
|
|||
|
DoNotRestart = 1,
|
|||
|
/**
|
|||
|
* Restart the server.
|
|||
|
*/
|
|||
|
Restart = 2
|
|||
|
}
|
|||
|
/**
|
|||
|
* A pluggable error handler that is invoked when the connection is either
|
|||
|
* producing errors or got closed.
|
|||
|
*/
|
|||
|
export interface ErrorHandler {
|
|||
|
/**
|
|||
|
* An error has occurred while writing or reading from the connection.
|
|||
|
*
|
|||
|
* @param error - the error received
|
|||
|
* @param message - the message to be delivered to the server if know.
|
|||
|
* @param count - a count indicating how often an error is received. Will
|
|||
|
* be reset if a message got successfully send or received.
|
|||
|
*/
|
|||
|
error(error: Error, message: { jsonrpc: string }, count: number): ErrorAction
|
|||
|
/**
|
|||
|
* The connection to the server got closed.
|
|||
|
*/
|
|||
|
closed(): CloseAction
|
|||
|
}
|
|||
|
export interface InitializationFailedHandler {
|
|||
|
(error: Error | any): boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface SynchronizeOptions {
|
|||
|
configurationSection?: string | string[]
|
|||
|
fileEvents?: FileSystemWatcher | FileSystemWatcher[]
|
|||
|
}
|
|||
|
|
|||
|
export enum RevealOutputChannelOn {
|
|||
|
Info = 1,
|
|||
|
Warn = 2,
|
|||
|
Error = 3,
|
|||
|
Never = 4
|
|||
|
}
|
|||
|
export interface ConfigurationItem {
|
|||
|
/**
|
|||
|
* The scope to get the configuration section for.
|
|||
|
*/
|
|||
|
scopeUri?: string
|
|||
|
/**
|
|||
|
* The configuration section asked for.
|
|||
|
*/
|
|||
|
section?: string
|
|||
|
}
|
|||
|
export interface ResponseError<D> {
|
|||
|
code: number
|
|||
|
data: D | undefined
|
|||
|
}
|
|||
|
|
|||
|
export type HandlerResult<R, E> = R | ResponseError<E> | Thenable<R> | Thenable<ResponseError<E>> | Thenable<R | ResponseError<E>>
|
|||
|
|
|||
|
export interface RequestHandler<P, R, E> {
|
|||
|
(params: P, token: CancellationToken): HandlerResult<R, E>
|
|||
|
}
|
|||
|
|
|||
|
export interface RequestHandler0<R, E> {
|
|||
|
(token: CancellationToken): HandlerResult<R, E>
|
|||
|
}
|
|||
|
/**
|
|||
|
* The parameters of a configuration request.
|
|||
|
*/
|
|||
|
export interface ConfigurationParams {
|
|||
|
items: ConfigurationItem[]
|
|||
|
}
|
|||
|
|
|||
|
export interface ConfigurationWorkspaceMiddleware {
|
|||
|
configuration?: (params: ConfigurationParams, token: CancellationToken, next: RequestHandler<ConfigurationParams, any[], void>) => HandlerResult<any[], void>
|
|||
|
}
|
|||
|
|
|||
|
export interface WorkspaceFolderWorkspaceMiddleware {
|
|||
|
workspaceFolders?: (token: CancellationToken, next: RequestHandler0<WorkspaceFolder[] | null, void>) => HandlerResult<WorkspaceFolder[] | null, void>
|
|||
|
didChangeWorkspaceFolders?: NextSignature<WorkspaceFoldersChangeEvent, void>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideTypeDefinitionSignature {
|
|||
|
(
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken
|
|||
|
): ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface TypeDefinitionMiddleware {
|
|||
|
provideTypeDefinition?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken,
|
|||
|
next: ProvideTypeDefinitionSignature
|
|||
|
) => ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideImplementationSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ImplementationMiddleware {
|
|||
|
provideImplementation?: (this: void, document: LinesTextDocument, position: Position, token: CancellationToken, next: ProvideImplementationSignature) => ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
export type ProvideDocumentColorsSignature = (document: LinesTextDocument, token: CancellationToken) => ProviderResult<ColorInformation[]>
|
|||
|
|
|||
|
export type ProvideColorPresentationSignature = (
|
|||
|
color: Color,
|
|||
|
context: { document: LinesTextDocument; range: Range },
|
|||
|
token: CancellationToken
|
|||
|
) => ProviderResult<ColorPresentation[]>
|
|||
|
|
|||
|
export interface ColorProviderMiddleware {
|
|||
|
provideDocumentColors?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
token: CancellationToken,
|
|||
|
next: ProvideDocumentColorsSignature
|
|||
|
) => ProviderResult<ColorInformation[]>
|
|||
|
provideColorPresentations?: (
|
|||
|
this: void,
|
|||
|
color: Color,
|
|||
|
context: { document: LinesTextDocument; range: Range },
|
|||
|
token: CancellationToken,
|
|||
|
next: ProvideColorPresentationSignature
|
|||
|
) => ProviderResult<ColorPresentation[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideDeclarationSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<Declaration | DeclarationLink[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface DeclarationMiddleware {
|
|||
|
provideDeclaration?: (this: void, document: LinesTextDocument, position: Position, token: CancellationToken, next: ProvideDeclarationSignature) => ProviderResult<Declaration | DeclarationLink[]>
|
|||
|
}
|
|||
|
|
|||
|
export type ProvideFoldingRangeSignature = (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
context: FoldingContext,
|
|||
|
token: CancellationToken
|
|||
|
) => ProviderResult<FoldingRange[]>
|
|||
|
|
|||
|
export interface FoldingRangeProviderMiddleware {
|
|||
|
provideFoldingRanges?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
context: FoldingContext,
|
|||
|
token: CancellationToken,
|
|||
|
next: ProvideFoldingRangeSignature
|
|||
|
) => ProviderResult<FoldingRange[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface PrepareCallHierarchySignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<CallHierarchyItem | CallHierarchyItem[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface CallHierarchyIncomingCallsSignature {
|
|||
|
(this: void, item: CallHierarchyItem, token: CancellationToken): ProviderResult<CallHierarchyIncomingCall[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface CallHierarchyOutgoingCallsSignature {
|
|||
|
(this: void, item: CallHierarchyItem, token: CancellationToken): ProviderResult<CallHierarchyOutgoingCall[]>
|
|||
|
}
|
|||
|
export interface CallHierarchyMiddleware {
|
|||
|
prepareCallHierarchy?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
positions: Position,
|
|||
|
token: CancellationToken,
|
|||
|
next: PrepareCallHierarchySignature
|
|||
|
) => ProviderResult<CallHierarchyItem | CallHierarchyItem[]>
|
|||
|
provideCallHierarchyIncomingCalls?: (
|
|||
|
this: void,
|
|||
|
item: CallHierarchyItem,
|
|||
|
token: CancellationToken,
|
|||
|
next: CallHierarchyIncomingCallsSignature
|
|||
|
) => ProviderResult<CallHierarchyIncomingCall[]>
|
|||
|
provideCallHierarchyOutgoingCalls?: (
|
|||
|
this: void,
|
|||
|
item: CallHierarchyItem,
|
|||
|
token: CancellationToken,
|
|||
|
next: CallHierarchyOutgoingCallsSignature
|
|||
|
) => ProviderResult<CallHierarchyOutgoingCall[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface DocumentSemanticsTokensSignature {
|
|||
|
(this: void, document: LinesTextDocument, token: CancellationToken): ProviderResult<SemanticTokens>
|
|||
|
}
|
|||
|
|
|||
|
export interface DocumentSemanticsTokensEditsSignature {
|
|||
|
(this: void, document: LinesTextDocument, previousResultId: string, token: CancellationToken): ProviderResult<SemanticTokens | SemanticTokensDelta>
|
|||
|
}
|
|||
|
|
|||
|
export interface DocumentRangeSemanticTokensSignature {
|
|||
|
(this: void, document: LinesTextDocument, range: Range, token: CancellationToken): ProviderResult<SemanticTokens>
|
|||
|
}
|
|||
|
|
|||
|
export interface SemanticTokensMiddleware {
|
|||
|
provideDocumentSemanticTokens?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
token: CancellationToken,
|
|||
|
next: DocumentSemanticsTokensSignature
|
|||
|
) => ProviderResult<SemanticTokens>
|
|||
|
provideDocumentSemanticTokensEdits?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
previousResultId: string,
|
|||
|
token: CancellationToken,
|
|||
|
next: DocumentSemanticsTokensEditsSignature
|
|||
|
) => ProviderResult<SemanticTokens | SemanticTokensDelta>
|
|||
|
provideDocumentRangeSemanticTokens?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
range: Range,
|
|||
|
token: CancellationToken,
|
|||
|
next: DocumentRangeSemanticTokensSignature
|
|||
|
) => ProviderResult<SemanticTokens>
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/**
|
|||
|
* File operation middleware
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface FileOperationsMiddleware {
|
|||
|
didCreateFiles?: NextSignature<FileCreateEvent, void>
|
|||
|
willCreateFiles?: NextSignature<FileWillCreateEvent, Thenable<WorkspaceEdit | null | undefined>>
|
|||
|
didRenameFiles?: NextSignature<FileRenameEvent, void>
|
|||
|
willRenameFiles?: NextSignature<FileWillRenameEvent, Thenable<WorkspaceEdit | null | undefined>>
|
|||
|
didDeleteFiles?: NextSignature<FileDeleteEvent, void>
|
|||
|
willDeleteFiles?: NextSignature<FileWillDeleteEvent, Thenable<WorkspaceEdit | null | undefined>>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideLinkedEditingRangeSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<LinkedEditingRanges>
|
|||
|
}
|
|||
|
|
|||
|
export interface LinkedEditingRangeMiddleware {
|
|||
|
provideLinkedEditingRange?: (
|
|||
|
this: void,
|
|||
|
document: LinesTextDocument,
|
|||
|
position: Position,
|
|||
|
token: CancellationToken,
|
|||
|
next: ProvideLinkedEditingRangeSignature
|
|||
|
) => ProviderResult<LinkedEditingRanges>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideSelectionRangeSignature {
|
|||
|
(this: void, document: LinesTextDocument, positions: Position[], token: CancellationToken): ProviderResult<SelectionRange[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface SelectionRangeProviderMiddleware {
|
|||
|
provideSelectionRanges?: (this: void, document: LinesTextDocument, positions: Position[], token: CancellationToken, next: ProvideSelectionRangeSignature) => ProviderResult<SelectionRange[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface HandleWorkDoneProgressSignature {
|
|||
|
(this: void, token: ProgressToken, params: WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd): void
|
|||
|
}
|
|||
|
|
|||
|
export interface HandleDiagnosticsSignature {
|
|||
|
(this: void, uri: string, diagnostics: Diagnostic[]): void
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideCompletionItemsSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, context: CompletionContext, token: CancellationToken): ProviderResult<CompletionItem[] | CompletionList | null>
|
|||
|
}
|
|||
|
|
|||
|
export interface ResolveCompletionItemSignature {
|
|||
|
(this: void, item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideHoverSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<Hover>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideSignatureHelpSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, context: SignatureHelpContext, token: CancellationToken): ProviderResult<SignatureHelp>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideDefinitionSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<Definition | DefinitionLink[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideReferencesSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, options: {
|
|||
|
includeDeclaration: boolean
|
|||
|
}, token: CancellationToken): ProviderResult<Location[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideDocumentHighlightsSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<DocumentHighlight[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideDocumentSymbolsSignature {
|
|||
|
(this: void, document: LinesTextDocument, token: CancellationToken): ProviderResult<SymbolInformation[] | DocumentSymbol[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideWorkspaceSymbolsSignature {
|
|||
|
(this: void, query: string, token: CancellationToken): ProviderResult<SymbolInformation[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideCodeActionsSignature {
|
|||
|
(this: void, document: LinesTextDocument, range: Range, context: CodeActionContext, token: CancellationToken): ProviderResult<(Command | CodeAction)[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ResolveCodeActionSignature {
|
|||
|
(this: void, item: CodeAction, token: CancellationToken): ProviderResult<CodeAction>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideCodeLensesSignature {
|
|||
|
(this: void, document: LinesTextDocument, token: CancellationToken): ProviderResult<CodeLens[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ResolveCodeLensSignature {
|
|||
|
(this: void, codeLens: CodeLens, token: CancellationToken): ProviderResult<CodeLens>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideDocumentFormattingEditsSignature {
|
|||
|
(this: void, document: LinesTextDocument, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideDocumentRangeFormattingEditsSignature {
|
|||
|
(this: void, document: LinesTextDocument, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideOnTypeFormattingEditsSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, ch: string, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface PrepareRenameSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, token: CancellationToken): ProviderResult<Range | {
|
|||
|
range: Range
|
|||
|
placeholder: string
|
|||
|
}>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideRenameEditsSignature {
|
|||
|
(this: void, document: LinesTextDocument, position: Position, newName: string, token: CancellationToken): ProviderResult<WorkspaceEdit>
|
|||
|
}
|
|||
|
|
|||
|
export interface ProvideDocumentLinksSignature {
|
|||
|
(this: void, document: LinesTextDocument, token: CancellationToken): ProviderResult<DocumentLink[]>
|
|||
|
}
|
|||
|
|
|||
|
export interface ResolveDocumentLinkSignature {
|
|||
|
(this: void, link: DocumentLink, token: CancellationToken): ProviderResult<DocumentLink>
|
|||
|
}
|
|||
|
|
|||
|
export interface ExecuteCommandSignature {
|
|||
|
(this: void, command: string, args: any[]): ProviderResult<any>
|
|||
|
}
|
|||
|
|
|||
|
export interface NextSignature<P, R> {
|
|||
|
(this: void, data: P, next: (data: P) => R): R
|
|||
|
}
|
|||
|
|
|||
|
export interface DidChangeConfigurationSignature {
|
|||
|
(this: void, sections: string[] | undefined): void
|
|||
|
}
|
|||
|
|
|||
|
export interface DidChangeWatchedFileSignature {
|
|||
|
(this: void, event: FileEvent): void
|
|||
|
}
|
|||
|
|
|||
|
export interface _WorkspaceMiddleware {
|
|||
|
didChangeConfiguration?: (this: void, sections: string[] | undefined, next: DidChangeConfigurationSignature) => void
|
|||
|
didChangeWatchedFile?: (this: void, event: FileEvent, next: DidChangeWatchedFileSignature) => void
|
|||
|
}
|
|||
|
|
|||
|
export type WorkspaceMiddleware = _WorkspaceMiddleware & ConfigurationWorkspaceMiddleware & WorkspaceFolderWorkspaceMiddleware & FileOperationsMiddleware
|
|||
|
|
|||
|
/**
|
|||
|
* Params to show a document.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface ShowDocumentParams {
|
|||
|
/**
|
|||
|
* The document uri to show.
|
|||
|
*/
|
|||
|
uri: string
|
|||
|
/**
|
|||
|
* Indicates to show the resource in an external program.
|
|||
|
* To show for example `https://code.visualstudio.com/`
|
|||
|
* in the default WEB browser set `external` to `true`.
|
|||
|
*/
|
|||
|
external?: boolean
|
|||
|
/**
|
|||
|
* An optional property to indicate whether the editor
|
|||
|
* showing the document should take focus or not.
|
|||
|
* Clients might ignore this property if an external
|
|||
|
* program in started.
|
|||
|
*/
|
|||
|
takeFocus?: boolean
|
|||
|
/**
|
|||
|
* An optional selection range if the document is a text
|
|||
|
* document. Clients might ignore the property if an
|
|||
|
* external program is started or the file is not a text
|
|||
|
* file.
|
|||
|
*/
|
|||
|
selection?: Range
|
|||
|
}
|
|||
|
/**
|
|||
|
* The result of an show document request.
|
|||
|
*
|
|||
|
* @since 3.16.0
|
|||
|
*/
|
|||
|
export interface ShowDocumentResult {
|
|||
|
/**
|
|||
|
* A boolean indicating if the show was successful.
|
|||
|
*/
|
|||
|
success: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface _WindowMiddleware {
|
|||
|
showDocument?: (
|
|||
|
this: void,
|
|||
|
params: ShowDocumentParams,
|
|||
|
next: RequestHandler<ShowDocumentParams, ShowDocumentResult, void>
|
|||
|
) => Promise<ShowDocumentResult>
|
|||
|
}
|
|||
|
export type WindowMiddleware = _WindowMiddleware
|
|||
|
|
|||
|
/**
|
|||
|
* The Middleware lets extensions intercept the request and notifications send and received
|
|||
|
* from the server
|
|||
|
*/
|
|||
|
interface _Middleware {
|
|||
|
didOpen?: NextSignature<LinesTextDocument, void>
|
|||
|
didChange?: NextSignature<DidChangeTextDocumentParams, void>
|
|||
|
willSave?: NextSignature<TextDocumentWillSaveEvent, void>
|
|||
|
willSaveWaitUntil?: NextSignature<TextDocumentWillSaveEvent, Thenable<TextEdit[]>>
|
|||
|
didSave?: NextSignature<LinesTextDocument, void>
|
|||
|
didClose?: NextSignature<LinesTextDocument, void>
|
|||
|
handleDiagnostics?: (this: void, uri: string, diagnostics: Diagnostic[], next: HandleDiagnosticsSignature) => void
|
|||
|
provideCompletionItem?: (this: void, document: LinesTextDocument, position: Position, context: CompletionContext, token: CancellationToken, next: ProvideCompletionItemsSignature) => ProviderResult<CompletionItem[] | CompletionList | null>
|
|||
|
resolveCompletionItem?: (this: void, item: CompletionItem, token: CancellationToken, next: ResolveCompletionItemSignature) => ProviderResult<CompletionItem>
|
|||
|
provideHover?: (this: void, document: LinesTextDocument, position: Position, token: CancellationToken, next: ProvideHoverSignature) => ProviderResult<Hover>
|
|||
|
provideSignatureHelp?: (this: void, document: LinesTextDocument, position: Position, context: SignatureHelpContext, token: CancellationToken, next: ProvideSignatureHelpSignature) => ProviderResult<SignatureHelp>
|
|||
|
provideDefinition?: (this: void, document: LinesTextDocument, position: Position, token: CancellationToken, next: ProvideDefinitionSignature) => ProviderResult<Definition | DefinitionLink[]>
|
|||
|
provideReferences?: (this: void, document: LinesTextDocument, position: Position, options: {
|
|||
|
includeDeclaration: boolean
|
|||
|
}, token: CancellationToken, next: ProvideReferencesSignature) => ProviderResult<Location[]>
|
|||
|
provideDocumentHighlights?: (this: void, document: LinesTextDocument, position: Position, token: CancellationToken, next: ProvideDocumentHighlightsSignature) => ProviderResult<DocumentHighlight[]>
|
|||
|
provideDocumentSymbols?: (this: void, document: LinesTextDocument, token: CancellationToken, next: ProvideDocumentSymbolsSignature) => ProviderResult<SymbolInformation[] | DocumentSymbol[]>
|
|||
|
provideWorkspaceSymbols?: (this: void, query: string, token: CancellationToken, next: ProvideWorkspaceSymbolsSignature) => ProviderResult<SymbolInformation[]>
|
|||
|
provideCodeActions?: (this: void, document: LinesTextDocument, range: Range, context: CodeActionContext, token: CancellationToken, next: ProvideCodeActionsSignature) => ProviderResult<(Command | CodeAction)[]>
|
|||
|
handleWorkDoneProgress?: (this: void, token: ProgressToken, params: WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd, next: HandleWorkDoneProgressSignature) => void
|
|||
|
resolveCodeAction?: (this: void, item: CodeAction, token: CancellationToken, next: ResolveCodeActionSignature) => ProviderResult<CodeAction>
|
|||
|
provideCodeLenses?: (this: void, document: LinesTextDocument, token: CancellationToken, next: ProvideCodeLensesSignature) => ProviderResult<CodeLens[]>
|
|||
|
resolveCodeLens?: (this: void, codeLens: CodeLens, token: CancellationToken, next: ResolveCodeLensSignature) => ProviderResult<CodeLens>
|
|||
|
provideDocumentFormattingEdits?: (this: void, document: LinesTextDocument, options: FormattingOptions, token: CancellationToken, next: ProvideDocumentFormattingEditsSignature) => ProviderResult<TextEdit[]>
|
|||
|
provideDocumentRangeFormattingEdits?: (this: void, document: LinesTextDocument, range: Range, options: FormattingOptions, token: CancellationToken, next: ProvideDocumentRangeFormattingEditsSignature) => ProviderResult<TextEdit[]>
|
|||
|
provideOnTypeFormattingEdits?: (this: void, document: LinesTextDocument, position: Position, ch: string, options: FormattingOptions, token: CancellationToken, next: ProvideOnTypeFormattingEditsSignature) => ProviderResult<TextEdit[]>
|
|||
|
prepareRename?: (this: void, document: LinesTextDocument, position: Position, token: CancellationToken, next: PrepareRenameSignature) => ProviderResult<Range | {
|
|||
|
range: Range
|
|||
|
placeholder: string
|
|||
|
}>
|
|||
|
provideRenameEdits?: (this: void, document: LinesTextDocument, position: Position, newName: string, token: CancellationToken, next: ProvideRenameEditsSignature) => ProviderResult<WorkspaceEdit>
|
|||
|
provideDocumentLinks?: (this: void, document: LinesTextDocument, token: CancellationToken, next: ProvideDocumentLinksSignature) => ProviderResult<DocumentLink[]>
|
|||
|
resolveDocumentLink?: (this: void, link: DocumentLink, token: CancellationToken, next: ResolveDocumentLinkSignature) => ProviderResult<DocumentLink>
|
|||
|
executeCommand?: (this: void, command: string, args: any[], next: ExecuteCommandSignature) => ProviderResult<any>
|
|||
|
workspace?: WorkspaceMiddleware
|
|||
|
window?: WindowMiddleware
|
|||
|
}
|
|||
|
export type Middleware = _Middleware & TypeDefinitionMiddleware & ImplementationMiddleware & ColorProviderMiddleware & DeclarationMiddleware & FoldingRangeProviderMiddleware & CallHierarchyMiddleware & SemanticTokensMiddleware & LinkedEditingRangeMiddleware & SelectionRangeProviderMiddleware
|
|||
|
|
|||
|
export interface ConnectionOptions {
|
|||
|
// cancellationStrategy: CancellationStrategy
|
|||
|
maxRestartCount?: number
|
|||
|
}
|
|||
|
|
|||
|
export interface LanguageClientOptions {
|
|||
|
ignoredRootPaths?: string[]
|
|||
|
disableSnippetCompletion?: boolean
|
|||
|
disableDynamicRegister?: boolean
|
|||
|
disabledFeatures?: string[]
|
|||
|
formatterPriority?: number
|
|||
|
documentSelector?: DocumentSelector | string[]
|
|||
|
synchronize?: SynchronizeOptions
|
|||
|
diagnosticCollectionName?: string
|
|||
|
outputChannelName?: string
|
|||
|
outputChannel?: OutputChannel
|
|||
|
revealOutputChannelOn?: RevealOutputChannelOn
|
|||
|
/**
|
|||
|
* The encoding use to read stdout and stderr. Defaults
|
|||
|
* to 'utf8' if omitted.
|
|||
|
*/
|
|||
|
stdioEncoding?: string
|
|||
|
initializationOptions?: any | (() => any)
|
|||
|
initializationFailedHandler?: InitializationFailedHandler
|
|||
|
progressOnInitialization?: boolean
|
|||
|
errorHandler?: ErrorHandler
|
|||
|
middleware?: Middleware
|
|||
|
workspaceFolder?: WorkspaceFolder
|
|||
|
connectionOptions?: ConnectionOptions
|
|||
|
markdown?: {
|
|||
|
isTrusted: boolean
|
|||
|
}
|
|||
|
}
|
|||
|
export enum State {
|
|||
|
Stopped = 1,
|
|||
|
Running = 2,
|
|||
|
Starting = 3
|
|||
|
}
|
|||
|
export interface StateChangeEvent {
|
|||
|
oldState: State
|
|||
|
newState: State
|
|||
|
}
|
|||
|
export enum ClientState {
|
|||
|
Initial = 0,
|
|||
|
Starting = 1,
|
|||
|
StartFailed = 2,
|
|||
|
Running = 3,
|
|||
|
Stopping = 4,
|
|||
|
Stopped = 5
|
|||
|
}
|
|||
|
export interface RegistrationData<T> {
|
|||
|
id: string
|
|||
|
registerOptions: T
|
|||
|
}
|
|||
|
/**
|
|||
|
* A static feature. A static feature can't be dynamically activate via the
|
|||
|
* server. It is wired during the initialize sequence.
|
|||
|
*/
|
|||
|
export interface StaticFeature {
|
|||
|
/**
|
|||
|
* Called to fill the initialize params.
|
|||
|
*
|
|||
|
* @params the initialize params.
|
|||
|
*/
|
|||
|
fillInitializeParams?: (params: any) => void
|
|||
|
/**
|
|||
|
* Called to fill in the client capabilities this feature implements.
|
|||
|
*
|
|||
|
* @param capabilities The client capabilities to fill.
|
|||
|
*/
|
|||
|
fillClientCapabilities(capabilities: any): void
|
|||
|
/**
|
|||
|
* Initialize the feature. This method is called on a feature instance
|
|||
|
* when the client has successfully received the initialize 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 constructor.
|
|||
|
* May be `undefined` if the client was created without a selector.
|
|||
|
*/
|
|||
|
initialize(capabilities: any, documentSelector: DocumentSelector | undefined): void
|
|||
|
/**
|
|||
|
* Called when the client is stopped to dispose this feature. Usually a feature
|
|||
|
* unregisters listeners registered hooked up with the VS Code extension host.
|
|||
|
*/
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
class ParameterStructures {
|
|||
|
private readonly kind
|
|||
|
/**
|
|||
|
* The parameter structure is automatically inferred on the number of parameters
|
|||
|
* and the parameter type in case of a single param.
|
|||
|
*/
|
|||
|
static readonly auto: ParameterStructures
|
|||
|
/**
|
|||
|
* Forces `byPosition` parameter structure. This is useful if you have a single
|
|||
|
* parameter which has a literal type.
|
|||
|
*/
|
|||
|
static readonly byPosition: ParameterStructures
|
|||
|
/**
|
|||
|
* Forces `byName` parameter structure. This is only useful when having a single
|
|||
|
* parameter. The library will report errors if used with a different number of
|
|||
|
* parameters.
|
|||
|
*/
|
|||
|
static readonly byName: ParameterStructures
|
|||
|
private constructor()
|
|||
|
static is(value: any): value is ParameterStructures
|
|||
|
toString(): string
|
|||
|
}
|
|||
|
/**
|
|||
|
* An interface to type messages.
|
|||
|
*/
|
|||
|
export interface MessageSignature {
|
|||
|
readonly method: string
|
|||
|
readonly numberOfParams: number
|
|||
|
readonly parameterStructures: ParameterStructures
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
*
|
|||
|
* An abstract implementation of a MessageType.
|
|||
|
*/
|
|||
|
abstract class AbstractMessageSignature implements MessageSignature {
|
|||
|
readonly method: string
|
|||
|
readonly numberOfParams: number
|
|||
|
constructor(method: string, numberOfParams: number)
|
|||
|
get parameterStructures(): ParameterStructures
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Classes to type request response pairs
|
|||
|
*/
|
|||
|
export class RequestType0<R, E> extends AbstractMessageSignature {
|
|||
|
/**
|
|||
|
* Clients must not use this property. It is here to ensure correct typing.
|
|||
|
*/
|
|||
|
readonly _: [R, E, _EM] | undefined
|
|||
|
constructor(method: string)
|
|||
|
}
|
|||
|
|
|||
|
export class RequestType<P, R, E> extends AbstractMessageSignature {
|
|||
|
private _parameterStructures
|
|||
|
/**
|
|||
|
* Clients must not use this property. It is here to ensure correct typing.
|
|||
|
*/
|
|||
|
readonly _: [P, R, E, _EM] | undefined
|
|||
|
constructor(method: string, _parameterStructures?: ParameterStructures)
|
|||
|
get parameterStructures(): ParameterStructures
|
|||
|
}
|
|||
|
|
|||
|
export class NotificationType<P> extends AbstractMessageSignature {
|
|||
|
/**
|
|||
|
* Clients must not use this property. It is here to ensure correct typing.
|
|||
|
*/
|
|||
|
readonly _: [P, _EM] | undefined
|
|||
|
constructor(method: string)
|
|||
|
}
|
|||
|
|
|||
|
export class NotificationType0 extends AbstractMessageSignature {
|
|||
|
/**
|
|||
|
* Clients must not use this property. It is here to ensure correct typing.
|
|||
|
*/
|
|||
|
readonly _: [_EM] | undefined
|
|||
|
constructor(method: string)
|
|||
|
}
|
|||
|
|
|||
|
export interface InitializeParams {
|
|||
|
/**
|
|||
|
* The process Id of the parent process that started
|
|||
|
* the server.
|
|||
|
*/
|
|||
|
processId: number | null
|
|||
|
/**
|
|||
|
* Information about the client
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
clientInfo?: {
|
|||
|
/**
|
|||
|
* The name of the client as defined by the client.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* The client's version as defined by the client.
|
|||
|
*/
|
|||
|
version?: string
|
|||
|
}
|
|||
|
/**
|
|||
|
* The rootPath of the workspace. Is null
|
|||
|
* if no folder is open.
|
|||
|
*
|
|||
|
* @deprecated in favour of rootUri.
|
|||
|
*/
|
|||
|
rootPath?: string | null
|
|||
|
/**
|
|||
|
* The rootUri of the workspace. Is null if no
|
|||
|
* folder is open. If both `rootPath` and `rootUri` are set
|
|||
|
* `rootUri` wins.
|
|||
|
*
|
|||
|
* @deprecated in favour of workspaceFolders.
|
|||
|
*/
|
|||
|
rootUri: string | null
|
|||
|
/**
|
|||
|
* The capabilities provided by the client (editor or tool)
|
|||
|
*/
|
|||
|
capabilities: any
|
|||
|
/**
|
|||
|
* User provided initialization options.
|
|||
|
*/
|
|||
|
initializationOptions?: any
|
|||
|
/**
|
|||
|
* The initial trace setting. If omitted trace is disabled ('off').
|
|||
|
*/
|
|||
|
trace?: 'off' | 'messages' | 'verbose'
|
|||
|
/**
|
|||
|
* An optional token that a server can use to report work done progress.
|
|||
|
*/
|
|||
|
workDoneToken?: ProgressToken
|
|||
|
}
|
|||
|
class RegistrationType<RO> {
|
|||
|
/**
|
|||
|
* Clients must not use this property. It is here to ensure correct typing.
|
|||
|
*/
|
|||
|
readonly ____: [RO, _EM] | undefined
|
|||
|
readonly method: string
|
|||
|
constructor(method: string)
|
|||
|
}
|
|||
|
/**
|
|||
|
* The result returned from an initialize request.
|
|||
|
*/
|
|||
|
export interface InitializeResult {
|
|||
|
/**
|
|||
|
* The capabilities the language server provides.
|
|||
|
*/
|
|||
|
capabilities: any
|
|||
|
/**
|
|||
|
* Information about the server.
|
|||
|
*
|
|||
|
* @since 3.15.0
|
|||
|
*/
|
|||
|
serverInfo?: {
|
|||
|
/**
|
|||
|
* The name of the server as defined by the server.
|
|||
|
*/
|
|||
|
name: string
|
|||
|
/**
|
|||
|
* The servers's version as defined by the server.
|
|||
|
*/
|
|||
|
version?: string
|
|||
|
}
|
|||
|
/**
|
|||
|
* Custom initialization results.
|
|||
|
*/
|
|||
|
[custom: string]: any
|
|||
|
}
|
|||
|
|
|||
|
export interface DynamicFeature<RO> {
|
|||
|
/**
|
|||
|
* 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: any): void
|
|||
|
/**
|
|||
|
* Initialize the feature. This method is called on a feature instance
|
|||
|
* when the client has successfully received the initialize 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 constructor.
|
|||
|
* May be `undefined` if the client was created without a selector.
|
|||
|
*/
|
|||
|
initialize(capabilities: any, documentSelector: DocumentSelector | undefined): void
|
|||
|
/**
|
|||
|
* The signature (e.g. method) for which this features support dynamic activation / registration.
|
|||
|
*/
|
|||
|
registrationType: RegistrationType<RO>
|
|||
|
/**
|
|||
|
* Is called when the server send a register request for the given message.
|
|||
|
*
|
|||
|
* @param data additional registration data as defined in the protocol.
|
|||
|
*/
|
|||
|
register(data: RegistrationData<RO>): void
|
|||
|
/**
|
|||
|
* Is called when the server wants to unregister a feature.
|
|||
|
*
|
|||
|
* @param id the id used when registering the feature.
|
|||
|
*/
|
|||
|
unregister(id: string): void
|
|||
|
/**
|
|||
|
* Called when the client is stopped to dispose this feature. Usually a feature
|
|||
|
* unregisters listeners registered hooked up with the VS Code extension host.
|
|||
|
*/
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface NotificationFeature<T extends Function> {
|
|||
|
/**
|
|||
|
* Triggers the corresponding RPC method.
|
|||
|
*/
|
|||
|
getProvider(document: TextDocument): {
|
|||
|
send: T
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
export interface ExecutableOptions {
|
|||
|
cwd?: string
|
|||
|
env?: any
|
|||
|
detached?: boolean
|
|||
|
shell?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface Executable {
|
|||
|
command: string
|
|||
|
args?: string[]
|
|||
|
options?: ExecutableOptions
|
|||
|
}
|
|||
|
|
|||
|
export interface ForkOptions {
|
|||
|
cwd?: string
|
|||
|
env?: any
|
|||
|
execPath?: string
|
|||
|
encoding?: string
|
|||
|
execArgv?: string[]
|
|||
|
}
|
|||
|
|
|||
|
export interface StreamInfo {
|
|||
|
writer: NodeJS.WritableStream
|
|||
|
reader: NodeJS.ReadableStream
|
|||
|
detached?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export enum TransportKind {
|
|||
|
stdio = 0,
|
|||
|
ipc = 1,
|
|||
|
pipe = 2,
|
|||
|
socket = 3
|
|||
|
}
|
|||
|
|
|||
|
export interface SocketTransport {
|
|||
|
kind: TransportKind.socket
|
|||
|
port: number
|
|||
|
}
|
|||
|
|
|||
|
export interface NodeModule {
|
|||
|
module: string
|
|||
|
transport?: TransportKind | SocketTransport
|
|||
|
args?: string[]
|
|||
|
runtime?: string
|
|||
|
options?: ForkOptions
|
|||
|
}
|
|||
|
|
|||
|
export interface ChildProcessInfo {
|
|||
|
process: cp.ChildProcess
|
|||
|
detached: boolean
|
|||
|
}
|
|||
|
|
|||
|
export interface PartialMessageInfo {
|
|||
|
readonly messageToken: number
|
|||
|
readonly waitingTime: number
|
|||
|
}
|
|||
|
|
|||
|
export interface MessageReader {
|
|||
|
readonly onError: Event<Error>
|
|||
|
readonly onClose: Event<void>
|
|||
|
readonly onPartialMessage: Event<PartialMessageInfo>
|
|||
|
listen(callback: (data: { jsonrpc: string }) => void): void
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export interface MessageWriter {
|
|||
|
readonly onError: Event<[Error, { jsonrpc: string } | undefined, number | undefined]>
|
|||
|
readonly onClose: Event<void>
|
|||
|
write(msg: { jsonrpc: string }): void
|
|||
|
dispose(): void
|
|||
|
}
|
|||
|
|
|||
|
export class NullLogger {
|
|||
|
constructor()
|
|||
|
error(message: string): void
|
|||
|
warn(message: string): void
|
|||
|
info(message: string): void
|
|||
|
log(message: string): void
|
|||
|
}
|
|||
|
|
|||
|
export interface MessageTransports {
|
|||
|
reader: MessageReader
|
|||
|
writer: MessageWriter
|
|||
|
detached?: boolean
|
|||
|
}
|
|||
|
|
|||
|
export namespace MessageTransports {
|
|||
|
/**
|
|||
|
* Checks whether the given value conforms to the [MessageTransports](#MessageTransports) interface.
|
|||
|
*/
|
|||
|
function is(value: any): value is MessageTransports
|
|||
|
}
|
|||
|
|
|||
|
export type ServerOptions = Executable | NodeModule | {
|
|||
|
run: Executable
|
|||
|
debug: Executable
|
|||
|
} | {
|
|||
|
run: NodeModule
|
|||
|
debug: NodeModule
|
|||
|
} | (() => Promise<cp.ChildProcess | StreamInfo | MessageTransports | ChildProcessInfo>)
|
|||
|
|
|||
|
export interface _EM {
|
|||
|
_$endMarker$_: number
|
|||
|
}
|
|||
|
|
|||
|
export class ProgressType<P> {
|
|||
|
/**
|
|||
|
* Clients must not use this property. It is here to ensure correct typing.
|
|||
|
*/
|
|||
|
readonly __?: [P, _EM]
|
|||
|
constructor()
|
|||
|
}
|
|||
|
|
|||
|
export enum Trace {
|
|||
|
Off = 0,
|
|||
|
Messages = 1,
|
|||
|
Verbose = 2
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* A language server for manage a language server.
|
|||
|
* It's recommended to use `services.registLanguageClient` for regist language client to serviers,
|
|||
|
* you can have language client listed in `CocList services` and services could start the language client
|
|||
|
* by `documentselector` of `clientOptions`.
|
|||
|
*/
|
|||
|
export class LanguageClient {
|
|||
|
readonly id: string
|
|||
|
readonly name: string
|
|||
|
constructor(id: string, name: string, serverOptions: ServerOptions, clientOptions: LanguageClientOptions, forceDebug?: boolean)
|
|||
|
/**
|
|||
|
* Create language client by name and options, don't forget regist language client
|
|||
|
* to services by `services.registLanguageClient`
|
|||
|
*/
|
|||
|
constructor(name: string, serverOptions: ServerOptions, clientOptions: LanguageClientOptions, forceDebug?: boolean)
|
|||
|
/**
|
|||
|
* R => result
|
|||
|
* E => Error result
|
|||
|
*/
|
|||
|
sendRequest<R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>
|
|||
|
/**
|
|||
|
* P => params
|
|||
|
* R => result
|
|||
|
* E => Error result
|
|||
|
*/
|
|||
|
sendRequest<P, R, E>(type: RequestType<P, R, E>, params: P, token?: CancellationToken): Promise<R>
|
|||
|
sendRequest<R>(method: string, token?: CancellationToken): Promise<R>
|
|||
|
sendRequest<R>(method: string, param: any, token?: CancellationToken): Promise<R>
|
|||
|
|
|||
|
onRequest<R, E>(type: RequestType0<R, E>, handler: RequestHandler0<R, E>): Disposable
|
|||
|
onRequest<P, R, E>(type: RequestType<P, R, E>, handler: RequestHandler<P, R, E>): Disposable
|
|||
|
onRequest<R, E>(method: string, handler: (...params: any[]) => HandlerResult<R, E>): Disposable
|
|||
|
|
|||
|
sendNotification(type: NotificationType0): void
|
|||
|
sendNotification<P>(type: NotificationType<P>, params?: P): void
|
|||
|
sendNotification(method: string): void
|
|||
|
sendNotification(method: string, params: any): void
|
|||
|
|
|||
|
onNotification(type: NotificationType0, handler: () => void): Disposable
|
|||
|
onNotification<P>(type: NotificationType<P>, handler: (params: P) => void): Disposable
|
|||
|
onNotification(method: string, handler: (...params: any[]) => void): Disposable
|
|||
|
|
|||
|
onProgress<P>(type: ProgressType<any>, token: string | number, handler: (params: P) => void): Disposable
|
|||
|
sendProgress<P>(type: ProgressType<P>, token: string | number, value: P): void
|
|||
|
|
|||
|
/**
|
|||
|
* Append info to outputChannel
|
|||
|
*/
|
|||
|
info(message: string, data?: any): void
|
|||
|
/**
|
|||
|
* Append warning to outputChannel
|
|||
|
*/
|
|||
|
warn(message: string, data?: any): void
|
|||
|
/**
|
|||
|
* append error to outputChannel
|
|||
|
*/
|
|||
|
error(message: string, data?: any): void
|
|||
|
getPublicState(): State
|
|||
|
get initializeResult(): InitializeResult | undefined
|
|||
|
|
|||
|
get clientOptions(): LanguageClientOptions
|
|||
|
/**
|
|||
|
* Fired on language server state change.
|
|||
|
*/
|
|||
|
get onDidChangeState(): Event<StateChangeEvent>
|
|||
|
get outputChannel(): OutputChannel
|
|||
|
get diagnostics(): DiagnosticCollection | undefined
|
|||
|
|
|||
|
/**
|
|||
|
* Current running state.
|
|||
|
*/
|
|||
|
get serviceState(): ServiceStat
|
|||
|
/**
|
|||
|
* Check if server could start.
|
|||
|
*/
|
|||
|
needsStart(): boolean
|
|||
|
/**
|
|||
|
* Check if server could stop.
|
|||
|
*/
|
|||
|
needsStop(): boolean
|
|||
|
onReady(): Promise<void>
|
|||
|
get started(): boolean
|
|||
|
set trace(value: Trace)
|
|||
|
|
|||
|
/**
|
|||
|
* Stop language server.
|
|||
|
*/
|
|||
|
stop(): Promise<void>
|
|||
|
|
|||
|
/**
|
|||
|
* Start language server, not needed when registered to services by `services.registLanguageClient`
|
|||
|
*/
|
|||
|
start(): Disposable
|
|||
|
/**
|
|||
|
* Restart language client.
|
|||
|
*/
|
|||
|
restart(): void
|
|||
|
|
|||
|
/**
|
|||
|
* Register custom feature.
|
|||
|
*/
|
|||
|
registerFeature(feature: StaticFeature | DynamicFeature<any>): void
|
|||
|
|
|||
|
/**
|
|||
|
* Log failed request to outputChannel.
|
|||
|
*/
|
|||
|
handleFailedRequest<T>(type: MessageSignature, token: CancellationToken | undefined, error: any, defaultValue: T)
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Monitor for setting change, restart language server when specified setting changed.
|
|||
|
*/
|
|||
|
export class SettingMonitor {
|
|||
|
constructor(client: LanguageClient, setting: string)
|
|||
|
start(): Disposable
|
|||
|
}
|
|||
|
// }}
|
|||
|
}
|
|||
|
// vim: set sw=2 ts=2 sts=2 et foldmarker={{,}} foldmethod=marker foldlevel=0 nofen:
|