@theia/core

@theia/core

Version 1.71.0
Published 8 days ago
15.1 MB
70 dependencies
EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 license

Install

npm i @theia/core

yarn add @theia/core

pnpm add @theia/core

Overview

Theia is a cloud & desktop IDE framework implemented in TypeScript.

Index

Variables

variable ACCOUNTS_MENU

const ACCOUNTS_MENU: MenuPath;

variable ACCOUNTS_SUBMENU

const ACCOUNTS_SUBMENU: string[];

variable BackendStopwatch

const BackendStopwatch: Symbol;

variable BackendStopwatchOptions

const BackendStopwatchOptions: Symbol;

variable CommandContribution

const CommandContribution: Symbol;

variable CommandService

const CommandService: Symbol;

variable commandServicePath

const commandServicePath: string;

variable ConnectionHandler

const ConnectionHandler: Symbol;

variable ContributionFilterRegistry

const ContributionFilterRegistry: Symbol;

variable ContributionProvider

const ContributionProvider: Symbol;

variable CorePreferenceContribution

const CorePreferenceContribution: Symbol;

variable CorePreferences

const CorePreferences: Symbol;

variable corePreferenceSchema

const corePreferenceSchema: PreferenceSchema;

variable DefaultSanitizationRules

const DefaultSanitizationRules: SanitizationRule[];

Default set of log sanitization rules.

variable EOL

const EOL: string;

variable Filter

const Filter: Symbol;

variable FilterContribution

const FilterContribution: Symbol;

variable ILogger

const ILogger: Symbol;

variable isOSX

const isOSX: boolean;

variable isWindows

const isWindows: boolean;

variable LINUX_ENV_HINT

const LINUX_ENV_HINT: string;

Hint appended to API key preference descriptions on Linux, where environment variables set in ~/.bashrc are not available to desktop-launched applications.

variable logger

let logger: ILogger;

variable LoggerFactory

const LoggerFactory: Symbol;

variable LoggerName

const LoggerName: Symbol;

variable LoggerSanitizer

const LoggerSanitizer: Symbol;

variable MAIN_MENU_BAR

const MAIN_MENU_BAR: MenuPath;

variable MANAGE_MENU

const MANAGE_MENU: MenuPath;

variable MAX_SAFE_INTEGER

const MAX_SAFE_INTEGER: number;

The maximum safe integer (2^32-1) is used as a placeholder for large numbers which are not allowed to be floats. For example as line/column arguments for monaco-ranges.

variable MEMORY_TEXT

const MEMORY_TEXT: string;

variable MEMORY_TEXT_READONLY

const MEMORY_TEXT_READONLY: string;

variable MenuContribution

const MenuContribution: Symbol;

variable MenuNodeFactory

const MenuNodeFactory: Symbol;

variable messageServicePath

const messageServicePath: string;

variable NO_OVERRIDE

const NO_OVERRIDE: {};

variable OSBackendProvider

const OSBackendProvider: Symbol;

variable OSBackendProviderPath

const OSBackendProviderPath: string;

variable OVERRIDE_PROPERTY

const OVERRIDE_PROPERTY: string;

variable OVERRIDE_PROPERTY_PATTERN

const OVERRIDE_PROPERTY_PATTERN: RegExp;

variable PREFERENCE_NAME_TREE_INDENT

const PREFERENCE_NAME_TREE_INDENT: string;

variable PreferenceConfiguration

const PreferenceConfiguration: Symbol;

variable PreferenceContribution

const PreferenceContribution: Symbol;

variable PreferenceProvider

const PreferenceProvider: Symbol;

variable PreferenceProviderProvider

const PreferenceProviderProvider: Symbol;

We cannot load providers directly in the case if they depend on PreferenceService somehow. It allows to load them lazily after DI is configured.

variable PreferenceProxyFactory

const PreferenceProxyFactory: Symbol;

variable PreferenceProxyOptions

const PreferenceProxyOptions: Symbol;

variable PreferenceProxySchema

const PreferenceProxySchema: Symbol;

variable PreferenceSchemaService

const PreferenceSchemaService: Symbol;

variable PreferenceService

const PreferenceService: Symbol;

variable ProgressClient

const ProgressClient: Symbol;

variable QuickInputService

const QuickInputService: Symbol;

variable quickInputServicePath

const quickInputServicePath: string;

variable QuickPickService

const QuickPickService: Symbol;

variable quickPickServicePath

const quickPickServicePath: string;

variable ResourceProvider

const ResourceProvider: Symbol;

variable ResourceResolver

const ResourceResolver: Symbol;

variable rootLoggerName

const rootLoggerName: string;

variable servicesPath

const servicesPath: string;

variable stopwatchPath

const stopwatchPath: string;

API path of the stopwatch service that exposes the back-end stopwatch to clients.

variable THEIA_VERSION

const THEIA_VERSION: string;

variable TreePreferences

const TreePreferences: Symbol;

variable treePreferencesSchema

const treePreferencesSchema: PreferenceSchema;

variable UNTITLED_SCHEME

const UNTITLED_SCHEME: string;

variable ValidPreferenceScopes

const ValidPreferenceScopes: Symbol;

An array of preference scopes that are valid in a given context, sorted from more general to more specific

Functions

function bindContribution

bindContribution: (
    bindable: Bindable,
    service: interfaces.ServiceIdentifier<any>,
    contributions: interfaces.ServiceIdentifier<any>[]
) => void;

Helper function to bind a service to a list of contributions easily.
Parameter bindable
a Container or the bind function directly.
Parameter service
an already bound service to refer the contributions to.
Parameter contributions
array of contribution identifiers to bind the service to.

function bindContributionProvider

bindContributionProvider: (bindable: Bindable, id: symbol) => void;

Binds a ContributionProvider for the given service identifier.
**In most cases, prefer bindRootContributionProvider instead.** This variant retains a reference to whichever container first resolves the provider. If that container is a short-lived child (e.g. a widget container), the provider will keep the child — and everything cached in it — alive for the lifetime of the application, causing a memory leak.
Use bindContributionProvider only when you are certain that some or all of the relevant services are scoped to a child container rather than the root container — for example, inside a ConnectionContainerModule (connection-scoped child containers).
Parameter bindable
A Container or Bind function to register the provider in.
Parameter id
The service identifier symbol whose contributions the provider collects.

function bindCorePreferences

bindCorePreferences: (bind: interfaces.Bind) => void;

function bindFactory

bindFactory: <F, C>(
    bind: interfaces.Bind,
    factoryId: interfaces.ServiceIdentifier<F>,
    constructor: interfaces.Newable<C>,
    ...parameterBindings: interfaces.ServiceIdentifier<unknown>[]
) => void;

This utility creates a factory function that accepts runtime arguments which are bound as constant values in a child container, allowing for dependency injection of both static dependencies (resolved as usual from the factory's container) and dynamic parameters (provided at factory invocation time).

Example 1

// Factory interface
interface UserPreferenceProviderFactory {
    (uri: URI, section: string): UserPreferenceProvider;
}
// Factory symbol
const UserPreferenceProviderFactory = Symbol('UserPreferenceProviderFactory');

// Bind the factory
bindFactory(
    bind,
    UserPreferenceProviderFactory,   // Service identifier of the factory
    UserPreferenceProvider,          // Service identifier of the entity to be constructed
    SectionPreferenceProviderUri,    // The first factory argument will be bound to this identifier (uri)
    SectionPreferenceProviderSection // The second factory argument will be bound to this identifier  (section)
);

// Usage: factory(uri, section) creates UserPreferenceProvider with injected dependencies
const factory = container.get(UserPreferenceProviderFactory);
const provider = factory(myUri, 'settings');

function bindPreferenceConfigurations

bindPreferenceConfigurations: (bind: interfaces.Bind) => void;

function bindRootContributionProvider

bindRootContributionProvider: (bindable: Bindable, id: symbol) => void;

Binds a ContributionProvider for the given service identifier, resolving contributions from the **root** (top-level) Inversify container.
**This is the recommended default** for binding contribution providers in module-level ContainerModule definitions. It walks up from whichever container first resolves the provider to the root container, ensuring the provider does not permanently retain a reference to a short-lived child container.
Use this function when contributions are registered at the application level (the common case for FrontendApplicationContribution, CommandContribution, MenuContribution, KeybindingContribution, and similar top-level contribution points).
If you need contributions that are scoped to a child container (e.g. connection-scoped), use bindContributionProvider instead.
See https://github.com/eclipse-theia/theia/issues/10877#issuecomment-1107000223
Parameter bindable
A Container or Bind function to register the provider in.
Parameter id
The service identifier symbol whose contributions the provider collects.

function bindTreePreferences

bindTreePreferences: (bind: interfaces.Bind) => void;

function cancelled

cancelled: () => Error;

function checkCancelled

checkCancelled: (token?: CancellationToken) => void;

function cloneAndChange

cloneAndChange: (obj: any, changer: (orig: any) => any) => any;

function cmd

cmd: (command: string, ...args: string[]) => CMD;

function commonPrefixLength

commonPrefixLength: (a: string, b: string) => number;

Returns
the length of the common prefix of the two strings.

function compare

compare: (a: string, b: string) => number;

function compareIgnoreCase

compareIgnoreCase: (a: string, b: string) => number;

function compareSubstring

compareSubstring: (
    a: string,
    b: string,
    aStart?: number,
    aEnd?: number,
    bStart?: number,
    bEnd?: number
) => number;

function compareSubstringIgnoreCase

compareSubstringIgnoreCase: (
    a: string,
    b: string,
    aStart?: number,
    aEnd?: number,
    bStart?: number,
    bEnd?: number
) => number;

function createCorePreferences

createCorePreferences: (
    preferences: PreferenceService,
    schema?: PreferenceSchema
) => CorePreferences;

function createPreferenceProxy

createPreferenceProxy: <T>(
    preferences: PreferenceService,
    promisedSchema: MaybePromise<IJSONSchema>,
    options?: PreferenceProxyOptions
) => PreferenceProxy<T>;

Creates a preference proxy for typesafe preference handling.
Parameter preferences
the underlying preference service to use for preference handling.
Parameter promisedSchema
the JSON Schema which describes which preferences are available including types and descriptions. Can be a promise.
Parameter options
configuration options.
Returns
the created preference proxy.
### Usage
1. Create JSON Schema specifying your preferences 2. Create Configuration type based on the JSON Schema 3. Bind the return value of createPreferenceProxy to make your preferences available wherever needed.
See CorePreferences for an example.
Note that if schema is a Promise, most actions will be no-ops until the promise is resolved.
Deprecated
1.23.0 use PreferenceProxyFactory instead.

function createUntitledURI

createUntitledURI: (extension?: string, parent?: URI) => URI;

Deprecated
Since 1.27.0. Please use UntitledResourceResolver.createUntitledURI instead.

function deepClone

deepClone: <T>(obj: T) => T;

function deepFreeze

deepFreeze: <T>(obj: T) => T;

function disposableTimeout

disposableTimeout: (
    handler: TimerHandler,
    timeout?: number,
    ...arguments: any[]
) => Disposable;

function endsWith

endsWith: (haystack: string, needle: string) => boolean;

Determines if haystack ends with needle.

function equalsIgnoreCase

equalsIgnoreCase: (a: string, b: string) => boolean;

function escapeInvisibleChars

escapeInvisibleChars: (value: string) => string;

function escapeRegExpCharacters

escapeRegExpCharacters: (value: string) => string;

Escapes regular expression characters in a given string

function filterItems

filterItems: (
    items: QuickPickItemOrSeparator[],
    filter: string
) => QuickPickItemOrSeparator[];

Filter the list of quick pick items based on the provided filter. Items are filtered based on if: - their label satisfies the filter using fuzzy. - their description satisfies the filter using fuzzy. - their detail satisfies the filter using fuzzy. Filtered items are also updated to display proper highlights based on how they were filtered.
Parameter items
the list of quick pick items.
Parameter filter
the filter to search for.
Returns
the list of quick pick items that satisfy the filter.

function findMatches

findMatches: (
    word: string,
    pattern: string
) => Array<{ start: number; end: number }> | undefined;

Find match highlights when testing a word against a pattern.
Parameter word
the word to test.
Parameter pattern
the word to match against.
Returns
the list of highlights if present.

function generateUuid

generateUuid: () => string;

function getOverridePattern

getOverridePattern: (identifier: string) => string;

function hashValue

hashValue: (value: string) => string;

This function will hash the given value using SHA1. The result will be a uuid.
Parameter value
the string to hash
Returns
a uuid

function isArray

isArray: <T>(
    value: unknown,
    every?: (value: unknown) => unknown,
    thisArg?: unknown
) => value is T[];

Parameter value
value to check.
Parameter every
optional predicate ran on every element of the array.
Parameter thisArg
value to substitute this with when invoking in the predicate.
Returns
whether or not value is an array.

function isBoolean

isBoolean: (value: unknown) => value is boolean;

function isCancelled

isCancelled: (err: Error | undefined) => boolean;

function isDefined

isDefined: <T>(arg: T | null | undefined) => arg is T;

Returns
whether the provided parameter is defined.

function isEmpty

isEmpty: (arg: Object) => boolean;

true if the argument is an empty object. Otherwise, false.

function isEmptyObject

isEmptyObject: (obj: unknown) => obj is object;

Returns
whether the provided parameter is an empty JavaScript Object or not.

function isError

isError: (value: unknown) => value is Error;

function isErrorLike

isErrorLike: (value: unknown) => value is Error;

function isFunction

isFunction: <T extends (...args: unknown[]) => unknown>(
    value: unknown
) => value is T;

function isLowerAsciiLetter

isLowerAsciiLetter: (code: number) => boolean;

function isNumber

isNumber: (value: unknown) => value is number;

function isObject

isObject: <T extends object>(value: unknown) => value is UnknownObject<T>;

function isString

isString: (value: unknown) => value is string;

function isStringArray

isStringArray: (value: unknown) => value is string[];

function isUndefined

isUndefined: (value: unknown) => value is undefined;

function isUndefinedOrNull

isUndefinedOrNull: (obj: unknown) => obj is null;

Returns
whether the provided parameter is undefined or null.

function isUpperAsciiLetter

isUpperAsciiLetter: (code: number) => boolean;

function isUUID

isUUID: (value: string) => boolean;

function notEmpty

notEmpty: <T>(arg: T | undefined | null) => arg is T;

function nullToUndefined

nullToUndefined: <T>(nullable: MaybeNull<T>) => MaybeUndefined<T>;

Creates a shallow copy with all ownkeys of the original object that are null made undefined

function regExpFlags

regExpFlags: (regexp: RegExp) => string;

function setRootLogger

setRootLogger: (aLogger: ILogger) => void;

function split

split: (s: string, splitter: string) => IterableIterator<string>;

function startsWithIgnoreCase

startsWithIgnoreCase: (str: string, candidate: string) => boolean;

function unescapeInvisibleChars

unescapeInvisibleChars: (value: string) => string;

function unreachable

unreachable: (_never: never, message?: string) => never;

Throws when called and statically makes sure that all variants of a type were consumed.

function unsetRootLogger

unsetRootLogger: () => void;

Counterpart of the #setRootLogger(ILogger). Restores the console.xxx bindings to the original one. Invoking has no side-effect if setRootLogger was not called before. Multiple function invocation has no side-effect either.

Classes

class AbstractChannel

abstract class AbstractChannel implements Channel {}

Reusable abstract Channel implementation that sets up the basic channel event listeners and offers a generic close method.

constructor

constructor();

property onClose

readonly onClose: Event<ChannelCloseEvent>;

property onCloseEmitter

onCloseEmitter: Emitter<ChannelCloseEvent>;

property onError

readonly onError: Event<unknown>;

property onErrorEmitter

onErrorEmitter: Emitter<unknown>;

property onMessage

readonly onMessage: Event<MessageProvider>;

property onMessageEmitter

onMessageEmitter: Emitter<MessageProvider>;

property toDispose

protected toDispose: DisposableCollection;

method close

close: () => void;

method getWriteBuffer

abstract getWriteBuffer: () => WriteBuffer;

class AbstractCompoundMenuImpl

abstract class AbstractCompoundMenuImpl implements MenuNode {}

Node representing a (sub)menu in the menu tree structure.

constructor

protected constructor(id: string, orderString?: string, when?: string);

property children

readonly children: MenuNode[];

property id

readonly id: string;

property orderString

protected readonly orderString?: string;

property sortString

readonly sortString: string;

property when

readonly when?: string;

method addNode

addNode: (...node: MenuNode[]) => void;

method getNode

getNode: (id: string) => MenuNode | undefined;

method getOrCreate

getOrCreate: (
    menuPath: MenuPath,
    pathIndex: number,
    endIndex: number
) => CompoundMenuImpl;

method isEmpty

isEmpty: <T>(
    effectiveMenuPath: MenuPath,
    contextMatcher: ContextExpressionMatcher<T>,
    context: T | undefined,
    ...args: unknown[]
) => boolean;

method isVisible

isVisible: <T>(
    effectiveMenuPath: MenuPath,
    contextMatcher: ContextExpressionMatcher<T>,
    context: T | undefined,
    ...args: unknown[]
) => boolean;

Menu nodes are sorted in ascending order based on their sortString.

method removeById

removeById: (id: string) => void;

method removeNode

removeNode: (node: MenuNode) => void;

class AbstractReferenceCollection

abstract class AbstractReferenceCollection<K, V extends Disposable>
    implements Disposable {}

Abstract class for a map of reference-counted disposable objects, with the following features:
- values are not inserted explicitly; instead, acquire() is used to create the value for a given key, or return the previously created value for it. How the value is created for a given key is implementation specific.
- any subsquent acquire() with the same key will bump the reference count on that value. acquire() returns not the value directly but a reference object that holds the value. Calling dispose() on the reference decreases the value's effective reference count.
- a contained value will have its dispose() function called when its reference count reaches zero. The key/value pair will be purged from the collection.
- calling dispose() on the value directly, instead of calling it on the reference returned by acquire(), will automatically dispose all outstanding references to that value and the key/value pair will be purged from the collection.
- supports synchronous and asynchronous implementations. acquire() will return a Promise if the value cannot be created immediately
- functions has|keys|values|get are always synchronous and the result excludes asynchronous additions in flight.
- functions values|get return the value directly and not a reference to the value. Use these functions to obtain a value without bumping its reference count.
- clients can register to be notified when values are added and removed; notification for asynchronous additions happen when the creation completes, not when it's requested.
- keys can be any value/object that can be successfully stringified using JSON.stringify(), sans arguments
- calling dispose() on the collection will dispose all outstanding references to all contained values, which results in the disposal of the values themselves.

constructor

constructor();

property onDidCreate

readonly onDidCreate: Event<V>;

property onDidCreateEmitter

protected readonly onDidCreateEmitter: Emitter<V>;

property onWillDispose

readonly onWillDispose: Event<V>;

property onWillDisposeEmitter

protected readonly onWillDisposeEmitter: Emitter<V>;

property references

protected readonly references: Map<string, DisposableCollection>;

property toDispose

protected readonly toDispose: DisposableCollection;

method acquire

abstract acquire: (args: K) => MaybePromise<Reference<V>>;

method clear

clear: () => void;

method createReferences

protected createReferences: (key: string, value: V) => DisposableCollection;

method dispose

dispose: () => void;

method doAcquire

protected doAcquire: (key: string, object: V) => Reference<V>;

method get

get: (args: K) => V | undefined;

method has

has: (args: K) => boolean;

method keys

keys: () => K[];

method toKey

protected toKey: (args: K) => string;

method values

values: () => V[];

class ActionMenuNode

class ActionMenuNode implements CommandMenu {}

Node representing an action in the menu tree structure. It's based on MenuAction for which it tries to determine the best label, icon and sortString with the given data.

constructor

constructor(
    action: MenuAction,
    commands: CommandRegistry,
    keybindingRegistry: KeybindingRegistry,
    contextKeyService: ContextKeyService
);

property action

protected readonly action: MenuAction;

property commands

protected readonly commands: CommandRegistry;

property contextKeyService

protected readonly contextKeyService: ContextKeyService;

property disposables

protected readonly disposables: DisposableCollection;

property icon

readonly icon: string;

property id

readonly id: string;

property keybindingRegistry

protected readonly keybindingRegistry: KeybindingRegistry;

property label

readonly label: string;

property onDidChange

onDidChange: Event<void>;

property onDidChangeEmitter

protected readonly onDidChangeEmitter: Emitter<void>;

property sortString

readonly sortString: string;

property when

readonly when: string;

method dispose

dispose: () => void;

method getAccelerator

getAccelerator: (context: HTMLElement | undefined) => string[];

method isEnabled

isEnabled: (effeciveMenuPath: MenuPath, ...args: unknown[]) => boolean;

method isToggled

isToggled: (effeciveMenuPath: MenuPath, ...args: unknown[]) => boolean;

method isVisible

isVisible: <T>(
    effeciveMenuPath: MenuPath,
    contextMatcher: ContextExpressionMatcher<T>,
    context: T | undefined,
    ...args: unknown[]
) => boolean;

method run

run: (effeciveMenuPath: MenuPath, ...args: unknown[]) => Promise<void>;

class AsyncEmitter

class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {}

property deliveryQueue

protected deliveryQueue: Promise<void>;

method deliver

protected deliver: (
    listeners: Callback[],
    event: WaitUntilData<T>,
    token: CancellationToken,
    promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>
) => Promise<void>;

method fire

fire: (
    event: WaitUntilData<T>,
    token?: CancellationToken,
    promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>
) => Promise<void>;

Fire listeners async one after another.

class CancellationError

class CancellationError extends Error {}

constructor

constructor();

class CancellationTokenSource

class CancellationTokenSource {}

constructor

constructor(parent?: CancellationToken);

property token

readonly token: CancellationToken;

method cancel

cancel: () => void;

method dispose

dispose: () => void;

class CommandRegistry

class CommandRegistry implements CommandService {}

The command registry manages commands and handlers.

constructor

constructor(contributionProvider: ContributionProvider<CommandContribution>);

property commandIds

readonly commandIds: string[];

Get all registered commands identifiers.

property commands

readonly commands: Command[];

Get all registered commands.

property contributionProvider

protected readonly contributionProvider: ContributionProvider<CommandContribution>;

property fireDidChange

protected fireDidChange: () => Promise<void>;

property onCommandsChanged

readonly onCommandsChanged: Event<void>;

property onCommandsChangedEmitter

protected readonly onCommandsChangedEmitter: Emitter<void>;

property onDidExecuteCommand

readonly onDidExecuteCommand: Event<CommandEvent>;

property onDidExecuteCommandEmitter

protected readonly onDidExecuteCommandEmitter: Emitter<CommandEvent>;

property onWillExecuteCommand

readonly onWillExecuteCommand: Event<WillExecuteCommandEvent>;

property onWillExecuteCommandEmitter

protected readonly onWillExecuteCommandEmitter: Emitter<WillExecuteCommandEvent>;

property recent

recent: Command[];

Get the list of recently used commands.

property toUnregisterCommands

protected readonly toUnregisterCommands: Map<string, Disposable>;

method addRecentCommand

addRecentCommand: (recent: Command | Command[]) => void;

Adds a command to recently used list. Prioritizes commands that were recently executed to be most recent.
Parameter recent
a recent command, or array of recent commands.

method clearCommandHistory

clearCommandHistory: () => void;

Clear the list of recently used commands.

method doFireDidChange

protected doFireDidChange: () => void;

method doRegisterCommand

protected doRegisterCommand: (command: Command) => Disposable;

method executeCommand

executeCommand: <T>(commandId: string, ...args: any[]) => Promise<T | undefined>;

Execute the active handler for the given command and arguments.
Reject if a command cannot be executed.

method fireWillExecuteCommand

protected fireWillExecuteCommand: (
    commandId: string,
    args?: any[]
) => Promise<void>;

method getActiveHandler

getActiveHandler: (
    commandId: string,
    ...args: any[]
) => CommandHandler | undefined;

Get an active handler for the given command or undefined.

method getAllCommands

getAllCommands: () => IterableIterator<
    Readonly<Command & { handlers: CommandHandler[] }>
>;

method getAllHandlers

getAllHandlers: (commandId: string) => CommandHandler[];

Returns with all handlers for the given command. If the command does not have any handlers, or the command is not registered, returns an empty array.

method getCommand

getCommand: (id: string) => Command | undefined;

Get a command for the given command identifier.

method getToggledHandler

getToggledHandler: (
    commandId: string,
    ...args: any[]
) => CommandHandler | undefined;

Get a toggled handler for the given command or undefined.

method getVisibleHandler

getVisibleHandler: (
    commandId: string,
    ...args: any[]
) => CommandHandler | undefined;

Get a visible handler for the given command or undefined.

method isEnabled

isEnabled: (command: string, ...args: any[]) => boolean;

Test whether there is an active handler for the given command.

method isToggled

isToggled: (command: string, ...args: any[]) => boolean;

Test whether there is a toggled handler for the given command.

method isVisible

isVisible: (command: string, ...args: any[]) => boolean;

Test whether there is a visible handler for the given command.

method onStart

onStart: () => void;

method registerCommand

registerCommand: (command: Command, handler?: CommandHandler) => Disposable;

Register the given command and handler if present.
Throw if a command is already registered for the given command identifier.

method registerHandler

registerHandler: (commandId: string, handler: CommandHandler) => Disposable;

Register the given handler for the given command identifier.
If there is already a handler for the given command then the given handler is registered as more specific, and has higher priority during enablement, visibility and toggle state evaluations.

method unregisterCommand

unregisterCommand: { (command: Command): void; (id: string): void };

Unregister command from the registry
Parameter command
Unregister command from the registry
Parameter id

class ConnectionErrorHandler

class ConnectionErrorHandler {}

constructor

constructor(options: ConnectionErrorHandlerOptions);

property options

protected readonly options: ResolvedConnectionErrorHandlerOptions;

property restarts

protected readonly restarts: number[];

method shouldRestart

shouldRestart: () => boolean;

method shouldStop

shouldStop: (error: Error, count?: number) => boolean;

class ContributionFilterRegistryImpl

class ContributionFilterRegistryImpl implements ContributionFilterRegistry {}

Registry of contribution filters.
Implement/bind to the FilterContribution interface/symbol to register your contribution filters.

constructor

constructor(contributions?: FilterContribution[]);

property genericFilters

protected genericFilters: Filter<Object>[];

property initialized

protected initialized: boolean;

property typeToFilters

protected typeToFilters: Map<
    interfaces.ServiceIdentifier<any>,
    Filter<Object>[]
>;

method addFilters

addFilters: (types: '*' | ContributionType[], filters: Filter<Object>[]) => void;

method applyFilters

applyFilters: <T extends Object>(
    toFilter: T[],
    type: interfaces.ServiceIdentifier<any>
) => T[];

method getFilters

protected getFilters: (
    type: interfaces.ServiceIdentifier<any>
) => Filter<Object>[];

method getOrCreate

protected getOrCreate: (
    type: interfaces.ServiceIdentifier<any>
) => Filter<Object>[];

class DefaultBackendStopwatch

class DefaultBackendStopwatch {}

Default implementation of the (remote) back-end stopwatch service.

property idSequence

protected idSequence: number;

property measurements

readonly measurements: Map<number, Measurement>;

property stopwatch

protected readonly stopwatch: Stopwatch;

method start

start: (name: string, options?: MeasurementOptions) => RemoteMeasurement;

method stop

stop: (
    measurementToken: RemoteMeasurement,
    message: string,
    messageArgs: any[]
) => void;

class DefaultLoggerSanitizer

class DefaultLoggerSanitizer implements LoggerSanitizer {}

Default implementation of LoggerSanitizer that masks credentials in URLs.

property rules

protected rules: SanitizationRule[];

method sanitize

sanitize: (message: string) => string;

class DefaultResourceProvider

class DefaultResourceProvider {}

constructor

constructor(resolversProvider: ContributionProvider<ResourceResolver>);

property resolversProvider

protected readonly resolversProvider: ContributionProvider<ResourceResolver>;

method get

get: (uri: URI) => Promise<Resource>;

Reject if a resource cannot be provided.

method init

init: () => void;

class DefaultsPreferenceProvider

class DefaultsPreferenceProvider
    extends PreferenceProviderBase
    implements PreferenceProvider {}

property preferenceOverrideService

protected readonly preferenceOverrideService: PreferenceLanguageOverrideService;

property preferenceSchemaService

protected readonly preferenceSchemaService: PreferenceSchemaService;

property ready

ready: Promise<void>;

method canHandleScope

canHandleScope: (scope: PreferenceScope) => boolean;

method changeFor

protected changeFor: (
    key: string,
    overrideIdentifier: string | undefined,
    oldValue: JSONValue | undefined,
    newValue: JSONValue | undefined
) => PreferenceProviderDataChange;

method get

get: <T>(preferenceName: string, resourceUri?: string) => T | undefined;

method getPreferences

getPreferences: () => JSONObject;

method init

init: () => void;

method resolve

resolve: <T>(
    preferenceName: string,
    resourceUri?: string
) => PreferenceResolveResult<T>;

method setPreference

setPreference: (
    key: string,
    value: JSONValue,
    resourceUri?: string
) => Promise<boolean>;

class DisposableCollection

class DisposableCollection implements Disposable {}

Utility for tracking a collection of Disposable objects.
This utility provides a number of benefits over just using an array of Disposables:
- the collection is auto-pruned when an element it contains is disposed by any code that has a reference to it - you can register to be notified when all elements in the collection have been disposed [1] - you can conveniently dispose all elements by calling dispose() on the collection
Unlike an array, however, this utility does not give you direct access to its elements.
Being notified when all elements are disposed is simple:
const dc = new DisposableCollection(myDisposables); dc.onDispose(() => { console.log('All elements in the collection have been disposed'); });
[1] The collection will notify only once. It will continue to function in so far as accepting new Disposables and pruning them when they are disposed, but such activity will never result in another notification.

constructor

constructor(...toDispose: Disposable[]);

property disposables

protected readonly disposables: Disposable[];

property disposed

readonly disposed: boolean;

property onDispose

readonly onDispose: Event<void>;

This event is fired only once on first dispose of not empty collection.

property onDisposeEmitter

protected readonly onDisposeEmitter: Emitter<void>;

method checkDisposed

protected checkDisposed: () => void;

method dispose

dispose: () => void;

method push

push: (disposable: Disposable) => Disposable;

method pushAll

pushAll: (disposables: Disposable[]) => Disposable[];

class DisposableWrapper

class DisposableWrapper implements Disposable {}

Wrapper for a Disposable that is not available immediately.

method dispose

dispose: () => void;

method set

set: (disposable: Disposable) => void;

class Emitter

class Emitter<T = any> {}

constructor

constructor(_options?: EmitterOptions);

property event

readonly event: Event<T>;

For the public to allow to subscribe to events from this Emitter

method checkMaxListeners

protected checkMaxListeners: (maxListeners: number) => (() => void) | undefined;

method dispose

dispose: () => void;

method fire

fire: (event: T) => any;

To be kept private to fire an event to subscribers

method popLeakingStack

protected popLeakingStack: (stack: string) => void;

method pushLeakingStack

protected pushLeakingStack: () => () => void;

method sequence

sequence: (
    processor: (listener: (e: T) => any) => MaybePromise<boolean>
) => Promise<void>;

Process each listener one by one. Return false to stop iterating over the listeners, true to continue.

class GroupImpl

class GroupImpl extends AbstractCompoundMenuImpl implements Group {}

constructor

constructor(id: string, orderString?: string, when?: string);

class InjectablePreferenceProxy

class InjectablePreferenceProxy<T extends Record<string, JSONValue>>
    implements
        ProxyHandler<T>,
        ProxyHandler<Disposable>,
        ProxyHandler<PreferenceEventEmitter<T>>,
        ProxyHandler<PreferenceRetrieval<T>> {}

property factory

protected readonly factory: PreferenceProxyFactory;

property isDeep

readonly isDeep: boolean;

property isFlat

readonly isFlat: boolean;

property onPreferenceChanged

readonly onPreferenceChanged: Event<PreferenceChangeEvent<T>>;

property onPreferenceChangedEmitter

readonly onPreferenceChangedEmitter: Emitter<PreferenceChangeEvent<T>>;

property options

protected readonly options: PreferenceProxyOptions;

property overrideIdentifier

readonly overrideIdentifier: string;

property preferences

protected readonly preferences: PreferenceService;

property prefix

readonly prefix: string;

property promisedSchema

protected readonly promisedSchema: () =>
    | PreferenceSchema
    | Promise<PreferenceSchema>;

property resourceUri

readonly resourceUri: string;

property schema

protected schema: PreferenceSchema;

property style

readonly style: 'flat' | 'deep' | 'both';

property toDispose

protected toDispose: DisposableCollection;

method buildNewChangeEvent

protected buildNewChangeEvent: (
    change: PreferenceProviderDataChange,
    overrideInfo?: OverridePreferenceName
) => PreferenceChangeEvent<T>;

method defineProperty

defineProperty: () => never;

method deleteProperty

deleteProperty: () => never;

method dispose

dispose: () => void;

method fireChangeEvent

protected fireChangeEvent: (change: PreferenceChangeEvent<T>) => void;

method get

get: (target: unknown, property: string, receiver: unknown) => unknown;

method getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: unknown,
    property: string
) => PropertyDescriptor;

