UNPKG

monaco-editor-core

Version:

A browser based code editor

1,721 lines (1,624 loc) • 255 kB
/*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ declare global { let MonacoEnvironment: Environment | undefined; } interface Window { MonacoEnvironment?: Environment | undefined; } export type Thenable<T> = PromiseLike<T>; export interface Environment { /** * Define a global `monaco` symbol. * This is true by default in AMD and false by default in ESM. */ globalAPI?: boolean; /** * The base url where the editor sources are found (which contains the vs folder) */ baseUrl?: string; /** * A web worker factory. * NOTE: If `getWorker` is defined, `getWorkerUrl` is not invoked. */ getWorker?(workerId: string, label: string): Promise<Worker> | Worker; /** * Return the location for web worker scripts. * NOTE: If `getWorker` is defined, `getWorkerUrl` is not invoked. */ getWorkerUrl?(workerId: string, label: string): string; /** * Create a trusted types policy (same API as window.trustedTypes.createPolicy) */ createTrustedTypesPolicy?( policyName: string, policyOptions?: ITrustedTypePolicyOptions, ): undefined | ITrustedTypePolicy; } export interface ITrustedTypePolicyOptions { createHTML?: (input: string, ...arguments: any[]) => string; createScript?: (input: string, ...arguments: any[]) => string; createScriptURL?: (input: string, ...arguments: any[]) => string; } export interface ITrustedTypePolicy { readonly name: string; createHTML?(input: string): any; createScript?(input: string): any; createScriptURL?(input: string): any; } export interface IDisposable { dispose(): void; } export interface IEvent<T> { (listener: (e: T) => any, thisArg?: any): IDisposable; } /** * A helper that allows to emit and listen to typed events */ export class Emitter<T> { constructor(); readonly event: IEvent<T>; fire(event: T): void; dispose(): void; } export enum MarkerTag { Unnecessary = 1, Deprecated = 2 } export enum MarkerSeverity { Hint = 1, Info = 2, Warning = 4, Error = 8 } export class CancellationTokenSource { constructor(parent?: CancellationToken); get token(): CancellationToken; cancel(): void; dispose(cancel?: boolean): void; } export interface CancellationToken { /** * A flag signalling is cancellation has been requested. */ readonly isCancellationRequested: boolean; /** * An event which fires when cancellation is requested. This event * only ever fires `once` as cancellation can only happen once. Listeners * that are registered after cancellation will be called (next event loop run), * but also only once. * * @event */ readonly onCancellationRequested: (listener: (e: any) => any, thisArgs?: any, disposables?: IDisposable[]) => IDisposable; } /** * Uniform Resource Identifier (Uri) http://tools.ietf.org/html/rfc3986. * This class is a simple parser which creates the basic component parts * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation * and encoding. * * ```txt * foo://example.com:8042/over/there?name=ferret#nose * \_/ \______________/\_________/ \_________/ \__/ * | | | | | * scheme authority path query fragment * | _____________________|__ * / \ / \ * urn:example:animal:ferret:nose * ``` */ export class Uri implements UriComponents { static isUri(thing: any): thing is Uri; /** * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'. * The part before the first colon. */ readonly scheme: string; /** * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'. * The part between the first double slashes and the next slash. */ readonly authority: string; /** * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'. */ readonly path: string; /** * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'. */ readonly query: string; /** * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'. */ readonly fragment: string; /** * Returns a string representing the corresponding file system path of this Uri. * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the * platform specific path separator. * * * Will *not* validate the path for invalid characters and semantics. * * Will *not* look at the scheme of this Uri. * * The result shall *not* be used for display purposes but for accessing a file on disk. * * * The *difference* to `Uri#path` is the use of the platform specific separator and the handling * of UNC paths. See the below sample of a file-uri with an authority (UNC path). * * ```ts const u = Uri.parse('file://server/c$/folder/file.txt') u.authority === 'server' u.path === '/shares/c$/file.txt' u.fsPath === '\\server\c$\folder\file.txt' ``` * * Using `Uri#path` to read a file (using fs-apis) would not be enough because parts of the path, * namely the server name, would be missing. Therefore `Uri#fsPath` exists - it's sugar to ease working * with URIs that represent files on disk (`file` scheme). */ get fsPath(): string; with(change: { scheme?: string; authority?: string | null; path?: string | null; query?: string | null; fragment?: string | null; }): Uri; /** * Creates a new Uri from a string, e.g. `http://www.example.com/some/path`, * `file:///usr/home`, or `scheme:with/path`. * * @param value A string which represents an Uri (see `Uri#toString`). */ static parse(value: string, _strict?: boolean): Uri; /** * Creates a new Uri from a file system path, e.g. `c:\my\files`, * `/usr/home`, or `\\server\share\some\path`. * * The *difference* between `Uri#parse` and `Uri#file` is that the latter treats the argument * as path, not as stringified-uri. E.g. `Uri.file(path)` is **not the same as** * `Uri.parse('file://' + path)` because the path might contain characters that are * interpreted (# and ?). See the following sample: * ```ts const good = Uri.file('/coding/c#/project1'); good.scheme === 'file'; good.path === '/coding/c#/project1'; good.fragment === ''; const bad = Uri.parse('file://' + '/coding/c#/project1'); bad.scheme === 'file'; bad.path === '/coding/c'; // path is now broken bad.fragment === '/project1'; ``` * * @param path A file system path (see `Uri#fsPath`) */ static file(path: string): Uri; /** * Creates new Uri from uri components. * * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs * validation and should be used for untrusted uri components retrieved from storage, * user input, command arguments etc */ static from(components: UriComponents, strict?: boolean): Uri; /** * Join a Uri path with path fragments and normalizes the resulting path. * * @param uri The input Uri. * @param pathFragment The path fragment to add to the Uri path. * @returns The resulting Uri. */ static joinPath(uri: Uri, ...pathFragment: string[]): Uri; /** * Creates a string representation for this Uri. It's guaranteed that calling * `Uri.parse` with the result of this function creates an Uri which is equal * to this Uri. * * * The result shall *not* be used for display purposes but for externalization or transport. * * The result will be encoded using the percentage encoding and encoding happens mostly * ignore the scheme-specific encoding rules. * * @param skipEncoding Do not encode the result, default is `false` */ toString(skipEncoding?: boolean): string; toJSON(): UriComponents; /** * A helper function to revive URIs. * * **Note** that this function should only be used when receiving Uri#toJSON generated data * and that it doesn't do any validation. Use {@link Uri.from} when received "untrusted" * uri components such as command arguments or data from storage. * * @param data The Uri components or Uri to revive. * @returns The revived Uri or undefined or null. */ static revive(data: UriComponents | Uri): Uri; static revive(data: UriComponents | Uri | undefined): Uri | undefined; static revive(data: UriComponents | Uri | null): Uri | null; static revive(data: UriComponents | Uri | undefined | null): Uri | undefined | null; } export interface UriComponents { scheme: string; authority?: string; path?: string; query?: string; fragment?: string; } /** * Virtual Key Codes, the value does not hold any inherent meaning. * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx * But these are "more general", as they should work across browsers & OS`s. */ export enum KeyCode { DependsOnKbLayout = -1, /** * Placed first to cover the 0 value of the enum. */ Unknown = 0, Backspace = 1, Tab = 2, Enter = 3, Shift = 4, Ctrl = 5, Alt = 6, PauseBreak = 7, CapsLock = 8, Escape = 9, Space = 10, PageUp = 11, PageDown = 12, End = 13, Home = 14, LeftArrow = 15, UpArrow = 16, RightArrow = 17, DownArrow = 18, Insert = 19, Delete = 20, Digit0 = 21, Digit1 = 22, Digit2 = 23, Digit3 = 24, Digit4 = 25, Digit5 = 26, Digit6 = 27, Digit7 = 28, Digit8 = 29, Digit9 = 30, KeyA = 31, KeyB = 32, KeyC = 33, KeyD = 34, KeyE = 35, KeyF = 36, KeyG = 37, KeyH = 38, KeyI = 39, KeyJ = 40, KeyK = 41, KeyL = 42, KeyM = 43, KeyN = 44, KeyO = 45, KeyP = 46, KeyQ = 47, KeyR = 48, KeyS = 49, KeyT = 50, KeyU = 51, KeyV = 52, KeyW = 53, KeyX = 54, KeyY = 55, KeyZ = 56, Meta = 57, ContextMenu = 58, F1 = 59, F2 = 60, F3 = 61, F4 = 62, F5 = 63, F6 = 64, F7 = 65, F8 = 66, F9 = 67, F10 = 68, F11 = 69, F12 = 70, F13 = 71, F14 = 72, F15 = 73, F16 = 74, F17 = 75, F18 = 76, F19 = 77, F20 = 78, F21 = 79, F22 = 80, F23 = 81, F24 = 82, NumLock = 83, ScrollLock = 84, /** * Used for miscellaneous characters; it can vary by keyboard. * For the US standard keyboard, the ';:' key */ Semicolon = 85, /** * For any country/region, the '+' key * For the US standard keyboard, the '=+' key */ Equal = 86, /** * For any country/region, the ',' key * For the US standard keyboard, the ',<' key */ Comma = 87, /** * For any country/region, the '-' key * For the US standard keyboard, the '-_' key */ Minus = 88, /** * For any country/region, the '.' key * For the US standard keyboard, the '.>' key */ Period = 89, /** * Used for miscellaneous characters; it can vary by keyboard. * For the US standard keyboard, the '/?' key */ Slash = 90, /** * Used for miscellaneous characters; it can vary by keyboard. * For the US standard keyboard, the '`~' key */ Backquote = 91, /** * Used for miscellaneous characters; it can vary by keyboard. * For the US standard keyboard, the '[{' key */ BracketLeft = 92, /** * Used for miscellaneous characters; it can vary by keyboard. * For the US standard keyboard, the '\|' key */ Backslash = 93, /** * Used for miscellaneous characters; it can vary by keyboard. * For the US standard keyboard, the ']}' key */ BracketRight = 94, /** * Used for miscellaneous characters; it can vary by keyboard. * For the US standard keyboard, the ''"' key */ Quote = 95, /** * Used for miscellaneous characters; it can vary by keyboard. */ OEM_8 = 96, /** * Either the angle bracket key or the backslash key on the RT 102-key keyboard. */ IntlBackslash = 97, Numpad0 = 98,// VK_NUMPAD0, 0x60, Numeric keypad 0 key Numpad1 = 99,// VK_NUMPAD1, 0x61, Numeric keypad 1 key Numpad2 = 100,// VK_NUMPAD2, 0x62, Numeric keypad 2 key Numpad3 = 101,// VK_NUMPAD3, 0x63, Numeric keypad 3 key Numpad4 = 102,// VK_NUMPAD4, 0x64, Numeric keypad 4 key Numpad5 = 103,// VK_NUMPAD5, 0x65, Numeric keypad 5 key Numpad6 = 104,// VK_NUMPAD6, 0x66, Numeric keypad 6 key Numpad7 = 105,// VK_NUMPAD7, 0x67, Numeric keypad 7 key Numpad8 = 106,// VK_NUMPAD8, 0x68, Numeric keypad 8 key Numpad9 = 107,// VK_NUMPAD9, 0x69, Numeric keypad 9 key NumpadMultiply = 108,// VK_MULTIPLY, 0x6A, Multiply key NumpadAdd = 109,// VK_ADD, 0x6B, Add key NUMPAD_SEPARATOR = 110,// VK_SEPARATOR, 0x6C, Separator key NumpadSubtract = 111,// VK_SUBTRACT, 0x6D, Subtract key NumpadDecimal = 112,// VK_DECIMAL, 0x6E, Decimal key NumpadDivide = 113,// VK_DIVIDE, 0x6F, /** * Cover all key codes when IME is processing input. */ KEY_IN_COMPOSITION = 114, ABNT_C1 = 115,// Brazilian (ABNT) Keyboard ABNT_C2 = 116,// Brazilian (ABNT) Keyboard AudioVolumeMute = 117, AudioVolumeUp = 118, AudioVolumeDown = 119, BrowserSearch = 120, BrowserHome = 121, BrowserBack = 122, BrowserForward = 123, MediaTrackNext = 124, MediaTrackPrevious = 125, MediaStop = 126, MediaPlayPause = 127, LaunchMediaPlayer = 128, LaunchMail = 129, LaunchApp2 = 130, /** * VK_CLEAR, 0x0C, CLEAR key */ Clear = 131, /** * Placed last to cover the length of the enum. * Please do not depend on this value! */ MAX_VALUE = 132 } export class KeyMod { static readonly CtrlCmd: number; static readonly Shift: number; static readonly Alt: number; static readonly WinCtrl: number; static chord(firstPart: number, secondPart: number): number; } export interface IMarkdownString { readonly value: string; readonly isTrusted?: boolean | MarkdownStringTrustedOptions; readonly supportThemeIcons?: boolean; readonly supportHtml?: boolean; readonly baseUri?: UriComponents; uris?: { [href: string]: UriComponents; }; } export interface MarkdownStringTrustedOptions { readonly enabledCommands: readonly string[]; } export interface IKeyboardEvent { readonly _standardKeyboardEventBrand: true; readonly browserEvent: KeyboardEvent; readonly target: HTMLElement; readonly ctrlKey: boolean; readonly shiftKey: boolean; readonly altKey: boolean; readonly metaKey: boolean; readonly altGraphKey: boolean; readonly keyCode: KeyCode; readonly code: string; equals(keybinding: number): boolean; preventDefault(): void; stopPropagation(): void; } export interface IMouseEvent { readonly browserEvent: MouseEvent; readonly leftButton: boolean; readonly middleButton: boolean; readonly rightButton: boolean; readonly buttons: number; readonly target: HTMLElement; readonly detail: number; readonly posx: number; readonly posy: number; readonly ctrlKey: boolean; readonly shiftKey: boolean; readonly altKey: boolean; readonly metaKey: boolean; readonly timestamp: number; preventDefault(): void; stopPropagation(): void; } export interface IScrollEvent { readonly scrollTop: number; readonly scrollLeft: number; readonly scrollWidth: number; readonly scrollHeight: number; readonly scrollTopChanged: boolean; readonly scrollLeftChanged: boolean; readonly scrollWidthChanged: boolean; readonly scrollHeightChanged: boolean; } /** * A position in the editor. This interface is suitable for serialization. */ export interface IPosition { /** * line number (starts at 1) */ readonly lineNumber: number; /** * column (the first character in a line is between column 1 and column 2) */ readonly column: number; } /** * A position in the editor. */ export class Position { /** * line number (starts at 1) */ readonly lineNumber: number; /** * column (the first character in a line is between column 1 and column 2) */ readonly column: number; constructor(lineNumber: number, column: number); /** * Create a new position from this position. * * @param newLineNumber new line number * @param newColumn new column */ with(newLineNumber?: number, newColumn?: number): Position; /** * Derive a new position from this position. * * @param deltaLineNumber line number delta * @param deltaColumn column delta */ delta(deltaLineNumber?: number, deltaColumn?: number): Position; /** * Test if this position equals other position */ equals(other: IPosition): boolean; /** * Test if position `a` equals position `b` */ static equals(a: IPosition | null, b: IPosition | null): boolean; /** * Test if this position is before other position. * If the two positions are equal, the result will be false. */ isBefore(other: IPosition): boolean; /** * Test if position `a` is before position `b`. * If the two positions are equal, the result will be false. */ static isBefore(a: IPosition, b: IPosition): boolean; /** * Test if this position is before other position. * If the two positions are equal, the result will be true. */ isBeforeOrEqual(other: IPosition): boolean; /** * Test if position `a` is before position `b`. * If the two positions are equal, the result will be true. */ static isBeforeOrEqual(a: IPosition, b: IPosition): boolean; /** * A function that compares positions, useful for sorting */ static compare(a: IPosition, b: IPosition): number; /** * Clone this position. */ clone(): Position; /** * Convert to a human-readable representation. */ toString(): string; /** * Create a `Position` from an `IPosition`. */ static lift(pos: IPosition): Position; /** * Test if `obj` is an `IPosition`. */ static isIPosition(obj: any): obj is IPosition; toJSON(): IPosition; } /** * A range in the editor. This interface is suitable for serialization. */ export interface IRange { /** * Line number on which the range starts (starts at 1). */ readonly startLineNumber: number; /** * Column on which the range starts in line `startLineNumber` (starts at 1). */ readonly startColumn: number; /** * Line number on which the range ends. */ readonly endLineNumber: number; /** * Column on which the range ends in line `endLineNumber`. */ readonly endColumn: number; } /** * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn) */ export class Range { /** * Line number on which the range starts (starts at 1). */ readonly startLineNumber: number; /** * Column on which the range starts in line `startLineNumber` (starts at 1). */ readonly startColumn: number; /** * Line number on which the range ends. */ readonly endLineNumber: number; /** * Column on which the range ends in line `endLineNumber`. */ readonly endColumn: number; constructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number); /** * Test if this range is empty. */ isEmpty(): boolean; /** * Test if `range` is empty. */ static isEmpty(range: IRange): boolean; /** * Test if position is in this range. If the position is at the edges, will return true. */ containsPosition(position: IPosition): boolean; /** * Test if `position` is in `range`. If the position is at the edges, will return true. */ static containsPosition(range: IRange, position: IPosition): boolean; /** * Test if range is in this range. If the range is equal to this range, will return true. */ containsRange(range: IRange): boolean; /** * Test if `otherRange` is in `range`. If the ranges are equal, will return true. */ static containsRange(range: IRange, otherRange: IRange): boolean; /** * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true. */ strictContainsRange(range: IRange): boolean; /** * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false. */ static strictContainsRange(range: IRange, otherRange: IRange): boolean; /** * A reunion of the two ranges. * The smallest position will be used as the start point, and the largest one as the end point. */ plusRange(range: IRange): Range; /** * A reunion of the two ranges. * The smallest position will be used as the start point, and the largest one as the end point. */ static plusRange(a: IRange, b: IRange): Range; /** * A intersection of the two ranges. */ intersectRanges(range: IRange): Range | null; /** * A intersection of the two ranges. */ static intersectRanges(a: IRange, b: IRange): Range | null; /** * Test if this range equals other. */ equalsRange(other: IRange | null | undefined): boolean; /** * Test if range `a` equals `b`. */ static equalsRange(a: IRange | null | undefined, b: IRange | null | undefined): boolean; /** * Return the end position (which will be after or equal to the start position) */ getEndPosition(): Position; /** * Return the end position (which will be after or equal to the start position) */ static getEndPosition(range: IRange): Position; /** * Return the start position (which will be before or equal to the end position) */ getStartPosition(): Position; /** * Return the start position (which will be before or equal to the end position) */ static getStartPosition(range: IRange): Position; /** * Transform to a user presentable string representation. */ toString(): string; /** * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position. */ setEndPosition(endLineNumber: number, endColumn: number): Range; /** * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position. */ setStartPosition(startLineNumber: number, startColumn: number): Range; /** * Create a new empty range using this range's start position. */ collapseToStart(): Range; /** * Create a new empty range using this range's start position. */ static collapseToStart(range: IRange): Range; /** * Create a new empty range using this range's end position. */ collapseToEnd(): Range; /** * Create a new empty range using this range's end position. */ static collapseToEnd(range: IRange): Range; /** * Moves the range by the given amount of lines. */ delta(lineCount: number): Range; static fromPositions(start: IPosition, end?: IPosition): Range; /** * Create a `Range` from an `IRange`. */ static lift(range: undefined | null): null; static lift(range: IRange): Range; static lift(range: IRange | undefined | null): Range | null; /** * Test if `obj` is an `IRange`. */ static isIRange(obj: any): obj is IRange; /** * Test if the two ranges are touching in any way. */ static areIntersectingOrTouching(a: IRange, b: IRange): boolean; /** * Test if the two ranges are intersecting. If the ranges are touching it returns true. */ static areIntersecting(a: IRange, b: IRange): boolean; /** * A function that compares ranges, useful for sorting ranges * It will first compare ranges on the startPosition and then on the endPosition */ static compareRangesUsingStarts(a: IRange | null | undefined, b: IRange | null | undefined): number; /** * A function that compares ranges, useful for sorting ranges * It will first compare ranges on the endPosition and then on the startPosition */ static compareRangesUsingEnds(a: IRange, b: IRange): number; /** * Test if the range spans multiple lines. */ static spansMultipleLines(range: IRange): boolean; toJSON(): IRange; } /** * A selection in the editor. * The selection is a range that has an orientation. */ export interface ISelection { /** * The line number on which the selection has started. */ readonly selectionStartLineNumber: number; /** * The column on `selectionStartLineNumber` where the selection has started. */ readonly selectionStartColumn: number; /** * The line number on which the selection has ended. */ readonly positionLineNumber: number; /** * The column on `positionLineNumber` where the selection has ended. */ readonly positionColumn: number; } /** * A selection in the editor. * The selection is a range that has an orientation. */ export class Selection extends Range { /** * The line number on which the selection has started. */ readonly selectionStartLineNumber: number; /** * The column on `selectionStartLineNumber` where the selection has started. */ readonly selectionStartColumn: number; /** * The line number on which the selection has ended. */ readonly positionLineNumber: number; /** * The column on `positionLineNumber` where the selection has ended. */ readonly positionColumn: number; constructor(selectionStartLineNumber: number, selectionStartColumn: number, positionLineNumber: number, positionColumn: number); /** * Transform to a human-readable representation. */ toString(): string; /** * Test if equals other selection. */ equalsSelection(other: ISelection): boolean; /** * Test if the two selections are equal. */ static selectionsEqual(a: ISelection, b: ISelection): boolean; /** * Get directions (LTR or RTL). */ getDirection(): SelectionDirection; /** * Create a new selection with a different `positionLineNumber` and `positionColumn`. */ setEndPosition(endLineNumber: number, endColumn: number): Selection; /** * Get the position at `positionLineNumber` and `positionColumn`. */ getPosition(): Position; /** * Get the position at the start of the selection. */ getSelectionStart(): Position; /** * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`. */ setStartPosition(startLineNumber: number, startColumn: number): Selection; /** * Create a `Selection` from one or two positions */ static fromPositions(start: IPosition, end?: IPosition): Selection; /** * Creates a `Selection` from a range, given a direction. */ static fromRange(range: Range, direction: SelectionDirection): Selection; /** * Create a `Selection` from an `ISelection`. */ static liftSelection(sel: ISelection): Selection; /** * `a` equals `b`. */ static selectionsArrEqual(a: ISelection[], b: ISelection[]): boolean; /** * Test if `obj` is an `ISelection`. */ static isISelection(obj: any): obj is ISelection; /** * Create with a direction. */ static createWithDirection(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, direction: SelectionDirection): Selection; } /** * The direction of a selection. */ export enum SelectionDirection { /** * The selection starts above where it ends. */ LTR = 0, /** * The selection starts below where it ends. */ RTL = 1 } export class Token { readonly offset: number; readonly type: string; readonly language: string; _tokenBrand: void; constructor(offset: number, type: string, language: string); toString(): string; } export namespace editor { /** * Create a new editor under `domElement`. * `domElement` should be empty (not contain other dom nodes). * The editor will read the size of `domElement`. */ export function create(domElement: HTMLElement, options?: IStandaloneEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneCodeEditor; /** * Emitted when an editor is created. * Creating a diff editor might cause this listener to be invoked with the two editors. * @event */ export function onDidCreateEditor(listener: (codeEditor: ICodeEditor) => void): IDisposable; /** * Emitted when an diff editor is created. * @event */ export function onDidCreateDiffEditor(listener: (diffEditor: IDiffEditor) => void): IDisposable; /** * Get all the created editors. */ export function getEditors(): readonly ICodeEditor[]; /** * Get all the created diff editors. */ export function getDiffEditors(): readonly IDiffEditor[]; /** * Create a new diff editor under `domElement`. * `domElement` should be empty (not contain other dom nodes). * The editor will read the size of `domElement`. */ export function createDiffEditor(domElement: HTMLElement, options?: IStandaloneDiffEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneDiffEditor; export function createMultiFileDiffEditor(domElement: HTMLElement, override?: IEditorOverrideServices): any; /** * Description of a command contribution */ export interface ICommandDescriptor { /** * An unique identifier of the contributed command. */ id: string; /** * Callback that will be executed when the command is triggered. */ run: ICommandHandler; } /** * Add a command. */ export function addCommand(descriptor: ICommandDescriptor): IDisposable; /** * Add an action to all editors. */ export function addEditorAction(descriptor: IActionDescriptor): IDisposable; /** * A keybinding rule. */ export interface IKeybindingRule { keybinding: number; command?: string | null; commandArgs?: any; when?: string | null; } /** * Add a keybinding rule. */ export function addKeybindingRule(rule: IKeybindingRule): IDisposable; /** * Add keybinding rules. */ export function addKeybindingRules(rules: IKeybindingRule[]): IDisposable; /** * Create a new editor model. * You can specify the language that should be set for this model or let the language be inferred from the `uri`. */ export function createModel(value: string, language?: string, uri?: Uri): ITextModel; /** * Change the language for a model. */ export function setModelLanguage(model: ITextModel, mimeTypeOrLanguageId: string): void; /** * Set the markers for a model. */ export function setModelMarkers(model: ITextModel, owner: string, markers: IMarkerData[]): void; /** * Remove all markers of an owner. */ export function removeAllMarkers(owner: string): void; /** * Get markers for owner and/or resource * * @returns list of markers */ export function getModelMarkers(filter: { owner?: string; resource?: Uri; take?: number; }): IMarker[]; /** * Emitted when markers change for a model. * @event */ export function onDidChangeMarkers(listener: (e: readonly Uri[]) => void): IDisposable; /** * Get the model that has `uri` if it exists. */ export function getModel(uri: Uri): ITextModel | null; /** * Get all the created models. */ export function getModels(): ITextModel[]; /** * Emitted when a model is created. * @event */ export function onDidCreateModel(listener: (model: ITextModel) => void): IDisposable; /** * Emitted right before a model is disposed. * @event */ export function onWillDisposeModel(listener: (model: ITextModel) => void): IDisposable; /** * Emitted when a different language is set to a model. * @event */ export function onDidChangeModelLanguage(listener: (e: { readonly model: ITextModel; readonly oldLanguage: string; }) => void): IDisposable; /** * Create a new web worker that has model syncing capabilities built in. * Specify an AMD module to load that will `create` an object that will be proxied. */ export function createWebWorker<T extends object>(opts: IWebWorkerOptions): MonacoWebWorker<T>; /** * Colorize the contents of `domNode` using attribute `data-lang`. */ export function colorizeElement(domNode: HTMLElement, options: IColorizerElementOptions): Promise<void>; /** * Colorize `text` using language `languageId`. */ export function colorize(text: string, languageId: string, options: IColorizerOptions): Promise<string>; /** * Colorize a line in a model. */ export function colorizeModelLine(model: ITextModel, lineNumber: number, tabSize?: number): string; /** * Tokenize `text` using language `languageId` */ export function tokenize(text: string, languageId: string): Token[][]; /** * Define a new theme or update an existing theme. */ export function defineTheme(themeName: string, themeData: IStandaloneThemeData): void; /** * Switches to a theme. */ export function setTheme(themeName: string): void; /** * Clears all cached font measurements and triggers re-measurement. */ export function remeasureFonts(): void; /** * Register a command. */ export function registerCommand(id: string, handler: (accessor: any, ...args: any[]) => void): IDisposable; export interface ILinkOpener { open(resource: Uri): boolean | Promise<boolean>; } /** * Registers a handler that is called when a link is opened in any editor. The handler callback should return `true` if the link was handled and `false` otherwise. * The handler that was registered last will be called first when a link is opened. * * Returns a disposable that can unregister the opener again. */ export function registerLinkOpener(opener: ILinkOpener): IDisposable; /** * Represents an object that can handle editor open operations (e.g. when "go to definition" is called * with a resource other than the current model). */ export interface ICodeEditorOpener { /** * Callback that is invoked when a resource other than the current model should be opened (e.g. when "go to definition" is called). * The callback should return `true` if the request was handled and `false` otherwise. * @param source The code editor instance that initiated the request. * @param resource The Uri of the resource that should be opened. * @param selectionOrPosition An optional position or selection inside the model corresponding to `resource` that can be used to set the cursor. */ openCodeEditor(source: ICodeEditor, resource: Uri, selectionOrPosition?: IRange | IPosition): boolean | Promise<boolean>; } /** * Registers a handler that is called when a resource other than the current model should be opened in the editor (e.g. "go to definition"). * The handler callback should return `true` if the request was handled and `false` otherwise. * * Returns a disposable that can unregister the opener again. * * If no handler is registered the default behavior is to do nothing for models other than the currently attached one. */ export function registerEditorOpener(opener: ICodeEditorOpener): IDisposable; export type BuiltinTheme = 'vs' | 'vs-dark' | 'hc-black' | 'hc-light'; export interface IStandaloneThemeData { base: BuiltinTheme; inherit: boolean; rules: ITokenThemeRule[]; encodedTokensColors?: string[]; colors: IColors; } export type IColors = { [colorId: string]: string; }; export interface ITokenThemeRule { token: string; foreground?: string; background?: string; fontStyle?: string; } /** * A web worker that can provide a proxy to an arbitrary file. */ export interface MonacoWebWorker<T> { /** * Terminate the web worker, thus invalidating the returned proxy. */ dispose(): void; /** * Get a proxy to the arbitrary loaded code. */ getProxy(): Promise<T>; /** * Synchronize (send) the models at `resources` to the web worker, * making them available in the monaco.worker.getMirrorModels(). */ withSyncedResources(resources: Uri[]): Promise<T>; } export interface IWebWorkerOptions { /** * The AMD moduleId to load. * It should export a function `create` that should return the exported proxy. */ moduleId: string; /** * The data to send over when calling create on the module. */ createData?: any; /** * A label to be used to identify the web worker for debugging purposes. */ label?: string; /** * An object that can be used by the web worker to make calls back to the main thread. */ host?: any; /** * Keep idle models. * Defaults to false, which means that idle models will stop syncing after a while. */ keepIdleModels?: boolean; } /** * Description of an action contribution */ export interface IActionDescriptor { /** * An unique identifier of the contributed action. */ id: string; /** * A label of the action that will be presented to the user. */ label: string; /** * Precondition rule. The value should be a [context key expression](https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts). */ precondition?: string; /** * An array of keybindings for the action. */ keybindings?: number[]; /** * The keybinding rule (condition on top of precondition). */ keybindingContext?: string; /** * Control if the action should show up in the context menu and where. * The context menu of the editor has these default: * navigation - The navigation group comes first in all cases. * 1_modification - This group comes next and contains commands that modify your code. * 9_cutcopypaste - The last default group with the basic editing commands. * You can also create your own group. * Defaults to null (don't show in context menu). */ contextMenuGroupId?: string; /** * Control the order in the context menu group. */ contextMenuOrder?: number; /** * Method that will be executed when the action is triggered. * @param editor The editor instance is passed in as a convenience */ run(editor: ICodeEditor, ...args: any[]): void | Promise<void>; } /** * Options which apply for all editors. */ export interface IGlobalEditorOptions { /** * The number of spaces a tab is equal to. * This setting is overridden based on the file contents when `detectIndentation` is on. * Defaults to 4. */ tabSize?: number; /** * Insert spaces when pressing `Tab`. * This setting is overridden based on the file contents when `detectIndentation` is on. * Defaults to true. */ insertSpaces?: boolean; /** * Controls whether `tabSize` and `insertSpaces` will be automatically detected when a file is opened based on the file contents. * Defaults to true. */ detectIndentation?: boolean; /** * Remove trailing auto inserted whitespace. * Defaults to true. */ trimAutoWhitespace?: boolean; /** * Special handling for large files to disable certain memory intensive features. * Defaults to true. */ largeFileOptimizations?: boolean; /** * Controls whether completions should be computed based on words in the document. * Defaults to true. */ wordBasedSuggestions?: 'off' | 'currentDocument' | 'matchingDocuments' | 'allDocuments'; /** * Controls whether word based completions should be included from opened documents of the same language or any language. */ wordBasedSuggestionsOnlySameLanguage?: boolean; /** * Controls whether the semanticHighlighting is shown for the languages that support it. * true: semanticHighlighting is enabled for all themes * false: semanticHighlighting is disabled for all themes * 'configuredByTheme': semanticHighlighting is controlled by the current color theme's semanticHighlighting setting. * Defaults to 'byTheme'. */ 'semanticHighlighting.enabled'?: true | false | 'configuredByTheme'; /** * Keep peek editors open even when double-clicking their content or when hitting `Escape`. * Defaults to false. */ stablePeek?: boolean; /** * Lines above this length will not be tokenized for performance reasons. * Defaults to 20000. */ maxTokenizationLineLength?: number; /** * Theme to be used for rendering. * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black', 'hc-light'. * You can create custom themes via `monaco.editor.defineTheme`. * To switch a theme, use `monaco.editor.setTheme`. * **NOTE**: The theme might be overwritten if the OS is in high contrast mode, unless `autoDetectHighContrast` is set to false. */ theme?: string; /** * If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme. * Defaults to true. */ autoDetectHighContrast?: boolean; } /** * The options to create an editor. */ export interface IStandaloneEditorConstructionOptions extends IEditorConstructionOptions, IGlobalEditorOptions { /** * The initial model associated with this code editor. */ model?: ITextModel | null; /** * The initial value of the auto created model in the editor. * To not automatically create a model, use `model: null`. */ value?: string; /** * The initial language of the auto created model in the editor. * To not automatically create a model, use `model: null`. */ language?: string; /** * Initial theme to be used for rendering. * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black', 'hc-light. * You can create custom themes via `monaco.editor.defineTheme`. * To switch a theme, use `monaco.editor.setTheme`. * **NOTE**: The theme might be overwritten if the OS is in high contrast mode, unless `autoDetectHighContrast` is set to false. */ theme?: string; /** * If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme. * Defaults to true. */ autoDetectHighContrast?: boolean; /** * An URL to open when Ctrl+H (Windows and Linux) or Cmd+H (OSX) is pressed in * the accessibility help dialog in the editor. * * Defaults to "https://go.microsoft.com/fwlink/?linkid=852450" */ accessibilityHelpUrl?: string; /** * Container element to use for ARIA messages. * Defaults to document.body. */ ariaContainerElement?: HTMLElement; } /** * The options to create a diff editor. */ export interface IStandaloneDiffEditorConstructionOptions extends IDiffEditorConstructionOptions { /** * Initial theme to be used for rendering. * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black', 'hc-light. * You can create custom themes via `monaco.editor.defineTheme`. * To switch a theme, use `monaco.editor.setTheme`. * **NOTE**: The theme might be overwritten if the OS is in high contrast mode, unless `autoDetectHighContrast` is set to false. */ theme?: string; /** * If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme. * Defaults to true. */ autoDetectHighContrast?: boolean; } export interface IStandaloneCodeEditor extends ICodeEditor { updateOptions(newOptions: IEditorOptions & IGlobalEditorOptions): void; addCommand(keybinding: number, handler: ICommandHandler, context?: string): string | null; createContextKey<T extends ContextKeyValue = ContextKeyValue>(key: string, defaultValue: T): IContextKey<T>; addAction(descriptor: IActionDescriptor): IDisposable; } export interface IStandaloneDiffEditor extends IDiffEditor { addCommand(keybinding: number, handler: ICommandHandler, context?: string): string | null; createContextKey<T extends ContextKeyValue = ContextKeyValue>(key: string, defaultValue: T): IContextKey<T>; addAction(descriptor: IActionDescriptor): IDisposable; getOriginalEditor(): IStandaloneCodeEditor; getModifiedEditor(): IStandaloneCodeEditor; } export interface ICommandHandler { (...args: any[]): void; } export interface ILocalizedString { original: string; value: string; } export interface ICommandMetadata { readonly description: ILocalizedString | string; } export interface IContextKey<T extends ContextKeyValue = ContextKeyValue> { set(value: T): void; reset(): void; get(): T | undefined; } export type ContextKeyValue = null | undefined | boolean | number | string | Array<null | undefined | boolean | number | string> | Record<string, null | undefined | boolean | number | string>; export interface IEditorOverrideServices { [index: string]: any; } export interface IMarker { owner: string; resource: Uri; severity: MarkerSeverity; code?: string | { value: string; target: Uri; }; message: string; source?: string; startLineNumber: number; startColumn: number; endLineNumber: number; endColumn: number; modelVersionId?: number; relatedInformation?: IRelatedInformation[]; tags?: MarkerTag[]; } /** * A structure defining a problem/warning/etc. */ export interface IMarkerData { code?: string | { value: string; target: Uri; }; severity: MarkerSeverity; message: string; source?: string; startLineNumber: number; startColumn: number; endLineNumber: number; endColumn: number; modelVersionId?: number; relatedInformation?: IRelatedInformation[]; tags?: MarkerTag[]; } /** * */ export interface IRelatedInformation { resource: Uri; message: string; startLineNumber: number; startColumn: number; endLineNumber: number; endColumn: number; } export interface IColorizerOptions { tabSize?: number; } export interface IColorizerElementOptions extends IColorizerOptions { theme?: string; mimeType?: string; } export enum ScrollbarVisibility { Auto = 1, Hidden = 2, Visible = 3 } export interface ThemeColor { id: string; } /** * A single edit operation, that acts as a simple replace. * i.e. Replace text at `range` with `text` in model. */ export interface ISingleEditOperation { /** * The range to replace. This can be empty to emulate a simple insert. */ range: IRange; /** * The text to replace with. This can be null to emulate a simple delete. */ text: string | null; /** * This indicates that this operation has "insert" semantics. * i.e. forceMoveMarkers = true => if `range` is collapsed, all markers at the position will be moved. */ forceMoveMarkers?: boolean; } /** * Word inside a model. */ export interface IWordAtPosition { /** * The word. */ readonly word: string; /** * The column where the word starts. */ readonly startColumn: number; /** * The column where the word ends. */ readonly endColumn: number; } /** * Vertical Lane in the overview ruler of the editor. */ export enum OverviewRulerLane { Left = 1, Center = 2, Right = 4, Full = 7 } /** * Vertical Lane in the glyph margin of the editor. */ export enum GlyphMarginLane { Left = 1, Center = 2, Right = 3 } export interface IGlyphMarginLanesModel { /** * The number of lanes that should be rendered in the editor. */ readonly requiredLanes: number; /** * Gets the lanes that should be rendered starting at a given line number. */ getLanesAtLine(lineNumber: number): GlyphMarginLane[]; /** * Resets the model and ensures it can contain at least `maxLine` lines. */ reset(maxLine: number): void; /** * Registers that a lane should be visible at the Range in the model. * @param persist - if true, notes that the lane should always be visible, * even on lines where there's no specific request for that lane. */ push(lane: GlyphMarginLane, range: Range, persist?: boolean): void; } /** * Position in the minimap to render the decoration. */ export enum MinimapPosition { Inline = 1, Gutter = 2 } /** * Section header style. */ export enum MinimapSectionHeaderStyle { Normal = 1, Underlined = 2 } export interface IDecorationOptions { /** * CSS color to render. * e.g.: rgba(100, 100, 100, 0.5) or a color from the color registry */ color: string | ThemeColor | undefined; /** * CSS color to render. * e.g.: rgba(100, 100, 100, 0.5) or a color from the color registry */ darkColor?: string | ThemeColor; } export interface IModelDecorationGlyphMarginOptions { /** * The position in the glyph margin. */ position: GlyphMarginLane; /** * Whether the glyph margin lane in {@link position} should be rendered even * outside of this decoration's range. */ persistLane?: boolean; } /** * Options for rendering a model decoration in the overview ruler. */ export interface IModelDecorationOverviewRulerOptions extends IDecorationOptions { /** * The position in the overview ruler. */ position: OverviewRulerLane; } /** * Options for rendering a model decoration in the minimap. */ export interface IModelDecorationMinimapOptions extends IDecorationOptions { /** * The position in the minimap. */ position: MinimapPosition; /** * If the decoration is for a section header, which header style. */ sectionHeaderStyle?: MinimapSectionHeaderStyle | null; /** * If the decoration is for a section header, the header text. */ sectionHeaderText?: string | null; } /** * Options for a model decoration. */ export interface IModelDecorationOptions { /** * Customize the growing behavior of the decoration when typing at the edges of the decoration. * Defaults to TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */ stickiness?: TrackedRangeStickiness; /** * CSS class name describing the decoration. */ className?: string | null; /** * Indicates whether the decoration should span across the entire line when it continues onto the next line. */ shouldFillLineOnLineBreak?: boolean | null; blockClassName?: string | null; /** * Indicates if this block should be rendered after the last line. * In this case, the range must be empty and set to the last line. */ blockIsAfterEnd?: boolean | null; blockDoesNotCollapse?: boolean | null; blockPadding?: [top: number, right: number, bottom: number, left: number] | null; /** * Message to be rendered when hovering over the glyph margin decoration. */ glyphMarginHoverMessage?: IMarkdownString | IMarkdownString[] | null; /** * Array of MarkdownString to render as the decoration message. */ hoverMessage?: IMarkdownString | IMarkdownString[] | null; /** * Array of MarkdownString to render as the line number message. */ lineNumberHoverMessage?: IMarkdownString | IMarkdownString[] | null; /** * Should the decoration expand to encompass a whole line. */ isWholeLine?: boolean; /** * Always render the decoration (even when the range it encompasses is collapsed). */ showIfCollapsed?: boolean; /** * Specifies the st