2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* Declaration module describing the TypeScript Server protocol
|
|
|
|
*/
|
|
|
|
declare namespace ts.server.protocol {
|
|
|
|
const enum CommandTypes {
|
2018-06-04 23:02:51 +02:00
|
|
|
JsxClosingTag = "jsxClosingTag",
|
2018-05-21 20:01:35 +02:00
|
|
|
Brace = "brace",
|
|
|
|
BraceCompletion = "braceCompletion",
|
|
|
|
GetSpanOfEnclosingComment = "getSpanOfEnclosingComment",
|
|
|
|
Change = "change",
|
|
|
|
Close = "close",
|
2018-07-06 01:05:09 +02:00
|
|
|
/** @deprecated Prefer CompletionInfo -- see comment on CompletionsResponse */
|
2018-05-21 20:01:35 +02:00
|
|
|
Completions = "completions",
|
2018-07-06 01:05:09 +02:00
|
|
|
CompletionInfo = "completionInfo",
|
2018-05-21 20:01:35 +02:00
|
|
|
CompletionDetails = "completionEntryDetails",
|
|
|
|
CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList",
|
|
|
|
CompileOnSaveEmitFile = "compileOnSaveEmitFile",
|
|
|
|
Configure = "configure",
|
|
|
|
Definition = "definition",
|
|
|
|
DefinitionAndBoundSpan = "definitionAndBoundSpan",
|
|
|
|
Implementation = "implementation",
|
|
|
|
Exit = "exit",
|
|
|
|
Format = "format",
|
|
|
|
Formatonkey = "formatonkey",
|
|
|
|
Geterr = "geterr",
|
|
|
|
GeterrForProject = "geterrForProject",
|
|
|
|
SemanticDiagnosticsSync = "semanticDiagnosticsSync",
|
|
|
|
SyntacticDiagnosticsSync = "syntacticDiagnosticsSync",
|
|
|
|
SuggestionDiagnosticsSync = "suggestionDiagnosticsSync",
|
|
|
|
NavBar = "navbar",
|
|
|
|
Navto = "navto",
|
|
|
|
NavTree = "navtree",
|
|
|
|
NavTreeFull = "navtree-full",
|
|
|
|
/** @deprecated */
|
|
|
|
Occurrences = "occurrences",
|
|
|
|
DocumentHighlights = "documentHighlights",
|
|
|
|
Open = "open",
|
|
|
|
Quickinfo = "quickinfo",
|
|
|
|
References = "references",
|
|
|
|
Reload = "reload",
|
|
|
|
Rename = "rename",
|
|
|
|
Saveto = "saveto",
|
|
|
|
SignatureHelp = "signatureHelp",
|
|
|
|
Status = "status",
|
|
|
|
TypeDefinition = "typeDefinition",
|
|
|
|
ProjectInfo = "projectInfo",
|
|
|
|
ReloadProjects = "reloadProjects",
|
|
|
|
Unknown = "unknown",
|
|
|
|
OpenExternalProject = "openExternalProject",
|
|
|
|
OpenExternalProjects = "openExternalProjects",
|
|
|
|
CloseExternalProject = "closeExternalProject",
|
2019-03-09 00:20:37 +01:00
|
|
|
UpdateOpen = "updateOpen",
|
2018-05-21 20:01:35 +02:00
|
|
|
GetOutliningSpans = "getOutliningSpans",
|
|
|
|
TodoComments = "todoComments",
|
|
|
|
Indentation = "indentation",
|
|
|
|
DocCommentTemplate = "docCommentTemplate",
|
|
|
|
CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects",
|
|
|
|
GetCodeFixes = "getCodeFixes",
|
|
|
|
GetCombinedCodeFix = "getCombinedCodeFix",
|
|
|
|
ApplyCodeActionCommand = "applyCodeActionCommand",
|
|
|
|
GetSupportedCodeFixes = "getSupportedCodeFixes",
|
|
|
|
GetApplicableRefactors = "getApplicableRefactors",
|
|
|
|
GetEditsForRefactor = "getEditsForRefactor",
|
|
|
|
OrganizeImports = "organizeImports",
|
2018-11-13 01:27:38 +01:00
|
|
|
GetEditsForFileRename = "getEditsForFileRename",
|
2019-07-29 19:33:43 +02:00
|
|
|
ConfigurePlugin = "configurePlugin",
|
|
|
|
SelectionRange = "selectionRange"
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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 {
|
|
|
|
type: "request";
|
|
|
|
/**
|
|
|
|
* 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 {
|
|
|
|
type: "event";
|
|
|
|
/**
|
|
|
|
* Name of event
|
|
|
|
*/
|
|
|
|
event: string;
|
|
|
|
/**
|
|
|
|
* Event-specific information
|
|
|
|
*/
|
|
|
|
body?: any;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Response by server to client request message.
|
|
|
|
*/
|
|
|
|
interface Response extends Message {
|
|
|
|
type: "response";
|
|
|
|
/**
|
|
|
|
* Sequence number of the request message.
|
|
|
|
*/
|
|
|
|
request_seq: number;
|
|
|
|
/**
|
|
|
|
* Outcome of the request.
|
|
|
|
*/
|
|
|
|
success: boolean;
|
|
|
|
/**
|
|
|
|
* The command requested.
|
|
|
|
*/
|
|
|
|
command: string;
|
|
|
|
/**
|
|
|
|
* If success === false, this should always be provided.
|
|
|
|
* Otherwise, may (or may not) contain a success message.
|
|
|
|
*/
|
|
|
|
message?: string;
|
|
|
|
/**
|
|
|
|
* Contains message body if success === true.
|
|
|
|
*/
|
|
|
|
body?: any;
|
2018-11-13 01:27:38 +01:00
|
|
|
/**
|
|
|
|
* Contains extra information that plugin can include to be passed on
|
|
|
|
*/
|
|
|
|
metadata?: unknown;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Arguments for FileRequest messages.
|
|
|
|
*/
|
|
|
|
interface FileRequestArgs {
|
|
|
|
/**
|
|
|
|
* The file for the request (absolute pathname required).
|
|
|
|
*/
|
|
|
|
file: string;
|
|
|
|
projectFileName?: string;
|
|
|
|
}
|
|
|
|
interface StatusRequest extends Request {
|
|
|
|
command: CommandTypes.Status;
|
|
|
|
}
|
|
|
|
interface StatusResponseBody {
|
|
|
|
/**
|
|
|
|
* The TypeScript version (`ts.version`).
|
|
|
|
*/
|
|
|
|
version: string;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Response to StatusRequest
|
|
|
|
*/
|
|
|
|
interface StatusResponse extends Response {
|
|
|
|
body: StatusResponseBody;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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 determine if the caret is inside a comment.
|
|
|
|
*/
|
|
|
|
interface SpanOfEnclosingCommentRequest extends FileLocationRequest {
|
|
|
|
command: CommandTypes.GetSpanOfEnclosingComment;
|
|
|
|
arguments: SpanOfEnclosingCommentRequestArgs;
|
|
|
|
}
|
|
|
|
interface SpanOfEnclosingCommentRequestArgs extends FileLocationRequestArgs {
|
|
|
|
/**
|
|
|
|
* Requires that the enclosing span be a multi-line comment, or else the request returns undefined.
|
|
|
|
*/
|
|
|
|
onlyMultiLine: boolean;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Request to obtain outlining spans in file.
|
|
|
|
*/
|
|
|
|
interface OutliningSpansRequest extends FileRequest {
|
|
|
|
command: CommandTypes.GetOutliningSpans;
|
|
|
|
}
|
|
|
|
interface OutliningSpan {
|
|
|
|
/** The span of the document to actually collapse. */
|
|
|
|
textSpan: TextSpan;
|
|
|
|
/** The span of the document to display when the user hovers over the collapsed span. */
|
|
|
|
hintSpan: TextSpan;
|
|
|
|
/** The text to display in the editor for the collapsed region. */
|
|
|
|
bannerText: string;
|
|
|
|
/**
|
|
|
|
* Whether or not this region should be automatically collapsed when
|
|
|
|
* the 'Collapse to Definitions' command is invoked.
|
|
|
|
*/
|
|
|
|
autoCollapse: boolean;
|
|
|
|
/**
|
|
|
|
* Classification of the contents of the span
|
|
|
|
*/
|
|
|
|
kind: OutliningSpanKind;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Response to OutliningSpansRequest request.
|
|
|
|
*/
|
|
|
|
interface OutliningSpansResponse extends Response {
|
|
|
|
body?: OutliningSpan[];
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
/** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */
|
|
|
|
reportsUnnecessary?: {};
|
2018-06-19 07:45:13 +02:00
|
|
|
relatedInformation?: DiagnosticRelatedInformation[];
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
type FileLocationOrRangeRequestArgs = FileLocationRequestArgs | FileRangeRequestArgs;
|
|
|
|
/**
|
|
|
|
* Request refactorings at a given position or selection area.
|
|
|
|
*/
|
|
|
|
interface GetApplicableRefactorsRequest extends Request {
|
|
|
|
command: CommandTypes.GetApplicableRefactors;
|
|
|
|
arguments: GetApplicableRefactorsRequestArgs;
|
|
|
|
}
|
|
|
|
type GetApplicableRefactorsRequestArgs = FileLocationOrRangeRequestArgs;
|
|
|
|
/**
|
|
|
|
* Response is a list of available refactorings.
|
|
|
|
* Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring
|
|
|
|
*/
|
|
|
|
interface GetApplicableRefactorsResponse extends Response {
|
|
|
|
body?: ApplicableRefactorInfo[];
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* A set of one or more available refactoring actions, grouped under a parent refactoring.
|
|
|
|
*/
|
|
|
|
interface ApplicableRefactorInfo {
|
|
|
|
/**
|
|
|
|
* The programmatic name of the refactoring
|
|
|
|
*/
|
|
|
|
name: string;
|
|
|
|
/**
|
|
|
|
* A description of this refactoring category to show to the user.
|
|
|
|
* If the refactoring gets inlined (see below), this text will not be visible.
|
|
|
|
*/
|
|
|
|
description: string;
|
|
|
|
/**
|
|
|
|
* Inlineable refactorings can have their actions hoisted out to the top level
|
|
|
|
* of a context menu. Non-inlineanable refactorings should always be shown inside
|
|
|
|
* their parent grouping.
|
|
|
|
*
|
|
|
|
* If not specified, this value is assumed to be 'true'
|
|
|
|
*/
|
|
|
|
inlineable?: boolean;
|
|
|
|
actions: RefactorActionInfo[];
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Represents a single refactoring action - for example, the "Extract Method..." refactor might
|
|
|
|
* offer several actions, each corresponding to a surround class or closure to extract into.
|
|
|
|
*/
|
|
|
|
interface RefactorActionInfo {
|
|
|
|
/**
|
|
|
|
* The programmatic name of the refactoring action
|
|
|
|
*/
|
|
|
|
name: string;
|
|
|
|
/**
|
|
|
|
* A description of this refactoring action to show to the user.
|
|
|
|
* If the parent refactoring is inlined away, this will be the only text shown,
|
|
|
|
* so this description should make sense by itself if the parent is inlineable=true
|
|
|
|
*/
|
|
|
|
description: string;
|
|
|
|
}
|
|
|
|
interface GetEditsForRefactorRequest extends Request {
|
|
|
|
command: CommandTypes.GetEditsForRefactor;
|
|
|
|
arguments: GetEditsForRefactorRequestArgs;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Request the edits that a particular refactoring action produces.
|
|
|
|
* Callers must specify the name of the refactor and the name of the action.
|
|
|
|
*/
|
|
|
|
type GetEditsForRefactorRequestArgs = FileLocationOrRangeRequestArgs & {
|
|
|
|
refactor: string;
|
|
|
|
action: string;
|
|
|
|
};
|
|
|
|
interface GetEditsForRefactorResponse extends Response {
|
|
|
|
body?: RefactorEditInfo;
|
|
|
|
}
|
|
|
|
interface RefactorEditInfo {
|
|
|
|
edits: FileCodeEdits[];
|
|
|
|
/**
|
|
|
|
* An optional location where the editor should start a rename operation once
|
|
|
|
* the refactoring edits have been applied
|
|
|
|
*/
|
|
|
|
renameLocation?: Location;
|
|
|
|
renameFilename?: string;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Organize imports by:
|
|
|
|
* 1) Removing unused imports
|
|
|
|
* 2) Coalescing imports from the same module
|
|
|
|
* 3) Sorting imports
|
|
|
|
*/
|
|
|
|
interface OrganizeImportsRequest extends Request {
|
|
|
|
command: CommandTypes.OrganizeImports;
|
|
|
|
arguments: OrganizeImportsRequestArgs;
|
|
|
|
}
|
|
|
|
type OrganizeImportsScope = GetCombinedCodeFixScope;
|
|
|
|
interface OrganizeImportsRequestArgs {
|
|
|
|
scope: OrganizeImportsScope;
|
|
|
|
}
|
|
|
|
interface OrganizeImportsResponse extends Response {
|
2018-06-21 06:40:48 +02:00
|
|
|
body: ReadonlyArray<FileCodeEdits>;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
interface GetEditsForFileRenameRequest extends Request {
|
|
|
|
command: CommandTypes.GetEditsForFileRename;
|
|
|
|
arguments: GetEditsForFileRenameRequestArgs;
|
|
|
|
}
|
2018-07-06 01:05:09 +02:00
|
|
|
/** Note: Paths may also be directories. */
|
|
|
|
interface GetEditsForFileRenameRequestArgs {
|
2018-05-21 20:01:35 +02:00
|
|
|
readonly oldFilePath: string;
|
|
|
|
readonly newFilePath: string;
|
|
|
|
}
|
|
|
|
interface GetEditsForFileRenameResponse extends Response {
|
2018-06-21 06:40:48 +02:00
|
|
|
body: ReadonlyArray<FileCodeEdits>;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Request for the available codefixes at a specific position.
|
|
|
|
*/
|
|
|
|
interface CodeFixRequest extends Request {
|
|
|
|
command: CommandTypes.GetCodeFixes;
|
|
|
|
arguments: CodeFixRequestArgs;
|
|
|
|
}
|
|
|
|
interface GetCombinedCodeFixRequest extends Request {
|
|
|
|
command: CommandTypes.GetCombinedCodeFix;
|
|
|
|
arguments: GetCombinedCodeFixRequestArgs;
|
|
|
|
}
|
|
|
|
interface GetCombinedCodeFixResponse extends Response {
|
|
|
|
body: CombinedCodeActions;
|
|
|
|
}
|
|
|
|
interface ApplyCodeActionCommandRequest extends Request {
|
|
|
|
command: CommandTypes.ApplyCodeActionCommand;
|
|
|
|
arguments: ApplyCodeActionCommandRequestArgs;
|
|
|
|
}
|
|
|
|
interface ApplyCodeActionCommandResponse extends Response {
|
|
|
|
}
|
|
|
|
interface FileRangeRequestArgs 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;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Instances of this interface specify errorcodes on a specific location in a sourcefile.
|
|
|
|
*/
|
|
|
|
interface CodeFixRequestArgs extends FileRangeRequestArgs {
|
|
|
|
/**
|
|
|
|
* Errorcodes we want to get the fixes for.
|
|
|
|
*/
|
2018-08-17 18:13:43 +02:00
|
|
|
errorCodes: ReadonlyArray<number>;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
interface GetCombinedCodeFixRequestArgs {
|
|
|
|
scope: GetCombinedCodeFixScope;
|
|
|
|
fixId: {};
|
|
|
|
}
|
|
|
|
interface GetCombinedCodeFixScope {
|
|
|
|
type: "file";
|
|
|
|
args: FileRequestArgs;
|
|
|
|
}
|
|
|
|
interface ApplyCodeActionCommandRequestArgs {
|
|
|
|
/** May also be an array of commands. */
|
|
|
|
command: {};
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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 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;
|
|
|
|
}
|
2018-08-17 18:13:43 +02:00
|
|
|
interface DefinitionAndBoundSpanRequest extends FileLocationRequest {
|
|
|
|
readonly command: CommandTypes.DefinitionAndBoundSpan;
|
|
|
|
}
|
|
|
|
interface DefinitionAndBoundSpanResponse extends Response {
|
|
|
|
readonly body: DefinitionInfoAndBoundSpan;
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* 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 (one-based) column 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;
|
|
|
|
}
|
2019-07-29 19:33:43 +02:00
|
|
|
interface TextSpanWithContext extends TextSpan {
|
|
|
|
contextStart?: Location;
|
|
|
|
contextEnd?: Location;
|
|
|
|
}
|
|
|
|
interface FileSpanWithContext extends FileSpan, TextSpanWithContext {
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
interface DefinitionInfoAndBoundSpan {
|
2019-07-29 19:33:43 +02:00
|
|
|
definitions: ReadonlyArray<FileSpanWithContext>;
|
2018-05-21 20:01:35 +02:00
|
|
|
textSpan: TextSpan;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Definition response message. Gives text range for definition.
|
|
|
|
*/
|
|
|
|
interface DefinitionResponse extends Response {
|
2019-07-29 19:33:43 +02:00
|
|
|
body?: FileSpanWithContext[];
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
interface DefinitionInfoAndBoundSpanReponse extends Response {
|
|
|
|
body?: DefinitionInfoAndBoundSpan;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Definition response message. Gives text range for definition.
|
|
|
|
*/
|
|
|
|
interface TypeDefinitionResponse extends Response {
|
2019-07-29 19:33:43 +02:00
|
|
|
body?: FileSpanWithContext[];
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Implementation response message. Gives text range for implementations.
|
|
|
|
*/
|
|
|
|
interface ImplementationResponse extends Response {
|
2019-07-29 19:33:43 +02:00
|
|
|
body?: FileSpanWithContext[];
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2018-06-04 23:02:51 +02:00
|
|
|
interface JsxClosingTagRequest extends FileLocationRequest {
|
|
|
|
readonly command: CommandTypes.JsxClosingTag;
|
|
|
|
readonly arguments: JsxClosingTagRequestArgs;
|
|
|
|
}
|
|
|
|
interface JsxClosingTagRequestArgs extends FileLocationRequestArgs {
|
|
|
|
}
|
|
|
|
interface JsxClosingTagResponse extends Response {
|
|
|
|
readonly body: TextInsertion;
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* @deprecated
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
/** @deprecated */
|
2019-07-29 19:33:43 +02:00
|
|
|
interface OccurrencesResponseItem extends FileSpanWithContext {
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* True if the occurrence is a write location, false otherwise.
|
|
|
|
*/
|
|
|
|
isWriteAccess: boolean;
|
|
|
|
/**
|
|
|
|
* True if the occurrence is in a string, undefined otherwise;
|
|
|
|
*/
|
|
|
|
isInString?: true;
|
|
|
|
}
|
|
|
|
/** @deprecated */
|
|
|
|
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.
|
|
|
|
*/
|
2019-07-29 19:33:43 +02:00
|
|
|
interface HighlightSpan extends TextSpanWithContext {
|
2018-05-21 20:01:35 +02:00
|
|
|
kind: HighlightSpanKind;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2019-07-29 19:33:43 +02:00
|
|
|
interface ReferencesResponseItem extends FileSpanWithContext {
|
2018-05-21 20:01:35 +02:00
|
|
|
/** 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.
|
|
|
|
*/
|
2018-11-13 01:27:38 +01:00
|
|
|
refs: ReadonlyArray<ReferencesResponseItem>;
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-10-16 21:28:14 +02:00
|
|
|
type RenameInfo = RenameInfoSuccess | RenameInfoFailure;
|
|
|
|
interface RenameInfoSuccess {
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* True if item can be renamed.
|
|
|
|
*/
|
2018-10-16 21:28:14 +02:00
|
|
|
canRename: true;
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
2018-10-16 21:28:14 +02:00
|
|
|
* File or directory to rename.
|
|
|
|
* If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
|
2018-05-21 20:01:35 +02:00
|
|
|
*/
|
2018-10-16 21:28:14 +02:00
|
|
|
fileToRename?: string;
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* 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: ScriptElementKind;
|
|
|
|
/**
|
|
|
|
* Optional modifiers for the kind (such as 'public').
|
|
|
|
*/
|
|
|
|
kindModifiers: string;
|
2018-10-16 21:28:14 +02:00
|
|
|
/** Span of text to rename. */
|
|
|
|
triggerSpan: TextSpan;
|
|
|
|
}
|
|
|
|
interface RenameInfoFailure {
|
|
|
|
canRename: false;
|
|
|
|
/**
|
|
|
|
* Error message if item can not be renamed.
|
|
|
|
*/
|
|
|
|
localizedErrorMessage: string;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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 */
|
2018-10-16 21:28:14 +02:00
|
|
|
locs: RenameTextSpan[];
|
|
|
|
}
|
2019-07-29 19:33:43 +02:00
|
|
|
interface RenameTextSpan extends TextSpanWithContext {
|
2018-10-16 21:28:14 +02:00
|
|
|
readonly prefixText?: string;
|
|
|
|
readonly suffixText?: string;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
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: ReadonlyArray<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 explicitly.
|
|
|
|
* 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;
|
|
|
|
preferences?: UserPreferences;
|
|
|
|
/**
|
|
|
|
* The host's additional supported .js 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 {
|
|
|
|
}
|
2018-11-13 01:27:38 +01:00
|
|
|
interface ConfigurePluginRequestArguments {
|
|
|
|
pluginName: string;
|
|
|
|
configuration: any;
|
|
|
|
}
|
|
|
|
interface ConfigurePluginRequest extends Request {
|
|
|
|
command: CommandTypes.ConfigurePlugin;
|
|
|
|
arguments: ConfigurePluginRequestArguments;
|
|
|
|
}
|
2019-07-29 19:33:43 +02:00
|
|
|
interface ConfigurePluginResponse extends Response {
|
|
|
|
}
|
|
|
|
interface SelectionRangeRequest extends FileRequest {
|
|
|
|
command: CommandTypes.SelectionRange;
|
|
|
|
arguments: SelectionRangeRequestArgs;
|
|
|
|
}
|
|
|
|
interface SelectionRangeRequestArgs extends FileRequestArgs {
|
|
|
|
locations: Location[];
|
|
|
|
}
|
|
|
|
interface SelectionRangeResponse extends Response {
|
|
|
|
body?: SelectionRange[];
|
|
|
|
}
|
|
|
|
interface SelectionRange {
|
|
|
|
textSpan: TextSpan;
|
|
|
|
parent?: SelectionRange;
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
/**
|
|
|
|
* Used to limit the searching for project config file. If given the searching will stop at this
|
|
|
|
* root path; otherwise it will go all the way up to the dist root path.
|
|
|
|
*/
|
|
|
|
projectRootPath?: string;
|
|
|
|
}
|
|
|
|
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 {
|
|
|
|
}
|
2019-03-09 00:20:37 +01:00
|
|
|
/**
|
|
|
|
* Request to synchronize list of open files with the client
|
|
|
|
*/
|
|
|
|
interface UpdateOpenRequest extends Request {
|
|
|
|
command: CommandTypes.UpdateOpen;
|
|
|
|
arguments: UpdateOpenRequestArgs;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Arguments to UpdateOpenRequest
|
|
|
|
*/
|
|
|
|
interface UpdateOpenRequestArgs {
|
|
|
|
/**
|
|
|
|
* List of newly open files
|
|
|
|
*/
|
|
|
|
openFiles?: OpenRequestArgs[];
|
|
|
|
/**
|
|
|
|
* List of open files files that were changes
|
|
|
|
*/
|
|
|
|
changedFiles?: FileCodeEdits[];
|
|
|
|
/**
|
|
|
|
* List of files that were closed
|
|
|
|
*/
|
|
|
|
closedFiles?: string[];
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
/**
|
|
|
|
* Specifies the project root path used to scope compiler options.
|
|
|
|
* It is an error to provide this property if the server has not been started with
|
|
|
|
* `useInferredProjectPerProjectRoot` enabled.
|
|
|
|
*/
|
|
|
|
projectRootPath?: string;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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[];
|
|
|
|
/**
|
|
|
|
* true if project uses outFile or out compiler option
|
|
|
|
*/
|
|
|
|
projectUsesOutFile: boolean;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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: ScriptElementKind;
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
/**
|
|
|
|
* JSDoc tags associated with symbol.
|
|
|
|
*/
|
|
|
|
tags: JSDocTagInfo[];
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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?: CodeFixAction[];
|
|
|
|
}
|
|
|
|
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[];
|
|
|
|
/** A command is an opaque object that should be passed to `ApplyCodeActionCommandRequestArgs` without modification. */
|
|
|
|
commands?: {}[];
|
|
|
|
}
|
|
|
|
interface CombinedCodeActions {
|
|
|
|
changes: ReadonlyArray<FileCodeEdits>;
|
|
|
|
commands?: ReadonlyArray<{}>;
|
|
|
|
}
|
|
|
|
interface CodeFixAction extends CodeAction {
|
|
|
|
/** Short name to identify the fix, for use by telemetry. */
|
|
|
|
fixName: string;
|
|
|
|
/**
|
|
|
|
* If present, one may call 'getCombinedCodeFix' with this fixId.
|
|
|
|
* This may be omitted to indicate that the code fix can't be applied in a group.
|
|
|
|
*/
|
|
|
|
fixId?: {};
|
|
|
|
/** Should be present if and only if 'fixId' is. */
|
|
|
|
fixAllDescription?: string;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
type CompletionsTriggerCharacter = "." | '"' | "'" | "`" | "/" | "@" | "<";
|
|
|
|
/**
|
|
|
|
* Arguments for completions messages.
|
|
|
|
*/
|
|
|
|
interface CompletionsRequestArgs extends FileLocationRequestArgs {
|
|
|
|
/**
|
|
|
|
* Optional prefix to apply to possible completions.
|
|
|
|
*/
|
|
|
|
prefix?: string;
|
2018-07-06 01:05:09 +02:00
|
|
|
/**
|
|
|
|
* Character that was responsible for triggering completion.
|
|
|
|
* Should be `undefined` if a user manually requested completion.
|
|
|
|
*/
|
2018-05-21 20:01:35 +02:00
|
|
|
triggerCharacter?: CompletionsTriggerCharacter;
|
|
|
|
/**
|
|
|
|
* @deprecated Use UserPreferences.includeCompletionsForModuleExports
|
|
|
|
*/
|
|
|
|
includeExternalModuleExports?: boolean;
|
|
|
|
/**
|
|
|
|
* @deprecated Use UserPreferences.includeCompletionsWithInsertText
|
|
|
|
*/
|
|
|
|
includeInsertTextCompletions?: boolean;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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 {
|
2018-10-16 21:28:14 +02:00
|
|
|
command: CommandTypes.Completions | CommandTypes.CompletionInfo;
|
2018-05-21 20:01:35 +02:00
|
|
|
arguments: CompletionsRequestArgs;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Arguments for completion details request.
|
|
|
|
*/
|
|
|
|
interface CompletionDetailsRequestArgs extends FileLocationRequestArgs {
|
|
|
|
/**
|
|
|
|
* Names of one or more entries for which to obtain details.
|
|
|
|
*/
|
|
|
|
entryNames: (string | CompletionEntryIdentifier)[];
|
|
|
|
}
|
|
|
|
interface CompletionEntryIdentifier {
|
|
|
|
name: string;
|
2018-06-04 23:02:51 +02:00
|
|
|
source?: string;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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: ScriptElementKind;
|
|
|
|
/**
|
|
|
|
* Optional modifiers for the kind (such as 'public').
|
|
|
|
*/
|
2018-06-04 23:02:51 +02:00
|
|
|
kindModifiers?: string;
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
/**
|
|
|
|
* Text to insert instead of `name`.
|
|
|
|
* This is used to support bracketed completions; If `name` might be "a-b" but `insertText` would be `["a-b"]`,
|
|
|
|
* coupled with `replacementSpan` to replace a dotted access with a bracket access.
|
|
|
|
*/
|
|
|
|
insertText?: 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.
|
|
|
|
* It will be set if the required span differs from the one generated by the default replacement behavior.
|
|
|
|
*/
|
|
|
|
replacementSpan?: TextSpan;
|
|
|
|
/**
|
|
|
|
* Indicates whether commiting this completion entry will require additional code actions to be
|
|
|
|
* made to avoid errors. The CompletionEntryDetails will have these actions.
|
|
|
|
*/
|
|
|
|
hasAction?: true;
|
|
|
|
/**
|
|
|
|
* Identifier (not necessarily human-readable) identifying where this completion came from.
|
|
|
|
*/
|
|
|
|
source?: string;
|
|
|
|
/**
|
|
|
|
* If true, this completion should be highlighted as recommended. There will only be one of these.
|
|
|
|
* This will be set when we know the user should write an expression with a certain type and that type is an enum or constructable class.
|
|
|
|
* Then either that enum/class or a namespace containing it will be the recommended symbol.
|
|
|
|
*/
|
|
|
|
isRecommended?: true;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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: ScriptElementKind;
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-06-04 23:02:51 +02:00
|
|
|
documentation?: SymbolDisplayPart[];
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* JSDoc tags for the symbol.
|
|
|
|
*/
|
2018-06-04 23:02:51 +02:00
|
|
|
tags?: JSDocTagInfo[];
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* The associated code actions for this entry
|
|
|
|
*/
|
|
|
|
codeActions?: CodeAction[];
|
|
|
|
/**
|
|
|
|
* Human-readable description of the `source` from the CompletionEntry.
|
|
|
|
*/
|
|
|
|
source?: SymbolDisplayPart[];
|
|
|
|
}
|
2018-07-06 01:05:09 +02:00
|
|
|
/** @deprecated Prefer CompletionInfoResponse, which supports several top-level fields in addition to the array of entries. */
|
2018-05-21 20:01:35 +02:00
|
|
|
interface CompletionsResponse extends Response {
|
|
|
|
body?: CompletionEntry[];
|
|
|
|
}
|
2018-07-06 01:05:09 +02:00
|
|
|
interface CompletionInfoResponse extends Response {
|
|
|
|
body?: CompletionInfo;
|
|
|
|
}
|
|
|
|
interface CompletionInfo {
|
|
|
|
readonly isGlobalCompletion: boolean;
|
|
|
|
readonly isMemberCompletion: boolean;
|
|
|
|
readonly isNewIdentifierLocation: boolean;
|
|
|
|
readonly entries: ReadonlyArray<CompletionEntry>;
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
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[];
|
|
|
|
/**
|
|
|
|
* The signature's JSDoc tags
|
|
|
|
*/
|
|
|
|
tags: JSDocTagInfo[];
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2018-07-06 01:05:09 +02:00
|
|
|
type SignatureHelpTriggerCharacter = "," | "(" | "<";
|
|
|
|
type SignatureHelpRetriggerCharacter = SignatureHelpTriggerCharacter | ")";
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* Arguments of a signature help request.
|
|
|
|
*/
|
|
|
|
interface SignatureHelpRequestArgs extends FileLocationRequestArgs {
|
2018-07-06 01:05:09 +02:00
|
|
|
/**
|
|
|
|
* Reason why signature help was invoked.
|
|
|
|
* See each individual possible
|
|
|
|
*/
|
|
|
|
triggerReason?: SignatureHelpTriggerReason;
|
|
|
|
}
|
|
|
|
type SignatureHelpTriggerReason = SignatureHelpInvokedReason | SignatureHelpCharacterTypedReason | SignatureHelpRetriggeredReason;
|
|
|
|
/**
|
|
|
|
* Signals that the user manually requested signature help.
|
|
|
|
* The language service will unconditionally attempt to provide a result.
|
|
|
|
*/
|
|
|
|
interface SignatureHelpInvokedReason {
|
|
|
|
kind: "invoked";
|
|
|
|
triggerCharacter?: undefined;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Signals that the signature help request came from a user typing a character.
|
|
|
|
* Depending on the character and the syntactic context, the request may or may not be served a result.
|
|
|
|
*/
|
|
|
|
interface SignatureHelpCharacterTypedReason {
|
|
|
|
kind: "characterTyped";
|
|
|
|
/**
|
|
|
|
* Character that was responsible for triggering signature help.
|
|
|
|
*/
|
|
|
|
triggerCharacter: SignatureHelpTriggerCharacter;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Signals that this signature help request came from typing a character or moving the cursor.
|
|
|
|
* This should only occur if a signature help session was already active and the editor needs to see if it should adjust.
|
|
|
|
* The language service will unconditionally attempt to provide a result.
|
|
|
|
* `triggerCharacter` can be `undefined` for a retrigger caused by a cursor move.
|
|
|
|
*/
|
|
|
|
interface SignatureHelpRetriggeredReason {
|
|
|
|
kind: "retrigger";
|
|
|
|
/**
|
|
|
|
* Character that was responsible for triggering signature help.
|
|
|
|
*/
|
|
|
|
triggerCharacter?: SignatureHelpRetriggerCharacter;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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[];
|
|
|
|
}
|
|
|
|
interface SuggestionDiagnosticsSyncRequest extends FileRequest {
|
|
|
|
command: CommandTypes.SuggestionDiagnosticsSync;
|
|
|
|
arguments: SuggestionDiagnosticsSyncRequestArgs;
|
|
|
|
}
|
|
|
|
type SuggestionDiagnosticsSyncRequestArgs = SemanticDiagnosticsSyncRequestArgs;
|
|
|
|
type SuggestionDiagnosticsSyncResponse = SemanticDiagnosticsSyncResponse;
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
type RequestCompletedEventName = "requestCompleted";
|
|
|
|
/**
|
|
|
|
* Event that is sent when server have finished processing request with specified id.
|
|
|
|
*/
|
|
|
|
interface RequestCompletedEvent extends Event {
|
|
|
|
event: RequestCompletedEventName;
|
|
|
|
body: RequestCompletedEventBody;
|
|
|
|
}
|
|
|
|
interface RequestCompletedEventBody {
|
|
|
|
request_seq: number;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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 category of the diagnostic message, e.g. "error", "warning", or "suggestion".
|
|
|
|
*/
|
|
|
|
category: string;
|
|
|
|
reportsUnnecessary?: {};
|
2018-06-19 07:45:13 +02:00
|
|
|
/**
|
|
|
|
* Any related spans the diagnostic may have, such as other locations relevant to an error, such as declarartion sites
|
|
|
|
*/
|
|
|
|
relatedInformation?: DiagnosticRelatedInformation[];
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* The error code of the diagnostic message.
|
|
|
|
*/
|
|
|
|
code?: number;
|
|
|
|
/**
|
|
|
|
* The name of the plugin reporting the message.
|
|
|
|
*/
|
|
|
|
source?: string;
|
|
|
|
}
|
|
|
|
interface DiagnosticWithFileName extends Diagnostic {
|
|
|
|
/**
|
|
|
|
* Name of the file the diagnostic is in
|
|
|
|
*/
|
|
|
|
fileName: string;
|
|
|
|
}
|
2018-06-19 07:45:13 +02:00
|
|
|
/**
|
|
|
|
* Represents additional spans returned with a diagnostic which are relevant to it
|
|
|
|
*/
|
|
|
|
interface DiagnosticRelatedInformation {
|
2018-07-06 01:05:09 +02:00
|
|
|
/**
|
|
|
|
* The category of the related information message, e.g. "error", "warning", or "suggestion".
|
|
|
|
*/
|
|
|
|
category: string;
|
|
|
|
/**
|
|
|
|
* The code used ot identify the related information
|
|
|
|
*/
|
|
|
|
code: number;
|
2018-06-19 07:45:13 +02:00
|
|
|
/**
|
|
|
|
* Text of related or additional information.
|
|
|
|
*/
|
|
|
|
message: string;
|
|
|
|
/**
|
|
|
|
* Associated location
|
|
|
|
*/
|
|
|
|
span?: FileSpan;
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
interface DiagnosticEventBody {
|
|
|
|
/**
|
|
|
|
* The file for which diagnostic information is reported.
|
|
|
|
*/
|
|
|
|
file: string;
|
|
|
|
/**
|
|
|
|
* An array of diagnostic information items.
|
|
|
|
*/
|
|
|
|
diagnostics: Diagnostic[];
|
|
|
|
}
|
|
|
|
type DiagnosticEventKind = "semanticDiag" | "syntaxDiag" | "suggestionDiag";
|
|
|
|
/**
|
|
|
|
* Event message for DiagnosticEventKind event types.
|
|
|
|
* These events provide syntactic and semantic errors for a file.
|
|
|
|
*/
|
|
|
|
interface DiagnosticEvent extends Event {
|
|
|
|
body?: DiagnosticEventBody;
|
2018-11-13 01:27:38 +01:00
|
|
|
event: DiagnosticEventKind;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
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: DiagnosticWithFileName[];
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
type ProjectsUpdatedInBackgroundEventName = "projectsUpdatedInBackground";
|
|
|
|
interface ProjectsUpdatedInBackgroundEvent extends Event {
|
|
|
|
event: ProjectsUpdatedInBackgroundEventName;
|
|
|
|
body: ProjectsUpdatedInBackgroundEventBody;
|
|
|
|
}
|
|
|
|
interface ProjectsUpdatedInBackgroundEventBody {
|
|
|
|
/**
|
|
|
|
* Current set of open files
|
|
|
|
*/
|
|
|
|
openFiles: string[];
|
|
|
|
}
|
2018-10-16 21:28:14 +02:00
|
|
|
type ProjectLoadingStartEventName = "projectLoadingStart";
|
|
|
|
interface ProjectLoadingStartEvent extends Event {
|
|
|
|
event: ProjectLoadingStartEventName;
|
|
|
|
body: ProjectLoadingStartEventBody;
|
|
|
|
}
|
|
|
|
interface ProjectLoadingStartEventBody {
|
|
|
|
/** name of the project */
|
|
|
|
projectName: string;
|
|
|
|
/** reason for loading */
|
|
|
|
reason: string;
|
|
|
|
}
|
|
|
|
type ProjectLoadingFinishEventName = "projectLoadingFinish";
|
|
|
|
interface ProjectLoadingFinishEvent extends Event {
|
|
|
|
event: ProjectLoadingFinishEventName;
|
|
|
|
body: ProjectLoadingFinishEventBody;
|
|
|
|
}
|
|
|
|
interface ProjectLoadingFinishEventBody {
|
|
|
|
/** name of the project */
|
|
|
|
projectName: string;
|
|
|
|
}
|
|
|
|
type SurveyReadyEventName = "surveyReady";
|
|
|
|
interface SurveyReadyEvent extends Event {
|
|
|
|
event: SurveyReadyEventName;
|
|
|
|
body: SurveyReadyEventBody;
|
|
|
|
}
|
|
|
|
interface SurveyReadyEventBody {
|
|
|
|
/** Name of the survey. This is an internal machine- and programmer-friendly name */
|
|
|
|
surveyId: string;
|
|
|
|
}
|
2018-08-17 18:13:43 +02:00
|
|
|
type LargeFileReferencedEventName = "largeFileReferenced";
|
|
|
|
interface LargeFileReferencedEvent extends Event {
|
|
|
|
event: LargeFileReferencedEventName;
|
|
|
|
body: LargeFileReferencedEventBody;
|
|
|
|
}
|
|
|
|
interface LargeFileReferencedEventBody {
|
|
|
|
/**
|
|
|
|
* name of the large file being loaded
|
|
|
|
*/
|
|
|
|
file: string;
|
|
|
|
/**
|
|
|
|
* size of the file
|
|
|
|
*/
|
|
|
|
fileSize: number;
|
|
|
|
/**
|
|
|
|
* max file size allowed on the server
|
|
|
|
*/
|
|
|
|
maxFileSize: number;
|
|
|
|
}
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-07-06 01:05:09 +02:00
|
|
|
interface NavtoItem extends FileSpan {
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* The symbol's name.
|
|
|
|
*/
|
|
|
|
name: string;
|
|
|
|
/**
|
|
|
|
* The symbol's kind (such as 'className' or 'parameterName').
|
|
|
|
*/
|
|
|
|
kind: ScriptElementKind;
|
|
|
|
/**
|
|
|
|
* exact, substring, or prefix.
|
|
|
|
*/
|
2018-07-06 01:05:09 +02:00
|
|
|
matchKind: string;
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* If this was a case sensitive or insensitive match.
|
|
|
|
*/
|
2018-07-06 01:05:09 +02:00
|
|
|
isCaseSensitive: boolean;
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* Optional modifiers for the kind (such as 'public').
|
|
|
|
*/
|
|
|
|
kindModifiers?: string;
|
|
|
|
/**
|
|
|
|
* 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?: ScriptElementKind;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* 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: ScriptElementKind;
|
|
|
|
/**
|
|
|
|
* 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: ScriptElementKind;
|
|
|
|
kindModifiers: string;
|
|
|
|
spans: TextSpan[];
|
2018-06-11 05:05:12 +02:00
|
|
|
nameSpan: TextSpan | undefined;
|
2018-05-21 20:01:35 +02:00
|
|
|
childItems?: NavigationTree[];
|
|
|
|
}
|
|
|
|
type TelemetryEventName = "telemetry";
|
|
|
|
interface TelemetryEvent extends Event {
|
|
|
|
event: TelemetryEventName;
|
|
|
|
body: TelemetryEventBody;
|
|
|
|
}
|
|
|
|
interface TelemetryEventBody {
|
|
|
|
telemetryEventName: string;
|
|
|
|
payload: any;
|
|
|
|
}
|
|
|
|
type TypesInstallerInitializationFailedEventName = "typesInstallerInitializationFailed";
|
|
|
|
interface TypesInstallerInitializationFailedEvent extends Event {
|
|
|
|
event: TypesInstallerInitializationFailedEventName;
|
|
|
|
body: TypesInstallerInitializationFailedEventBody;
|
|
|
|
}
|
|
|
|
interface TypesInstallerInitializationFailedEventBody {
|
|
|
|
message: string;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
const enum IndentStyle {
|
|
|
|
None = "None",
|
|
|
|
Block = "Block",
|
|
|
|
Smart = "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;
|
|
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
|
|
|
|
insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
|
|
|
|
insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
|
|
|
|
insertSpaceAfterTypeAssertion?: boolean;
|
|
|
|
insertSpaceBeforeFunctionParenthesis?: boolean;
|
|
|
|
placeOpenBraceOnNewLineForFunctions?: boolean;
|
|
|
|
placeOpenBraceOnNewLineForControlBlocks?: boolean;
|
|
|
|
insertSpaceBeforeTypeAnnotation?: boolean;
|
|
|
|
}
|
|
|
|
interface UserPreferences {
|
|
|
|
readonly disableSuggestions?: boolean;
|
2019-02-28 23:35:03 +01:00
|
|
|
readonly quotePreference?: "auto" | "double" | "single";
|
2018-05-21 20:01:35 +02:00
|
|
|
/**
|
|
|
|
* If enabled, TypeScript will search through all external modules' exports and add them to the completions list.
|
|
|
|
* This affects lone identifier completions but not completions on the right hand side of `obj.`.
|
|
|
|
*/
|
|
|
|
readonly includeCompletionsForModuleExports?: boolean;
|
|
|
|
/**
|
|
|
|
* If enabled, the completion list will include completions with invalid identifier names.
|
|
|
|
* For those entries, The `insertText` and `replacementSpan` properties will be set to change from `.x` property access to `["x"]`.
|
|
|
|
*/
|
|
|
|
readonly includeCompletionsWithInsertText?: boolean;
|
|
|
|
readonly importModuleSpecifierPreference?: "relative" | "non-relative";
|
|
|
|
readonly allowTextChangesInNewFiles?: boolean;
|
2018-10-16 21:28:14 +02:00
|
|
|
readonly lazyConfiguredProjectsFromExternalProject?: boolean;
|
2019-02-28 23:35:03 +01:00
|
|
|
readonly providePrefixAndSuffixTextForRename?: boolean;
|
|
|
|
readonly allowRenameOfImportPath?: boolean;
|
2018-05-21 20:01:35 +02:00
|
|
|
}
|
|
|
|
interface CompilerOptions {
|
|
|
|
allowJs?: boolean;
|
|
|
|
allowSyntheticDefaultImports?: boolean;
|
|
|
|
allowUnreachableCode?: boolean;
|
|
|
|
allowUnusedLabels?: boolean;
|
|
|
|
alwaysStrict?: boolean;
|
|
|
|
baseUrl?: string;
|
|
|
|
charset?: string;
|
|
|
|
checkJs?: boolean;
|
|
|
|
declaration?: boolean;
|
|
|
|
declarationDir?: string;
|
|
|
|
disableSizeLimit?: boolean;
|
|
|
|
downlevelIteration?: boolean;
|
|
|
|
emitBOM?: boolean;
|
|
|
|
emitDecoratorMetadata?: boolean;
|
|
|
|
experimentalDecorators?: boolean;
|
|
|
|
forceConsistentCasingInFileNames?: boolean;
|
|
|
|
importHelpers?: 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[]>;
|
|
|
|
plugins?: PluginImport[];
|
|
|
|
preserveConstEnums?: boolean;
|
|
|
|
preserveSymlinks?: boolean;
|
|
|
|
project?: string;
|
|
|
|
reactNamespace?: string;
|
|
|
|
removeComments?: boolean;
|
|
|
|
references?: ProjectReference[];
|
|
|
|
rootDir?: string;
|
|
|
|
rootDirs?: string[];
|
|
|
|
skipLibCheck?: boolean;
|
|
|
|
skipDefaultLibCheck?: boolean;
|
|
|
|
sourceMap?: boolean;
|
|
|
|
sourceRoot?: string;
|
|
|
|
strict?: boolean;
|
|
|
|
strictNullChecks?: boolean;
|
|
|
|
suppressExcessPropertyErrors?: boolean;
|
|
|
|
suppressImplicitAnyIndexErrors?: boolean;
|
|
|
|
target?: ScriptTarget | ts.ScriptTarget;
|
|
|
|
traceResolution?: boolean;
|
|
|
|
resolveJsonModule?: boolean;
|
|
|
|
types?: string[];
|
|
|
|
/** Paths used to used to compute primary types search locations */
|
|
|
|
typeRoots?: string[];
|
|
|
|
[option: string]: CompilerOptionsValue | undefined;
|
|
|
|
}
|
|
|
|
const enum JsxEmit {
|
|
|
|
None = "None",
|
|
|
|
Preserve = "Preserve",
|
|
|
|
ReactNative = "ReactNative",
|
|
|
|
React = "React"
|
|
|
|
}
|
|
|
|
const enum ModuleKind {
|
|
|
|
None = "None",
|
|
|
|
CommonJS = "CommonJS",
|
|
|
|
AMD = "AMD",
|
|
|
|
UMD = "UMD",
|
|
|
|
System = "System",
|
|
|
|
ES6 = "ES6",
|
|
|
|
ES2015 = "ES2015",
|
|
|
|
ESNext = "ESNext"
|
|
|
|
}
|
|
|
|
const enum ModuleResolutionKind {
|
|
|
|
Classic = "Classic",
|
|
|
|
Node = "Node"
|
|
|
|
}
|
|
|
|
const enum NewLineKind {
|
|
|
|
Crlf = "Crlf",
|
|
|
|
Lf = "Lf"
|
|
|
|
}
|
|
|
|
const enum ScriptTarget {
|
|
|
|
ES3 = "ES3",
|
|
|
|
ES5 = "ES5",
|
|
|
|
ES6 = "ES6",
|
|
|
|
ES2015 = "ES2015",
|
|
|
|
ES2016 = "ES2016",
|
|
|
|
ES2017 = "ES2017",
|
2019-07-29 19:33:43 +02:00
|
|
|
ES2018 = "ES2018",
|
|
|
|
ES2019 = "ES2019",
|
|
|
|
ES2020 = "ES2020",
|
2018-05-21 20:01:35 +02:00
|
|
|
ESNext = "ESNext"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
declare namespace ts.server.protocol {
|
|
|
|
|
|
|
|
interface TextInsertion {
|
|
|
|
newText: string;
|
2018-06-21 06:40:48 +02:00
|
|
|
/** The position in newText the caret should point to after the insertion. */
|
2018-05-21 20:01:35 +02:00
|
|
|
caretOffset: number;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface TodoCommentDescriptor {
|
|
|
|
text: string;
|
|
|
|
priority: number;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface TodoComment {
|
|
|
|
descriptor: TodoCommentDescriptor;
|
|
|
|
message: string;
|
|
|
|
position: number;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum OutliningSpanKind {
|
2018-06-21 06:40:48 +02:00
|
|
|
/** Single or multi-line comments */
|
2018-05-21 20:01:35 +02:00
|
|
|
Comment = "comment",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** Sections marked by '// #region' and '// #endregion' comments */
|
2018-05-21 20:01:35 +02:00
|
|
|
Region = "region",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** Declarations and expressions */
|
2018-05-21 20:01:35 +02:00
|
|
|
Code = "code",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** Contiguous blocks of import declarations */
|
2018-05-21 20:01:35 +02:00
|
|
|
Imports = "imports"
|
|
|
|
}
|
|
|
|
|
|
|
|
enum HighlightSpanKind {
|
|
|
|
none = "none",
|
|
|
|
definition = "definition",
|
|
|
|
reference = "reference",
|
|
|
|
writtenReference = "writtenReference"
|
|
|
|
}
|
|
|
|
|
|
|
|
enum ScriptElementKind {
|
|
|
|
unknown = "",
|
|
|
|
warning = "warning",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** predefined type (void) or keyword (class) */
|
2018-05-21 20:01:35 +02:00
|
|
|
keyword = "keyword",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** top level script node */
|
2018-05-21 20:01:35 +02:00
|
|
|
scriptElement = "script",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** module foo {} */
|
2018-05-21 20:01:35 +02:00
|
|
|
moduleElement = "module",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** class X {} */
|
2018-05-21 20:01:35 +02:00
|
|
|
classElement = "class",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** var x = class X {} */
|
2018-05-21 20:01:35 +02:00
|
|
|
localClassElement = "local class",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** interface Y {} */
|
2018-05-21 20:01:35 +02:00
|
|
|
interfaceElement = "interface",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** type T = ... */
|
2018-05-21 20:01:35 +02:00
|
|
|
typeElement = "type",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** enum E */
|
2018-05-21 20:01:35 +02:00
|
|
|
enumElement = "enum",
|
|
|
|
enumMemberElement = "enum member",
|
2018-06-21 06:40:48 +02:00
|
|
|
/**
|
|
|
|
* Inside module and script only
|
|
|
|
* const v = ..
|
|
|
|
*/
|
2018-05-21 20:01:35 +02:00
|
|
|
variableElement = "var",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** Inside function */
|
2018-05-21 20:01:35 +02:00
|
|
|
localVariableElement = "local var",
|
2018-06-21 06:40:48 +02:00
|
|
|
/**
|
|
|
|
* Inside module and script only
|
|
|
|
* function f() { }
|
|
|
|
*/
|
2018-05-21 20:01:35 +02:00
|
|
|
functionElement = "function",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** Inside function */
|
2018-05-21 20:01:35 +02:00
|
|
|
localFunctionElement = "local function",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** class X { [public|private]* foo() {} } */
|
2018-05-21 20:01:35 +02:00
|
|
|
memberFunctionElement = "method",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** class X { [public|private]* [get|set] foo:number; } */
|
2018-05-21 20:01:35 +02:00
|
|
|
memberGetAccessorElement = "getter",
|
|
|
|
memberSetAccessorElement = "setter",
|
2018-06-21 06:40:48 +02:00
|
|
|
/**
|
|
|
|
* class X { [public|private]* foo:number; }
|
|
|
|
* interface Y { foo:number; }
|
|
|
|
*/
|
2018-05-21 20:01:35 +02:00
|
|
|
memberVariableElement = "property",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** class X { constructor() { } } */
|
2018-05-21 20:01:35 +02:00
|
|
|
constructorImplementationElement = "constructor",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** interface Y { ():number; } */
|
2018-05-21 20:01:35 +02:00
|
|
|
callSignatureElement = "call",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** interface Y { []:number; } */
|
2018-05-21 20:01:35 +02:00
|
|
|
indexSignatureElement = "index",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** interface Y { new():Y; } */
|
2018-05-21 20:01:35 +02:00
|
|
|
constructSignatureElement = "construct",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** function foo(*Y*: string) */
|
2018-05-21 20:01:35 +02:00
|
|
|
parameterElement = "parameter",
|
|
|
|
typeParameterElement = "type parameter",
|
|
|
|
primitiveType = "primitive type",
|
|
|
|
label = "label",
|
|
|
|
alias = "alias",
|
|
|
|
constElement = "const",
|
|
|
|
letElement = "let",
|
|
|
|
directory = "directory",
|
|
|
|
externalModuleName = "external module name",
|
2018-06-21 06:40:48 +02:00
|
|
|
/**
|
|
|
|
* <JsxTagName attribute1 attribute2={0} />
|
|
|
|
*/
|
2018-05-21 20:01:35 +02:00
|
|
|
jsxAttribute = "JSX attribute",
|
2018-06-21 06:40:48 +02:00
|
|
|
/** String literal */
|
2018-05-21 20:01:35 +02:00
|
|
|
string = "string"
|
|
|
|
}
|
|
|
|
|
|
|
|
interface TypeAcquisition {
|
|
|
|
enableAutoDiscovery?: boolean;
|
|
|
|
enable?: boolean;
|
|
|
|
include?: string[];
|
|
|
|
exclude?: string[];
|
|
|
|
[option: string]: string[] | boolean | undefined;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface FileExtensionInfo {
|
|
|
|
extension: string;
|
|
|
|
isMixedContent: boolean;
|
|
|
|
scriptKind?: ScriptKind;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface JSDocTagInfo {
|
|
|
|
name: string;
|
|
|
|
text?: string;
|
|
|
|
}
|
|
|
|
|
2018-06-21 06:40:48 +02:00
|
|
|
/**
|
|
|
|
* Type of objects whose values are all of the same type.
|
|
|
|
* The `in` and `for-in` operators can *not* be safely used,
|
|
|
|
* since `Object.prototype` may be modified by outside code.
|
|
|
|
*/
|
2018-05-21 20:01:35 +02:00
|
|
|
interface MapLike<T> {
|
|
|
|
[index: string]: T;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface PluginImport {
|
|
|
|
name: string;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface ProjectReference {
|
2018-06-21 06:40:48 +02:00
|
|
|
/** A normalized path on disk */
|
2018-05-21 20:01:35 +02:00
|
|
|
path: string;
|
2018-06-21 06:40:48 +02:00
|
|
|
/** The path as the user originally wrote it */
|
2018-05-21 20:01:35 +02:00
|
|
|
originalPath?: string;
|
2018-06-21 06:40:48 +02:00
|
|
|
/** True if the output of this reference should be prepended to the output of this project. Only valid for --outFile compilations */
|
2018-05-21 20:01:35 +02:00
|
|
|
prepend?: boolean;
|
2018-06-21 06:40:48 +02:00
|
|
|
/** True if it is intended that this reference form a circularity */
|
2018-05-21 20:01:35 +02:00
|
|
|
circular?: boolean;
|
|
|
|
}
|
|
|
|
|
|
|
|
type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined;
|
|
|
|
}
|
|
|
|
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;
|