method getValue

protected getValue: <K extends keyof T & string>(
    preferenceIdentifier: K | (OverridePreferenceName & { preferenceName: K }),
    defaultValue: T[K],
    resourceUri?: string | undefined
) => T[K];

method handlePreferenceChanges

protected handlePreferenceChanges: (changes: PreferenceChanges) => void;

method init

protected init: () => void;

method isRelevantChange

protected isRelevantChange: (
    change: PreferenceChange,
    overrideInfo?: OverridePreferenceName
) => boolean;

method ownKeys

ownKeys: () => string[];

method set

set: (
    target: unknown,
    property: string,
    value: unknown,
    receiver: unknown
) => boolean;

method subscribeToChangeEvents

protected subscribeToChangeEvents: () => void;

method toJSON

toJSON: () => JSONValue;

class InMemoryResources

class InMemoryResources implements ResourceResolver {}

property resources

protected readonly resources: SyncReferenceCollection<string, MutableResource>;

method acquire

protected acquire: (uri: string) => ReferenceMutableResource;

method add

add: (uri: URI, contents: string) => Resource;

method resolve

resolve: (uri: URI) => Resource;

method update

update: (uri: URI, contents: string) => Resource;

class InMemoryTextResource

class InMemoryTextResource implements Resource {}

Resource implementation for 'mem-txt' URI scheme where content is saved in URI query.

constructor

constructor(uri: URI);

property readOnly

readonly readOnly: boolean;

property uri

readonly uri: URI;

method dispose

dispose: () => void;

method readContents

readContents: (
    options?: { encoding?: string | undefined } | undefined
) => Promise<string>;

class InMemoryTextResourceResolver

class InMemoryTextResourceResolver implements ResourceResolver {}

ResourceResolver implementation for 'mem-txt' URI scheme.

method resolve

resolve: (uri: URI) => MaybePromise<Resource>;

class JsonRpcConnectionHandler

class JsonRpcConnectionHandler<T extends object> extends RpcConnectionHandler<T> {}

Deprecated
since 1.39.0 use RpcConnectionHandler instead

class JsonRpcProxyFactory

class JsonRpcProxyFactory<T extends object> extends RpcProxyFactory<T> {}

Deprecated
since 1.39.0 use RpcProxyFactory instead

class ListenerList

class ListenerList<T, U> {}

property registration

registration: Listener.Registration<T, U>;

method invoke

invoke: (e: T, callback: (value: U) => void) => void;

class Logger

class Logger implements ILogger {}

property cache

protected cache: Map<string, ILogger>;

property created

protected created: Promise<void>;

property factory

protected readonly factory: LoggerFactory;

property loggerWatcher

protected readonly loggerWatcher: LoggerWatcher;

property name

protected name: string;

property sanitizer

protected readonly sanitizer: LoggerSanitizer;

property server

protected readonly server: ILoggerServer;

method child

child: (name: string) => ILogger;

method debug

debug: (arg: any | Loggable, ...params: any[]) => Promise<void>;

method error

error: (arg: any | Loggable, ...params: any[]) => Promise<void>;

method fatal

fatal: (arg: any | Loggable, ...params: any[]) => Promise<void>;

method format

protected format: (value: any) => any;

method getLog

protected getLog: (logLevel: number) => Promise<Log>;

method getLogLevel

getLogLevel: () => Promise<number>;

method ifDebug

ifDebug: () => Promise<void>;

method ifEnabled

ifEnabled: (logLevel: number) => Promise<void>;

method ifError

ifError: () => Promise<void>;

method ifFatal

ifFatal: () => Promise<void>;

method ifInfo

ifInfo: () => Promise<void>;

method ifTrace

ifTrace: () => Promise<void>;

method ifWarn

ifWarn: () => Promise<void>;

method info

info: (arg: any | Loggable, ...params: any[]) => Promise<void>;

method init

protected init: () => void;

method isDebug

isDebug: () => Promise<boolean>;

method isEnabled

isEnabled: (logLevel: number) => Promise<boolean>;

method isError

isError: () => Promise<boolean>;

method isFatal

isFatal: () => Promise<boolean>;

method isInfo

isInfo: () => Promise<boolean>;

method isTrace

isTrace: () => Promise<boolean>;

method isWarn

isWarn: () => Promise<boolean>;

method log

log: (logLevel: number, arg2: any | Loggable, ...params: any[]) => Promise<void>;

method sanitize

protected sanitize: (message: string) => string;

method setLogLevel

setLogLevel: (logLevel: number) => Promise<void>;

method trace

trace: (arg: any | Loggable, ...params: any[]) => Promise<void>;

method warn

warn: (arg: any | Loggable, ...params: any[]) => Promise<void>;

class MeasurementContext

class MeasurementContext<T extends object = object> {}

Tracks the settlement of async work initiated by contributions during application startup.
A contribution "settles" when all promises it returned from lifecycle methods (initialize, configure, onStart, etc.) have resolved. Individual settlement is only logged when a contribution returned promises from more than one lifecycle method; otherwise the single lifecycle measurement already describes the work. An aggregate "all settled" message is logged once all tracked promises across all contributions have resolved.
Typical usage: 1. Create the context at the start of the application lifecycle. 2. Before each lifecycle call, call ensureEntry to start the per-contribution clock. 3. After each lifecycle call, call trackSettlement with the return value. 4. After the startup sequence completes, call armAllSettled to enable the aggregate message.

constructor

constructor(stopwatch: Stopwatch, owner: string, thresholdMillis: number);

property owner

protected readonly owner: string;

property stopwatch

protected readonly stopwatch: Stopwatch;

property thresholdMillis

protected readonly thresholdMillis: number;

method armAllSettled

armAllSettled: () => void;

Arm the aggregate "all settled" log message. Call this after the startup sequence has finished collecting all promises. If all promises have already settled, the message is logged immediately.

method ensureEntry

ensureEntry: (item: T) => void;

Ensure that settlement tracking has been started for the given contribution. Starts the per-contribution measurement clock on the first call for each contribution.

method trackSettlement

trackSettlement: (item: T, result: MaybePromise<unknown>) => void;

Track a promise returned by a contribution's lifecycle method. Must be called after the corresponding Stopwatch.startAsync has completed so that the settlement log appears after the lifecycle measurement log.

class MenuModelRegistry

class MenuModelRegistry {}

The MenuModelRegistry allows to register and unregister menus, submenus and actions via strings and MenuActions without the need to access the underlying UI representation.

constructor

constructor(
    contributions: ContributionProvider<MenuContribution>,
    commands: CommandRegistry,
    menuNodeFactory: MenuNodeFactory
);

property commands

protected readonly commands: CommandRegistry;

property contributions

protected readonly contributions: ContributionProvider<MenuContribution>;

property isReady

protected isReady: boolean;

property menuNodeFactory

protected readonly menuNodeFactory: MenuNodeFactory;

property onDidChange

readonly onDidChange: Event<MenuChangedEvent>;

property onDidChangeEmitter

protected readonly onDidChangeEmitter: Emitter<MenuChangedEvent>;

property root

protected root: CompoundMenuNode & MutableCompoundMenuNode;

method findInNode

protected findInNode: (
    root: MenuNode,
    menuPath: MenuPath,
    pathIndex: number
) => MenuNode | undefined;

method fireChangeEvent

protected fireChangeEvent: <T extends MenuChangedEvent>(evt: T) => void;

method getMenu

getMenu: (menuPath: MenuPath) => CompoundMenuNode | undefined;

method getMenuNode

getMenuNode: (menuPath: string[]) => MenuNode | undefined;

method isEmpty

static isEmpty: (node: MenuNode) => boolean;

method linkCompoundMenuNode

linkCompoundMenuNode: (params: {
    newParentPath: MenuPath;
    submenuPath: MenuPath;
    order?: string;
    when?: string;
}) => Disposable;

method onStart

onStart: () => void;

method registerCommandMenu

registerCommandMenu: (menuPath: MenuPath, item: CommandMenu) => Disposable;

Adds the given menu action to the menu denoted by the given path.
Returns
a disposable which, when called, will remove the menu action again.

method registerMenuAction

registerMenuAction: (menuPath: MenuPath, item: MenuAction) => Disposable;

Adds the given menu action to the menu denoted by the given path.
Returns
a disposable which, when called, will remove the menu action again.

method registerSubmenu

registerSubmenu: (
    menuPath: MenuPath,
    label: string,
    options?: {
        sortString?: string;
        icon?: string;
        when?: string;
        contextKeyOverlay?: Record<string, string>;
    }
) => Disposable;

Register a new menu at the given path with the given label. (If the menu already exists without a label, iconClass or order this method can be used to set them.)
Parameter menuPath
the path for which a new submenu shall be registered.
Parameter label
the label to be used for the new submenu.
Parameter options
optionally allows to set an icon class and specify the order of the new menu.
Returns
if the menu was successfully created a disposable will be returned which, when called, will remove the menu again. If the menu already existed a no-op disposable will be returned.
Note that if the menu already existed and was registered with a different label an error will be thrown.

method removeActionInSubtree

protected removeActionInSubtree: (parent: MenuNode, id: string) => void;

method removeSingleRootNode

static removeSingleRootNode: (
    fullMenuModel: CompoundMenuNode
) => CompoundMenuNode;

Checks the given menu model whether it will show a menu with a single submenu.
Parameter fullMenuModel
the menu model to analyze
Parameter menuPath
the menu's path
Returns
if the menu will show a single submenu this returns a menu that will show the child elements of the submenu, otherwise the given fullMenuModel is return

method removeSingleRootNodes

