Provided by: node-typescript_4.9.5+ds1-2_all 
NAME
tsserver - TypeScript standalone server
The TypeScript standalone server (aka tsserver) is a node executable that encapsulates the
TypeScript compiler and language services, and exposes them through a JSON protocol.
tsserver is well suited for editors and IDE support.
NAME
Protocol
Definition
The server communication protocol is defined in the ts.server.protocol namespace, declared
in `tsserverlibrary.d.ts`
⟨https://github.com/microsoft/TypeScript/blob/main/lib/tsserverlibrary.d.ts⟩.
The executable can be found in lib folder under the typescript package.
npm install --save typescript
ls node_modules\typescript\lib\tsserver.js
Message format
tsserver listens on stdin and writes messages back to stdout.
Requests are JSON following the protocol definition. Here is an example request to open a
file c:/DefinitelyTyped/gregorian-calendar/index.d.ts:
{"seq":1,"type":"request","command":"open","arguments":{"file":"c:/DefinitelyTyped/gregorian-calendar/index.d.ts"}}
Responses are augmented JSON format. The Message starts with a header with the content
length followed by a line separator (\r\n) followed by the response body as a JSON string:
Here is an example of a response for a quickinfo command:
Content-Length: 116
{"seq":0,"type":"response","command":"quickinfo","request_seq":2,"success":false,"message":"No content available."}
Similarly events have the same format as a response.
Here is an example event for error message:
Content-Length: 261
{"seq":0,"type":"event","event":"semanticDiag","body":{"file":"c:/DefinitelyTyped/gregorian-calendar/index.d.ts","diagnostics":[{"start":{"line":264,"offset":44},"end":{"line":264,"offset":50},"text":"Binding element 'Object'
implicitly has an 'any' type."}]}}
Commands
tsserver supports a set of commands. The full list of commands supported by the server can
be found under ts.server.protocol.CommandTypes
⟨https://github.com/microsoft/TypeScript/blob/main/src/server/protocol.ts⟩.
Each command is associated with a request and a response interface. For instance command
"completions" corresponds to request interface CompletionsRequest, and response interface
defined in CompletionsResponse.
NAME
Sample implementations
Sublime text plugin
TypeScript-Sublime-Plugin ⟨https://github.com/Microsoft/TypeScript-Sublime-Plugin⟩ is a
Sublime text plugin written in Python that uses tsserver.
Visual Studio Code
VS Code ⟨https://code.visualstudio.com/⟩' s TypeScript support
⟨https://github.com/microsoft/vscode/tree/master/extensions/typescript-language-features⟩
is implemented in TypeScript using tsserver.
Tide
Tide ⟨https://github.com/ananthakumaran/tide⟩ is an elisp implementation for emacs plugin
using tsserver
Neovim
nvim-typescript ⟨https://github.com/mhartington/nvim-typescript⟩ is a neovim plugin using
tsserver
NAME
Advanced topics
Logging
tsserver logging is configured through the TSS_LOG environment variable.
TSS_LOG can have the following format:
[-level <terse | normal | requestTime | verbose>]
[-traceToConsole <true | false>]
[-logToFile <true | false>]
[-file <log file path>]
Note: file defaults to __dirname\.log<PID> if not specified
Example: set TSS_LOG=-level verbose -file c:\tmp\tsserver.log
Cancellation
tsserver on startup will try to load module ./cancellationToken from the containing
directory. This module should export a factory function that accepts a list of command
line arguments and returns HostCancellationToken
⟨https://github.com/Microsoft/TypeScript/blob/master/src/services/types.ts#L119-L121⟩.
tsserver will use this token to check if in-flight operation should be cancelled.
NOTE: This token will be used for all operations so if one operation is cancelled and
cancellation was reported through the token then when another operation is started - token
should be reset into the non-cancelled state.
Default implementation of the cancellation token uses the presence of named pipes as a way
to signal cancellation.
• Before spawning the server, the client generates a unique name. This name is passed to
the server as a cancellationPipeName command line argument.
• If some operation on the client side should be cancelled - client opens a named pipe
with a name generated on step 1. Nothing needs to be written in the pipe - default
cancellation token will interpret the presence of named pipe as a cancellation request.
• After receiving acknowledgment from the server, the client closes the pipe so it can
use the same pipe name for the next operation.
Server can split execution of some commands (like geterr) in a few steps that will be
executed with a delay. This allows it to react on user actions more promptly and not run
heavy computations if their results will not be used. However, it introduces a tricky
moment in support of cancellations. By allowing request to be suspended and resumed later
we break the invariant that was the cornerstone for default implementation of
cancellation. Namely now requests can overlap so one pipe name can no longer be used
because client have no reason what request is currently executing and will be cancelled.
To deal with this issue tsserver allows pipe name to be computed dynamically based on
current request id. To enable this the client need to provide a value that ends with * as
the --cancellationPipeName argument. If provided cancellation pipe name ends with * then
default implementation of cancellation token will build expected pipe name as
<cancellationPipeName argument without *><currentRequestId>. This will allow client to
signal any request it thinks is in flight by creating a named pipe with a proper name.
Note that server will always send requestCompleted message to denote that asynchronous
request was completed (either by running to completion or via cancellation) so the client
can close named pipe once this message is received.
Commandline options
--cancellationPipeName
Name of the pipe used as a request cancellation semaphore. See Cancellation for more information.
--syntaxOnly
A streamlined mode for when the server will only be answering syntactic queries.
--suppressDiagnosticEvents
Opt out of receiving events when new diagnostics are discovered (i.e. must request them explicitly).
--eventPort
Port used for receiving events. If non is specified events are sent to stdout.
--useSingleInferredProject
Put all open .ts and .js files that do not have a .tsconfig file in a common project
--noGetErrOnBackgroundUpdate
Opt out of starting getErr on projectsUpdatedInBackground event
--locale
The locale to use to show error messages, e.g. en-us.
Possible values are: English (US): en, Czech: cs, German: de, Spanish: es, French: fr, Italian: it, Japanese: ja, Korean: ko, Polish: pl,
Portuguese(Brazil): pt-BR, Russian: ru, Turkish: tr, Simplified Chinese: zh-CN, Traditional Chinese: zh-TW
TSSERVER(1) General Commands Manual TSSERVER(1)
NAME
Project System
There are three kinds of projects:
Configured Project
Configured projects are defined by a configuration file, which can be either tsconfig.json
That configuratiojsconfig.jsonthelproject root path and defines what files to include.
The configuration file also provide the compiler options to be used for this project.
You can find more information in the
tsconfig.json documentation
⟨http://www.typescriptlang.org/docs/handbook/tsconfig-json.html⟩.
External Project
The hostnisxresponsibleeforrsupplying thetlistcofifilesjintthismprojecttand compilerwoptions to use.
Currently VS is the only consumer of this type of project, to model the TS/JS files in a .csproj project.
Inferred Project
If a filefdoesdnotohavesaaconfigurationefile (tsconfig.jsonoor jsconfig.json) in the current directory or any parent directories, the server will create an inferred project for it.
The server will include the loose file, then includes all other files included by triple slash references and module imports from the original file transitively.
Compilation options will use the default options for inferred projects.
The host can set the defaults of an inferred project.
Relationship Among These Projects
In general, the relationship can be summarized as configured projects > external projects
> inferred projects.
For example, if file1.ts belongs to an inferred project, but later a new tsconfig.json also includes this file.
Then after the tsconfig.json file is found, file1.ts will no longer belong to the previous inferred project but the newly created configured project instead.
If file1.ts used to be the root file of the inferred project, that inferred project will now be destroyed; otherwise it will remain with one fewer file.
For another example, if a tsconfig.json file is created to include some files used to belong to an external project (let's call it EP1), then in the current implementation EP1 will be destroyed, all its files either go to the new configured project or will belong to a new inferred project the next time it is opened.
One thing to notice is that one file can belong to multiple projects of the same kind at the same time. E.g., a file can be included by multiple configured projects / inferred projects / external projects.
October 2023 TSSERVER(1)