1883 lines
60 KiB
TypeScript
1883 lines
60 KiB
TypeScript
/**
|
|
* Declaration module describing the TypeScript Server protocol
|
|
*/
|
|
declare namespace ts.server.protocol {
|
|
namespace CommandTypes {
|
|
type Brace = "brace";
|
|
type BraceCompletion = "braceCompletion";
|
|
type Change = "change";
|
|
type Close = "close";
|
|
type Completions = "completions";
|
|
type CompletionDetails = "completionEntryDetails";
|
|
type CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList";
|
|
type CompileOnSaveEmitFile = "compileOnSaveEmitFile";
|
|
type Configure = "configure";
|
|
type Definition = "definition";
|
|
type Implementation = "implementation";
|
|
type Exit = "exit";
|
|
type Format = "format";
|
|
type Formatonkey = "formatonkey";
|
|
type Geterr = "geterr";
|
|
type GeterrForProject = "geterrForProject";
|
|
type SemanticDiagnosticsSync = "semanticDiagnosticsSync";
|
|
type SyntacticDiagnosticsSync = "syntacticDiagnosticsSync";
|
|
type NavBar = "navbar";
|
|
type Navto = "navto";
|
|
type NavTree = "navtree";
|
|
type NavTreeFull = "navtree-full";
|
|
type Occurrences = "occurrences";
|
|
type DocumentHighlights = "documentHighlights";
|
|
type Open = "open";
|
|
type Quickinfo = "quickinfo";
|
|
type References = "references";
|
|
type Reload = "reload";
|
|
type Rename = "rename";
|
|
type Saveto = "saveto";
|
|
type SignatureHelp = "signatureHelp";
|
|
type TypeDefinition = "typeDefinition";
|
|
type ProjectInfo = "projectInfo";
|
|
type ReloadProjects = "reloadProjects";
|
|
type Unknown = "unknown";
|
|
type OpenExternalProject = "openExternalProject";
|
|
type OpenExternalProjects = "openExternalProjects";
|
|
type CloseExternalProject = "closeExternalProject";
|
|
type TodoComments = "todoComments";
|
|
type Indentation = "indentation";
|
|
type DocCommentTemplate = "docCommentTemplate";
|
|
type CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects";
|
|
type GetCodeFixes = "getCodeFixes";
|
|
type GetSupportedCodeFixes = "getSupportedCodeFixes";
|
|
}
|
|
/**
|
|
* A TypeScript Server message
|
|
*/
|
|
interface Message {
|
|
/**
|
|
* Sequence number of the message
|
|
*/
|
|
seq: number;
|
|
/**
|
|
* One of "request", "response", or "event"
|
|
*/
|
|
type: "request" | "response" | "event";
|
|
}
|
|
/**
|
|
* Client-initiated request message
|
|
*/
|
|
interface Request extends Message {
|
|
/**
|
|
* The command to execute
|
|
*/
|
|
command: string;
|
|
/**
|
|
* Object containing arguments for the command
|
|
*/
|
|
arguments?: any;
|
|
}
|
|
/**
|
|
* Request to reload the project structure for all the opened files
|
|
*/
|
|
interface ReloadProjectsRequest extends Message {
|
|
command: CommandTypes.ReloadProjects;
|
|
}
|
|
/**
|
|
* Server-initiated event message
|
|
*/
|
|
interface Event extends Message {
|
|
/**
|
|
* Name of event
|
|
*/
|
|
event: string;
|
|
/**
|
|
* Event-specific information
|
|
*/
|
|
body?: any;
|
|
}
|
|
/**
|
|
* Response by server to client request message.
|
|
*/
|
|
interface Response extends Message {
|
|
/**
|
|
* Sequence number of the request message.
|
|
*/
|
|
request_seq: number;
|
|
/**
|
|
* Outcome of the request.
|
|
*/
|
|
success: boolean;
|
|
/**
|
|
* The command requested.
|
|
*/
|
|
command: string;
|
|
/**
|
|
* Contains error message if success === false.
|
|
*/
|
|
message?: string;
|
|
/**
|
|
* Contains message body if success === true.
|
|
*/
|
|
body?: any;
|
|
}
|
|
/**
|
|
* Arguments for FileRequest messages.
|
|
*/
|
|
interface FileRequestArgs {
|
|
/**
|
|
* The file for the request (absolute pathname required).
|
|
*/
|
|
file: string;
|
|
projectFileName?: string;
|
|
}
|
|
/**
|
|
* Requests a JS Doc comment template for a given position
|
|
*/
|
|
interface DocCommentTemplateRequest extends FileLocationRequest {
|
|
command: CommandTypes.DocCommentTemplate;
|
|
}
|
|
/**
|
|
* Response to DocCommentTemplateRequest
|
|
*/
|
|
interface DocCommandTemplateResponse extends Response {
|
|
body?: TextInsertion;
|
|
}
|
|
/**
|
|
* A request to get TODO comments from the file
|
|
*/
|
|
interface TodoCommentRequest extends FileRequest {
|
|
command: CommandTypes.TodoComments;
|
|
arguments: TodoCommentRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments for TodoCommentRequest request.
|
|
*/
|
|
interface TodoCommentRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* Array of target TodoCommentDescriptors that describes TODO comments to be found
|
|
*/
|
|
descriptors: TodoCommentDescriptor[];
|
|
}
|
|
/**
|
|
* Response for TodoCommentRequest request.
|
|
*/
|
|
interface TodoCommentsResponse extends Response {
|
|
body?: TodoComment[];
|
|
}
|
|
/**
|
|
* A request to get indentation for a location in file
|
|
*/
|
|
interface IndentationRequest extends FileLocationRequest {
|
|
command: CommandTypes.Indentation;
|
|
arguments: IndentationRequestArgs;
|
|
}
|
|
/**
|
|
* Response for IndentationRequest request.
|
|
*/
|
|
interface IndentationResponse extends Response {
|
|
body?: IndentationResult;
|
|
}
|
|
/**
|
|
* Indentation result representing where indentation should be placed
|
|
*/
|
|
interface IndentationResult {
|
|
/**
|
|
* The base position in the document that the indent should be relative to
|
|
*/
|
|
position: number;
|
|
/**
|
|
* The number of columns the indent should be at relative to the position's column.
|
|
*/
|
|
indentation: number;
|
|
}
|
|
/**
|
|
* Arguments for IndentationRequest request.
|
|
*/
|
|
interface IndentationRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* An optional set of settings to be used when computing indentation.
|
|
* If argument is omitted - then it will use settings for file that were previously set via 'configure' request or global settings.
|
|
*/
|
|
options?: EditorSettings;
|
|
}
|
|
/**
|
|
* Arguments for ProjectInfoRequest request.
|
|
*/
|
|
interface ProjectInfoRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* Indicate if the file name list of the project is needed
|
|
*/
|
|
needFileNameList: boolean;
|
|
}
|
|
/**
|
|
* A request to get the project information of the current file.
|
|
*/
|
|
interface ProjectInfoRequest extends Request {
|
|
command: CommandTypes.ProjectInfo;
|
|
arguments: ProjectInfoRequestArgs;
|
|
}
|
|
/**
|
|
* A request to retrieve compiler options diagnostics for a project
|
|
*/
|
|
interface CompilerOptionsDiagnosticsRequest extends Request {
|
|
arguments: CompilerOptionsDiagnosticsRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments for CompilerOptionsDiagnosticsRequest request.
|
|
*/
|
|
interface CompilerOptionsDiagnosticsRequestArgs {
|
|
/**
|
|
* Name of the project to retrieve compiler options diagnostics.
|
|
*/
|
|
projectFileName: string;
|
|
}
|
|
/**
|
|
* Response message body for "projectInfo" request
|
|
*/
|
|
interface ProjectInfo {
|
|
/**
|
|
* For configured project, this is the normalized path of the 'tsconfig.json' file
|
|
* For inferred project, this is undefined
|
|
*/
|
|
configFileName: string;
|
|
/**
|
|
* The list of normalized file name in the project, including 'lib.d.ts'
|
|
*/
|
|
fileNames?: string[];
|
|
/**
|
|
* Indicates if the project has a active language service instance
|
|
*/
|
|
languageServiceDisabled?: boolean;
|
|
}
|
|
/**
|
|
* Represents diagnostic info that includes location of diagnostic in two forms
|
|
* - start position and length of the error span
|
|
* - startLocation and endLocation - a pair of Location objects that store start/end line and offset of the error span.
|
|
*/
|
|
interface DiagnosticWithLinePosition {
|
|
message: string;
|
|
start: number;
|
|
length: number;
|
|
startLocation: Location;
|
|
endLocation: Location;
|
|
category: string;
|
|
code: number;
|
|
}
|
|
/**
|
|
* Response message for "projectInfo" request
|
|
*/
|
|
interface ProjectInfoResponse extends Response {
|
|
body?: ProjectInfo;
|
|
}
|
|
/**
|
|
* Request whose sole parameter is a file name.
|
|
*/
|
|
interface FileRequest extends Request {
|
|
arguments: FileRequestArgs;
|
|
}
|
|
/**
|
|
* Instances of this interface specify a location in a source file:
|
|
* (file, line, character offset), where line and character offset are 1-based.
|
|
*/
|
|
interface FileLocationRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* The line number for the request (1-based).
|
|
*/
|
|
line: number;
|
|
/**
|
|
* The character offset (on the line) for the request (1-based).
|
|
*/
|
|
offset: number;
|
|
}
|
|
/**
|
|
* Request for the available codefixes at a specific position.
|
|
*/
|
|
interface CodeFixRequest extends Request {
|
|
command: CommandTypes.GetCodeFixes;
|
|
arguments: CodeFixRequestArgs;
|
|
}
|
|
/**
|
|
* Instances of this interface specify errorcodes on a specific location in a sourcefile.
|
|
*/
|
|
interface CodeFixRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* The line number for the request (1-based).
|
|
*/
|
|
startLine: number;
|
|
/**
|
|
* The character offset (on the line) for the request (1-based).
|
|
*/
|
|
startOffset: number;
|
|
/**
|
|
* The line number for the request (1-based).
|
|
*/
|
|
endLine: number;
|
|
/**
|
|
* The character offset (on the line) for the request (1-based).
|
|
*/
|
|
endOffset: number;
|
|
/**
|
|
* Errorcodes we want to get the fixes for.
|
|
*/
|
|
errorCodes?: number[];
|
|
}
|
|
/**
|
|
* Response for GetCodeFixes request.
|
|
*/
|
|
interface GetCodeFixesResponse extends Response {
|
|
body?: CodeAction[];
|
|
}
|
|
/**
|
|
* A request whose arguments specify a file location (file, line, col).
|
|
*/
|
|
interface FileLocationRequest extends FileRequest {
|
|
arguments: FileLocationRequestArgs;
|
|
}
|
|
/**
|
|
* A request to get codes of supported code fixes.
|
|
*/
|
|
interface GetSupportedCodeFixesRequest extends Request {
|
|
command: CommandTypes.GetSupportedCodeFixes;
|
|
}
|
|
/**
|
|
* A response for GetSupportedCodeFixesRequest request.
|
|
*/
|
|
interface GetSupportedCodeFixesResponse extends Response {
|
|
/**
|
|
* List of error codes supported by the server.
|
|
*/
|
|
body?: string[];
|
|
}
|
|
/**
|
|
* Arguments for EncodedSemanticClassificationsRequest request.
|
|
*/
|
|
interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* Start position of the span.
|
|
*/
|
|
start: number;
|
|
/**
|
|
* Length of the span.
|
|
*/
|
|
length: number;
|
|
}
|
|
/**
|
|
* Arguments in document highlight request; include: filesToSearch, file,
|
|
* line, offset.
|
|
*/
|
|
interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* List of files to search for document highlights.
|
|
*/
|
|
filesToSearch: string[];
|
|
}
|
|
/**
|
|
* Go to definition request; value of command field is
|
|
* "definition". Return response giving the file locations that
|
|
* define the symbol found in file at location line, col.
|
|
*/
|
|
interface DefinitionRequest extends FileLocationRequest {
|
|
command: CommandTypes.Definition;
|
|
}
|
|
/**
|
|
* Go to type request; value of command field is
|
|
* "typeDefinition". Return response giving the file locations that
|
|
* define the type for the symbol found in file at location line, col.
|
|
*/
|
|
interface TypeDefinitionRequest extends FileLocationRequest {
|
|
command: CommandTypes.TypeDefinition;
|
|
}
|
|
/**
|
|
* Go to implementation request; value of command field is
|
|
* "implementation". Return response giving the file locations that
|
|
* implement the symbol found in file at location line, col.
|
|
*/
|
|
interface ImplementationRequest extends FileLocationRequest {
|
|
command: CommandTypes.Implementation;
|
|
}
|
|
/**
|
|
* Location in source code expressed as (one-based) line and character offset.
|
|
*/
|
|
interface Location {
|
|
line: number;
|
|
offset: number;
|
|
}
|
|
/**
|
|
* Object found in response messages defining a span of text in source code.
|
|
*/
|
|
interface TextSpan {
|
|
/**
|
|
* First character of the definition.
|
|
*/
|
|
start: Location;
|
|
/**
|
|
* One character past last character of the definition.
|
|
*/
|
|
end: Location;
|
|
}
|
|
/**
|
|
* Object found in response messages defining a span of text in a specific source file.
|
|
*/
|
|
interface FileSpan extends TextSpan {
|
|
/**
|
|
* File containing text span.
|
|
*/
|
|
file: string;
|
|
}
|
|
/**
|
|
* Definition response message. Gives text range for definition.
|
|
*/
|
|
interface DefinitionResponse extends Response {
|
|
body?: FileSpan[];
|
|
}
|
|
/**
|
|
* Definition response message. Gives text range for definition.
|
|
*/
|
|
interface TypeDefinitionResponse extends Response {
|
|
body?: FileSpan[];
|
|
}
|
|
/**
|
|
* Implementation response message. Gives text range for implementations.
|
|
*/
|
|
interface ImplementationResponse extends Response {
|
|
body?: FileSpan[];
|
|
}
|
|
/**
|
|
* Request to get brace completion for a location in the file.
|
|
*/
|
|
interface BraceCompletionRequest extends FileLocationRequest {
|
|
command: CommandTypes.BraceCompletion;
|
|
arguments: BraceCompletionRequestArgs;
|
|
}
|
|
/**
|
|
* Argument for BraceCompletionRequest request.
|
|
*/
|
|
interface BraceCompletionRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* Kind of opening brace
|
|
*/
|
|
openingBrace: string;
|
|
}
|
|
/**
|
|
* Get occurrences request; value of command field is
|
|
* "occurrences". Return response giving spans that are relevant
|
|
* in the file at a given line and column.
|
|
*/
|
|
interface OccurrencesRequest extends FileLocationRequest {
|
|
command: CommandTypes.Occurrences;
|
|
}
|
|
interface OccurrencesResponseItem extends FileSpan {
|
|
/**
|
|
* True if the occurrence is a write location, false otherwise.
|
|
*/
|
|
isWriteAccess: boolean;
|
|
}
|
|
interface OccurrencesResponse extends Response {
|
|
body?: OccurrencesResponseItem[];
|
|
}
|
|
/**
|
|
* Get document highlights request; value of command field is
|
|
* "documentHighlights". Return response giving spans that are relevant
|
|
* in the file at a given line and column.
|
|
*/
|
|
interface DocumentHighlightsRequest extends FileLocationRequest {
|
|
command: CommandTypes.DocumentHighlights;
|
|
arguments: DocumentHighlightsRequestArgs;
|
|
}
|
|
/**
|
|
* Span augmented with extra information that denotes the kind of the highlighting to be used for span.
|
|
* Kind is taken from HighlightSpanKind type.
|
|
*/
|
|
interface HighlightSpan extends TextSpan {
|
|
kind: string;
|
|
}
|
|
/**
|
|
* Represents a set of highligh spans for a give name
|
|
*/
|
|
interface DocumentHighlightsItem {
|
|
/**
|
|
* File containing highlight spans.
|
|
*/
|
|
file: string;
|
|
/**
|
|
* Spans to highlight in file.
|
|
*/
|
|
highlightSpans: HighlightSpan[];
|
|
}
|
|
/**
|
|
* Response for a DocumentHighlightsRequest request.
|
|
*/
|
|
interface DocumentHighlightsResponse extends Response {
|
|
body?: DocumentHighlightsItem[];
|
|
}
|
|
/**
|
|
* Find references request; value of command field is
|
|
* "references". Return response giving the file locations that
|
|
* reference the symbol found in file at location line, col.
|
|
*/
|
|
interface ReferencesRequest extends FileLocationRequest {
|
|
command: CommandTypes.References;
|
|
}
|
|
interface ReferencesResponseItem extends FileSpan {
|
|
/** Text of line containing the reference. Including this
|
|
* with the response avoids latency of editor loading files
|
|
* to show text of reference line (the server already has
|
|
* loaded the referencing files).
|
|
*/
|
|
lineText: string;
|
|
/**
|
|
* True if reference is a write location, false otherwise.
|
|
*/
|
|
isWriteAccess: boolean;
|
|
/**
|
|
* True if reference is a definition, false otherwise.
|
|
*/
|
|
isDefinition: boolean;
|
|
}
|
|
/**
|
|
* The body of a "references" response message.
|
|
*/
|
|
interface ReferencesResponseBody {
|
|
/**
|
|
* The file locations referencing the symbol.
|
|
*/
|
|
refs: ReferencesResponseItem[];
|
|
/**
|
|
* The name of the symbol.
|
|
*/
|
|
symbolName: string;
|
|
/**
|
|
* The start character offset of the symbol (on the line provided by the references request).
|
|
*/
|
|
symbolStartOffset: number;
|
|
/**
|
|
* The full display name of the symbol.
|
|
*/
|
|
symbolDisplayString: string;
|
|
}
|
|
/**
|
|
* Response to "references" request.
|
|
*/
|
|
interface ReferencesResponse extends Response {
|
|
body?: ReferencesResponseBody;
|
|
}
|
|
/**
|
|
* Argument for RenameRequest request.
|
|
*/
|
|
interface RenameRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* Should text at specified location be found/changed in comments?
|
|
*/
|
|
findInComments?: boolean;
|
|
/**
|
|
* Should text at specified location be found/changed in strings?
|
|
*/
|
|
findInStrings?: boolean;
|
|
}
|
|
/**
|
|
* Rename request; value of command field is "rename". Return
|
|
* response giving the file locations that reference the symbol
|
|
* found in file at location line, col. Also return full display
|
|
* name of the symbol so that client can print it unambiguously.
|
|
*/
|
|
interface RenameRequest extends FileLocationRequest {
|
|
command: CommandTypes.Rename;
|
|
arguments: RenameRequestArgs;
|
|
}
|
|
/**
|
|
* Information about the item to be renamed.
|
|
*/
|
|
interface RenameInfo {
|
|
/**
|
|
* True if item can be renamed.
|
|
*/
|
|
canRename: boolean;
|
|
/**
|
|
* Error message if item can not be renamed.
|
|
*/
|
|
localizedErrorMessage?: string;
|
|
/**
|
|
* Display name of the item to be renamed.
|
|
*/
|
|
displayName: string;
|
|
/**
|
|
* Full display name of item to be renamed.
|
|
*/
|
|
fullDisplayName: string;
|
|
/**
|
|
* The items's kind (such as 'className' or 'parameterName' or plain 'text').
|
|
*/
|
|
kind: string;
|
|
/**
|
|
* Optional modifiers for the kind (such as 'public').
|
|
*/
|
|
kindModifiers: string;
|
|
}
|
|
/**
|
|
* A group of text spans, all in 'file'.
|
|
*/
|
|
interface SpanGroup {
|
|
/** The file to which the spans apply */
|
|
file: string;
|
|
/** The text spans in this group */
|
|
locs: TextSpan[];
|
|
}
|
|
interface RenameResponseBody {
|
|
/**
|
|
* Information about the item to be renamed.
|
|
*/
|
|
info: RenameInfo;
|
|
/**
|
|
* An array of span groups (one per file) that refer to the item to be renamed.
|
|
*/
|
|
locs: SpanGroup[];
|
|
}
|
|
/**
|
|
* Rename response message.
|
|
*/
|
|
interface RenameResponse extends Response {
|
|
body?: RenameResponseBody;
|
|
}
|
|
/**
|
|
* Represents a file in external project.
|
|
* External project is project whose set of files, compilation options and open\close state
|
|
* is maintained by the client (i.e. if all this data come from .csproj file in Visual Studio).
|
|
* External project will exist even if all files in it are closed and should be closed explicity.
|
|
* If external project includes one or more tsconfig.json/jsconfig.json files then tsserver will
|
|
* create configured project for every config file but will maintain a link that these projects were created
|
|
* as a result of opening external project so they should be removed once external project is closed.
|
|
*/
|
|
interface ExternalFile {
|
|
/**
|
|
* Name of file file
|
|
*/
|
|
fileName: string;
|
|
/**
|
|
* Script kind of the file
|
|
*/
|
|
scriptKind?: ScriptKindName | ts.ScriptKind;
|
|
/**
|
|
* Whether file has mixed content (i.e. .cshtml file that combines html markup with C#/JavaScript)
|
|
*/
|
|
hasMixedContent?: boolean;
|
|
/**
|
|
* Content of the file
|
|
*/
|
|
content?: string;
|
|
}
|
|
/**
|
|
* Represent an external project
|
|
*/
|
|
interface ExternalProject {
|
|
/**
|
|
* Project name
|
|
*/
|
|
projectFileName: string;
|
|
/**
|
|
* List of root files in project
|
|
*/
|
|
rootFiles: ExternalFile[];
|
|
/**
|
|
* Compiler options for the project
|
|
*/
|
|
options: ExternalProjectCompilerOptions;
|
|
/**
|
|
* @deprecated typingOptions. Use typeAcquisition instead
|
|
*/
|
|
typingOptions?: TypeAcquisition;
|
|
/**
|
|
* Explicitly specified type acquisition for the project
|
|
*/
|
|
typeAcquisition?: TypeAcquisition;
|
|
}
|
|
interface CompileOnSaveMixin {
|
|
/**
|
|
* If compile on save is enabled for the project
|
|
*/
|
|
compileOnSave?: boolean;
|
|
}
|
|
/**
|
|
* For external projects, some of the project settings are sent together with
|
|
* compiler settings.
|
|
*/
|
|
type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin;
|
|
/**
|
|
* Represents a set of changes that happen in project
|
|
*/
|
|
interface ProjectChanges {
|
|
/**
|
|
* List of added files
|
|
*/
|
|
added: string[];
|
|
/**
|
|
* List of removed files
|
|
*/
|
|
removed: string[];
|
|
/**
|
|
* List of updated files
|
|
*/
|
|
updated: string[];
|
|
}
|
|
/**
|
|
* Information found in a configure request.
|
|
*/
|
|
interface ConfigureRequestArguments {
|
|
/**
|
|
* Information about the host, for example 'Emacs 24.4' or
|
|
* 'Sublime Text version 3075'
|
|
*/
|
|
hostInfo?: string;
|
|
/**
|
|
* If present, tab settings apply only to this file.
|
|
*/
|
|
file?: string;
|
|
/**
|
|
* The format options to use during formatting and other code editing features.
|
|
*/
|
|
formatOptions?: FormatCodeSettings;
|
|
/**
|
|
* The host's additional supported file extensions
|
|
*/
|
|
extraFileExtensions?: FileExtensionInfo[];
|
|
}
|
|
/**
|
|
* Configure request; value of command field is "configure". Specifies
|
|
* host information, such as host type, tab size, and indent size.
|
|
*/
|
|
interface ConfigureRequest extends Request {
|
|
command: CommandTypes.Configure;
|
|
arguments: ConfigureRequestArguments;
|
|
}
|
|
/**
|
|
* Response to "configure" request. This is just an acknowledgement, so
|
|
* no body field is required.
|
|
*/
|
|
interface ConfigureResponse extends Response {
|
|
}
|
|
/**
|
|
* Information found in an "open" request.
|
|
*/
|
|
interface OpenRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* Used when a version of the file content is known to be more up to date than the one on disk.
|
|
* Then the known content will be used upon opening instead of the disk copy
|
|
*/
|
|
fileContent?: string;
|
|
/**
|
|
* Used to specify the script kind of the file explicitly. It could be one of the following:
|
|
* "TS", "JS", "TSX", "JSX"
|
|
*/
|
|
scriptKindName?: ScriptKindName;
|
|
}
|
|
type ScriptKindName = "TS" | "JS" | "TSX" | "JSX";
|
|
/**
|
|
* Open request; value of command field is "open". Notify the
|
|
* server that the client has file open. The server will not
|
|
* monitor the filesystem for changes in this file and will assume
|
|
* that the client is updating the server (using the change and/or
|
|
* reload messages) when the file changes. Server does not currently
|
|
* send a response to an open request.
|
|
*/
|
|
interface OpenRequest extends Request {
|
|
command: CommandTypes.Open;
|
|
arguments: OpenRequestArgs;
|
|
}
|
|
/**
|
|
* Request to open or update external project
|
|
*/
|
|
interface OpenExternalProjectRequest extends Request {
|
|
command: CommandTypes.OpenExternalProject;
|
|
arguments: OpenExternalProjectArgs;
|
|
}
|
|
/**
|
|
* Arguments to OpenExternalProjectRequest request
|
|
*/
|
|
type OpenExternalProjectArgs = ExternalProject;
|
|
/**
|
|
* Request to open multiple external projects
|
|
*/
|
|
interface OpenExternalProjectsRequest extends Request {
|
|
command: CommandTypes.OpenExternalProjects;
|
|
arguments: OpenExternalProjectsArgs;
|
|
}
|
|
/**
|
|
* Arguments to OpenExternalProjectsRequest
|
|
*/
|
|
interface OpenExternalProjectsArgs {
|
|
/**
|
|
* List of external projects to open or update
|
|
*/
|
|
projects: ExternalProject[];
|
|
}
|
|
/**
|
|
* Response to OpenExternalProjectRequest request. This is just an acknowledgement, so
|
|
* no body field is required.
|
|
*/
|
|
interface OpenExternalProjectResponse extends Response {
|
|
}
|
|
/**
|
|
* Response to OpenExternalProjectsRequest request. This is just an acknowledgement, so
|
|
* no body field is required.
|
|
*/
|
|
interface OpenExternalProjectsResponse extends Response {
|
|
}
|
|
/**
|
|
* Request to close external project.
|
|
*/
|
|
interface CloseExternalProjectRequest extends Request {
|
|
command: CommandTypes.CloseExternalProject;
|
|
arguments: CloseExternalProjectRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments to CloseExternalProjectRequest request
|
|
*/
|
|
interface CloseExternalProjectRequestArgs {
|
|
/**
|
|
* Name of the project to close
|
|
*/
|
|
projectFileName: string;
|
|
}
|
|
/**
|
|
* Response to CloseExternalProjectRequest request. This is just an acknowledgement, so
|
|
* no body field is required.
|
|
*/
|
|
interface CloseExternalProjectResponse extends Response {
|
|
}
|
|
/**
|
|
* Request to set compiler options for inferred projects.
|
|
* External projects are opened / closed explicitly.
|
|
* Configured projects are opened when user opens loose file that has 'tsconfig.json' or 'jsconfig.json' anywhere in one of containing folders.
|
|
* This configuration file will be used to obtain a list of files and configuration settings for the project.
|
|
* Inferred projects are created when user opens a loose file that is not the part of external project
|
|
* or configured project and will contain only open file and transitive closure of referenced files if 'useOneInferredProject' is false,
|
|
* or all open loose files and its transitive closure of referenced files if 'useOneInferredProject' is true.
|
|
*/
|
|
interface SetCompilerOptionsForInferredProjectsRequest extends Request {
|
|
command: CommandTypes.CompilerOptionsForInferredProjects;
|
|
arguments: SetCompilerOptionsForInferredProjectsArgs;
|
|
}
|
|
/**
|
|
* Argument for SetCompilerOptionsForInferredProjectsRequest request.
|
|
*/
|
|
interface SetCompilerOptionsForInferredProjectsArgs {
|
|
/**
|
|
* Compiler options to be used with inferred projects.
|
|
*/
|
|
options: ExternalProjectCompilerOptions;
|
|
}
|
|
/**
|
|
* Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so
|
|
* no body field is required.
|
|
*/
|
|
interface SetCompilerOptionsForInferredProjectsResponse extends Response {
|
|
}
|
|
/**
|
|
* Exit request; value of command field is "exit". Ask the server process
|
|
* to exit.
|
|
*/
|
|
interface ExitRequest extends Request {
|
|
command: CommandTypes.Exit;
|
|
}
|
|
/**
|
|
* Close request; value of command field is "close". Notify the
|
|
* server that the client has closed a previously open file. If
|
|
* file is still referenced by open files, the server will resume
|
|
* monitoring the filesystem for changes to file. Server does not
|
|
* currently send a response to a close request.
|
|
*/
|
|
interface CloseRequest extends FileRequest {
|
|
command: CommandTypes.Close;
|
|
}
|
|
/**
|
|
* Request to obtain the list of files that should be regenerated if target file is recompiled.
|
|
* NOTE: this us query-only operation and does not generate any output on disk.
|
|
*/
|
|
interface CompileOnSaveAffectedFileListRequest extends FileRequest {
|
|
command: CommandTypes.CompileOnSaveAffectedFileList;
|
|
}
|
|
/**
|
|
* Contains a list of files that should be regenerated in a project
|
|
*/
|
|
interface CompileOnSaveAffectedFileListSingleProject {
|
|
/**
|
|
* Project name
|
|
*/
|
|
projectFileName: string;
|
|
/**
|
|
* List of files names that should be recompiled
|
|
*/
|
|
fileNames: string[];
|
|
}
|
|
/**
|
|
* Response for CompileOnSaveAffectedFileListRequest request;
|
|
*/
|
|
interface CompileOnSaveAffectedFileListResponse extends Response {
|
|
body: CompileOnSaveAffectedFileListSingleProject[];
|
|
}
|
|
/**
|
|
* Request to recompile the file. All generated outputs (.js, .d.ts or .js.map files) is written on disk.
|
|
*/
|
|
interface CompileOnSaveEmitFileRequest extends FileRequest {
|
|
command: CommandTypes.CompileOnSaveEmitFile;
|
|
arguments: CompileOnSaveEmitFileRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments for CompileOnSaveEmitFileRequest
|
|
*/
|
|
interface CompileOnSaveEmitFileRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* if true - then file should be recompiled even if it does not have any changes.
|
|
*/
|
|
forced?: boolean;
|
|
}
|
|
/**
|
|
* Quickinfo request; value of command field is
|
|
* "quickinfo". Return response giving a quick type and
|
|
* documentation string for the symbol found in file at location
|
|
* line, col.
|
|
*/
|
|
interface QuickInfoRequest extends FileLocationRequest {
|
|
command: CommandTypes.Quickinfo;
|
|
}
|
|
/**
|
|
* Body of QuickInfoResponse.
|
|
*/
|
|
interface QuickInfoResponseBody {
|
|
/**
|
|
* The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
|
|
*/
|
|
kind: string;
|
|
/**
|
|
* Optional modifiers for the kind (such as 'public').
|
|
*/
|
|
kindModifiers: string;
|
|
/**
|
|
* Starting file location of symbol.
|
|
*/
|
|
start: Location;
|
|
/**
|
|
* One past last character of symbol.
|
|
*/
|
|
end: Location;
|
|
/**
|
|
* Type and kind of symbol.
|
|
*/
|
|
displayString: string;
|
|
/**
|
|
* Documentation associated with symbol.
|
|
*/
|
|
documentation: string;
|
|
}
|
|
/**
|
|
* Quickinfo response message.
|
|
*/
|
|
interface QuickInfoResponse extends Response {
|
|
body?: QuickInfoResponseBody;
|
|
}
|
|
/**
|
|
* Arguments for format messages.
|
|
*/
|
|
interface FormatRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* Last line of range for which to format text in file.
|
|
*/
|
|
endLine: number;
|
|
/**
|
|
* Character offset on last line of range for which to format text in file.
|
|
*/
|
|
endOffset: number;
|
|
/**
|
|
* Format options to be used.
|
|
*/
|
|
options?: FormatCodeSettings;
|
|
}
|
|
/**
|
|
* Format request; value of command field is "format". Return
|
|
* response giving zero or more edit instructions. The edit
|
|
* instructions will be sorted in file order. Applying the edit
|
|
* instructions in reverse to file will result in correctly
|
|
* reformatted text.
|
|
*/
|
|
interface FormatRequest extends FileLocationRequest {
|
|
command: CommandTypes.Format;
|
|
arguments: FormatRequestArgs;
|
|
}
|
|
/**
|
|
* Object found in response messages defining an editing
|
|
* instruction for a span of text in source code. The effect of
|
|
* this instruction is to replace the text starting at start and
|
|
* ending one character before end with newText. For an insertion,
|
|
* the text span is empty. For a deletion, newText is empty.
|
|
*/
|
|
interface CodeEdit {
|
|
/**
|
|
* First character of the text span to edit.
|
|
*/
|
|
start: Location;
|
|
/**
|
|
* One character past last character of the text span to edit.
|
|
*/
|
|
end: Location;
|
|
/**
|
|
* Replace the span defined above with this string (may be
|
|
* the empty string).
|
|
*/
|
|
newText: string;
|
|
}
|
|
interface FileCodeEdits {
|
|
fileName: string;
|
|
textChanges: CodeEdit[];
|
|
}
|
|
interface CodeFixResponse extends Response {
|
|
/** The code actions that are available */
|
|
body?: CodeAction[];
|
|
}
|
|
interface CodeAction {
|
|
/** Description of the code action to display in the UI of the editor */
|
|
description: string;
|
|
/** Text changes to apply to each file as part of the code action */
|
|
changes: FileCodeEdits[];
|
|
}
|
|
/**
|
|
* Format and format on key response message.
|
|
*/
|
|
interface FormatResponse extends Response {
|
|
body?: CodeEdit[];
|
|
}
|
|
/**
|
|
* Arguments for format on key messages.
|
|
*/
|
|
interface FormatOnKeyRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* Key pressed (';', '\n', or '}').
|
|
*/
|
|
key: string;
|
|
options?: FormatCodeSettings;
|
|
}
|
|
/**
|
|
* Format on key request; value of command field is
|
|
* "formatonkey". Given file location and key typed (as string),
|
|
* return response giving zero or more edit instructions. The
|
|
* edit instructions will be sorted in file order. Applying the
|
|
* edit instructions in reverse to file will result in correctly
|
|
* reformatted text.
|
|
*/
|
|
interface FormatOnKeyRequest extends FileLocationRequest {
|
|
command: CommandTypes.Formatonkey;
|
|
arguments: FormatOnKeyRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments for completions messages.
|
|
*/
|
|
interface CompletionsRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* Optional prefix to apply to possible completions.
|
|
*/
|
|
prefix?: string;
|
|
}
|
|
/**
|
|
* Completions request; value of command field is "completions".
|
|
* Given a file location (file, line, col) and a prefix (which may
|
|
* be the empty string), return the possible completions that
|
|
* begin with prefix.
|
|
*/
|
|
interface CompletionsRequest extends FileLocationRequest {
|
|
command: CommandTypes.Completions;
|
|
arguments: CompletionsRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments for completion details request.
|
|
*/
|
|
interface CompletionDetailsRequestArgs extends FileLocationRequestArgs {
|
|
/**
|
|
* Names of one or more entries for which to obtain details.
|
|
*/
|
|
entryNames: string[];
|
|
}
|
|
/**
|
|
* Completion entry details request; value of command field is
|
|
* "completionEntryDetails". Given a file location (file, line,
|
|
* col) and an array of completion entry names return more
|
|
* detailed information for each completion entry.
|
|
*/
|
|
interface CompletionDetailsRequest extends FileLocationRequest {
|
|
command: CommandTypes.CompletionDetails;
|
|
arguments: CompletionDetailsRequestArgs;
|
|
}
|
|
/**
|
|
* Part of a symbol description.
|
|
*/
|
|
interface SymbolDisplayPart {
|
|
/**
|
|
* Text of an item describing the symbol.
|
|
*/
|
|
text: string;
|
|
/**
|
|
* The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
|
|
*/
|
|
kind: string;
|
|
}
|
|
/**
|
|
* An item found in a completion response.
|
|
*/
|
|
interface CompletionEntry {
|
|
/**
|
|
* The symbol's name.
|
|
*/
|
|
name: string;
|
|
/**
|
|
* The symbol's kind (such as 'className' or 'parameterName').
|
|
*/
|
|
kind: string;
|
|
/**
|
|
* Optional modifiers for the kind (such as 'public').
|
|
*/
|
|
kindModifiers: string;
|
|
/**
|
|
* A string that is used for comparing completion items so that they can be ordered. This
|
|
* is often the same as the name but may be different in certain circumstances.
|
|
*/
|
|
sortText: string;
|
|
/**
|
|
* An optional span that indicates the text to be replaced by this completion item. If present,
|
|
* this span should be used instead of the default one.
|
|
*/
|
|
replacementSpan?: TextSpan;
|
|
}
|
|
/**
|
|
* Additional completion entry details, available on demand
|
|
*/
|
|
interface CompletionEntryDetails {
|
|
/**
|
|
* The symbol's name.
|
|
*/
|
|
name: string;
|
|
/**
|
|
* The symbol's kind (such as 'className' or 'parameterName').
|
|
*/
|
|
kind: string;
|
|
/**
|
|
* Optional modifiers for the kind (such as 'public').
|
|
*/
|
|
kindModifiers: string;
|
|
/**
|
|
* Display parts of the symbol (similar to quick info).
|
|
*/
|
|
displayParts: SymbolDisplayPart[];
|
|
/**
|
|
* Documentation strings for the symbol.
|
|
*/
|
|
documentation: SymbolDisplayPart[];
|
|
}
|
|
interface CompletionsResponse extends Response {
|
|
body?: CompletionEntry[];
|
|
}
|
|
interface CompletionDetailsResponse extends Response {
|
|
body?: CompletionEntryDetails[];
|
|
}
|
|
/**
|
|
* Signature help information for a single parameter
|
|
*/
|
|
interface SignatureHelpParameter {
|
|
/**
|
|
* The parameter's name
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Documentation of the parameter.
|
|
*/
|
|
documentation: SymbolDisplayPart[];
|
|
/**
|
|
* Display parts of the parameter.
|
|
*/
|
|
displayParts: SymbolDisplayPart[];
|
|
/**
|
|
* Whether the parameter is optional or not.
|
|
*/
|
|
isOptional: boolean;
|
|
}
|
|
/**
|
|
* Represents a single signature to show in signature help.
|
|
*/
|
|
interface SignatureHelpItem {
|
|
/**
|
|
* Whether the signature accepts a variable number of arguments.
|
|
*/
|
|
isVariadic: boolean;
|
|
/**
|
|
* The prefix display parts.
|
|
*/
|
|
prefixDisplayParts: SymbolDisplayPart[];
|
|
/**
|
|
* The suffix display parts.
|
|
*/
|
|
suffixDisplayParts: SymbolDisplayPart[];
|
|
/**
|
|
* The separator display parts.
|
|
*/
|
|
separatorDisplayParts: SymbolDisplayPart[];
|
|
/**
|
|
* The signature helps items for the parameters.
|
|
*/
|
|
parameters: SignatureHelpParameter[];
|
|
/**
|
|
* The signature's documentation
|
|
*/
|
|
documentation: SymbolDisplayPart[];
|
|
}
|
|
/**
|
|
* Signature help items found in the response of a signature help request.
|
|
*/
|
|
interface SignatureHelpItems {
|
|
/**
|
|
* The signature help items.
|
|
*/
|
|
items: SignatureHelpItem[];
|
|
/**
|
|
* The span for which signature help should appear on a signature
|
|
*/
|
|
applicableSpan: TextSpan;
|
|
/**
|
|
* The item selected in the set of available help items.
|
|
*/
|
|
selectedItemIndex: number;
|
|
/**
|
|
* The argument selected in the set of parameters.
|
|
*/
|
|
argumentIndex: number;
|
|
/**
|
|
* The argument count
|
|
*/
|
|
argumentCount: number;
|
|
}
|
|
/**
|
|
* Arguments of a signature help request.
|
|
*/
|
|
interface SignatureHelpRequestArgs extends FileLocationRequestArgs {
|
|
}
|
|
/**
|
|
* Signature help request; value of command field is "signatureHelp".
|
|
* Given a file location (file, line, col), return the signature
|
|
* help.
|
|
*/
|
|
interface SignatureHelpRequest extends FileLocationRequest {
|
|
command: CommandTypes.SignatureHelp;
|
|
arguments: SignatureHelpRequestArgs;
|
|
}
|
|
/**
|
|
* Response object for a SignatureHelpRequest.
|
|
*/
|
|
interface SignatureHelpResponse extends Response {
|
|
body?: SignatureHelpItems;
|
|
}
|
|
/**
|
|
* Synchronous request for semantic diagnostics of one file.
|
|
*/
|
|
interface SemanticDiagnosticsSyncRequest extends FileRequest {
|
|
command: CommandTypes.SemanticDiagnosticsSync;
|
|
arguments: SemanticDiagnosticsSyncRequestArgs;
|
|
}
|
|
interface SemanticDiagnosticsSyncRequestArgs extends FileRequestArgs {
|
|
includeLinePosition?: boolean;
|
|
}
|
|
/**
|
|
* Response object for synchronous sematic diagnostics request.
|
|
*/
|
|
interface SemanticDiagnosticsSyncResponse extends Response {
|
|
body?: Diagnostic[] | DiagnosticWithLinePosition[];
|
|
}
|
|
/**
|
|
* Synchronous request for syntactic diagnostics of one file.
|
|
*/
|
|
interface SyntacticDiagnosticsSyncRequest extends FileRequest {
|
|
command: CommandTypes.SyntacticDiagnosticsSync;
|
|
arguments: SyntacticDiagnosticsSyncRequestArgs;
|
|
}
|
|
interface SyntacticDiagnosticsSyncRequestArgs extends FileRequestArgs {
|
|
includeLinePosition?: boolean;
|
|
}
|
|
/**
|
|
* Response object for synchronous syntactic diagnostics request.
|
|
*/
|
|
interface SyntacticDiagnosticsSyncResponse extends Response {
|
|
body?: Diagnostic[] | DiagnosticWithLinePosition[];
|
|
}
|
|
/**
|
|
* Arguments for GeterrForProject request.
|
|
*/
|
|
interface GeterrForProjectRequestArgs {
|
|
/**
|
|
* the file requesting project error list
|
|
*/
|
|
file: string;
|
|
/**
|
|
* Delay in milliseconds to wait before starting to compute
|
|
* errors for the files in the file list
|
|
*/
|
|
delay: number;
|
|
}
|
|
/**
|
|
* GeterrForProjectRequest request; value of command field is
|
|
* "geterrForProject". It works similarly with 'Geterr', only
|
|
* it request for every file in this project.
|
|
*/
|
|
interface GeterrForProjectRequest extends Request {
|
|
command: CommandTypes.GeterrForProject;
|
|
arguments: GeterrForProjectRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments for geterr messages.
|
|
*/
|
|
interface GeterrRequestArgs {
|
|
/**
|
|
* List of file names for which to compute compiler errors.
|
|
* The files will be checked in list order.
|
|
*/
|
|
files: string[];
|
|
/**
|
|
* Delay in milliseconds to wait before starting to compute
|
|
* errors for the files in the file list
|
|
*/
|
|
delay: number;
|
|
}
|
|
/**
|
|
* Geterr request; value of command field is "geterr". Wait for
|
|
* delay milliseconds and then, if during the wait no change or
|
|
* reload messages have arrived for the first file in the files
|
|
* list, get the syntactic errors for the file, field requests,
|
|
* and then get the semantic errors for the file. Repeat with a
|
|
* smaller delay for each subsequent file on the files list. Best
|
|
* practice for an editor is to send a file list containing each
|
|
* file that is currently visible, in most-recently-used order.
|
|
*/
|
|
interface GeterrRequest extends Request {
|
|
command: CommandTypes.Geterr;
|
|
arguments: GeterrRequestArgs;
|
|
}
|
|
/**
|
|
* Item of diagnostic information found in a DiagnosticEvent message.
|
|
*/
|
|
interface Diagnostic {
|
|
/**
|
|
* Starting file location at which text applies.
|
|
*/
|
|
start: Location;
|
|
/**
|
|
* The last file location at which the text applies.
|
|
*/
|
|
end: Location;
|
|
/**
|
|
* Text of diagnostic message.
|
|
*/
|
|
text: string;
|
|
/**
|
|
* The error code of the diagnostic message.
|
|
*/
|
|
code?: number;
|
|
}
|
|
interface DiagnosticEventBody {
|
|
/**
|
|
* The file for which diagnostic information is reported.
|
|
*/
|
|
file: string;
|
|
/**
|
|
* An array of diagnostic information items.
|
|
*/
|
|
diagnostics: Diagnostic[];
|
|
}
|
|
/**
|
|
* Event message for "syntaxDiag" and "semanticDiag" event types.
|
|
* These events provide syntactic and semantic errors for a file.
|
|
*/
|
|
interface DiagnosticEvent extends Event {
|
|
body?: DiagnosticEventBody;
|
|
}
|
|
interface ConfigFileDiagnosticEventBody {
|
|
/**
|
|
* The file which trigged the searching and error-checking of the config file
|
|
*/
|
|
triggerFile: string;
|
|
/**
|
|
* The name of the found config file.
|
|
*/
|
|
configFile: string;
|
|
/**
|
|
* An arry of diagnostic information items for the found config file.
|
|
*/
|
|
diagnostics: Diagnostic[];
|
|
}
|
|
/**
|
|
* Event message for "configFileDiag" event type.
|
|
* This event provides errors for a found config file.
|
|
*/
|
|
interface ConfigFileDiagnosticEvent extends Event {
|
|
body?: ConfigFileDiagnosticEventBody;
|
|
event: "configFileDiag";
|
|
}
|
|
type ProjectLanguageServiceStateEventName = "projectLanguageServiceState";
|
|
interface ProjectLanguageServiceStateEvent extends Event {
|
|
event: ProjectLanguageServiceStateEventName;
|
|
body?: ProjectLanguageServiceStateEventBody;
|
|
}
|
|
interface ProjectLanguageServiceStateEventBody {
|
|
/**
|
|
* Project name that has changes in the state of language service.
|
|
* For configured projects this will be the config file path.
|
|
* For external projects this will be the name of the projects specified when project was open.
|
|
* For inferred projects this event is not raised.
|
|
*/
|
|
projectName: string;
|
|
/**
|
|
* True if language service state switched from disabled to enabled
|
|
* and false otherwise.
|
|
*/
|
|
languageServiceEnabled: boolean;
|
|
}
|
|
/**
|
|
* Arguments for reload request.
|
|
*/
|
|
interface ReloadRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* Name of temporary file from which to reload file
|
|
* contents. May be same as file.
|
|
*/
|
|
tmpfile: string;
|
|
}
|
|
/**
|
|
* Reload request message; value of command field is "reload".
|
|
* Reload contents of file with name given by the 'file' argument
|
|
* from temporary file with name given by the 'tmpfile' argument.
|
|
* The two names can be identical.
|
|
*/
|
|
interface ReloadRequest extends FileRequest {
|
|
command: CommandTypes.Reload;
|
|
arguments: ReloadRequestArgs;
|
|
}
|
|
/**
|
|
* Response to "reload" request. This is just an acknowledgement, so
|
|
* no body field is required.
|
|
*/
|
|
interface ReloadResponse extends Response {
|
|
}
|
|
/**
|
|
* Arguments for saveto request.
|
|
*/
|
|
interface SavetoRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* Name of temporary file into which to save server's view of
|
|
* file contents.
|
|
*/
|
|
tmpfile: string;
|
|
}
|
|
/**
|
|
* Saveto request message; value of command field is "saveto".
|
|
* For debugging purposes, save to a temporaryfile (named by
|
|
* argument 'tmpfile') the contents of file named by argument
|
|
* 'file'. The server does not currently send a response to a
|
|
* "saveto" request.
|
|
*/
|
|
interface SavetoRequest extends FileRequest {
|
|
command: CommandTypes.Saveto;
|
|
arguments: SavetoRequestArgs;
|
|
}
|
|
/**
|
|
* Arguments for navto request message.
|
|
*/
|
|
interface NavtoRequestArgs extends FileRequestArgs {
|
|
/**
|
|
* Search term to navigate to from current location; term can
|
|
* be '.*' or an identifier prefix.
|
|
*/
|
|
searchValue: string;
|
|
/**
|
|
* Optional limit on the number of items to return.
|
|
*/
|
|
maxResultCount?: number;
|
|
/**
|
|
* Optional flag to indicate we want results for just the current file
|
|
* or the entire project.
|
|
*/
|
|
currentFileOnly?: boolean;
|
|
projectFileName?: string;
|
|
}
|
|
/**
|
|
* Navto request message; value of command field is "navto".
|
|
* Return list of objects giving file locations and symbols that
|
|
* match the search term given in argument 'searchTerm'. The
|
|
* context for the search is given by the named file.
|
|
*/
|
|
interface NavtoRequest extends FileRequest {
|
|
command: CommandTypes.Navto;
|
|
arguments: NavtoRequestArgs;
|
|
}
|
|
/**
|
|
* An item found in a navto response.
|
|
*/
|
|
interface NavtoItem {
|
|
/**
|
|
* The symbol's name.
|
|
*/
|
|
name: string;
|
|
/**
|
|
* The symbol's kind (such as 'className' or 'parameterName').
|
|
*/
|
|
kind: string;
|
|
/**
|
|
* exact, substring, or prefix.
|
|
*/
|
|
matchKind?: string;
|
|
/**
|
|
* If this was a case sensitive or insensitive match.
|
|
*/
|
|
isCaseSensitive?: boolean;
|
|
/**
|
|
* Optional modifiers for the kind (such as 'public').
|
|
*/
|
|
kindModifiers?: string;
|
|
/**
|
|
* The file in which the symbol is found.
|
|
*/
|
|
file: string;
|
|
/**
|
|
* The location within file at which the symbol is found.
|
|
*/
|
|
start: Location;
|
|
/**
|
|
* One past the last character of the symbol.
|
|
*/
|
|
end: Location;
|
|
/**
|
|
* Name of symbol's container symbol (if any); for example,
|
|
* the class name if symbol is a class member.
|
|
*/
|
|
containerName?: string;
|
|
/**
|
|
* Kind of symbol's container symbol (if any).
|
|
*/
|
|
containerKind?: string;
|
|
}
|
|
/**
|
|
* Navto response message. Body is an array of navto items. Each
|
|
* item gives a symbol that matched the search term.
|
|
*/
|
|
interface NavtoResponse extends Response {
|
|
body?: NavtoItem[];
|
|
}
|
|
/**
|
|
* Arguments for change request message.
|
|
*/
|
|
interface ChangeRequestArgs extends FormatRequestArgs {
|
|
/**
|
|
* Optional string to insert at location (file, line, offset).
|
|
*/
|
|
insertString?: string;
|
|
}
|
|
/**
|
|
* Change request message; value of command field is "change".
|
|
* Update the server's view of the file named by argument 'file'.
|
|
* Server does not currently send a response to a change request.
|
|
*/
|
|
interface ChangeRequest extends FileLocationRequest {
|
|
command: CommandTypes.Change;
|
|
arguments: ChangeRequestArgs;
|
|
}
|
|
/**
|
|
* Response to "brace" request.
|
|
*/
|
|
interface BraceResponse extends Response {
|
|
body?: TextSpan[];
|
|
}
|
|
/**
|
|
* Brace matching request; value of command field is "brace".
|
|
* Return response giving the file locations of matching braces
|
|
* found in file at location line, offset.
|
|
*/
|
|
interface BraceRequest extends FileLocationRequest {
|
|
command: CommandTypes.Brace;
|
|
}
|
|
/**
|
|
* NavBar items request; value of command field is "navbar".
|
|
* Return response giving the list of navigation bar entries
|
|
* extracted from the requested file.
|
|
*/
|
|
interface NavBarRequest extends FileRequest {
|
|
command: CommandTypes.NavBar;
|
|
}
|
|
/**
|
|
* NavTree request; value of command field is "navtree".
|
|
* Return response giving the navigation tree of the requested file.
|
|
*/
|
|
interface NavTreeRequest extends FileRequest {
|
|
command: CommandTypes.NavTree;
|
|
}
|
|
interface NavigationBarItem {
|
|
/**
|
|
* The item's display text.
|
|
*/
|
|
text: string;
|
|
/**
|
|
* The symbol's kind (such as 'className' or 'parameterName').
|
|
*/
|
|
kind: string;
|
|
/**
|
|
* Optional modifiers for the kind (such as 'public').
|
|
*/
|
|
kindModifiers?: string;
|
|
/**
|
|
* The definition locations of the item.
|
|
*/
|
|
spans: TextSpan[];
|
|
/**
|
|
* Optional children.
|
|
*/
|
|
childItems?: NavigationBarItem[];
|
|
/**
|
|
* Number of levels deep this item should appear.
|
|
*/
|
|
indent: number;
|
|
}
|
|
/** protocol.NavigationTree is identical to ts.NavigationTree, except using protocol.TextSpan instead of ts.TextSpan */
|
|
interface NavigationTree {
|
|
text: string;
|
|
kind: string;
|
|
kindModifiers: string;
|
|
spans: TextSpan[];
|
|
childItems?: NavigationTree[];
|
|
}
|
|
type TelemetryEventName = "telemetry";
|
|
interface TelemetryEvent extends Event {
|
|
event: TelemetryEventName;
|
|
body: TelemetryEventBody;
|
|
}
|
|
interface TelemetryEventBody {
|
|
telemetryEventName: string;
|
|
payload: any;
|
|
}
|
|
type TypingsInstalledTelemetryEventName = "typingsInstalled";
|
|
interface TypingsInstalledTelemetryEventBody extends TelemetryEventBody {
|
|
telemetryEventName: TypingsInstalledTelemetryEventName;
|
|
payload: TypingsInstalledTelemetryEventPayload;
|
|
}
|
|
interface TypingsInstalledTelemetryEventPayload {
|
|
/**
|
|
* Comma separated list of installed typing packages
|
|
*/
|
|
installedPackages: string;
|
|
/**
|
|
* true if install request succeeded, otherwise - false
|
|
*/
|
|
installSuccess: boolean;
|
|
/**
|
|
* version of typings installer
|
|
*/
|
|
typingsInstallerVersion: string;
|
|
}
|
|
type BeginInstallTypesEventName = "beginInstallTypes";
|
|
type EndInstallTypesEventName = "endInstallTypes";
|
|
interface BeginInstallTypesEvent extends Event {
|
|
event: BeginInstallTypesEventName;
|
|
body: BeginInstallTypesEventBody;
|
|
}
|
|
interface EndInstallTypesEvent extends Event {
|
|
event: EndInstallTypesEventName;
|
|
body: EndInstallTypesEventBody;
|
|
}
|
|
interface InstallTypesEventBody {
|
|
/**
|
|
* correlation id to match begin and end events
|
|
*/
|
|
eventId: number;
|
|
/**
|
|
* list of packages to install
|
|
*/
|
|
packages: ReadonlyArray<string>;
|
|
}
|
|
interface BeginInstallTypesEventBody extends InstallTypesEventBody {
|
|
}
|
|
interface EndInstallTypesEventBody extends InstallTypesEventBody {
|
|
/**
|
|
* true if installation succeeded, otherwise false
|
|
*/
|
|
success: boolean;
|
|
}
|
|
interface NavBarResponse extends Response {
|
|
body?: NavigationBarItem[];
|
|
}
|
|
interface NavTreeResponse extends Response {
|
|
body?: NavigationTree;
|
|
}
|
|
namespace IndentStyle {
|
|
type None = "None";
|
|
type Block = "Block";
|
|
type Smart = "Smart";
|
|
}
|
|
type IndentStyle = IndentStyle.None | IndentStyle.Block | IndentStyle.Smart;
|
|
interface EditorSettings {
|
|
baseIndentSize?: number;
|
|
indentSize?: number;
|
|
tabSize?: number;
|
|
newLineCharacter?: string;
|
|
convertTabsToSpaces?: boolean;
|
|
indentStyle?: IndentStyle | ts.IndentStyle;
|
|
}
|
|
interface FormatCodeSettings extends EditorSettings {
|
|
insertSpaceAfterCommaDelimiter?: boolean;
|
|
insertSpaceAfterSemicolonInForStatements?: boolean;
|
|
insertSpaceBeforeAndAfterBinaryOperators?: boolean;
|
|
insertSpaceAfterConstructor?: boolean;
|
|
insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
|
|
insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
|
|
insertSpaceBeforeFunctionParenthesis?: boolean;
|
|
placeOpenBraceOnNewLineForFunctions?: boolean;
|
|
placeOpenBraceOnNewLineForControlBlocks?: boolean;
|
|
}
|
|
interface CompilerOptions {
|
|
allowJs?: boolean;
|
|
allowSyntheticDefaultImports?: boolean;
|
|
allowUnreachableCode?: boolean;
|
|
allowUnusedLabels?: boolean;
|
|
baseUrl?: string;
|
|
charset?: string;
|
|
declaration?: boolean;
|
|
declarationDir?: string;
|
|
disableSizeLimit?: boolean;
|
|
emitBOM?: boolean;
|
|
emitDecoratorMetadata?: boolean;
|
|
experimentalDecorators?: boolean;
|
|
forceConsistentCasingInFileNames?: boolean;
|
|
inlineSourceMap?: boolean;
|
|
inlineSources?: boolean;
|
|
isolatedModules?: boolean;
|
|
jsx?: JsxEmit | ts.JsxEmit;
|
|
lib?: string[];
|
|
locale?: string;
|
|
mapRoot?: string;
|
|
maxNodeModuleJsDepth?: number;
|
|
module?: ModuleKind | ts.ModuleKind;
|
|
moduleResolution?: ModuleResolutionKind | ts.ModuleResolutionKind;
|
|
newLine?: NewLineKind | ts.NewLineKind;
|
|
noEmit?: boolean;
|
|
noEmitHelpers?: boolean;
|
|
noEmitOnError?: boolean;
|
|
noErrorTruncation?: boolean;
|
|
noFallthroughCasesInSwitch?: boolean;
|
|
noImplicitAny?: boolean;
|
|
noImplicitReturns?: boolean;
|
|
noImplicitThis?: boolean;
|
|
noUnusedLocals?: boolean;
|
|
noUnusedParameters?: boolean;
|
|
noImplicitUseStrict?: boolean;
|
|
noLib?: boolean;
|
|
noResolve?: boolean;
|
|
out?: string;
|
|
outDir?: string;
|
|
outFile?: string;
|
|
paths?: MapLike<string[]>;
|
|
preserveConstEnums?: boolean;
|
|
project?: string;
|
|
reactNamespace?: string;
|
|
removeComments?: boolean;
|
|
rootDir?: string;
|
|
rootDirs?: string[];
|
|
skipLibCheck?: boolean;
|
|
skipDefaultLibCheck?: boolean;
|
|
sourceMap?: boolean;
|
|
sourceRoot?: string;
|
|
strictNullChecks?: boolean;
|
|
suppressExcessPropertyErrors?: boolean;
|
|
suppressImplicitAnyIndexErrors?: boolean;
|
|
target?: ScriptTarget | ts.ScriptTarget;
|
|
traceResolution?: boolean;
|
|
types?: string[];
|
|
/** Paths used to used to compute primary types search locations */
|
|
typeRoots?: string[];
|
|
[option: string]: CompilerOptionsValue | undefined;
|
|
}
|
|
namespace JsxEmit {
|
|
type None = "None";
|
|
type Preserve = "Preserve";
|
|
type React = "React";
|
|
}
|
|
type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React;
|
|
namespace ModuleKind {
|
|
type None = "None";
|
|
type CommonJS = "CommonJS";
|
|
type AMD = "AMD";
|
|
type UMD = "UMD";
|
|
type System = "System";
|
|
type ES6 = "ES6";
|
|
type ES2015 = "ES2015";
|
|
}
|
|
type ModuleKind = ModuleKind.None | ModuleKind.CommonJS | ModuleKind.AMD | ModuleKind.UMD | ModuleKind.System | ModuleKind.ES6 | ModuleKind.ES2015;
|
|
namespace ModuleResolutionKind {
|
|
type Classic = "Classic";
|
|
type Node = "Node";
|
|
}
|
|
type ModuleResolutionKind = ModuleResolutionKind.Classic | ModuleResolutionKind.Node;
|
|
namespace NewLineKind {
|
|
type Crlf = "Crlf";
|
|
type Lf = "Lf";
|
|
}
|
|
type NewLineKind = NewLineKind.Crlf | NewLineKind.Lf;
|
|
namespace ScriptTarget {
|
|
type ES3 = "ES3";
|
|
type ES5 = "ES5";
|
|
type ES6 = "ES6";
|
|
type ES2015 = "ES2015";
|
|
}
|
|
type ScriptTarget = ScriptTarget.ES3 | ScriptTarget.ES5 | ScriptTarget.ES6 | ScriptTarget.ES2015;
|
|
}
|
|
declare namespace ts.server.protocol {
|
|
|
|
interface TextInsertion {
|
|
newText: string;
|
|
/** The position in newText the caret should point to after the insertion. */
|
|
caretOffset: number;
|
|
}
|
|
|
|
interface TodoCommentDescriptor {
|
|
text: string;
|
|
priority: number;
|
|
}
|
|
|
|
interface TodoComment {
|
|
descriptor: TodoCommentDescriptor;
|
|
message: string;
|
|
position: number;
|
|
}
|
|
|
|
interface TypeAcquisition {
|
|
enableAutoDiscovery?: boolean;
|
|
enable?: boolean;
|
|
include?: string[];
|
|
exclude?: string[];
|
|
[option: string]: string[] | boolean | undefined;
|
|
}
|
|
|
|
interface FileExtensionInfo {
|
|
extension: string;
|
|
scriptKind: ScriptKind;
|
|
isMixedContent: boolean;
|
|
}
|
|
|
|
interface MapLike<T> {
|
|
[index: string]: T;
|
|
}
|
|
|
|
type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]>;
|
|
}
|
|
declare namespace ts {
|
|
// these types are empty stubs for types from services and should not be used directly
|
|
export type ScriptKind = never;
|
|
export type IndentStyle = never;
|
|
export type JsxEmit = never;
|
|
export type ModuleKind = never;
|
|
export type ModuleResolutionKind = never;
|
|
export type NewLineKind = never;
|
|
export type ScriptTarget = never;
|
|
}
|
|
import protocol = ts.server.protocol;
|
|
export = protocol;
|
|
export as namespace protocol; |