static removeSingleRootNodes: (
    fullMenuModel: CompoundMenuNode
) => CompoundMenuNode;

method unregisterMenuAction

unregisterMenuAction: {
    (item: MenuAction, menuPath?: MenuPath): void;
    (command: Command, menuPath?: MenuPath): void;
    (id: string, menuPath?: MenuPath): void;
};

Unregister all menu nodes with the same id as the given menu action.
Parameter item
the item whose id will be used.
Parameter menuPath
if specified only nodes within the path will be unregistered.
Unregister all menu nodes with the same id as the given command.
Parameter command
the command whose id will be used.
Parameter menuPath
if specified only nodes within the path will be unregistered.
Unregister all menu nodes with the given id.
Parameter id
the id which shall be removed.
Parameter menuPath
if specified only nodes within the path will be unregistered.

class MessageClient

class MessageClient {}

method reportProgress

reportProgress: (
    progressId: string,
    update: ProgressUpdate,
    message: ProgressMessage,
    cancellationToken: CancellationToken
) => Promise<void>;

Update a previously created progress message.
To be implemented by an extension, e.g. by the messages extension.

method showMessage

showMessage: (message: Message) => Promise<string | undefined>;

Show a message of the given type and possible actions to the user. Resolve to a chosen action. Never reject.
To be implemented by an extension, e.g. by the messages extension.

method showProgress

showProgress: (
    progressId: string,
    message: ProgressMessage,
    cancellationToken: CancellationToken
) => Promise<string | undefined>;

Show a progress message with possible actions to user.
To be implemented by an extension, e.g. by the messages extension.

class MessageService

class MessageService {}

Service to log and categorize messages, show progress information and offer actions.
The messages are processed by this service and forwarded to an injected MessageClient. For example "@theia/messages" provides such a client, rendering messages as notifications in the frontend.
### Example usage
@inject(MessageService) protected readonly messageService: MessageService; messageService.warn("Typings not available"); messageService.error("Could not restore state", ["Rollback", "Ignore"]) .then(action => action === "Rollback" && rollback());

constructor

constructor(client: MessageClient);

property client

protected readonly client: MessageClient;

method error

error: {
    <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
    <T extends string>(
        message: string,
        options?: MessageOptions,
        ...actions: T[]
    ): Promise<T>;
};

Logs the message as "error" and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.
Logs the message as "error" and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter options
additional options. Can be omitted
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.

method info

info: {
    <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
    <T extends string>(
        message: string,
        options?: MessageOptions,
        ...actions: T[]
    ): Promise<T>;
};

Logs the message as "info" and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.
Logs the message as "info" and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter options
additional options. Can be omitted
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.

method log

log: {
    <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
    <T extends string>(
        message: string,
        options?: MessageOptions,
        ...actions: T[]
    ): Promise<T>;
};

Logs the message and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.
Logs the message and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter options
additional options. Can be omitted
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.

method newProgressId

protected newProgressId: () => string;

method processMessage

protected processMessage: (
    type: MessageType,
    text: string,
    args?: any[]
) => Promise<string | undefined>;

method showProgress

showProgress: (
    message: ProgressMessage,
    onDidCancel?: () => void
) => Promise<Progress>;

Shows the given message as a progress.

Parameter message

the message to show for the progress.

Parameter onDidCancel

an optional callback which will be invoked if the progress indicator was canceled.

Returns

a promise resolving to a Progress object with which the progress can be updated.

### Example usage

  @inject(MessageService)
  protected readonly messageService: MessageService;

  // this will show "Progress" as a cancelable message
  this.messageService.showProgress({text: 'Progress'});

  // this will show "Rolling back" with "Cancel" and an additional "Skip" action
  this.messageService.showProgress({
    text: `Rolling back`,
    actions: ["Skip"],
  },
  () => console.log("canceled"))
  .then((progress) => {
    // register if interested in the result (only necessary for custom actions)
    progress.result.then((result) => {
      // will be 'Cancel', 'Skip' or `undefined`
      console.log("result is", result);
    });
    progress.report({message: "Cleaning references", work: {done: 10, total: 100}});
    progress.report({message: "Restoring previous state", work: {done: 80, total: 100}});
    progress.report({message: "Complete", work: {done: 100, total: 100}});
    // we are done so we can cancel the progress message, note that this will also invoke `onDidCancel`
    progress.cancel();
  });

method warn

warn: {
    <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
    <T extends string>(
        message: string,
        options?: MessageOptions,
        ...actions: T[]
    ): Promise<T>;
};

Logs the message as "warning" and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.
Logs the message as "warning" and, if given, offers actions to act on it.
Parameter message
the message to log.
Parameter options
additional options. Can be omitted
Parameter actions
the actions to offer. Can be omitted.
Returns
the selected action if there is any, undefined when there was no action or none was selected.

class MutableResource

class MutableResource implements Resource {}

constructor

constructor(uri: URI);

property contents

protected contents: string;

property onDidChangeContents

readonly onDidChangeContents: Event<void>;

property onDidChangeContentsEmitter

protected readonly onDidChangeContentsEmitter: Emitter<void>;

property uri

readonly uri: URI;

method dispose

dispose: () => void;

method fireDidChangeContents

protected fireDidChangeContents: () => void;

method readContents

readContents: () => Promise<string>;

method saveContents

saveContents: (contents: string) => Promise<void>;

class NullBackendStopwatch

class NullBackendStopwatch implements BackendStopwatch {}

No-op implementation of the (remote) back-end stopwatch service.

method start

start: () => Promise<RemoteMeasurement>;

method stop

stop: () => Promise<void>;

class Path

class Path {}

constructor

constructor(raw: string);

The raw should be normalized, meaning that only '/' is allowed as a path separator.

property base

readonly base: string;

property dir

readonly dir: Path;

Returns the parent directory if it exists (hasDir === true) or this otherwise.

property ext

readonly ext: string;

property hasDir

readonly hasDir: boolean;

Returns true if this has a parent directory, false otherwise.
_This implementation returns true if and only if this is not the root dir and there is a path separator in the raw path._

property isAbsolute

readonly isAbsolute: boolean;

property isRoot

readonly isRoot: boolean;

property name

readonly name: string;

property root

readonly root: Path;

property separator

static separator: string;

method computeDir

protected computeDir: () => Path;

method computeRoot

protected computeRoot: () => Path | undefined;

method fsPath

fsPath: (format?: Path.Format) => string;

Converts the current path into a file system path.
Parameter format
Determines the format of the path. If undefined, the format will be determined by the OS.backend.type value.
Returns
A file system path.

method isDrive

static isDrive: (segment: string) => boolean;

method isEqualOrParent

isEqualOrParent: (path: Path) => boolean;

method join

join: (...paths: string[]) => Path;

method normalize

normalize: () => Path;

method normalizeDrive

static normalizeDrive: (path: string) => string;

vscode-uri always normalizes drive letters to lower case: https://github.com/Microsoft/vscode-uri/blob/b1d3221579f97f28a839b6f996d76fc45e9964d8/src/index.ts#L1025 Theia path should be adjusted to this.

method normalizePathSeparator

static normalizePathSeparator: (path: string) => string;

Normalize path separator to use Path.separator
Parameter Path
candidate to normalize
Returns
Normalized string path

method relative

relative: (path: Path) => Path | undefined;

method relativity

relativity: (path: Path) => number;

method resolve

resolve: (...paths: string[]) => Path | undefined;

Parameter paths
portions of a path
Returns
a new Path if an absolute path can be computed from the segments passed in + this.raw If no absolute path can be computed, returns undefined.
Processes the path segments passed in from right to left (reverse order) concatenating until an absolute path is found.

method tildify

static tildify: (resourcePath: string, home: string) => string;

Tildify path, replacing home with ~ if user's home is present at the beginning of the path. This is a non-operation for Windows.
Parameter resourcePath
Parameter home

method toString

toString: () => string;

method untildify

static untildify: (resourcePath: string, home: string) => string;

Untildify path, replacing ~ with home if ~ present at the beginning of the path. This is a non-operation for Windows.
Parameter resourcePath
Parameter home

method windowsPath

static windowsPath: (path: string) => string;

Creates a windows path from the given path string. A windows path uses an upper case drive letter and backwards slashes.
Parameter path
The input path
Returns
Windows style path

class PreferenceChangeImpl

class PreferenceChangeImpl implements PreferenceChange {}

constructor

constructor(change: PreferenceProviderDataChange);

property change

protected readonly change: PreferenceProviderDataChange;

property domain

readonly domain: string[];

property preferenceName

readonly preferenceName: string;

property scope

readonly scope: PreferenceScope;

method affects

affects: (resourceUri?: string) => boolean;

class PreferenceConfigurations

class PreferenceConfigurations {}

property provider

protected readonly provider: ContributionProvider<PreferenceConfiguration>;

property sectionNames

protected sectionNames: string[];

method createUri

createUri: (folder: URI, configPath?: string, configName?: string) => URI;

method getConfigName

getConfigName: () => string;

method getName

getName: (configUri: URI) => string;

method getPath

getPath: (configUri: URI) => string;

method getPaths

getPaths: () => string[];

method getSectionNames

getSectionNames: () => string[];

method isAnyConfig

isAnyConfig: (name: string) => boolean;

method isConfigUri

isConfigUri: (configUri: URI | undefined) => boolean;

method isSectionName

isSectionName: (name: string) => boolean;

method isSectionUri

isSectionUri: (configUri: URI | undefined) => boolean;

class PreferenceLanguageOverrideService

class PreferenceLanguageOverrideService {}

property preferenceSchemaService

protected readonly preferenceSchemaService: PreferenceSchemaService;

method computeOverridePatternPropertiesKey

computeOverridePatternPropertiesKey: () => string | undefined;

method getOverridePreferenceNames

getOverridePreferenceNames: (preferenceName: string) => IterableIterator<string>;

method markLanguageOverride

markLanguageOverride: (overrideIdentifier: string) => string;

Parameter overrideIdentifier
the language id associated for a language override, e.g. typescript
Returns
the form used to mark language overrides in preference files, e.g. [typescript]

method overriddenPreferenceName

overriddenPreferenceName: (name: string) => OverridePreferenceName | undefined;

Returns
an OverridePreferenceName if the name contains a language override, e.g. [typescript].editor.tabSize.

method overridePreferenceName

overridePreferenceName: ({
    preferenceName,
    overrideIdentifier,
}: OverridePreferenceName) => string;

Returns
the flat JSON path to an overridden preference, e.g. [typescript].editor.tabSize.

method testOverrideValue

static testOverrideValue: (
    name: string,
    value: unknown
) => value is IndexedAccess<JSONValue>;

class PreferenceProviderBase

abstract class PreferenceProviderBase {}

constructor

constructor();

property deferredChanges

protected deferredChanges: PreferenceProviderDataChanges;

property fireDidPreferencesChanged

protected fireDidPreferencesChanged: () => Promise<boolean>;

property onDidPreferencesChanged

readonly onDidPreferencesChanged: Event<PreferenceProviderDataChanges>;

property onDidPreferencesChangedEmitter

protected readonly onDidPreferencesChangedEmitter: Emitter<PreferenceProviderDataChanges>;

property toDispose

protected readonly toDispose: DisposableCollection;

method dispose

dispose: () => void;

method emitPreferencesChangedEvent

protected emitPreferencesChangedEvent: (
    changes: PreferenceProviderDataChanges | PreferenceProviderDataChange[]
) => Promise<boolean>;

Informs the listeners that one or more preferences of this provider are changed. The listeners are able to find what was changed from the emitted event.

method mergePreferenceProviderDataChange

protected mergePreferenceProviderDataChange: (
    change: PreferenceProviderDataChange
) => void;

class PreferenceProviderImpl

abstract class PreferenceProviderImpl
    extends PreferenceProviderBase
    implements PreferenceProvider {}

The PreferenceProvider is used to store and retrieve preference values. A PreferenceProvider does not operate in a global scope but is configured for one or more PreferenceScopes. The (default implementation for the) PreferenceService aggregates all PreferenceProviders and serves as a common facade for manipulating preference values.

constructor

constructor();

property ready

readonly ready: Promise<void>;

Resolved when the preference provider is ready to provide preferences It should be resolved by subclasses.

method canHandleScope

canHandleScope: (scope: PreferenceScope) => boolean;

method get

get: <T>(preferenceName: string, resourceUri?: string) => T | undefined;

method getConfigUri

getConfigUri: (resourceUri?: string, sectionName?: string) => URI | undefined;

method getContainingConfigUri

getContainingConfigUri: (
    resourceUri?: string,
    sectionName?: string
) => URI | undefined;

method getDomain

getDomain: () => string[] | undefined;

Retrieve the domain for this provider.
Returns
the domain or undefined if this provider is suitable for all domains.

method getParsedContent

protected getParsedContent: (jsonData: unknown) => { [key: string]: unknown };

method getPreferences

abstract getPreferences: (resourceUri?: string) => JSONObject;

method resolve

resolve: <T>(
    preferenceName: string,
    resourceUri?: string
) => PreferenceResolveResult<T>;

method setPreference

abstract setPreference: (
    key: string,
    value: unknown,
    resourceUri?: string
) => Promise<boolean>;

class PreferenceProxyChange

class PreferenceProxyChange extends PreferenceChangeImpl {}

constructor

constructor(change: PreferenceProviderDataChange, overrideIdentifier?: string);

property overrideIdentifier

protected readonly overrideIdentifier?: string;

method affects

affects: (resourceUri?: string, overrideIdentifier?: string) => boolean;

class PreferenceSchemaServiceImpl

class PreferenceSchemaServiceImpl implements PreferenceSchemaService {}

property defaultOverrides

protected readonly defaultOverrides: Map<
    string,
    Map<string | object, [number, JSONValue][]>
>;

