To help you get started, we've collected the most common ways that typescript-language-server is being used within popular public projects.

eclipse-theia / theia / packages / typescript / src / browser / typescript-frontend-contribution.ts View on Github

QuickPickService, KeybindingRegistry, KeybindingContribution, QuickPickItem, StorageService, LabelProvider, FrontendApplicationContribution, StatusBar, StatusBarAlignment
} from '@theia/core/lib/browser';
import { ExecuteCommandRequest } from '@theia/languages/lib/browser';
import { FileSystemWatcher, FileMoveEvent } from '@theia/filesystem/lib/browser';
import { EditorManager, EditorWidget, EDITOR_CONTEXT_MENU, TextEditor } from '@theia/editor/lib/browser';
import { CommandContribution, CommandRegistry, Command, MenuModelRegistry, MenuContribution, DisposableCollection } from '@theia/core/lib/common';
import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
import { TYPESCRIPT_LANGUAGE_ID, TS_JS_LANGUAGES } from '../common';
import { TypeScriptClientContribution, TypescriptContributionData } from './typescript-client-contribution';
import { TypeScriptKeybindingContexts } from './typescript-keybinding-contexts';
import { TypescriptVersion } from '../common/typescript-version-service';
import URI from '@theia/core/lib/common/uri';

export namespace TypeScriptCommands {
    export const applyCompletionCodeAction: Command = {
        id: Commands.APPLY_COMPLETION_CODE_ACTION
    };
    // TODO: get rid of me when https://github.com/TypeFox/monaco-languageclient/issues/104 is resolved
    export const organizeImports: Command = {
        category: 'TypeScript',
        label: 'Organize Imports',
        id: 'typescript.edit.organizeImports'
    };
    export const openServerLog: Command = {
        category: 'TypeScript',
        label: 'Open Server Log',
        id: 'typescript.server.openLog'
    };
    export const selectVersion: Command = {
        category: 'TypeScript',
        label: 'Select Version',
        id: 'typescript.selectVersion'

View more ways to use typescript-language-server

TypeScript Language Server

Language Server Protocol implementation for TypeScript wrapping tsserver.

Based on concepts and ideas from https://github.com/prabirshrestha/typescript-language-server and originally maintained by TypeFox.

Maintained by a community of contributors like you.

• Installing
• Running the language server
• CLI Options
• Configuration
• Features
  • Code actions on save
  • Workspace commands (workspace/executeCommand)
    • Go to Source Definition
    • Apply Workspace Edits
    • Apply Code Action
    • Apply Refactoring
    • Organize Imports
    • Rename File
    • Configure plugin
  • Code Lenses (textDocument/codeLens)
  • Inlay hints (textDocument/inlayHint)
  • TypeScript Version Notification
• Development
  • Build
  • Dev
  • Test
  • Publishing

Installing

npm install -g typescript-language-server typescript

Running the language server

typescript-language-server --stdio

CLI Options

  Usage: typescript-language-server [options]


  Options:

    -V, --version                          output the version number
    --stdio                                use stdio (required option)
    --log-level                 A number indicating the log level (4 = log, 3 = info, 2 = warn, 1 = error). Defaults to `3`.
    -h, --help                             output usage information

Configuration

See configuration documentation.

Features

Code actions on save

Server announces support for the following code action kinds:

• source.fixAll.ts - despite the name, fixes a couple of specific issues: unreachable code, await in non-async functions, incorrectly implemented interface
• source.removeUnused.ts - removes declared but unused variables
• source.addMissingImports.ts - adds imports for used but not imported symbols
• source.removeUnusedImports.ts - removes unused imports
• source.sortImports.ts - sorts imports
• source.organizeImports.ts - organizes and removes unused imports

This allows editors that support running code actions on save to automatically run fixes associated with those kinds.

Those code actions, if they apply in the current code, should also be presented in the list of "Source Actions" if the editor exposes those.

The user can enable it with a setting similar to (can vary per-editor):

"codeActionsOnSave": {
    "source.organizeImports.ts": true,
    // or just
    "source.organizeImports": true,
}

Workspace commands (workspace/executeCommand)

See LSP specification.

Most of the time, you'll execute commands with arguments retrieved from another request like textDocument/codeAction. There are some use cases for calling them manually.

lsp refers to the language server protocol types, tsp refers to the typescript server protocol types.

Go to Source Definition

• Request:

  {
      command: `_typescript.goToSourceDefinition`
      arguments: [
          lsp.DocumentUri,  // String URI of the document
          lsp.Position,     // Line and character position (zero-based)
      ]
  }
  

• Response:

  lsp.Location[] | null
  

(This command is supported from Typescript 4.7.)

Apply Workspace Edits

• Request:

  {
      command: `_typescript.applyWorkspaceEdit`
      arguments: [lsp.WorkspaceEdit]
  }
  

• Response:

  lsp.ApplyWorkspaceEditResult
  

Apply Code Action

• Request:

  {
      command: `_typescript.applyCodeAction`
      arguments: [
          tsp.CodeAction,  // TypeScript Code Action object
      ]
  }
  

• Response:

  void
  

Apply Refactoring

• Request:

  {
      command: `_typescript.applyRefactoring`
      arguments: [
          tsp.GetEditsForRefactorRequestArgs,
      ]
  }
  

• Response:

  void
  

Organize Imports

• Request:

  {
      command: `_typescript.organizeImports`
      arguments: [
          // The "skipDestructiveCodeActions" argument is supported from Typescript 4.4+
          [string] | [string, { skipDestructiveCodeActions?: boolean }],
      ]
  }
  

• Response:

  void
  

Rename File

• Request:

  {
      command: `_typescript.applyRenameFile`
      arguments: [
          { sourceUri: string; targetUri: string; },
      ]
  }
  

• Response:

  void
  

Configure plugin

• Request:

  {
      command: `_typescript.configurePlugin`
      arguments: [pluginName: string, configuration: any]
  }
  

• Response:

  void
  

Code Lenses (textDocument/codeLens)

Code lenses can be enabled using the implementationsCodeLens and referencesCodeLens workspace configuration options.

Code lenses provide a count of references and/or implemenations for symbols in the document. For clients that support it it's also possible to click on those to navigate to the relevant locations in the the project. Do note that clicking those trigger a editor.action.showReferences command which is something that client needs to have explicit support for. Many do by default but some don't. An example command will look like this:

command: {
    title: '1 reference',
    command: 'editor.action.showReferences',
    arguments: [
        'file://project/foo.ts',    // URI
        { line: 1, character: 1 },  // Position
        [                           // A list of Location objects.
            {
                uri: 'file://project/bar.ts',
                range: {
                    start: {
                        line: 7,
                        character: 24,
                    },
                    end: {
                        line: 7,
                        character: 28,
                    },
                },
            },
        ],
    ],
}

Inlay hints (textDocument/inlayHint)

For the request to return any results, some or all of the following options need to be enabled through preferences:

export interface InlayHintsOptions extends UserPreferences {
    includeInlayParameterNameHints: 'none' | 'literals' | 'all';
    includeInlayParameterNameHintsWhenArgumentMatchesName: boolean;
    includeInlayFunctionParameterTypeHints: boolean;
    includeInlayVariableTypeHints: boolean;
    includeInlayVariableTypeHintsWhenTypeMatchesName: boolean;
    includeInlayPropertyDeclarationTypeHints: boolean;
    includeInlayFunctionLikeReturnTypeHints: boolean;
    includeInlayEnumMemberValueHints: boolean;
}

TypeScript Version Notification

Right after initializing, the server sends a custom $/typescriptVersion notification that carries information about the version of TypeScript that is utilized by the server. The editor can then display that information in the UI.

The $/typescriptVersion notification params include two properties:

• version - a semantic version (for example 4.8.4)
• source - a string specifying whether used TypeScript version comes from the local workspace (workspace), is explicitly specified through a initializationOptions.tsserver.path setting (user-setting) or was bundled with the server (bundled)

Development

Build

yarn build

Dev

Build and rebuild on change.

yarn dev

Test

• yarn test - run all tests in watch mode for developing
• yarn test:commit - run all tests once

By default only console logs of level warning and higher are printed to the console. You can override the CONSOLE_LOG_LEVEL level in package.json to either log, info, warning or error to log other levels.

Publishing

The project uses https://github.com/google-github-actions/release-please-action Github action to automatically release new version on merging a release PR.