This map stores default overrides. The primary map key is the base preference name. The preference name maps to a second map keyed by the override identifier or a special object value `NO_OVERRIDE', representing default overrides for the base property. The value in this second map is an array of entries in reverse order of their insertion. This is necessary becuaus multiple clients might register overrides for the same preference key/override combination. The elements in this array consist of a unique, generated identifier and the actual override value. This allows us to always return the last registerd override even when overrides are later removed.

property defaultValueChangedEmitter

protected readonly defaultValueChangedEmitter: Emitter<DefaultValueChangedEvent>;

property jsonSchemas

protected readonly jsonSchemas: IJSONSchema[];

property nextOverrideValueId

protected nextOverrideValueId: number;

property nextSchemaTitle

protected nextSchemaTitle: number;

property onDidChangeDefaultValue

readonly onDidChangeDefaultValue: Event<DefaultValueChangedEvent>;

property onDidChangeSchema

readonly onDidChangeSchema: Event<void>;

property overrideIdentifiers

readonly overrideIdentifiers: ReadonlySet<string>;

property pendingDefaultRegistrationWarnings

protected pendingDefaultRegistrationWarnings: Set<string>;

property preferenceContributions

protected readonly preferenceContributions: ContributionProvider<PreferenceContribution>;

property properties

protected readonly properties: Map<string, PreferenceDataProperty>;

property ready

readonly ready: Promise<void>;

property schemaChangedEmitter

protected readonly schemaChangedEmitter: Emitter<void>;

property schemas

protected readonly schemas: Set<PreferenceSchema>;

property validScopes

readonly validScopes: readonly PreferenceScope[];

method addOverrideToJsonSchema

addOverrideToJsonSchema: (overrideIdentifier: string) => void;

method addSchema

addSchema: (schema: PreferenceSchema) => Disposable;

method changeFor

protected changeFor: (
    key: string,
    overrideIdentifier: string | undefined,
    overrides: Map<string | object, [number, JSONValue][]> | undefined,
    oldValue: JSONValue | undefined,
    newValue: JSONValue | undefined
) => DefaultValueChangedEvent;

method deleteFromJSONSchemas

protected deleteFromJSONSchemas: (
    key: string,
    property: PreferenceDataProperty
) => void;

method dispose

dispose: () => void;

method getDefaultValue

getDefaultValue: (
    key: string,
    overrideIdentifier: string | undefined
) => JSONValue | undefined;

method getDefaultValues

getDefaultValues: () => JSONObject;

method getJSONSchema

getJSONSchema: (scope: PreferenceScope) => IJSONSchema;

method getSchemaProperties

getSchemaProperties: () => ReadonlyMap<string, PreferenceDataProperty>;

method getSchemaProperty

getSchemaProperty: (key: string) => PreferenceDataProperty | undefined;

method init

protected init: () => void;

method inspectDefaultValue

inspectDefaultValue: (
    key: string,
    overrideIdentifier: string | undefined
) => JSONValue | undefined;

method isValidInScope

isValidInScope: (preferenceName: string, scope: PreferenceScope) => boolean;

method logDefaultRegistrationWarning

protected logDefaultRegistrationWarning: (key: string) => void;

method logDefaultRegistrationWarnings

protected logDefaultRegistrationWarnings: () => void;

method registerOverride

registerOverride: (
    key: string,
    overrideIdentifier: string | undefined,
    value: JSONValue
) => Disposable;

method registerOverrideIdentifier

registerOverrideIdentifier: (overrideIdentifier: string) => Disposable;

method removeOverride

protected removeOverride: (
    key: string,
    overrideIdentifier: string | undefined,
    overrideValueId: number
) => void;

method setJSONSchemaProperty

protected setJSONSchemaProperty: (
    schema: IJSONSchema,
    key: string,
    property: PreferenceDataProperty
) => void;

method setJSONSchemasProperty

protected setJSONSchemasProperty: (
    key: string,
    property: PreferenceDataProperty
) => void;

method updateSchemaProperty

updateSchemaProperty: (key: string, property: PreferenceDataProperty) => void;

class PreferenceServiceImpl

class PreferenceServiceImpl implements PreferenceService {}

property configurations

protected readonly configurations: PreferenceConfigurations;

property isReady

readonly isReady: boolean;

property onPreferenceChanged

readonly onPreferenceChanged: Event<PreferenceChange>;

property onPreferenceChangedEmitter

protected readonly onPreferenceChangedEmitter: Emitter<PreferenceChange>;

property onPreferencesChanged

readonly onPreferencesChanged: Event<PreferenceChanges>;

property onPreferencesChangedEmitter

protected readonly onPreferencesChangedEmitter: Emitter<PreferenceChanges>;

property preferenceOverrideService

protected readonly preferenceOverrideService: PreferenceLanguageOverrideService;

property preferenceProviders

protected readonly preferenceProviders: Map<PreferenceScope, PreferenceProvider>;

property providerProvider

protected readonly providerProvider: PreferenceProviderProvider;

property ready

readonly ready: Promise<void>;

property schemaService

protected readonly schemaService: PreferenceSchemaService;

property toDispose

protected readonly toDispose: DisposableCollection;

method dispose

dispose: () => void;

method doGet

protected doGet: <T>(
    preferenceName: string,
    defaultValue?: T,
    resourceUri?: string
) => T | undefined;

method doHas

protected doHas: (preferenceName: string, resourceUri?: string) => boolean;

method doInspectInScope

protected doInspectInScope: <T>(
    preferenceName: string,
    scope: PreferenceScope,
    resourceUri?: string
) => T | undefined;

method doResolve

protected doResolve: <T>(
    preferenceName: string,
    defaultValue?: T,
    resourceUri?: string
) => PreferenceResolveResult<T>;

method get

get: {
    <T>(preferenceName: string): T | undefined;
    <T>(preferenceName: string, defaultValue: T): T;
    <T>(preferenceName: string, defaultValue: T, resourceUri: string): T;
    <T>(preferenceName: string, defaultValue?: T, resourceUri?: string): T;
};

method getAffectedPreferenceNames

protected getAffectedPreferenceNames: (
    change: PreferenceProviderDataChange,
    accept: (affectedPreferenceName: string) => void
) => void;

method getBoolean

getBoolean: {
    (preferenceName: string): boolean | undefined;
    (preferenceName: string, defaultValue: boolean): boolean;
    (
        preferenceName: string,
        defaultValue: boolean,
        resourceUri: string
    ): boolean;
};

method getConfigUri

getConfigUri: (
    scope: PreferenceScope,
    resourceUri?: string,
    sectionName?: string
) => URI | undefined;

method getNumber

getNumber: {
    (preferenceName: string): number | undefined;
    (preferenceName: string, defaultValue: number): number;
    (preferenceName: string, defaultValue: number, resourceUri: string): number;
};

method getProvider

protected getProvider: (
    scope: PreferenceScope
) => PreferenceProvider | undefined;

method getScopedValueFromInspection

protected getScopedValueFromInspection: <T>(
    inspection: PreferenceInspection<T>,
    scope: PreferenceScope
) => T | undefined;

method getScopesToChange

protected getScopesToChange: (
    inspection: PreferenceInspection<any>,
    intendedValue: any
) => PreferenceScope[];

method getString

getString: {
    (preferenceName: string): string | undefined;
    (preferenceName: string, defaultValue: string): string;
    (preferenceName: string, defaultValue: string, resourceUri: string): string;
};

method has

has: (preferenceName: string, resourceUri?: string) => boolean;

method init

protected init: () => void;

method initializeProviders

protected initializeProviders: () => Promise<void>;

method inspect

inspect: <T extends JSONValue>(
    preferenceName: string,
    resourceUri?: string,
    forceLanguageOverride?: boolean
) => PreferenceInspection<T> | undefined;

method inspectInScope

inspectInScope: <T extends JSONValue>(
    preferenceName: string,
    scope: PreferenceScope,
    resourceUri?: string,
    forceLanguageOverride?: boolean
) => T | undefined;

method overriddenPreferenceName

overriddenPreferenceName: (
    preferenceName: string
) => OverridePreferenceName | undefined;

method overridePreferenceName

overridePreferenceName: (options: OverridePreferenceName) => string;

method reconcilePreferences

protected reconcilePreferences: (changes: PreferenceProviderDataChanges) => void;

method resolve

resolve: <T>(
    preferenceName: string,
    defaultValue?: T,
    resourceUri?: string
) => PreferenceResolveResult<T>;

method set

set: (
    preferenceName: string,
    value: any,
    scope: PreferenceScope | undefined,
    resourceUri?: string
) => Promise<void>;

method updateValue

updateValue: (
    preferenceName: string,
    value: any,
    resourceUri?: string
) => Promise<void>;

class ProgressService

class ProgressService {}

property client

protected readonly client: ProgressClient;

property messageService

protected readonly messageService: MessageService;

method newProgressId

protected newProgressId: () => string;

method shouldDelegate

protected shouldDelegate: (message: ProgressMessage) => boolean;

method showProgress

showProgress: (
    message: ProgressMessage,
    onDidCancel?: () => void
) => Promise<Progress>;

method withProgress

withProgress: <T>(
    text: string,
    locationId: string,
    task: () => Promise<T>,
    onDidCancel?: () => void
) => Promise<T>;

class QueueableEmitter

class QueueableEmitter<T> extends Emitter<T[]> {}

property currentQueue

currentQueue?: T[];

method fire

fire: () => void;

method queue

queue: (...arg: T[]) => void;

class ReferenceCollection

class ReferenceCollection<
    K,
    V extends Disposable
> extends AbstractReferenceCollection<K, V> {}

Asynchronous implementation of AbstractReferenceCollection that requires the client to provide a value factory, used to service the acquire() function. That factory may return a Promise if the value cannot be created immediately.

constructor

constructor(factory: (key: K) => MaybePromise<V>);

property factory

protected readonly factory: (key: K) => MaybePromise<V>;

property pendingValues

protected readonly pendingValues: Map<string, MaybePromise<V>>;

method acquire

acquire: (args: K) => Promise<Reference<V>>;

method getOrCreateValue

protected getOrCreateValue: (key: string, args: K) => Promise<V>;

class ReferenceMutableResource

class ReferenceMutableResource implements Resource {}

constructor

constructor(reference: Reference<MutableResource>);

property onDidChangeContents

readonly onDidChangeContents: Event<void>;

property reference

protected reference: Reference<MutableResource>;

property uri

readonly uri: URI;

method dispose

dispose: () => void;

method readContents

readContents: () => Promise<string>;

method saveContents

saveContents: (contents: string) => Promise<void>;

class RpcConnectionHandler

class RpcConnectionHandler<T extends object> implements ConnectionHandler {}

constructor

constructor(
    path: string,
    targetFactory: (proxy: RpcProxy<T>) => any,
    factoryConstructor?: new () => RpcProxyFactory<T>
);

property factoryConstructor

readonly factoryConstructor: new () => RpcProxyFactory<T>;

property path

readonly path: string;

property targetFactory

readonly targetFactory: (proxy: RpcProxy<T>) => any;

method onConnection

onConnection: (connection: Channel) => void;

class RpcProtocol

class RpcProtocol {}

Establish a RPC protocol on top of a given channel. By default the rpc protocol is bi-directional, meaning it is possible to send requests and notifications to the remote side (i.e. acts as client) as well as receiving requests and notifications from the remote side (i.e. acts as a server). Clients can get a promise for a remote request result that will be either resolved or rejected depending on the success of the request. Keeps track of outstanding requests and matches replies to the appropriate request Currently, there is no timeout handling for long running requests implemented. The bi-directional mode can be reconfigured using the RpcProtocolOptions to construct an RPC protocol instance that acts only as client or server instead.

constructor

constructor(
    channel: Channel,
    requestHandler: RequestHandler,
    options?: RpcProtocolOptions
);

property CANCELLATION_TOKEN_KEY

static readonly CANCELLATION_TOKEN_KEY: string;

property cancellationTokenSources

protected readonly cancellationTokenSources: Map<
    number,
    CancellationTokenSource
>;

property channel

readonly channel: Channel;

property decoder

protected readonly decoder: RpcMessageDecoder;

property encoder

protected readonly encoder: RpcMessageEncoder;

property mode

protected readonly mode: 'default' | 'clientOnly' | 'serverOnly';

property nextMessageId

protected nextMessageId: number;

property onNotification

readonly onNotification: Event<{ method: string; args: any[] }>;

property onNotificationEmitter

protected readonly onNotificationEmitter: Emitter<{
    method: string;
    args: any[];
}>;

property pendingRequestCancellationEventListeners

protected readonly pendingRequestCancellationEventListeners: Map<
    number,
    DisposableWrapper
>;

property pendingRequests

protected readonly pendingRequests: Map<number, Deferred<any>>;

property requestHandler

readonly requestHandler: RequestHandler;

property toDispose

protected toDispose: DisposableCollection;

method disposeCancellationEventListener

protected disposeCancellationEventListener: (id: number) => void;

method handleCancel

protected handleCancel: (id: number) => void;

method handleMessage

handleMessage: (message: RpcMessage) => void;

method handleNotify

protected handleNotify: (
    method: string,
    args: any[],
    id?: number
) => Promise<void>;

method handleReply

protected handleReply: (id: number, value: any) => void;

method handleReplyErr

protected handleReplyErr: (id: number, error: any) => void;

method handleRequest

protected handleRequest: (
    id: number,
    method: string,
    args: any[]
) => Promise<void>;

method sendCancel

sendCancel: (requestId: number) => void;

method sendNotification

sendNotification: (method: string, args: any[]) => void;

method sendRequest

sendRequest: <T>(method: string, args: any[]) => Promise<T>;

class RpcProxyFactory

class RpcProxyFactory<T extends object> implements ProxyHandler<T> {}

Factory for RPC proxy objects.
A RPC proxy exposes the programmatic interface of an object through Theia's RPC protocol. This allows remote programs to call methods of this objects by sending RPC requests. This takes place over a bi-directional stream, where both ends can expose an object and both can call methods on each other' exposed object.
For example, assuming we have an object of the following type on one end:
class Foo { bar(baz: number): number { return baz + 1 } }
which we want to expose through a RPC interface. We would do:
let target = new Foo() let factory = new RpcProxyFactory('/foo', target) factory.onConnection(connection)
The party at the other end of the connection, in order to remotely call methods on this object would do:
let factory = new RpcProxyFactory('/foo') factory.onConnection(connection) let proxy = factory.createProxy(); let result = proxy.bar(42) // result is equal to 43
One the wire, it would look like this:
--> { "type":"1", "id": 1, "method": "bar", "args": [42]} <-- { "type":"3", "id": 1, "res": 43}
Note that in the code of the caller, we didn't pass a target object to RpcProxyFactory, because we don't want/need to expose an object. If we had passed a target object, the other side could've called methods on it.
Parameter
- The type of the object to expose to RPC.

constructor

constructor(target?: any, rpcProtocolFactory?: RpcProtocolFactory);

Build a new RpcProxyFactory.
Parameter target
The object to expose to RPC methods calls. If this is omitted, the proxy won't be able to handle requests, only send them.

property onDidCloseConnectionEmitter

protected readonly onDidCloseConnectionEmitter: Emitter<void>;

property onDidOpenConnectionEmitter

protected readonly onDidOpenConnectionEmitter: Emitter<void>;

property rpcDeferred

protected rpcDeferred: Deferred<RpcProtocol>;

property rpcProtocolFactory

protected rpcProtocolFactory: RpcProtocolFactory;

property target

target?: any;

method createProxy

createProxy: () => RpcProxy<T>;

Create a Proxy exposing the interface of an object of type T. This Proxy can be used to do RPC method calls on the remote target object as if it was local.
If T implements RpcServer then a client is used as a target object for a remote target object.

method deserializeError

protected deserializeError: (capturedError: Error, e: any) => any;

method get

get: (target: T, p: PropertyKey, receiver: any) => any;

Get a callable object that executes a RPC method call.
Getting a property on the Proxy object returns a callable that, when called, executes a RPC call. The name of the property defines the method to be called. The callable takes a variable number of arguments, which are passed in the RPC method call.
For example, if you have a Proxy object:
let fooProxyFactory = RpcProxyFactory('/foo') let fooProxy = fooProxyFactory.createProxy()
accessing fooProxy.bar will return a callable that, when called, executes a RPC method call to method bar. Therefore, doing fooProxy.bar() will call the bar method on the remote Foo object.
Parameter target
unused.
Parameter p
The property accessed on the Proxy object.
Parameter receiver
unused.
Returns
A callable that executes the RPC call.

method isNotification

protected isNotification: (p: PropertyKey) => boolean;

Return whether the given property represents a notification.
A property leads to a notification rather than a method call if its name begins with notify or on.
Parameter p
The property being called on the proxy. Whether p represents a notification.

method listen

listen: (channel: Channel) => void;

Connect a Channel to the factory by creating an RpcProtocol on top of it.
This protocol will be used to send/receive RPC requests and responses.

method onNotification

protected onNotification: (method: string, ...args: any[]) => void;

Process an incoming RPC notification.
Same as [[onRequest]], but called on incoming notifications rather than methods calls.

method onRequest

protected onRequest: (method: string, ...args: any[]) => Promise<any>;

Process an incoming RPC method call.
onRequest is called when the RPC connection received a method call request. It calls the corresponding method on [[target]].
The return value is a Promise object that is resolved with the return value of the method call, if it is successful. The promise is rejected if the called method does not exist or if it throws.
Returns
A promise of the method call completion.

method serializeError

protected serializeError: (e: any) => any;

method waitForConnection

protected waitForConnection: () => void;

class SelectionService

class SelectionService implements SelectionProvider<Object | undefined> {}

Singleton service that is used to share the current selection globally in a Theia application. On each change of selection, subscribers are notified and receive the updated selection object.

property onSelectionChanged

readonly onSelectionChanged: Event<any>;

property onSelectionChangedEmitter

protected readonly onSelectionChangedEmitter: Emitter<any>;

property selection

selection: Object;

class SimpleStopwatch

class SimpleStopwatch extends Stopwatch {}

A simple Stopwatch that uses a caller-supplied time function and logs via console. Usable without Inversify DI: this class does not assign nor use the inherited logger field.

constructor

constructor(owner: string, now: () => number);

method log

protected log: (
    measurement: Measurement,
    activity: string,
    options: {
        now: () => number;
        owner?: string;
        context?: string;
        arguments?: any[];
    } & MeasurementOptions
) => void;

method start

start: (name: string, options?: MeasurementOptions) => Measurement;

class SocketWriteBuffer

class SocketWriteBuffer {}

property bufferWritePosition

protected bufferWritePosition: number;

property disconnectedBuffer

protected disconnectedBuffer: Uint8Array;

property maxBufferSize

readonly maxBufferSize: number;

method buffer

buffer: (data: Uint8Array) => void;

method drain

drain: () => void;

method ensureWriteBuffer

protected ensureWriteBuffer: (byteLength: number) => void;

method flush

flush: (socket: WebSocket) => void;

class Stopwatch

abstract class Stopwatch {}

A factory of Measurements for performance logging.

constructor

constructor(defaultLogOptions: LogOptions);

property defaultLogOptions

protected readonly defaultLogOptions: LogOptions;

property logger

protected readonly logger: ILogger;

property onDidAddMeasurementResult

readonly onDidAddMeasurementResult: Event<MeasurementResult>;

property onDidAddMeasurementResultEmitter

protected onDidAddMeasurementResultEmitter: Emitter<MeasurementResult>;

property storedMeasurements

readonly storedMeasurements: readonly MeasurementResult[];

method atLevel

protected atLevel: (
    logOptions: LogOptions,
    levelOverride?: LogLevel,
    optionalArgs?: any[]
) => LogOptions;

method createMeasurement

protected createMeasurement: (
    name: string,
    measure: () => { startTime: number; duration: number },
    options?: MeasurementOptions
) => Measurement;

method log

protected log: (
    measurement: Measurement,
    activity: string,
    options: LogOptions
) => void;

method logLevel

protected logLevel: (elapsed: number, options?: Partial<LogOptions>) => LogLevel;

method mergeLogOptions

protected mergeLogOptions: (logOptions?: Partial<LogOptions>) => LogOptions;

method start

abstract start: (name: string, options?: MeasurementOptions) => Measurement;

Create a Measurement that will compute its elapsed time when logged.
Parameter name
the
Parameter options
optional configuration of the new measurement
Returns
a self-timing measurement

method startAsync

startAsync: <T>(
    name: string,
    description: string,
    computation: () => MaybePromise<T>,
    options?: MeasurementOptions
) => Promise<T>;

Wrap an asynchronous function in a Measurement that logs itself on completion. If obtaining and awaiting the computation runs too long according to the threshold set in the options, then the log message is a warning, otherwise a debug log.
Parameter name
the to wrap around the function
Parameter description
a description of what the function does, to be included in the log
Parameter computation
a supplier of the asynchronous function to wrap
Parameter options
optional addition configuration as for measure
Returns
the wrapped computation
See Also
- MeasurementOptions.thresholdMillis

class SubmenuImpl

class SubmenuImpl extends AbstractCompoundMenuImpl implements Submenu {}

constructor

constructor(
    id: string,
    label: string,
    contextKeyOverlays: Record<string, string>,
    orderString?: string,
    icon?: string,
    when?: string
);

property contextKeyOverlays

readonly contextKeyOverlays: Record<string, string>;

property icon

readonly icon?: string;

property label

readonly label: string;

class SubMenuLink

class SubMenuLink implements CompoundMenuNode {}

constructor

constructor(delegate: Submenu, _sortString?: string, _when?: string);

property children

readonly children: MenuNode[];

property contextKeyOverlays

readonly contextKeyOverlays: Record<string, string>;

property icon

readonly icon: string;

property id

readonly id: string;

property label

readonly label: string;

property onDidChange

readonly onDidChange: Event<void>;

property sortString

readonly sortString: string;

property when

readonly when: string;

method isEmpty

isEmpty: <T>(
    effectiveMenuPath: MenuPath,
    contextMatcher: ContextExpressionMatcher<T>,
    context: T | undefined,
    ...args: unknown[]
) => boolean;

method isVisible

isVisible: <T>(
    effectiveMenuPath: MenuPath,
    contextMatcher: ContextExpressionMatcher<T>,
    context: T | undefined,
    ...args: unknown[]
) => boolean;

class SyncReferenceCollection

class SyncReferenceCollection<
    K,
    V extends Disposable
> extends AbstractReferenceCollection<K, V> {}

Synchronous implementation of AbstractReferenceCollection that requires the client to provide a value factory, used to service the acquire() function.

constructor

constructor(factory: (key: K) => V);

property factory

protected readonly factory: (key: K) => V;

method acquire

acquire: (args: K) => Reference<V>;

method getOrCreateValue

protected getOrCreateValue: (key: string, args: K) => V;

class TelemetryTrustedValue

class TelemetryTrustedValue<T> {}

constructor

constructor(value: {});

property value

readonly value: {};

class TreeConfiguration

class TreeConfiguration {}

property [PREFERENCE_NAME_TREE_INDENT]

[PREFERENCE_NAME_TREE_INDENT]: number;

class UntitledResource

class UntitledResource implements Resource {}

constructor

constructor(
    resources: Map<string, UntitledResource>,
    uri: URI,
    content?: string,
    encoding?: string
);

property autosaveable

readonly autosaveable: boolean;

property encoding

readonly encoding: string;

property initiallyDirty

readonly initiallyDirty: boolean;

property onDidChangeContents

readonly onDidChangeContents: Event<void>;

property onDidChangeContentsEmitter

protected readonly onDidChangeContentsEmitter: Emitter<void>;

property uri

uri: URI;

property version

readonly version: ResourceVersion;

method dispose

dispose: () => void;

method fireDidChangeContents

protected fireDidChangeContents: () => void;

method readContents

readContents: (
    options?: { encoding?: string | undefined } | undefined
) => Promise<string>;

method saveContents

saveContents: (
    content: string,
    options?: { encoding?: string; overwriteEncoding?: boolean }
) => Promise<void>;

class UntitledResourceResolver

class UntitledResourceResolver implements ResourceResolver {}

property resources

protected readonly resources: Map<string, UntitledResource>;

method createUntitledResource

createUntitledResource: (
    content?: string,
    extension?: string,
    uri?: URI,
    encoding?: string
) => Promise<UntitledResource>;

method createUntitledURI

createUntitledURI: (extension?: string, parent?: URI) => URI;

method has

has: (uri: URI) => boolean;

method resolve

resolve: (uri: URI) => Promise<UntitledResource>;

class URI

class URI {}

constructor

constructor(uri?: any);

property allLocations

readonly allLocations: URI[];

Return all uri from the current to the top most.

property authority

readonly authority: string;

property displayName

readonly displayName: string;

TODO move implementation to DefaultUriLabelProviderContribution.getName
Deprecated
use LabelProvider.getName instead

property fragment

readonly fragment: string;

property parent

readonly parent: URI;

property path

readonly path: Path;

property query

readonly query: string;

property scheme

readonly scheme: string;

method fromComponents

static fromComponents: {
    (components: UriComponents): URI;
    (components: undefined): undefined;
};

method fromFilePath

static fromFilePath: (path: string) => URI;

method getDistinctParents

static getDistinctParents: (uris: URI[]) => URI[];

method isEqual

isEqual: (uri: URI, caseSensitive?: boolean) => boolean;

method isEqualOrParent

isEqualOrParent: (uri: URI, caseSensitive?: boolean) => boolean;

method normalizePath

normalizePath: () => URI;

return a new URI replacing the current with its normalized path, resolving '..' and '.' segments

method relative

relative: (uri: URI) => Path | undefined;

method resolve

resolve: (path: string | Path) => URI;

method resolveToAbsolute

resolveToAbsolute: (...pathSegments: Array<string | Path>) => URI | undefined;

Returns
a new, absolute URI if one can be computed from the path segments passed in.

method toComponents

toComponents: () => UriComponents;

method toString

toString: (skipEncoding?: boolean) => string;

method withAuthority

withAuthority: (authority: string) => URI;

return a new URI replacing the current with the given authority

method withFragment

withFragment: (fragment: string) => URI;

return a new URI replacing the current with the given fragment

method withoutAuthority

withoutAuthority: () => URI;

return this URI without a authority

method withoutFragment

withoutFragment: () => URI;

return this URI without a fragment

method withoutPath

withoutPath: () => URI;

return this URI without a path

method withoutQuery

withoutQuery: () => URI;

return this URI without a query

method withPath

withPath: (path: string | Path) => URI;

return a new URI replacing the current with the given path

method withQuery

withQuery: (query: string) => URI;

return a new URI replacing the current with the given query

method withScheme

withScheme: (scheme: string) => URI;

return a new URI replacing the current with the given scheme

Interfaces

interface AcceleratorSource

interface AcceleratorSource {}

method getAccelerator

getAccelerator: (context: HTMLElement | undefined) => string[];

interface Action

interface Action {}

method isEnabled

isEnabled: (effectiveMenuPath: MenuPath, ...args: unknown[]) => boolean;

method isToggled

isToggled: (effectiveMenuPath: MenuPath, ...args: unknown[]) => boolean;

method run

run: (effectiveMenuPath: MenuPath, ...args: unknown[]) => Promise<void>;

interface ApplicationError

interface ApplicationError<C extends number, D> extends Error {}

property code

readonly code: C;

property data

readonly data: D;

method toJson

toJson: () => ApplicationError.Literal<D>;

interface BackendStopwatch

interface BackendStopwatch {}

A service that exposes the back-end's Stopwatch to clients via the remote API. If you do not need this service then bind or re-bind the NullBackendStopwatch implementation to this service interface.

method start

start: (
    name: string,
    options?: MeasurementOptions
) => Promise<RemoteMeasurement>;

Create a Measurement that will compute the time that elapsed on the back-end when logged.
Parameter name
the
Parameter options
optional configuration of the new measurement
Returns
a token identifying an unique self-timing measurement relative to the back-end's timeline

method stop

stop: (
    measurement: RemoteMeasurement,
    message: string,
    messageArgs: any[]
) => Promise<void>;

Stop a measurement previously and log in the back-end a measurement of its duration relative to the back-end's timeline.
Parameter measurement
token identifying a measurement previously
Parameter message
a message to log
Parameter messageArgs
optional arguments to the message

interface CancellationToken

interface CancellationToken {}

property isCancellationRequested

readonly isCancellationRequested: boolean;

property onCancellationRequested

readonly onCancellationRequested: Event<void>;

interface Channel

interface Channel {}

A channel is a bidirectional communications channel with lifecycle and error signalling. Note that creation of channels is specific to particular implementations and thus not part of the protocol.

property onClose

onClose: Event<ChannelCloseEvent>;

The remote side has closed the channel

property onError

onError: Event<unknown>;

An error has occurred while writing to or reading from the channel

property onMessage

onMessage: Event<MessageProvider>;

A message has arrived and can be read by listeners using a MessageProvider.

method close

close: () => void;

Close this channel. No onClose event should be sent

method getWriteBuffer

getWriteBuffer: () => WriteBuffer;

Obtain a WriteBuffer to write a message to the channel.

interface ChannelCloseEvent

interface ChannelCloseEvent {}

The event that is emitted when a channel is closed from the remote side.

property code

code?: number;

property reason

reason: string;

interface Command

interface Command {}

A command is a unique identifier of a function which can be executed by a user via a keyboard shortcut, a menu action or directly.

property category

category?: string;

A category of this command.

property iconClass

iconClass?: string;

An icon class of this command.

property id

id: string;

A unique identifier of this command.

property label

label?: string;

A label of this command.

property originalCategory

originalCategory?: string;

property originalLabel

originalLabel?: string;

property shortTitle

shortTitle?: string;

A short title used for display in menus.

interface CommandContribution

interface CommandContribution {}

The command contribution should be implemented to register custom commands and handler.

method registerCommands

registerCommands: (commands: CommandRegistry) => void;

interface CommandEvent

interface CommandEvent {}

property args

args: any[];

property commandId

commandId: string;

interface CommandHandler

interface CommandHandler {}

A command handler is an implementation of a command.
A command can have multiple handlers but they should be active in different contexts, otherwise first active will be executed.

property onDidChangeEnabled

onDidChangeEnabled?: Event<void>;

method execute

execute: (...args: any[]) => any;

Execute this handler.
Don't call it directly, use CommandService.executeCommand instead.

method isEnabled

isEnabled: (...args: any[]) => boolean;

Test whether this handler is enabled (active).

method isToggled

isToggled: (...args: any[]) => boolean;

Test whether menu items for this handler should be toggled.

method isVisible

isVisible: (...args: any[]) => boolean;

Test whether menu items for this handler should be visible.

interface CommandService

interface CommandService {}

The command service should be used to execute commands.

property onDidExecuteCommand

readonly onDidExecuteCommand: Event<CommandEvent>;

An event is emitted when a command was executed.

property onWillExecuteCommand

readonly onWillExecuteCommand: Event<WillExecuteCommandEvent>;

An event is emitted when a command is about to be executed.
It can be used to install or activate a command handler.

method executeCommand

executeCommand: <T>(command: string, ...args: any[]) => Promise<T | undefined>;

Execute the active handler for the given command and arguments.
Reject if a command cannot be executed.

interface CompoundMenuNode

interface CompoundMenuNode extends MenuNode {}

property children

children: MenuNode[];

property contextKeyOverlays

contextKeyOverlays?: Record<string, string>;

method isEmpty

isEmpty: <T>(
    effectiveMenuPath: MenuPath,
    contextMatcher: ContextExpressionMatcher<T>,
    context: T | undefined,
    ...args: unknown[]
) => boolean;

Whether the group or submenu contains any visible children
Parameter effectiveMenuPath
The menu path where visibility is checked
Parameter contextMatcher
The context matcher to use
Parameter context
the context to use
Parameter args
the command arguments, if applicable

interface ConnectionHandler

interface ConnectionHandler {}

property path

readonly path: string;

method onConnection

onConnection: (connection: Channel) => void;

interface ContextExpressionMatcher

interface ContextExpressionMatcher<T> {}

method match

match: (whenExpression: string, context: T | undefined) => boolean;

interface ContributionFilterRegistry

interface ContributionFilterRegistry {}

method addFilters

addFilters: {
    (types: '*', filters: Filter<Object>[]): void;
    (
        types: interfaces.ServiceIdentifier<any>[],
        filters: Filter<Object>[]
    ): void;
};

Add filters to be applied for every type of contribution.
Given a list of contribution types, register filters to apply.
Parameter types
types for which to register the filters.

method applyFilters

applyFilters: <T extends Object>(
    toFilter: T[],
    type: interfaces.ServiceIdentifier<any>
) => T[];

Applies the filters for the given contribution type. Generic filters will be applied on any given type.
Parameter toFilter
the elements to filter
Parameter type
the contribution type for which potentially filters were registered
Returns
the filtered elements

interface ContributionProvider

interface ContributionProvider<T extends object> {}

method getContributions

getContributions: (recursive?: boolean) => T[];

Parameter recursive
true if the contributions should be collected from the parent containers as well. Otherwise, false. It is false by default.

interface CoreConfiguration

interface CoreConfiguration {}

property 'application.confirmExit'

'application.confirmExit': 'never' | 'ifRequired' | 'always';

property 'breadcrumbs.enabled'

'breadcrumbs.enabled': boolean;

property 'files.encoding'

'files.encoding': string;

property 'keyboard.dispatch'

'keyboard.dispatch': 'code' | 'keyCode';

property 'window.menuBarVisibility'

'window.menuBarVisibility': 'classic' | 'visible' | 'hidden' | 'compact';

property 'window.tabbar.enhancedPreview'

'window.tabbar.enhancedPreview': 'classic' | 'enhanced' | 'visual';

property 'window.tabCloseIconPlacement'

'window.tabCloseIconPlacement': 'end' | 'start';

property 'window.title'

'window.title': string;

property 'window.titleSeparator'

'window.titleSeparator': string;

property 'workbench.colorTheme'

'workbench.colorTheme': string;

property 'workbench.commandPalette.history'

'workbench.commandPalette.history': number;

property 'workbench.editor.closeOnFileDelete'

'workbench.editor.closeOnFileDelete': boolean;

property 'workbench.editor.decorations.badges'

'workbench.editor.decorations.badges': boolean;

property 'workbench.editor.highlightModifiedTabs'

'workbench.editor.highlightModifiedTabs': boolean;

property 'workbench.editor.mouseBackForwardToNavigate'

'workbench.editor.mouseBackForwardToNavigate': boolean;

property 'workbench.editor.revealIfOpen'

'workbench.editor.revealIfOpen': boolean;

property 'workbench.hover.delay'

'workbench.hover.delay': number;

property 'workbench.iconTheme'

'workbench.iconTheme': string;

property 'workbench.list.openMode'

'workbench.list.openMode': 'singleClick' | 'doubleClick';

property 'workbench.sash.hoverDelay'

'workbench.sash.hoverDelay': number;

property 'workbench.sash.size'

'workbench.sash.size': number;

property 'workbench.silentNotifications'

'workbench.silentNotifications': boolean;

property 'workbench.statusBar.visible'

'workbench.statusBar.visible': boolean;

property 'workbench.tab.maximize'

'workbench.tab.maximize': boolean;

property 'workbench.tab.shrinkToFit.defaultSize'

'workbench.tab.shrinkToFit.defaultSize': number;

property 'workbench.tab.shrinkToFit.enabled'

'workbench.tab.shrinkToFit.enabled': boolean;

property 'workbench.tab.shrinkToFit.minimumSize'

'workbench.tab.shrinkToFit.minimumSize': number;

property 'workbench.tree.renderIndentGuides'

'workbench.tree.renderIndentGuides': 'onHover' | 'none' | 'always';

interface DefaultValueChangedEvent

interface DefaultValueChangedEvent {}

property key

key: string;

The preference key

property newValue

newValue: JSONValue | undefined;

property oldValue

oldValue: JSONValue | undefined;

property otherAffectedOverrides

otherAffectedOverrides: string[];

When the default for the base property changes, indicates which override identifiers will be affected

property overrideIdentifier

overrideIdentifier?: string;

The override identifier that the default changed for

interface Disposable

interface Disposable {}

method dispose

dispose: () => void;

Dispose this object.

interface EmitterOptions

interface EmitterOptions {}

property errorHandling

errorHandling?: ErrorHandlingStrategy;

How errors thrown by event listeners are handled during Emitter.fire.

property onFirstListenerAdd

onFirstListenerAdd?: Function;

property onLastListenerRemove

onLastListenerRemove?: Function;

interface Event

interface Event<T> {}

Represents a typed event.

call signature

(
    listener: (e: T) => any,
    thisArgs?: any,
    disposables?: DisposableGroup
): Disposable;

Parameter listener
The listener function will be call when the event happens.
Parameter thisArgs
The 'this' which will be used when calling the event listener.
Parameter disposables
An array to which a {{IDisposable}} will be added. a disposable to remove the listener again.

interface FilterContribution

interface FilterContribution {}

method registerContributionFilters

registerContributionFilters: (registry: ContributionFilterRegistry) => void;

Use the registry to register your contribution filters. * Note that filtering contributions based on their class (constructor) name is discouraged. Class names are minified in production builds and therefore not reliable. Use instance of checks or direct constructor comparison instead:
registry.addFilters('*', [ contrib => !(contrib instanceof SampleFilteredCommandContribution) ]);

interface ILogger

interface ILogger {}

method child

child: (name: string) => ILogger;

Create a child logger from this logger.
Parameter name
The name of the child logger.

method debug

debug: {
    (loggable: Loggable): Promise<void>;
    (message: any, ...params: any[]): Promise<void>;
};

Log a loggable with the debug level if it is enabled.
Log a message with the debug level if it is enabled.
Parameter message
The message format string.
Parameter params
The format string variables.

method error

error: {
    (loggable: Loggable): Promise<void>;
    (message: any, ...params: any[]): Promise<void>;
};

Log a loggable with the error level if it is enabled.
Log a message with the error level.
Parameter message
The message format string.
Parameter params
The format string variables.

method fatal

fatal: {
    (loggable: Loggable): Promise<void>;
    (message: any, ...params: any[]): Promise<void>;
};

Log a loggable with the fatal level if it is enabled.
Log a message with the fatal level if it is enabled.
Parameter message
The message format string.
Parameter params
The format string variables.

method getLogLevel

getLogLevel: () => Promise<number>;

Get the log level.
Returns
a Promise to the log level.

method ifDebug

ifDebug: () => Promise<void>;

Resolve if the debug level is enabled.

method ifEnabled

ifEnabled: (logLevel: number) => Promise<void>;

Resolve if the given log is enabled.

method ifError

ifError: () => Promise<void>;

Resolve if the error level is enabled.

method ifFatal

ifFatal: () => Promise<void>;

Resolve if the fatal level is enabled.

method ifInfo

ifInfo: () => Promise<void>;

Resolve if the info level is enabled.

method ifTrace

ifTrace: () => Promise<void>;

Resolve if the trace level is enabled.

method ifWarn

ifWarn: () => Promise<void>;

Resolve if the warn level is enabled.

method info

info: {
    (loggable: Loggable): Promise<void>;
    (message: any, ...params: any[]): Promise<void>;
};

Log a loggable with the info level if it is enabled.
Log a message with the info level if it is enabled.
Parameter message
The message format string.
Parameter params
The format string variables.

method isDebug

isDebug: () => Promise<boolean>;

Test whether the debug level is enabled.

method isEnabled

isEnabled: (logLevel: number) => Promise<boolean>;

Test whether the given log level is enabled.

method isError

isError: () => Promise<boolean>;

Test whether the error level is enabled.

method isFatal

isFatal: () => Promise<boolean>;

Test whether the fatal level is enabled.

method isInfo

isInfo: () => Promise<boolean>;

Test whether the info level is enabled.

method isTrace

isTrace: () => Promise<boolean>;

Test whether the trace level is enabled.

method isWarn

isWarn: () => Promise<boolean>;

Test whether the warn level is enabled.

method log

log: {
    (logLevel: number, loggable: Loggable): Promise<void>;
    (logLevel: number, message: any, ...params: any[]): void;
};

Log a loggable with the given level if it is enabled.
Log a message with the given level if it is enabled.
Parameter logLevel
The loglevel to use.
Parameter message
The message format string.
Parameter params
The format string variables.

method setLogLevel

setLogLevel: (logLevel: number) => Promise<void>;

Set the log level.
Parameter loglevel
The loglevel to set. see Logger.LogLevel for possible options.

method trace

trace: {
    (loggable: Loggable): Promise<void>;
    (message: any, ...params: any[]): Promise<void>;
};

Log a loggable with the trace level if it is enabled.
Log a message with the trace level if it is enabled.
Parameter message
The message format string.
Parameter params
The format string variables.

method warn

warn: {
    (loggable: Loggable): Promise<void>;
    (message: any, ...params: any[]): Promise<void>;
};

Log a loggable with the warn level if it is enabled.
Log a message with the warn level if it is enabled.
Parameter message
The message format string.
Parameter params
The format string variables.

interface IndexedAccess

interface IndexedAccess<T> {}

index signature

[name: string]: T;

interface InputBox

interface InputBox extends QuickInput {}

property buttons

buttons: ReadonlyArray<QuickInputButton>;

property onDidAccept

readonly onDidAccept: Event<void>;

property onDidChangeValue

readonly onDidChangeValue: Event<string>;

property onDidTriggerButton

readonly onDidTriggerButton: Event<QuickInputButton>;

property password

password: boolean;

property placeholder

placeholder: string | undefined;

property prompt

prompt: string | undefined;

property severity

severity?: Severity;

property validationMessage

validationMessage: string | undefined;

property value

value: string | undefined;

property valueSelection

valueSelection: Readonly<[number, number]> | undefined;

interface InputOptions

interface InputOptions {}

property ignoreFocusLost

ignoreFocusLost?: boolean;

property password

password?: boolean;

property placeHolder

placeHolder?: string;

property prompt

prompt?: string;

property title

title?: string;

property value

value?: string;

property valueSelection

valueSelection?: [number, number];

method validateInput

validateInput: (
    input: string
) =>
    | Promise<
          string | { content: string; severity: Severity } | null | undefined
      >
    | undefined;

interface LoggerSanitizer

interface LoggerSanitizer {}

Service for sanitizing log messages to remove sensitive information.

Adopters can rebind this service to customize sanitization behavior, for example to mask additional patterns like API keys or tokens.

Example 1

// Custom sanitizer that extends the default behavior
@injectable()
class CustomLoggerSanitizer extends DefaultLoggerSanitizer {
    override sanitize(message: string): string {
        let sanitized = super.sanitize(message);
        // Add custom sanitization, e.g., mask API keys
        sanitized = sanitized.replace(/api[_-]?key[=:]\s*['"]?[\w-]+['"]?/gi, 'api_key=****');
        return sanitized;
    }
}

// In your module:
rebind(LoggerSanitizer).to(CustomLoggerSanitizer).inSingletonScope();

method sanitize

sanitize: (message: string) => string;

Sanitizes a log message by masking sensitive information.
Parameter message
The log message to sanitize
Returns
The sanitized message with sensitive data masked

interface Match

interface Match {}

property end

end: number;

property start

start: number;

interface Measurement

interface Measurement {}

A Measurement counts the time elapsed between its creation when the Stopwatch is and when it is .

property elapsed

elapsed?: number;

The elapsed time measured, if it has been and measured, or NaN if the platform disabled performance measurement.

property name

name: string;

The measurement name. This may show up in the performance measurement framework appropriate to the application context.

method debug

debug: (detail: string, ...optionalArgs: any[]) => void;

Compute the elapsed time and log a debug message annotated with that timing information.
Parameter detail
a message detailing what activity was measured
Parameter optionalArgs
optional message arguments as per the usual console API

method error

error: (detail: string, ...optionalArgs: any[]) => void;

Compute the elapsed time and log an error message annotated with that timing information.
Parameter detail
a message detailing what activity was measured
Parameter optionalArgs
optional message arguments as per the usual console API

method info

info: (detail: string, ...optionalArgs: any[]) => void;

Compute the elapsed time and log an info message annotated with that timing information.
Parameter detail
a message detailing what activity was measured
Parameter optionalArgs
optional message arguments as per the usual console API

method log

log: (detail: string, ...optionalArgs: any[]) => void;

Compute the elapsed time and log a message annotated with that timing information. The message is logged at the level determined by the MeasurementOptions.
Parameter detail
a message detailing what activity was measured
Parameter optionalArgs
optional message arguments as per the usual console API

method stop

stop: () => number;

Compute the elapsed time, in milliseconds, if not already done (only has effect on the first invocation). A NaN result indicates that the watch was stopped but failed to make a measurement.

method warn

warn: (detail: string, ...optionalArgs: any[]) => void;

Compute the elapsed time and log a warning message annotated with that timing information.
Parameter detail
a message detailing what activity was measured
Parameter optionalArgs
optional message arguments as per the usual console API

interface MeasurementOptions

interface MeasurementOptions {}

Optional configuration of a Measurement specified at the time of its creation.

property context

context?: string;

A specific context of the application in which an activity was measured. Results in logs being emitted with a "[]" qualified at the head.

property defaultLogLevel

defaultLogLevel?: LogLevel;

An optional logging level at which to emit the log message. The default value is LogLevel.INFO.

property storeResults

storeResults?: boolean;

Flag to indicate whether the stopwatch should store measurement results for later retrieval. For example the cache can be used to retrieve measurements which were taken during startup before a listener had a chance to register.

property thresholdMillis

thresholdMillis?: number;

Some measurements are measured against a threshold (in millis) that they should not exceed. If omitted, the implied threshold is unlimited time (no threshold).
See Also
- Stopwatch.startAsync
- thresholdLogLevel

interface MeasurementResult

interface MeasurementResult {}

Captures the result of a Measurement in a serializable format.

property elapsed

elapsed: number;

The elapsed time measured, if it has been and measured, or NaN if the platform disabled performance measurement.

property name

name: string;

The measurement name. This may show up in the performance measurement framework appropriate to the application context.

property owner

owner?: string;

An optional label for the application the start of which (in real time) is the basis of all measurements.

property startTime

startTime: number;

The time when the measurement recording has been started

interface MenuAction

interface MenuAction {}

property commandId

readonly commandId: string;

The command to execute.

property icon

readonly icon?: string;

Icon classes for the menu node. If present, these will produce an icon to the left of the label in browser-style menus.

property label

readonly label?: string;

property order

readonly order?: string;

Menu entries are sorted in ascending order based on their order strings. If omitted the determined label will be used instead.

property when

readonly when?: string;

interface MenuChangedEvent

interface MenuChangedEvent {}

property kind

kind: ChangeKind;

property path

path: MenuPath;

interface MenuContribution

interface MenuContribution {}

Representation of a menu contribution.

Note that there are also convenience classes which combine multiple contributions into one. For example to register a view together with a menu and keybinding you could use AbstractViewContribution instead.

### Example usage

import { MenuContribution, MenuModelRegistry, MAIN_MENU_BAR } from '@theia/core';

@injectable()
export class NewMenuContribution implements MenuContribution {
   registerMenus(menus: MenuModelRegistry): void {
        const menuPath = [...MAIN_MENU_BAR, '99_mymenu'];
        menus.registerSubmenu(menuPath, 'My Menu');

        menus.registerMenuAction(menuPath, {
           commandId: MyCommand.id,
           label: 'My Action'
        });
    }
}

method registerMenus

registerMenus: (menus: MenuModelRegistry) => void;

Registers menus.
Parameter menus
the menu model registry.

interface MenuNodeFactory

interface MenuNodeFactory {}

method createCommandMenu

createCommandMenu: (item: MenuAction) => CommandMenu;

method createGroup

createGroup: (
    id: string,
    orderString?: string,
    when?: string
) => Group & MutableCompoundMenuNode;

method createSubmenu

createSubmenu: (
    id: string,
    label: string,
    contextKeyOverlays: Record<string, string> | undefined,
    orderString?: string,
    icon?: string,
    when?: string
) => Submenu & MutableCompoundMenuNode;

method createSubmenuLink

createSubmenuLink: (
    delegate: Submenu,
    sortString?: string,
    when?: string
) => MenuNode;

interface Message

interface Message {}

property actions

readonly actions?: string[];

Actions offered to the user in the context of the message.

property options

readonly options?: MessageOptions;

Additional options.

property source

readonly source?: string;

property text

readonly text: string;

Message text.

property type

readonly type?: MessageType;

Type of the message, i.e. error, warning, info, etc.

interface MessageOptions

interface MessageOptions {}

property timeout

readonly timeout?: number;

Timeout in milliseconds. 0 and negative values are treated as no timeout.

interface MutableCompoundMenuNode

interface MutableCompoundMenuNode {}

method addNode

addNode: (...node: MenuNode[]) => void;

method getOrCreate

getOrCreate: (
    menuPath: MenuPath,
    pathIndex: number,
    endIndex: number
) => CompoundMenuNode & MutableCompoundMenuNode;

method removeNode

removeNode: (node: MenuNode) => void;

interface OSBackendProvider

interface OSBackendProvider {}

method getBackendOS

getBackendOS: () => Promise<OS.Type>;

interface OverridePreferenceName

interface OverridePreferenceName {}

property overrideIdentifier

overrideIdentifier: string;

property preferenceName

preferenceName: string;

interface PickOptions

interface PickOptions<T extends QuickPickItem> {}

property activeItem

activeItem?: Promise<T> | T;

property autoFocusOnList

autoFocusOnList?: boolean;

property canPickMany

canPickMany?: boolean;

property contextKey

contextKey?: string;

property ignoreFocusLost

ignoreFocusLost?: boolean;

property matchOnDescription

matchOnDescription?: boolean;

property matchOnDetail

matchOnDetail?: boolean;

property matchOnLabel

matchOnLabel?: boolean;

property onDidFocus

onDidFocus?: (entry: T) => void;

property placeHolder

placeHolder?: string;

property prompt

prompt?: string;

property title

title?: string;

interface PreferenceChange

interface PreferenceChange
    extends Omit<PreferenceProviderDataChange, 'newValue' | 'oldValue'> {}

Representation of a preference change. A preference value can be set to undefined for a specific scope. This means that the value from a more general scope will be used.

method affects

affects: (resourceUri?: string) => boolean;

Tests wether the given resource is affected by the preference change.
Parameter resourceUri
the uri of the resource to test.

interface PreferenceChanges

interface PreferenceChanges {}

A key-value storage for PreferenceChanges. Used to aggregate multiple simultaneous preference changes.

index signature

[preferenceName: string]: PreferenceChange;

interface PreferenceConfiguration

interface PreferenceConfiguration {}

property name

name: string;

interface PreferenceContribution

interface PreferenceContribution {}

A PreferenceContribution allows adding additional custom preferences. For this, the PreferenceContribution has to provide a valid PrefernceSchema specifying which preferences are available including their types and description.

### Example usage

const MyPreferencesSchema: PreferenceSchema = {
    'scope': PreferenceScope.Folder,
    'properties': {
        'myext.decorations.enabled': {
            'type': 'boolean',
            'description': 'Show file status',
            'default': true
        },
        // [...]
    }
}
@injectable()
export class MyPreferenceContribution implements PreferenceContribution{
    schema= MyPreferencesSchema;
}

property schema

readonly schema?: PreferenceSchema;

method initSchema

initSchema: (service: PreferenceSchemaService) => Promise<void>;

Allows to do additional intialisation of the preference schema, for example registering overrides
Parameter service
the preference schema service

interface PreferenceDataProperty

interface PreferenceDataProperty extends IJSONSchema {}

property hidden

hidden?: boolean;

If true, this item will registered as part of the preference schema, but hidden in the preference editor UI.

property included

included?: boolean;

If false, the preference will not be included in the schema or the UI. E.g. OS-Specific prefs

property overridable

overridable?: boolean;

Whether distinct values can be defined for language override identifers. E.g. values valid when editing typescript files vs. when editing Java files

property scope

scope?: PreferenceScope;

The maximum scope where values for this property can be set.

property tags

tags?: string[];

Tags can be searched for in the UI

property typeDetails

typeDetails?: any;

Metadata intended for custom renderers

interface PreferenceEventEmitter

interface PreferenceEventEmitter<T> {}

property onPreferenceChanged

readonly onPreferenceChanged: Event<PreferenceChangeEvent<T>>;

property ready

readonly ready: Promise<void>;

interface PreferenceInspection

interface PreferenceInspection<T = JSONValue> {}

Return type of the PreferenceService.inspect call.

property defaultValue

defaultValue: T | undefined;

Value in default scope.

property globalValue

globalValue: T | undefined;

Value in user scope.

property preferenceName

preferenceName: string;

The preference identifier.

property value

value: T | undefined;

The value that is active, i.e. the value set in the lowest scope available.

property workspaceFolderValue

workspaceFolderValue: T | undefined;

Value in folder scope.

property workspaceValue

workspaceValue: T | undefined;

Value in workspace scope.

interface PreferenceProvider

interface PreferenceProvider extends Disposable {}

property onDidPreferencesChanged

readonly onDidPreferencesChanged: Event<PreferenceProviderDataChanges>;

property ready

ready: Promise<void>;

method canHandleScope

canHandleScope: (scope: PreferenceScope) => boolean;

Whether t
Parameter scope
the scope to handle

method get

get: <T>(preferenceName: string, resourceUri?: string) => T | undefined;

Retrieve the stored value for the given preference and resource URI.
Parameter preferenceName
the preference identifier.
Parameter resourceUri
the uri of the resource for which the preference is stored. This is used to retrieve a potentially different value for the same preference for different resources, for example files.encoding.
Returns
the value stored for the given preference and resourceUri if it exists, otherwise undefined.

method getConfigUri

getConfigUri: (resourceUri?: string, sectionName?: string) => URI | undefined;

Retrieve the configuration URI for the given resource URI.
Parameter resourceUri
the uri of the resource or undefined.
Parameter sectionName
the section to return the URI for, e.g. tasks or launch. Defaults to settings.
Returns
the corresponding resource URI or undefined if there is no valid URI.

method getContainingConfigUri

getContainingConfigUri: (
    resourceUri?: string,
    sectionName?: string
) => URI | undefined;

Retrieves the first valid configuration URI contained by the given resource.
Parameter resourceUri
the uri of the container resource or undefined.
Returns
the first valid configuration URI contained by the given resource undefined if there is no valid configuration URI at all.

method getPreferences

getPreferences: (resourceUri?: string) => JSONObject;

Return a JSONObject with all preferences stored in this preference provider

method resolve

resolve: <T>(
    preferenceName: string,
    resourceUri?: string
) => PreferenceResolveResult<T>;

Resolve the value for the given preference and resource URI.
Parameter preferenceName
the preference identifier.
Parameter resourceUri
the URI of the resource for which this provider should resolve the preference. This is used to retrieve a potentially different value for the same preference for different resources, for example files.encoding.
Returns
an object containing the value stored for the given preference and resourceUri if it exists, otherwise undefined.

method setPreference

setPreference: (
    key: string,
    value: JSONValue,
    resourceUri?: string
) => Promise<boolean>;

Stores a new value for the given preference key in the provider.
Parameter key
the preference key (typically the name).
Parameter value
the new preference value.
Parameter resourceUri
the URI of the resource for which the preference is stored.
Returns
a promise that only resolves if all changes were delivered. If changes were made then implementation must either await on this.emitPreferencesChangedEvent(...) or this.pendingChanges if changes are fired indirectly.

interface PreferenceProviderDataChange

interface PreferenceProviderDataChange {}

property domain

readonly domain?: string[];

URIs of the scopes in which this change applies.

property newValue

readonly newValue?: JSONValue;

The new value of the changed preference. Can be undefined for multiple reasons: - The preference has been reset to its default value. - The preference has been reset and has no value explicitly stored. If undefined, use the preference service to determine the effective new value if needed.

property oldValue

readonly oldValue?: JSONValue;

The old value of the changed preference.

property preferenceName

readonly preferenceName: string;

The name of the changed preference.

property scope

readonly scope: PreferenceScope;

The PreferenceScope of the changed preference.

interface PreferenceProviderDataChanges

interface PreferenceProviderDataChanges {}

index signature

[preferenceName: string]: PreferenceProviderDataChange;

interface PreferenceProxyFactory

interface PreferenceProxyFactory {}

call signature

<T>(
    schema: MaybePromise<PreferenceSchema>,
    options?: PreferenceProxyOptions
): PreferenceProxy<T>;

interface PreferenceProxyOptions

interface PreferenceProxyOptions {}

Proxy configuration parameters.

property isDisposable

isDisposable?: boolean;

Indicates whether the proxy should be disposable. Proxies that are shared between multiple callers should not be disposable.

property overrideIdentifier

overrideIdentifier?: string;

The overrideIdentifier to use with the underlying preferenceService. Useful to potentially override existing values while keeping both values in store.
For example to store different editor settings, e.g. "[markdown].editor.autoIndent", "[json].editor.autoIndent" and "editor.autoIndent"

property prefix

prefix?: string;

Prefix which is transparently added to all preference identifiers.

property resourceUri

resourceUri?: string;

The default resourceUri to use if none was specified when calling "set" or "get".

property style

style?: 'flat' | 'deep' | 'both';

Indicates whether '.' in schema properties shall be interpreted as regular names (flat), as declaring nested objects (deep) or both. Default is flat.
When 'deep' or 'both' is given, nested preference proxies can be retrieved.

interface PreferenceResolveResult

interface PreferenceResolveResult<T> {}

property configUri

configUri?: URI;

property value

value?: T;

interface PreferenceRetrieval

interface PreferenceRetrieval<T> {}

Generic interface to declare a typesafe get function based on the given configuration type.

### Illustration

interface PreferenceConfiguration {
 'myext.enabled': boolean,
}
const enabled : boolean = prefs.get('myext.enabled'); // valid
const debug : string = prefs.get('myext.enabled'); // invalid
prefs.get('foobar'); // invalid

method get

get: <K extends keyof T>(
    preferenceName: K | { preferenceName: K; overrideIdentifier?: string },
    defaultValue?: T[K],
    resourceUri?: string
) => T[K];

interface PreferenceSchema

interface PreferenceSchema {}

property defaultOverridable

defaultOverridable?: boolean;

Whether properties in this schema are overridable by default. Defaults to false.

property properties

properties: IndexedAccess<PreferenceDataProperty>;

property scope

scope?: PreferenceScope;

The default scope for properties in this schema

property title

title?: string;

Optional title to be used in UI

interface PreferenceSchemaService

interface PreferenceSchemaService {}

property onDidChangeDefaultValue

onDidChangeDefaultValue: Event<DefaultValueChangedEvent>;

property onDidChangeSchema

onDidChangeSchema: Event<void>;

property overrideIdentifiers

readonly overrideIdentifiers: ReadonlySet<string>;

property ready

readonly ready: Promise<void>;

Resolves after static contributions have been processed

property validScopes

readonly validScopes: readonly PreferenceScope[];

The scopes which this preference schema service handles. Any properties that are not applicable within the valid scopes will be ignored

method addSchema

addSchema: (schema: PreferenceSchema) => Disposable;

Add a preference schema. It is an error to register the same property in two different schemas
Parameter schema
The schema to add
Returns
A disposable to remove the schema

method getDefaultValue

getDefaultValue: (
    key: string,
    overrideIdentifier: string | undefined
) => JSONValue | undefined;

Get the default value for a preference. This is the value a client will see for the given key/override
Parameter key
The preference key
Parameter overrideIdentifier
The override identifier, undefined for global default
Returns
The default value or undefined if not found

method getDefaultValues

getDefaultValues: () => JSONObject;

Get the collection of all defined default values as JSONObject of the form like in a preferences.json
#### Example usage ```json { "my.preference": "a string default", "[typescript]": { "another.preference": 39 } }

method getJSONSchema

getJSONSchema: (scope: PreferenceScope) => IJSONSchema;

Gets a JSON schema a preference.json file for the given scope.
Parameter scope
The scope to generate schema for
Returns
The JSON schema

method getSchemaProperties

getSchemaProperties: () => ReadonlyMap<string, PreferenceDataProperty>;

method getSchemaProperty

getSchemaProperty: (key: string) => PreferenceDataProperty | undefined;

method inspectDefaultValue

inspectDefaultValue: (
    key: string,
    overrideIdentifier: string | undefined
) => JSONValue | undefined;

Gets the default value for a preference. This method not fall back to the global value if no override is given
Parameter key
The preference key
Parameter overrideIdentifier
The override identifier, undefined for global default
Returns
The default value or undefined if not found

method isValidInScope

isValidInScope: (preferenceName: string, scope: PreferenceScope) => boolean;

Check if a preference is valid in a specific scope
Parameter preferenceName
The preference name
Parameter scope
The scope to check
Returns
True if the preference is valid in the given scope

method registerOverride

registerOverride: (
    key: string,
    overrideIdentifier: string | undefined,
    value: JSONValue
) => Disposable;

Register an override for a preference default value. If multiple overrides are registered for the same value, the last override will be in effect. Removing the last override will make the second-to-last override active, etc.
Parameter key
The preference key
Parameter overrideIdentifier
The override identifier, undefined for global default
Parameter value
The default value
Returns
A disposable to unregister the override

method registerOverrideIdentifier

registerOverrideIdentifier: (overrideIdentifier: string) => Disposable;

Register an override identifier for language specific preferences
Parameter overrideIdentifier
The identifier to register
Returns
A disposable to unregister the identifier

method updateSchemaProperty

updateSchemaProperty: (key: string, property: PreferenceDataProperty) => void;

Update a property in the schema. The corresponding JSON Schemas, etc. will be updated
Parameter key
The property key
Parameter property
The updated property

interface PreferenceService

interface PreferenceService extends Disposable {}

Service to manage preferences including, among others, getting and setting preference values as well as listening to preference changes.
Depending on your use case you might also want to look at createPreferenceProxy with which you can easily create a typesafe schema-based interface for your preferences. Internally the proxy uses the PreferenceService so both approaches are compatible.

property isReady

readonly isReady: boolean;

Indicates whether the service has successfully initialized. Will be true when resolves.

property onPreferenceChanged

onPreferenceChanged: Event<PreferenceChange>;

Registers a callback which will be called whenever a preference is changed.

property onPreferencesChanged

onPreferencesChanged: Event<PreferenceChanges>;

Registers a callback which will be called whenever one or more preferences are changed.

property ready

readonly ready: Promise<void>;

Promise indicating whether the service successfully initialized.

method get

get: {
    <T>(preferenceName: string): T | undefined;
    <T>(preferenceName: string, defaultValue: T): T;
    <T>(preferenceName: string, defaultValue: T, resourceUri?: string): T;
    <T>(preferenceName: string, defaultValue?: T, resourceUri?: string): T;
};

Retrieve the stored value for the given preference.
Parameter preferenceName
the preference identifier.
Returns
the value stored for the given preference when it exists, undefined otherwise.
Retrieve the stored value for the given preference.
Parameter preferenceName
the preference identifier.
Parameter defaultValue
the value to return when no value for the given preference is stored.
Returns
the value stored for the given preference when it exists, otherwise the given default value.
Retrieve the stored value for the given preference and resourceUri.
Parameter preferenceName
the preference identifier.
Parameter defaultValue
the value to return when no value for the given preference is stored.
Parameter resourceUri
the uri of the resource for which the preference is stored. This used to retrieve a potentially different value for the same preference for different resources, for example files.encoding.
Returns
the value stored for the given preference and resourceUri when it exists, otherwise the given default value.

method getConfigUri

getConfigUri: (
    scope: PreferenceScope,
    resourceUri?: string,
    sectionName?: string
) => URI | undefined;

Returns the uri of the configuration resource for the given scope and optional resource uri.
Parameter scope
the PreferenceScope to query for.
Parameter resourceUri
the optional uri of the resource-specific preference handling
Parameter sectionName
the optional preference section to query for.
Returns
the uri of the configuration resource for the given scope and optional resource uri it it exists, undefined otherwise.

method inspect

inspect: <T extends JSONValue>(
    preferenceName: string,
    resourceUri?: string,
    forceLanguageOverride?: boolean
) => PreferenceInspection<T> | undefined;

Retrieve the stored value for the given preference and resourceUri in all available scopes.
Parameter preferenceName
the preference identifier.
Parameter resourceUri
the uri of the resource for which the preference is stored.
Parameter forceLanguageOverride
if true and preferenceName is a language override, only values for the specified override will be returned. Otherwise, values for the override will be returned where defined, and values from the base preference will be returned otherwise.
an object containing the value of the given preference for all scopes.

method inspectInScope

inspectInScope: <T extends JSONValue>(
    preferenceName: string,
    scope: PreferenceScope,
    resourceUri?: string,
    forceLanguageOverride?: boolean
) => T | undefined;

For behavior, see PreferenceService.inspect.
Returns
the value in the scope specified.

method overriddenPreferenceName

overriddenPreferenceName: (
    preferenceName: string
) => OverridePreferenceName | undefined;

Tries to split the given preference identifier into the original OverridePreferenceName attributes with which this identifier was created. Returns undefined if this is not possible, for example when the given preference identifier was not generated by overridePreferenceName.
This method is checked when resolving preferences. Therefore together with "overridePreferenceName" this can be used to handle specialized preferences, e.g. "[markdown].editor.autoIndent" and "editor.autoIndent".
Parameter preferenceName
the preferenceName which might have been created via PreferenceService.overridePreferenceName.
Returns
the OverridePreferenceName which was used to create the given preferenceName if this was the case, undefined otherwise.

method overridePreferenceName

overridePreferenceName: (options: OverridePreferenceName) => string;

Returns a new preference identifier based on the given OverridePreferenceName.
Parameter options
the override specification.
Returns
the calculated string based on the given OverridePreferenceName.

method resolve

resolve: <T>(
    preferenceName: string,
    defaultValue?: T,
    resourceUri?: string
) => PreferenceResolveResult<T>;

Retrieve the stored value for the given preference and resourceUri.
Parameter preferenceName
the preference identifier.
Parameter defaultValue
the value to return when no value for the given preference is stored.
Parameter resourceUri
the uri of the resource for which the preference is stored. This used to retrieve a potentially different value for the same preference for different resources, for example files.encoding.
Returns
an object containing the value stored for the given preference and resourceUri when it exists, otherwise the given default value. If determinable the object will also contain the uri of the configuration resource in which the preference was stored.

method set

set: (
    preferenceName: string,
    value: any,
    scope?: PreferenceScope,
    resourceUri?: string
) => Promise<void>;

Sets the given preference to the given value.
Parameter preferenceName
the preference identifier.
Parameter value
the new value of the preference.
Parameter scope
the scope for which the value shall be set, i.e. user, workspace etc. When the folder scope is specified a resourceUri must be provided.
Parameter resourceUri
the uri of the resource for which the preference is stored. This used to store a potentially different value for the same preference for different resources, for example files.encoding.
Returns
a promise which resolves to undefined when setting the preference was successful. Otherwise it rejects with an error.

method updateValue

updateValue: (
    preferenceName: string,
    value: any,
    resourceUri?: string
) => Promise<void>;

Determines and applies the changes necessary to apply value to either the resourceUri supplied or the active session. If there is no setting for the preferenceName, the change will be applied in user scope. If there is a setting conflicting with the specified value, the change will be applied in the most specific scope with a conflicting value.
Parameter preferenceName
the identifier of the preference to modify.
Parameter value
the value to which to set the preference. undefined will reset the preference to its default value.
Parameter resourceUri
the uri of the resource to which the change is to apply. If none is provided, folder scope will be ignored.

interface Prioritizeable

interface Prioritizeable<T> {}

property priority

readonly priority: number;

property value

readonly value: T;

interface Progress

interface Progress {}

property cancel

readonly cancel: () => void;

Cancel or complete the current progress.

property id

readonly id: string;

Unique progress id.

property report

readonly report: (update: ProgressUpdate) => void;

Update the current progress.
Parameter update
the data to update.

property result

readonly result: Promise<string | undefined>;

Result of the progress.
Returns
a promise which resolves to either 'Cancel', an alternative action or undefined.

interface ProgressClient

interface ProgressClient {}

method reportProgress

reportProgress: (
    progressId: string,
    update: ProgressUpdate,
    message: ProgressMessage,
    cancellationToken: CancellationToken
) => Promise<void>;

Update a previously created progress message.

method showProgress

showProgress: (
    progressId: string,
    message: ProgressMessage,
    cancellationToken: CancellationToken
) => Promise<string | undefined>;

Show a progress message with possible actions to user.

interface ProgressMessage

interface ProgressMessage extends Message {}

property options

readonly options?: ProgressMessageOptions;

property type

readonly type?: MessageType.Progress;

interface ProgressMessageOptions

interface ProgressMessageOptions extends MessageOptions {}

property cancelable

readonly cancelable?: boolean;

Default: false

property location

readonly location?: string;

Known values: notification | window | scm

interface ProgressUpdate

interface ProgressUpdate {}

property message

readonly message?: string;

Updated message for the progress.

property work

readonly work?: {
    done: number;
    total: number;
};

Updated ratio between steps done so far and total number of steps.

interface QuickInput

interface QuickInput {}

property busy

busy: boolean;

property contextKey

contextKey: string | undefined;

property description

description: string | undefined;

property enabled

enabled: boolean;

property ignoreFocusOut

ignoreFocusOut: boolean;

property onDidHide

readonly onDidHide: Event<{
    reason: QuickInputHideReason;
}>;

property onDispose

readonly onDispose: Event<void>;

property step

step: number | undefined;

property title

title: string | undefined;

property totalSteps

totalSteps: number | undefined;

method dispose

dispose: () => void;

method hide

hide: () => void;

method show

show: () => void;

interface QuickInputButton

interface QuickInputButton {}

property alwaysVisible

alwaysVisible?: boolean;

Whether the button should be visible even when the user is not hovering.

property iconClass

iconClass?: string;

property location

location?: QuickInputButtonLocation;

The location where the button should be rendered.

property toggle

toggle?: {
    checked: boolean;
};

When present, indicates that the button is a toggle button.

property tooltip

tooltip?: string;

interface QuickInputButtonHandle

interface QuickInputButtonHandle extends QuickInputButton {}

property handle

handle: number;

interface QuickInputService

interface QuickInputService {}

property backButton

readonly backButton: QuickInputButton;

property onHide

readonly onHide: Event<void>;

property onShow

readonly onShow: Event<void>;

method createInputBox

createInputBox: () => InputBox;

method createQuickPick

createQuickPick: <T extends QuickPickItem>() => QuickPick<T>;

Provides raw access to the quick pick controller.

method hide

hide: () => void;

method input

input: (
    options?: InputOptions,
    token?: CancellationToken
) => Promise<string | undefined>;

method open

open: (filter: string) => void;

method pick

pick: {
    <T extends QuickPickItem>(
        picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[],
        options?: PickOptions<T> & { canPickMany: true },
        token?: CancellationToken
    ): Promise<T[] | undefined>;
    <T extends QuickPickItem>(
        picks: QuickPickInput<T>[] | Promise<QuickPickInput<T>[]>,
        options?: PickOptions<T> & { canPickMany: false },
        token?: CancellationToken
    ): Promise<T>;
    <T extends QuickPickItem>(
        picks: QuickPickInput<T>[] | Promise<QuickPickInput<T>[]>,
        options?: Omit<PickOptions<T>, 'canPickMany'>,
        token?: CancellationToken
    ): Promise<T>;
};

method showQuickPick

showQuickPick: <T extends QuickPickItem>(
    items: Array<T | QuickPickSeparator>,
    options?: QuickPickOptions<T>
) => Promise<T | undefined>;

interface QuickPick

interface QuickPick<T extends QuickPickItemOrSeparator> extends QuickInput {}

property activeItems

activeItems: ReadonlyArray<T>;

property buttons

buttons: ReadonlyArray<QuickInputButton>;

property canSelectMany

canSelectMany: boolean;

property items

items: ReadonlyArray<T | QuickPickSeparator>;

property keepScrollPosition

keepScrollPosition: boolean;

property matchOnDescription

matchOnDescription: boolean;

property matchOnDetail

matchOnDetail: boolean;

property onDidAccept

readonly onDidAccept: Event<
    | {
          inBackground: boolean;
      }
    | undefined
>;

property onDidChangeActive

readonly onDidChangeActive: Event<T[]>;

property onDidChangeSelection

readonly onDidChangeSelection: Event<T[]>;

property onDidChangeValue

readonly onDidChangeValue: Event<string>;

property onDidTriggerButton

readonly onDidTriggerButton: Event<QuickInputButton>;

property onDidTriggerItemButton

readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<QuickPickItem>>;

property placeholder

placeholder: string | undefined;

property selectedItems

selectedItems: ReadonlyArray<T>;

property value

value: string;

interface QuickPickItem

interface QuickPickItem {}

property alwaysShow

alwaysShow?: boolean;

property ariaLabel

ariaLabel?: string;

property buttons

buttons?: QuickInputButton[];

property description

description?: string;

property detail

detail?: string;

property execute

execute?: () => void;

property highlights

highlights?: QuickPickItemHighlights;

property iconClasses

iconClasses?: string[];

property id

id?: string;

property keySequence

keySequence?: KeySequence;

property label

label: string;

property meta

meta?: string;

property type

type?: 'item';

interface QuickPickItemButtonContext

interface QuickPickItemButtonContext<T extends QuickPickItemOrSeparator>
    extends QuickPickItemButtonEvent<T> {}

method removeItem

removeItem: () => void;

interface QuickPickItemButtonEvent

interface QuickPickItemButtonEvent<T extends QuickPickItemOrSeparator> {}

property button

button: QuickInputButton;

property item

item: T;

interface QuickPickItemHighlights

interface QuickPickItemHighlights {}

property description

description?: Match[];

property detail

detail?: Match[];

property label

label?: Match[];

interface QuickPickOptions

interface QuickPickOptions<T extends QuickPickItemOrSeparator> {}

property activeItem

activeItem?: T;

property ariaLabel

ariaLabel?: string;

property autoFocusOnList

autoFocusOnList?: boolean;

property busy

busy?: boolean;

property buttons

buttons?: Array<QuickInputButton>;

property canAcceptInBackground

canAcceptInBackground?: boolean;

property canSelectMany

canSelectMany?: boolean;

property contextKey

contextKey?: string;

property customButton

customButton?: boolean;

property customHover

customHover?: string;

property customLabel

customLabel?: string;

property description

description?: string;

property enabled

enabled?: boolean;

property filterValue

filterValue?: (value: string) => string;

property hideCheckAll

hideCheckAll?: boolean;

property hideInput

hideInput?: boolean;

property ignoreFocusOut

ignoreFocusOut?: boolean;

property keepScrollPosition

keepScrollPosition?: boolean;

property matchOnDescription

matchOnDescription?: boolean;

property matchOnDetail

matchOnDetail?: boolean;

property matchOnLabel

matchOnLabel?: boolean;

property onDidAccept

onDidAccept?: () => void;

property onDidChangeActive

onDidChangeActive?: (quickPick: QuickPick<T>, activeItems: Array<T>) => void;

property onDidChangeSelection

onDidChangeSelection?: (
    quickPick: QuickPick<T>,
    selectedItems: Array<T>
) => void;

property onDidChangeValue

onDidChangeValue?: (quickPick: QuickPick<T>, filter: string) => void;

property onDidCustom

onDidCustom?: () => void;

property onDidHide

onDidHide?: () => void;

property onDidTriggerButton

onDidTriggerButton?: (button: QuickInputButton) => void;

property onDidTriggerItemButton

onDidTriggerItemButton?: (
    ItemButtonEvent: QuickPickItemButtonContext<T>
) => void;

property placeholder

placeholder?: string;

property prompt

prompt?: string;

property runIfSingle

runIfSingle?: boolean;

property sortByLabel

sortByLabel?: boolean;

property step

step?: number;

property title

title?: string;

property totalSteps

totalSteps?: number;

property validationMessage

validationMessage?: string;

property value

value?: string;

property valueSelection

valueSelection?: Readonly<[number, number]>;

interface QuickPickSeparator

interface QuickPickSeparator {}

property label

label?: string;

property type

type: 'separator';

interface QuickPickSeparator

interface QuickPickSeparator {}

property label

label?: string;

property type

type: 'separator';

interface QuickPickService

interface QuickPickService {}

property onDidAccept

readonly onDidAccept: Event<void>;

property onDidChangeActive

readonly onDidChangeActive: Event<{
    quickPick: QuickPick<QuickPickItem>;
    activeItems: Array<QuickPickItem>;
}>;

property onDidChangeSelection

readonly onDidChangeSelection: Event<{
    quickPick: QuickPick<QuickPickItem>;
    selectedItems: Array<QuickPickItem>;
}>;

property onDidChangeValue

readonly onDidChangeValue: Event<{
    quickPick: QuickPick<QuickPickItem>;
    filter: string;
}>;

property onDidHide

readonly onDidHide: Event<void>;

property onDidTriggerButton

readonly onDidTriggerButton: Event<QuickInputButtonHandle>;

method hide

hide: () => void;

method setItems

setItems: <T extends QuickPickItem>(items: Array<T>) => void;

method show

show: <T extends QuickPickItem>(
    items: Array<T | QuickPickSeparator>,
    options?: QuickPickOptions<T>
) => Promise<T | undefined>;

interface QuickPickValue

interface QuickPickValue<V> extends QuickPickItem {}

property value

value: V;

interface ReadBuffer

interface ReadBuffer {}

A buffer maintaining a read position in a buffer containing a received message capable of reading primitive values.

method readBytes

readBytes: () => Uint8Array;

method readLength

readLength: () => number;

method readNumber

readNumber: () => number;

method readString

readString: () => string;

method readUint16

readUint16: () => number;

method readUint32

readUint32: () => number;

method readUint8

readUint8: () => number;

method sliceAtReadPosition

sliceAtReadPosition: () => ReadBuffer;

Returns a new read buffer whose starting read position is the current read position of this buffer. This is useful to create read buffers sub messages. (e.g. when using a multiplexer the beginning of the message might contain some protocol overhead which should not be part of the message reader that is sent to the target channel)

interface Reference

interface Reference<T> extends Disposable {}

property object

readonly object: T;

interface ResolvedConnectionErrorHandlerOptions

interface ResolvedConnectionErrorHandlerOptions {}

property logger

readonly logger: ILogger;

property maxErrors

readonly maxErrors: number;

The maximum amount of errors allowed before stopping the server.

property maxRestarts

readonly maxRestarts: number;

The minimum amount of restarts allowed in the restart interval.

property restartInterval

readonly restartInterval: number;

In minutes.

property serverName

readonly serverName: string;

interface Resource

interface Resource extends Disposable {}

property autosaveable

readonly autosaveable?: boolean;

If false, the application should not attempt to auto-save this resource.

property encoding

readonly encoding?: string | undefined;

Latest read encoding of this resource.
Optional if a resource does not support encoding, check with in operator`. Undefined if a resource did not read content yet.

property initiallyDirty

readonly initiallyDirty?: boolean;

property onDidChangeContents

readonly onDidChangeContents?: Event<void>;

property onDidChangeReadOnly

readonly onDidChangeReadOnly?: Event<boolean | MarkdownString>;

property readOnly

readonly readOnly?: boolean | MarkdownString;

property uri

readonly uri: URI;

property version

readonly version?: ResourceVersion | undefined;

Latest read version of this resource.
Optional if a resource does not support versioning, check with in operator`. Undefined if a resource did not read content yet.

method guessEncoding

guessEncoding: () => Promise<string | undefined>;

method readContents

readContents: (options?: ResourceReadOptions) => Promise<string>;

Reads latest content of this resource.
If a resource supports versioning it updates version to latest. If a resource supports encoding it updates encoding to latest.
Throws
ResourceError.NotFound if a resource not found

method readStream

readStream: (options?: ResourceReadOptions) => Promise<ReadableStream<string>>;

Stream latest content of this resource.
If a resource supports versioning it updates version to latest. If a resource supports encoding it updates encoding to latest.
Throws
ResourceError.NotFound if a resource not found

method saveContentChanges

saveContentChanges: (
    changes: TextDocumentContentChangeEvent[],
    options?: ResourceSaveOptions
) => Promise<void>;

Applies incremental content changes to this resource.
If a resource supports versioning clients can pass some version to check against it, if it is not provided latest version is used. It updates version to latest.
Throws
ResourceError.NotFound if a resource not found or was not read yet
Throws
ResourceError.OutOfSync if latest resource version is out of sync with the given

method saveContents

saveContents: (content: string, options?: ResourceSaveOptions) => Promise<void>;

Rewrites the complete content for this resource. If a resource does not exist it will be created.
If a resource supports versioning clients can pass some version to check against it, if it is not provided latest version is used.
It updates version and encoding to latest.
Throws
ResourceError.OutOfSync if latest resource version is out of sync with the given

method saveStream

saveStream: (
    content: Readable<string>,
    options?: ResourceSaveOptions
) => Promise<void>;

Rewrites the complete content for this resource. If a resource does not exist it will be created.
If a resource supports versioning clients can pass some version to check against it, if it is not provided latest version is used.
It updates version and encoding to latest.
Throws
ResourceError.OutOfSync if latest resource version is out of sync with the given

interface ResourceReadOptions

interface ResourceReadOptions {}

property encoding

encoding?: string;

interface ResourceResolver

interface ResourceResolver {}

property priority

priority?: number;

Resolvers will be ordered by descending priority. Default: 0

method resolve

resolve: (uri: URI) => MaybePromise<Resource>;

Reject if a resource cannot be provided.

interface ResourceSaveOptions

interface ResourceSaveOptions {}

property encoding

encoding?: string;

property overwriteEncoding

overwriteEncoding?: boolean;

property version

version?: ResourceVersion;

interface ResourceVersion

interface ResourceVersion {}

interface RpcConnectionEventEmitter

interface RpcConnectionEventEmitter {}

property onDidCloseConnection

readonly onDidCloseConnection: Event<void>;

property onDidOpenConnection

readonly onDidOpenConnection: Event<void>;

interface RpcProtocolOptions

interface RpcProtocolOptions {}

Initialization options for a RpcProtocol.

property decoder

decoder?: RpcMessageDecoder;

The message decoder that should be used. If undefined the default RpcMessageDecoder will be used.

property encoder

encoder?: RpcMessageEncoder;

The message encoder that should be used. If undefined the default RpcMessageEncoder will be used.

property mode

mode?: 'default' | 'clientOnly' | 'serverOnly';

The runtime mode determines whether the RPC protocol is bi-directional (default) or acts as a client or server only.

interface SanitizationRule

interface SanitizationRule {}

Represents a sanitization rule with a pattern and replacement string.

property pattern

pattern: RegExp;

The regex pattern to match sensitive information. Can use capture groups that can be referenced in the replacement string.

property precheck

precheck?: (message: string) => boolean;

Optional quick check function that returns true if the message might contain sensitive data matching this rule. Used as a fast early-exit optimization to avoid running expensive regex operations on messages that definitely don't contain sensitive data.
If not provided, the regex pattern will always be executed.

property replacement

replacement: string;

The replacement string. Can include capture group references like $1, $2, etc.

interface SelectionProvider

interface SelectionProvider<T> {}

SelectionProvider is implemented by services to notify listeners about selection changes.

property onSelectionChanged

onSelectionChanged: Event<T | undefined>;

interface StructuralMenuChange

interface StructuralMenuChange extends MenuChangedEvent {}

property affectedChildId

affectedChildId: string;

property kind

kind: ChangeKind.ADDED | ChangeKind.REMOVED | ChangeKind.LINKED;

interface TelemetryLogger

interface TelemetryLogger {}

property options

readonly options: TelemetryLoggerOptions | undefined;

property sender

readonly sender: TelemetrySender;

method dispose

dispose: () => void;

method logError

logError: (
    eventNameOrException: string | Error,
    data?: Record<string, any | TelemetryTrustedValue<any>>
) => void;

method logUsage

logUsage: (
    eventName: string,
    data?: Record<string, any | TelemetryTrustedValue<any>>
) => void;

interface TextDocumentContentChangeDelta

interface TextDocumentContentChangeDelta {}

property range

readonly range: Range;

property rangeLength

readonly rangeLength?: number;

property text

readonly text: string;

interface UriSelection

interface UriSelection {}

property uri

readonly uri: URI;

interface WaitUntilEvent

interface WaitUntilEvent {}

property token

token: CancellationToken;

A cancellation token.

method waitUntil

waitUntil: (thenable: Promise<any>) => void;

Allows to pause the event loop until the provided thenable resolved.
*Note:* It can only be called during event dispatch and not in an asynchronous manner
Parameter thenable
A thenable that delays execution.

interface WillExecuteCommandEvent

interface WillExecuteCommandEvent extends WaitUntilEvent, CommandEvent {}

interface WriteBuffer

interface WriteBuffer {}

A buffer maintaining a write position capable of writing primitive values

method commit

commit: () => void;

Makes any writes to the buffer permanent, for example by sending the writes over a channel. You must obtain a new write buffer after committing

method writeBytes

writeBytes: (value: Uint8Array) => this;

method writeLength

writeLength: (value: number) => this;

method writeNumber

writeNumber: (value: number) => this;

method writeRaw

writeRaw: (bytes: Uint8Array) => this;

method writeString

writeString: (value: string) => this;

method writeUint16

writeUint16: (value: number) => this;

method writeUint32

writeUint32: (value: number) => this;

method writeUint8

writeUint8: (byte: number) => this;

Enums

enum ChangeKind

enum ChangeKind {
    ADDED = 0,
    REMOVED = 1,
    CHANGED = 2,
    LINKED = 3,
}

member ADDED

ADDED = 0

member CHANGED

CHANGED = 2

member LINKED

LINKED = 3

member REMOVED

REMOVED = 1

enum LogLevel

enum LogLevel {
    FATAL = 60,
    ERROR = 50,
    WARN = 40,
    INFO = 30,
    DEBUG = 20,
    TRACE = 10,
}

member DEBUG

DEBUG = 20

member ERROR

ERROR = 50

member FATAL

FATAL = 60

member INFO

INFO = 30

member TRACE

TRACE = 10

member WARN

WARN = 40

enum MessageType

enum MessageType {
    Error = 1,
    Warning = 2,
    Info = 3,
    Log = 4,
    Progress = 5,
}

member Error

Error = 1

member Info

Info = 3

member Log

Log = 4

member Progress

Progress = 5

member Warning

Warning = 2

enum PreferenceScope

enum PreferenceScope {
    Default = 0,
    User = 1,
    Workspace = 2,
    Folder = 3,
}

member Default

Default = 0

member Folder

Folder = 3

member User

User = 1

member Workspace

Workspace = 2

enum QuickInputButtonLocation

enum QuickInputButtonLocation {
    Title = 1,
    Inline = 2,
    Input = 3,
}

Specifies the location where a QuickInputButton should be rendered.

member Inline

Inline = 2

The button is rendered inline to the right of the input box.

member Input

Input = 3

The button is rendered at the far end inside the input box.

member Title

Title = 1

The button is rendered in the title bar.

enum QuickInputHideReason

enum QuickInputHideReason {
    Blur = 1,
    Gesture = 2,
    Other = 3,
}

member Blur

Blur = 1

Focus was moved away from the input, but the user may not have explicitly closed it.

member Gesture

Gesture = 2

An explicit close gesture, like striking the Escape key

member Other

Other = 3

Any other reason

enum ViewColumn

enum ViewColumn {
    Active = -1,
    Beside = -2,
    One = 1,
    Two = 2,
    Three = 3,
    Four = 4,
    Five = 5,
    Six = 6,
    Seven = 7,
    Eight = 8,
    Nine = 9,
}

Denotes a column in the editor window. Columns are used to show editors side by side.

member Active

Active = -1

member Beside

Beside = -2

member Eight

Eight = 8

member Five

Five = 5

member Four

Four = 4

member Nine

Nine = 9

member One

One = 1

member Seven

Seven = 7

member Six

Six = 6

member Three

Three = 3

member Two

Two = 2

Type Aliases

type Bindable

type Bindable = interfaces.Bind | interfaces.Container;

type CMD

type CMD = [string, string[]];

type CommandMenu

type CommandMenu = MenuNode & RenderedMenuNode & Action;

type CompoundMenuImpl

type CompoundMenuImpl = SubmenuImpl | GroupImpl;

type ConnectionErrorHandlerOptions

type ConnectionErrorHandlerOptions =
    Partial<ResolvedConnectionErrorHandlerOptions> & {
        readonly serverName: string;
        readonly logger: ILogger;
    };

type ContributionType

type ContributionType = interfaces.ServiceIdentifier<any>;

type CorePreferences

type CorePreferences = PreferenceProxy<CoreConfiguration>;

type Deferred

type Deferred<T> = {
    [P in keyof T]: Promise<T[P]>;
};

type DisposableGroup

type DisposableGroup =
    | {
          push(disposable: Disposable): void;
      }
    | {
          add(disposable: Disposable): void;
      };

type ErrorHandlingStrategy

type ErrorHandlingStrategy = 'log' | 'propagate' | ((error: unknown) => void);

A strategy for handling errors in firing an emitter's event, one of
- 'log' (default): errors are caught and logged via console.error - 'propagate': all listeners are called; if any throw, the errors are collected and re-thrown after all listeners complete (single error re-thrown directly, multiple errors wrapped in an AggregateError) - (error: unknown) => void: a custom callback invoked for each error

type Filter

type Filter<T extends Object> = (toTest: T) => boolean;

Parameter toTest
Object that should be tested
Returns
true if the object passes the test, false otherwise.

type Group

type Group = CompoundMenuNode;

type JsonRpcConnectionEventEmitter

type JsonRpcConnectionEventEmitter = RpcConnectionEventEmitter;

Deprecated
since 1.39.0 use RpcConnectionEventEmitter instead

type JsonRpcProxy

type JsonRpcProxy<T> = RpcProxy<T>;

Deprecated
since 1.39.0 use RpcProxy instead

type JsonRpcServer

type JsonRpcServer<Client> = RpcServer<Client>;

Deprecated
since 1.39.0 use RpcServer instead

type Log

type Log = (message: any, ...params: any[]) => void;

type Loggable

type Loggable = (log: Log) => void;

type LoggerFactory

type LoggerFactory = (name: string) => ILogger;

type MaybeArray

type MaybeArray<T> = T | T[];

type MaybeNull

type MaybeNull<T> = {
    [P in keyof T]: T[P] | null;
};

type MaybePromise

type MaybePromise<T> = T | PromiseLike<T>;

type MaybeUndefined

type MaybeUndefined<T> = {
    [P in keyof T]?: T[P] | undefined;
};

type MenuPath

type MenuPath = string[];

type MessageProvider

type MessageProvider = () => ReadBuffer;

The MessageProvider is emitted when a channel receives a new message. Listeners can invoke the provider to obtain a new ReadBuffer for the received message. This ensures that each listener has its own isolated ReadBuffer instance.

type Mutable

type Mutable<T> = {
    -readonly [P in keyof T]: T[P];
};

type PreferenceChangeEvent

type PreferenceChangeEvent<T> = {
    affects(resourceUri?: string, overrideIdentifier?: string): boolean;
} & {
    [K in keyof T]-?: {
        readonly preferenceName: K;
    };
}[keyof T];

Union of all possible key/value pairs for a type T

type PreferenceInspectionScope

type PreferenceInspectionScope = keyof Omit<
    PreferenceInspection<unknown>,
    'preferenceName'
>;

type PreferenceProviderProvider

type PreferenceProviderProvider = (
    scope: PreferenceScope,
    uri?: URI
) => PreferenceProvider | undefined;

type PreferenceProxy

type PreferenceProxy<T> = Readonly<T> &
    Disposable &
    PreferenceEventEmitter<T> &
    PreferenceRetrieval<T>;

Typesafe schema-based preferences utility based on the PreferenceService. Can be used to get preferences as well as listen to preference changes.
See createPreferenceProxy on how to instantiate preference proxies.
### Example usage
preferences.onPreferenceChanged(({ preferenceName, newValue }) => { ... }); const enabled = preferences['myext.enabled'];

type QuickPickInput

type QuickPickInput<T = QuickPickItem> = T | QuickPickSeparator;

type QuickPickItemOrSeparator

type QuickPickItemOrSeparator = QuickPickItem | QuickPickSeparator;

type QuickPicks

type QuickPicks = (QuickPickSeparator | QuickPickItem)[];

type RecursivePartial

type RecursivePartial<T> = {
    [P in keyof T]?: T[P] extends (infer I)[]
        ? RecursivePartial<I>[]
        : RecursivePartial<T[P]>;
};

type RecursiveReadonly

type RecursiveReadonly<T> = {
    readonly [P in keyof T]: T[P] extends Array<infer I>
        ? RecursiveReadonly<I>[]
        : T[P] extends object
        ? RecursiveReadonly<T[P]>
        : T[P];
};

type RemoteMeasurement

type RemoteMeasurement = number;

Token representing a remote measurement in the BackendStopwatch protocol.

type RequestHandler

type RequestHandler = (method: string, args: any[]) => Promise<any>;

Handles request messages received by the RPCProtocol.

type ResourceProvider

type ResourceProvider = (uri: URI) => Promise<Resource>;

type RpcProtocolFactory

type RpcProtocolFactory = (
    channel: Channel,
    requestHandler: RequestHandler
) => RpcProtocol;

Factory for creating a new RpcProtocol for a given chanel and RequestHandler.

type RpcProxy

type RpcProxy<T> = T & RpcConnectionEventEmitter;

type RpcServer

type RpcServer<Client> = Disposable & {
    /**
     * If this server is a proxy to a remote server then
     * a client is used as a local object
     * to handle RPC messages from the remote server.
     */
    setClient(client: Client | undefined): void;
    getClient?(): Client | undefined;
};

type Submenu

type Submenu = CompoundMenuNode & RenderedMenuNode;

type TreePreferences

type TreePreferences = PreferenceProxy<TreeConfiguration>;

type WaitUntilData

type WaitUntilData<T> = Omit<T, 'waitUntil' | 'token'>;

Namespaces

namespace AcceleratorSource

namespace AcceleratorSource {}

function is

is: (node: unknown) => node is AcceleratorSource;

namespace Action

namespace Action {}

function is

is: (node: object) => node is Action;

namespace ApplicationError

namespace ApplicationError {}

function declare

declare: <C extends number, D>(
    code: C,
    factory: (...args: any[]) => Literal<D>
) => Constructor<C, D>;

function fromJson

fromJson: <C extends number, D>(
    code: C,
    raw: Literal<D>
) => ApplicationError<C, D>;

function is

is: <C extends number, D>(
    arg: object | undefined
) => arg is ApplicationError<C, D>;

interface Constructor

interface Constructor<C extends number, D> {}

property code

code: C;

method is

is: (arg: object | undefined) => arg is ApplicationError<C, D>;

call signature

(...args: any[]): ApplicationError<C, D>;

interface Literal

interface Literal<D> {}

property data

data: D;

property message

message: string;

property stack

stack?: string;

namespace ArrayUtils

namespace ArrayUtils {}

variable HeadAndChildrenImpl

const HeadAndChildrenImpl: {
    head<T>(this: T[]): T;
    children<T>(this: T[]): Tail<T>;
};

variable TailImpl

const TailImpl: { tail<T>(this: T[]): T };

function asHeadAndTail

asHeadAndTail: <T>(array: Array<T>) => HeadAndTail<T>;

function asTail

asTail: <T>(array: Array<T>) => Tail<T>;

function binarySearch2

binarySearch2: (
    length: number,
    compareToKey: (index: number) => number
) => number;

Performs a binary search algorithm over a sorted collection. Useful for cases when we need to perform a binary search over something that isn't actually an array, and converting data to an array would defeat the use of binary search in the first place.
Parameter length
The collection length.
Parameter compareToKey
A function that takes an index of an element in the collection and returns zero if the value at this index is equal to the search key, a negative number if the value precedes the search key in the sorting order, or a positive number if the search key precedes the value. A non-negative index of an element, if found. If not found, the result is -(n+1) (or ~n, using bitwise notation), where n is the index where the key should be inserted to maintain the sorting order.

function checkAdjacentItems

checkAdjacentItems: <T>(
    items: readonly T[],
    predicate: (item1: T, item2: T) => boolean
) => boolean;

function coalesce

coalesce: <T>(array: ReadonlyArray<T | undefined | null>) => T[];

Returns
New array with all falsy values removed. The original array IS NOT modified.

function equals

equals: <T>(
    one: ReadonlyArray<T> | undefined,
    other: ReadonlyArray<T> | undefined,
    itemEquals?: (a: T, b: T) => boolean
) => boolean;

function findLast

findLast: <T>(
    array: readonly T[],
    predicate: (item: T) => boolean
) => T | undefined;

function findLastIdx

findLastIdx: <T>(
    array: readonly T[],
    predicate: (item: T) => boolean,
    fromIndex?: number
) => number;

function groupBy

groupBy: <T>(data: ReadonlyArray<T>, compare: (a: T, b: T) => number) => T[][];

groups array elements through a comparator function
Parameter data
array of elements to group
Parameter compare
comparator function: return of 0 means should group, anything above means not group
Returns
array of arrays with grouped elements

function partition

partition: <T>(
    array: T[],
    filter: (e: T, idx: number, arr: T[]) => boolean | undefined
) => [T[], T[]];

function shallowEqual

shallowEqual: <T>(left: readonly T[], right: readonly T[]) => boolean;

function startsWith

startsWith: <T>(left: readonly T[], right: readonly T[]) => boolean;

interface Children

interface Children<T> extends Array<T> {}

method children

children: () => Tail<T>;

interface Head

interface Head<T> extends Array<T> {}

method head

head: () => T;

interface HeadAndTail

interface HeadAndTail<T> extends Head<T>, Tail<T>, Children<T> {}

interface Tail

interface Tail<T> extends Array<T> {}

method tail

tail: () => T;

enum Sort

enum Sort {
    LeftBeforeRight = -1,
    RightBeforeLeft = 1,
    Equal = 0,
}

member Equal

Equal = 0

member LeftBeforeRight

LeftBeforeRight = -1

member RightBeforeLeft

RightBeforeLeft = 1

namespace Bindable

namespace Bindable {}

function isContainer

isContainer: (arg: Bindable) => arg is interfaces.Container;

namespace CancellationToken

namespace CancellationToken {}

variable Cancelled

const Cancelled: CancellationToken;

variable None

const None: CancellationToken;

function is

is: (value: unknown) => value is CancellationToken;

namespace Command

namespace Command {}

function compareCommands

compareCommands: (a: Command, b: Command) => number;

Comparator function for when sorting commands

function equals

equals: (a: Command, b: Command) => boolean;

Determine if two commands are equal.
Parameter a
the first command for comparison.
Parameter b
the second command for comparison.

function is

is: (arg: unknown) => arg is Command;

function toDefaultLocalizedCommand

toDefaultLocalizedCommand: (command: Command) => Command;

function toLocalizedCommand

toLocalizedCommand: (
    command: Command,
    nlsLabelKey?: string,
    nlsCategoryKey?: string
) => Command;

Utility function to easily translate commands

namespace CommandMenu

namespace CommandMenu {}

function is

is: (node: MenuNode | undefined) => node is CommandMenu;

namespace CompoundMenuNode

namespace CompoundMenuNode {}

function is

is: (node?: unknown) => node is CompoundMenuNode;

function isNavigationGroup

isNavigationGroup: (node: MenuNode) => node is CompoundMenuNode;

Indicates whether the given node is the special navigation menu.
Parameter node
the menu node to check.
Returns
true when the given node is a CompoundMenuNode with id navigation, false otherwise.

function sortChildren

sortChildren: (m1: MenuNode, m2: MenuNode) => number;

namespace Disposable

namespace Disposable {}

variable NULL

const NULL: Disposable;

Always provides a reference to a new disposable.

function create

create: (func: () => void) => Disposable;

function is

is: (arg: unknown) => arg is Disposable;

namespace DisposableGroup

namespace DisposableGroup {}

function canAdd

canAdd: (
    candidate?: DisposableGroup
) => candidate is { add(disposable: Disposable): void };

function canPush

canPush: (
    candidate?: DisposableGroup
) => candidate is { push(disposable: Disposable): void };

namespace Event

namespace Event {}

variable None

const None: Event<any>;

function addMaxListeners

addMaxListeners: (event: Event<unknown>, add: number) => number;

function any

any: {
    <T>(...events: Event<T>[]): Event<T>;
    (...events: Event<any>[]): Event<void>;
};

Given a collection of events, returns a single event which emits whenever any of the provided events emit.

function filter

filter: {
    <T>(event: Event<T>, predicate: (e: T) => unknown): Event<T>;
    <T, S extends T>(event: Event<T>, predicate: (e: T) => e is S): Event<S>;
};

function getMaxListeners

getMaxListeners: (event: Event<unknown>) => number;

function map

map: <I, O>(event: Event<I>, mapFunc: (i: I) => O) => Event<O>;

Given an event and a map function, returns another event which maps each element through the mapping function.

function once

once: <T>(event: Event<T>) => Event<T>;

Given an event, returns another event which only fires once.

function setMaxListeners

setMaxListeners: <N extends number>(event: Event<unknown>, maxListeners: N) => N;

function toPromise

toPromise: <T>(event: Event<T>) => Promise<T>;

namespace file-icons-js

module 'file-icons-js' {}

function getClass

getClass: (filePath: string) => string;

function getClassWithColor

getClassWithColor: (filePath: string) => string;

namespace Group

namespace Group {}

function is

is: (obj: unknown) => obj is CompoundMenuNode;

namespace Listener

namespace Listener {}

variable None

const None: Registration<void, void>;

function awaitAll

awaitAll: <T, U>(value: T, list: ListenerList<T, Promise<U>>) => Promise<U[]>;

Convenience function to await all listener invocations
Parameter value
The value to invoke the listeners with
Parameter list
the listener list to invoke
Returns
the return values from the listener invocation

type Registration

type Registration<T, U = void> = (listener: (e: T) => U) => Disposable;

namespace LogLevel

namespace LogLevel {}

variable strings

const strings: Map<LogLevel, string>;

function fromString

fromString: (levelStr: string) => LogLevel | undefined;

function toString

toString: (level: LogLevel) => string | undefined;

namespace MapUtils

namespace MapUtils {}

function addOrInsertWith

addOrInsertWith: <K, V>(container: Map<K, V[]>, key: K, ...values: V[]) => void;

namespace MenuAction

namespace MenuAction {}

function is

is: (obj: unknown) => obj is MenuAction;

namespace MutableCompoundMenuNode

namespace MutableCompoundMenuNode {}

function is

is: (node: unknown) => node is MutableCompoundMenuNode;

namespace native-keymap

module 'native-keymap' {}

function getCurrentKeyboardLayout

getCurrentKeyboardLayout: () => IKeyboardLayoutInfo;

function getKeyMap

getKeyMap: () => IKeyboardMapping;

function isISOKeyboard

isISOKeyboard: () => boolean;

function onDidChangeKeyboardLayout

onDidChangeKeyboardLayout: (callback: () => void) => void;

interface ILinuxKeyboardLayoutInfo

interface ILinuxKeyboardLayoutInfo {}

property layout

layout: string;

property model

model: string;

property options

options: string;

property rules

rules: string;

property variant

variant: string;

interface ILinuxKeyboardMapping

interface ILinuxKeyboardMapping {}

index signature

[code: string]: ILinuxKeyMapping;

interface ILinuxKeyMapping

interface ILinuxKeyMapping {}

property value

value: string;

property withAltGr

withAltGr: string;

property withShift

withShift: string;

property withShiftAltGr

withShiftAltGr: string;

interface IMacKeyboardLayoutInfo

interface IMacKeyboardLayoutInfo {}

property id

id: string;

property lang

lang: string;

interface IMacKeyboardMapping

interface IMacKeyboardMapping {}

index signature

[code: string]: IMacKeyMapping;

interface IMacKeyMapping

interface IMacKeyMapping {}

property value

value: string;

property valueIsDeadKey

valueIsDeadKey: boolean;

property withAltGr

withAltGr: string;

property withAltGrIsDeadKey

withAltGrIsDeadKey: boolean;

property withShift

withShift: string;

property withShiftAltGr

withShiftAltGr: string;

property withShiftAltGrIsDeadKey

withShiftAltGrIsDeadKey: boolean;

property withShiftIsDeadKey

withShiftIsDeadKey: boolean;

interface IWindowsKeyboardLayoutInfo

interface IWindowsKeyboardLayoutInfo {}

property id

id: string;

property name

name: string;

property text

text: string;

interface IWindowsKeyboardMapping

interface IWindowsKeyboardMapping {}

index signature

[code: string]: IWindowsKeyMapping;

interface IWindowsKeyMapping

interface IWindowsKeyMapping {}

property value

value: string;

property vkey

vkey: string;

property withAltGr

withAltGr: string;

property withShift

withShift: string;

property withShiftAltGr

withShiftAltGr: string;

type IKeyboardLayoutInfo

type IKeyboardLayoutInfo =
    | IWindowsKeyboardLayoutInfo
    | ILinuxKeyboardLayoutInfo
    | IMacKeyboardLayoutInfo;

type IKeyboardMapping

type IKeyboardMapping =
    | IWindowsKeyboardMapping
    | ILinuxKeyboardMapping
    | IMacKeyboardMapping;

namespace nls

namespace nls {}

variable defaultLocale

const defaultLocale: string;

variable locale

const locale: string;

variable localeId

const localeId: string;

variable localization

let localization: Localization;

function getDefaultKey

getDefaultKey: (defaultValue: string) => string;

function isSelectedLocale

isSelectedLocale: (id: string) => boolean;

function localize

localize: (key: string, defaultValue: string, ...args: FormatType[]) => string;

function localizeByDefault

localizeByDefault: (defaultValue: string, ...args: FormatType[]) => string;

Automatically localizes a text if that text also exists in the vscode repository.

function setHtmlLang

setHtmlLang: (element: HTMLElement) => void;

Sets the 'lang' attribute on the given HTML element based on the current locale. If no locale is set, defaults to 'en' (English). Typically used with document.documentElement (the tag) to set the page language.
Parameter element
The HTML element to set the language attribute on

function setHtmlNoTranslate

setHtmlNoTranslate: (element: HTMLElement) => void;

Sets the 'translate' attribute to 'no' and adds the 'notranslate' class to the given HTML element. This prevents translation tools from translating the content of the element. Typically used with document.documentElement (the tag) to disable page translation.
Parameter element
The HTML element to set translation attributes on

function setLocale

setLocale: (id: string) => void;

namespace OS

namespace OS {}

variable backend

const backend: {
    type: typeof type;
    isWindows: boolean;
    isOSX: boolean;
    EOL: string;
};

function type

type: () => OS.Type;

Returns with the type of the operating system. If it is neither [Windows](isWindows) nor [OS X](isOSX), then it always return with the Linux OS type.

enum Type

enum Type {
    Windows = 'Windows',
    Linux = 'Linux',
    OSX = 'OSX',
}

Enumeration of the supported operating systems.

member Linux

Linux = 'Linux'

member OSX

OSX = 'OSX'

member Windows

Windows = 'Windows'

namespace OverridePreferenceName

namespace OverridePreferenceName {}

function is

is: (arg: unknown) => arg is OverridePreferenceName;

namespace Path

namespace Path {}

enum Format

enum Format {
    Posix = 0,
    Windows = 1,
}

member Posix

Posix = 0

member Windows

Windows = 1

namespace PreferenceProviderDataChange

namespace PreferenceProviderDataChange {}

function affects

affects: (change: PreferenceProviderDataChange, resourceUri?: string) => boolean;

namespace PreferenceScope

namespace PreferenceScope {}

function getReversedScopes

getReversedScopes: () => PreferenceScope[];

Returns
preference scopes from narrowest to broadest. Folder -> Default.

function getScopeNames

getScopeNames: (scope?: PreferenceScope) => string[];

function getScopes

getScopes: () => PreferenceScope[];

Returns
preference scopes from broadest to narrowest: Default -> Folder.

function is

is: (scope: unknown) => scope is PreferenceScope;

namespace PreferenceUtils

namespace PreferenceUtils {}

function deepEqual

deepEqual: (a: JSONValue | undefined, b: JSONValue | undefined) => boolean;

Handles deep equality with the possibility of undefined

function merge

merge: (source: JSONValue | undefined, target: JSONValue) => JSONValue;

namespace Prioritizeable

namespace Prioritizeable {}

function compare

compare: <T>(p: Prioritizeable<T>, p2: Prioritizeable<T>) => number;

function isValid

isValid: <T>(p: Prioritizeable<T>) => boolean;

function prioritizeAll

prioritizeAll: <T>(
    values: MaybePromise<T>[],
    getPriority: GetPriority<T>
) => Promise<Prioritizeable<T>[]>;

function prioritizeAllSync

prioritizeAllSync: <T>(
    values: T[],
    getPriority: GetPrioritySync<T>
) => Prioritizeable<T>[];

function toPrioritizeable

toPrioritizeable: {
    <T>(rawValue: MaybePromise<T>, getPriority: GetPriority<T>): Promise<
        Prioritizeable<T>
    >;
    <T>(rawValue: MaybePromise<T>[], getPriority: GetPriority<T>): Promise<
        Prioritizeable<T>[]
    >;
};

function toPrioritizeableSync

toPrioritizeableSync: <T>(
    rawValue: T[],
    getPriority: GetPrioritySync<T>
) => Prioritizeable<T>[];

type GetPriority

type GetPriority<T> = (value: T) => MaybePromise<number>;

type GetPrioritySync

type GetPrioritySync<T> = (value: T) => number;

namespace ProgressMessage

namespace ProgressMessage {}

variable Cancel

const Cancel: string;

function isCancelable

isCancelable: (message: ProgressMessage) => boolean;

namespace QuickPickItem

namespace QuickPickItem {}

function is

is: (item: QuickPickSeparator | QuickPickItem) => item is QuickPickItem;

namespace QuickPickSeparator

namespace QuickPickSeparator {}

function is

is: (item: QuickPickItemOrSeparator) => item is QuickPickSeparator;

namespace RenderedMenuNode

namespace RenderedMenuNode {}

function is

is: (node: unknown) => node is RenderedMenuNode;

namespace Resource

namespace Resource {}

function save

save: (
    resource: Resource,
    context: SaveContext,
    token?: CancellationToken
) => Promise<void>;

function shouldSaveContent

shouldSaveContent: (
    resource: Resource,
    { contentLength, changes }: SaveContext
) => boolean;

function trySaveContentChanges

trySaveContentChanges: (
    resource: Resource,
    context: SaveContext
) => Promise<boolean>;

interface SaveContext

interface SaveContext {}

property changes

changes?: TextDocumentContentChangeEvent[];

property content

content: string | Readable<string>;

property contentLength

contentLength: number;

property options

options?: ResourceSaveOptions;

namespace ResourceError

namespace ResourceError {}

variable NotFound

const NotFound: ApplicationError.Constructor<-40000, { uri: URI }>;

variable OutOfSync

const OutOfSync: ApplicationError.Constructor<-40001, { uri: URI }>;

namespace StructuralMenuChange

namespace StructuralMenuChange {}

function is

is: (evt: MenuChangedEvent) => evt is StructuralMenuChange;

namespace TextDocumentContentChangeDelta

namespace TextDocumentContentChangeDelta {}

function is

is: (arg: unknown) => arg is TextDocumentContentChangeDelta;

namespace UriSelection

namespace UriSelection {}

function getUri

getUri: (selection: unknown) => URI | undefined;

function getUris

getUris: (selection: unknown) => URI[];

function is

is: (arg: unknown) => arg is UriSelection;

namespace WaitUntilEvent

namespace WaitUntilEvent {}

function fire

fire: <T extends WaitUntilEvent>(
    emitter: Emitter<T>,
    event: WaitUntilData<T>,
    timeout?: number,
    token?: CancellationToken
) => Promise<void>;

Fire all listeners in the same tick.
Use AsyncEmitter.fire to fire listeners async one after another.

Package Files (70)

Dependencies (70)

Dev Dependencies (4)

Peer Dependencies (1)

@theia/electron

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@theia/core.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@theia/core)

HTML

<a href="https://www.jsdocs.io/package/@theia/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 second ago.
Package analyzed in 23645 ms.
Missing or incorrect documentation? Open an issue for this package.

@theia/core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ACCOUNTS_MENU

variable ACCOUNTS_SUBMENU

variable BackendStopwatch

variable BackendStopwatchOptions

variable CommandContribution

variable CommandService

variable commandServicePath

variable ConnectionHandler

variable ContributionFilterRegistry

variable ContributionProvider

variable CorePreferenceContribution

variable CorePreferences

variable corePreferenceSchema

variable DefaultSanitizationRules

variable EOL

variable Filter

variable FilterContribution

variable ILogger

variable isOSX

variable isWindows

variable LINUX_ENV_HINT

variable logger

variable LoggerFactory

variable LoggerName

variable LoggerSanitizer

variable MAIN_MENU_BAR

variable MANAGE_MENU

variable MAX_SAFE_INTEGER

variable MEMORY_TEXT

variable MEMORY_TEXT_READONLY

variable MenuContribution

variable MenuNodeFactory

variable messageServicePath

variable NO_OVERRIDE

variable OSBackendProvider

variable OSBackendProviderPath

variable OVERRIDE_PROPERTY

variable OVERRIDE_PROPERTY_PATTERN

variable PREFERENCE_NAME_TREE_INDENT

variable PreferenceConfiguration

variable PreferenceContribution

variable PreferenceProvider

variable PreferenceProviderProvider

variable PreferenceProxyFactory

variable PreferenceProxyOptions

variable PreferenceProxySchema

variable PreferenceSchemaService

variable PreferenceService

variable ProgressClient

variable QuickInputService

variable quickInputServicePath

variable QuickPickService

variable quickPickServicePath

variable ResourceProvider

variable ResourceResolver

variable rootLoggerName

variable servicesPath

variable stopwatchPath

variable THEIA_VERSION

variable TreePreferences

variable treePreferencesSchema

variable UNTITLED_SCHEME

variable ValidPreferenceScopes

Functions

function bindContribution

Parameter bindable

Parameter service

Parameter contributions