import { IDimension } from "../../../../base/browser/dom.js"; import { Orientation } from "../../../../base/browser/ui/splitview/splitview.js"; import { Color } from "../../../../base/common/color.js"; import { Event } from "../../../../base/common/event.js"; import { DisposableStore, IDisposable, type IReference } from "../../../../base/common/lifecycle.js"; import { OperatingSystem } from "../../../../base/common/platform.js"; import { URI, UriComponents } from "../../../../base/common/uri.js"; import { IKeyMods } from "../../../../platform/quickinput/common/quickInput.js"; import { IMarkProperties, ITerminalCapabilityStore, ITerminalCommand } from "../../../../platform/terminal/common/capabilities/capabilities.js"; import { IMergedEnvironmentVariableCollection } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/terminal/common/environmentVariable"; import { IExtensionTerminalProfile, IReconnectionProperties, IShellIntegration, IShellLaunchConfig, ITerminalDimensions, ITerminalLaunchError, ITerminalProfile, ITerminalTabLayoutInfoById, TerminalExitReason, TerminalIcon, TerminalLocation, TerminalShellType, TerminalType, TitleEventSource, WaitOnExitValue, type IDecorationAddon, type ShellIntegrationInjectionFailureReason } from "../../../../platform/terminal/common/terminal.js"; import { IColorTheme } from "../../../../platform/theme/common/themeService.js"; import { IWorkspaceFolder } from "../../../../platform/workspace/common/workspace.js"; import { ITerminalStatusList } from "@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminal/browser/terminalStatusList"; import { XtermTerminal } from "@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal"; import { IRegisterContributedProfileArgs, ITerminalFont, ITerminalProcessInfo } from "../common/terminal.js"; import type { IMarker, ITheme, Terminal as RawXtermTerminal, IBufferRange, IMarker as IXtermMarker } from "@xterm/xterm"; import { ScrollPosition } from "@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/terminal/browser/xterm/markNavigationAddon"; import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js"; import { GroupIdentifier } from "../../../common/editor.js"; import { ACTIVE_GROUP_TYPE, AUX_WINDOW_GROUP_TYPE, SIDE_GROUP_TYPE } from "../../../services/editor/common/editorService.js"; import type { ICurrentPartialCommand } from "../../../../platform/terminal/common/capabilities/commandDetection/terminalCommand.js"; import type { IBufferSet } from "./xterm-private.js"; import type { IMenu } from "../../../../platform/actions/common/actions.js"; import type { IProgressState } from "@xterm/addon-progress"; import type { IEditorOptions } from "../../../../platform/editor/common/editor.js"; import type { MaybePromise } from "../../../../base/common/async.js"; import { type SingleOrMany } from "../../../../base/common/types.js"; /** * A terminal contribution that gets created whenever a terminal is created. A contribution has * access to the process manager through the constructor and provides a method for when xterm.js has * been initialized. */ export interface ITerminalContribution extends IDisposable { layout?(xterm: IXtermTerminal & { raw: RawXtermTerminal; }, dimension: IDimension): void; xtermOpen?(xterm: IXtermTerminal & { raw: RawXtermTerminal; }): void; xtermReady?(xterm: IXtermTerminal & { raw: RawXtermTerminal; }): void; handleMouseEvent?(event: MouseEvent): MaybePromise<{ handled: boolean; } | void>; } /** * Service enabling communication between the chat tool implementation in terminal contrib and workbench contribs. * Acts as a communication mechanism for chat-related terminal features. */ export interface IChatTerminalToolProgressPart { readonly elementIndex: number; readonly contentIndex: number; focusTerminal(): Promise; toggleOutputFromKeyboard(): Promise; focusOutput(): void; getCommandAndOutputAsText(): string | undefined; } export declare enum Direction { Left = 0, Right = 1, Up = 2, Down = 3 } export interface IQuickPickTerminalObject { config: IRegisterContributedProfileArgs | ITerminalProfile | { profile: IExtensionTerminalProfile; options: { icon?: string; color?: string; }; } | undefined; keyMods: IKeyMods | undefined; } export interface IMarkTracker { scrollToPreviousMark(scrollPosition?: ScrollPosition, retainSelection?: boolean, skipEmptyCommands?: boolean): void; scrollToNextMark(): void; selectToPreviousMark(): void; selectToNextMark(): void; selectToPreviousLine(): void; selectToNextLine(): void; clear(): void; scrollToClosestMarker(startMarkerId: string, endMarkerId?: string, highlight?: boolean | undefined): void; scrollToLine(line: number, position: ScrollPosition): void; revealCommand(command: ITerminalCommand | ICurrentPartialCommand | URI, position?: ScrollPosition): void; revealRange(range: IBufferRange): void; registerTemporaryDecoration(marker: IMarker, endMarker: IMarker | undefined, showOutline: boolean): void; showCommandGuide(command: ITerminalCommand | undefined): void; saveScrollState(): void; restoreScrollState(): void; } export interface ITerminalGroup { activeInstance: ITerminalInstance | undefined; terminalInstances: ITerminalInstance[]; title: string; readonly hadFocusOnExit: boolean; readonly onDidDisposeInstance: Event; readonly onDisposed: Event; readonly onInstancesChanged: Event; readonly onPanelOrientationChanged: Event; focusPreviousPane(): void; focusNextPane(): void; resizePane(direction: Direction): void; resizePanes(relativeSizes: number[]): void; setActiveInstanceByIndex(index: number, force?: boolean): void; attachToElement(element: HTMLElement): void; addInstance(instance: ITerminalInstance): void; removeInstance(instance: ITerminalInstance): void; moveInstance(instances: SingleOrMany, index: number, position: "before" | "after"): void; setVisible(visible: boolean): void; layout(width: number, height: number): void; addDisposable(disposable: IDisposable): void; split(shellLaunchConfig: IShellLaunchConfig): ITerminalInstance; getLayoutInfo(isActive: boolean): ITerminalTabLayoutInfoById; } export declare enum TerminalConnectionState { Connecting = 0, Connected = 1 } export interface IDetachedXTermOptions { cols: number; rows: number; colorProvider: IXtermColorProvider; capabilities?: ITerminalCapabilityStore & IDisposable; readonly?: boolean; processInfo: ITerminalProcessInfo; disableOverviewRuler?: boolean; } /** * A generic interface implemented in both the {@link ITerminalInstance} (an * interface used for terminals attached to the terminal panel or editor) and * {@link IDetachedTerminalInstance} (a terminal used elsewhere in VS Code UI). */ export interface IBaseTerminalInstance { readonly capabilities: ITerminalCapabilityStore; /** * DOM element the terminal is mounted in. */ readonly domElement?: HTMLElement; /** * Current selection in the terminal. */ readonly selection: string | undefined; /** * Check if anything is selected in terminal. */ hasSelection(): boolean; /** * Clear current selection. */ clearSelection(): void; /** * Focuses the terminal instance if it's able to (the xterm.js instance must exist). * * @param force Force focus even if there is a selection. */ focus(force?: boolean): void; /** * Force the scroll bar to be visible until {@link resetScrollbarVisibility} is called. */ forceScrollbarVisibility(): void; /** * Resets the scroll bar to only be visible when needed, this does nothing unless * {@link forceScrollbarVisibility} was called. */ resetScrollbarVisibility(): void; /** * Gets a terminal contribution by its ID. */ getContribution(id: string): T | null; } /** * A {@link ITerminalInstance}-like object that emulates a subset of * capabilities. This instance is returned from {@link ITerminalService.createDetachedTerminal} * to represent terminals that appear in other parts of the VS Code UI outside * of the "Terminal" view or editors. */ export interface IDetachedTerminalInstance extends IDisposable, IBaseTerminalInstance { readonly xterm: IDetachedXtermTerminal; /** * Event fired when data is received from the terminal. */ onData: Event; /** * Attached the terminal to the given element. This should be preferred over * calling {@link IXtermTerminal.attachToElement} so that extra DOM elements * for contributions are initialized. * * @param container Container the terminal will be rendered in * @param options Additional options for mounting the terminal in an element */ attachToElement(container: HTMLElement, options?: Partial): void; } export declare const isDetachedTerminalInstance: (t: ITerminalInstance | IDetachedTerminalInstance) => t is IDetachedTerminalInstance; export declare class TerminalLinkQuickPickEvent extends MouseEvent { } export interface ITerminalServiceNativeDelegate { getWindowCount(): Promise; } export declare const terminalEditorId = "terminalEditor"; interface ITerminalEditorInputObject { readonly id: number; readonly pid: number; readonly title: string; readonly titleSource: TitleEventSource; readonly cwd: string; readonly icon: TerminalIcon | undefined; readonly color: string | undefined; readonly hasChildProcesses?: boolean; readonly type?: TerminalType; readonly isFeatureTerminal?: boolean; readonly hideFromUser?: boolean; readonly reconnectionProperties?: IReconnectionProperties; readonly shellIntegrationNonce: string; } export interface ISerializedTerminalEditorInput extends ITerminalEditorInputObject { } export interface IDeserializedTerminalEditorInput extends ITerminalEditorInputObject { } export type ITerminalLocationOptions = TerminalLocation | TerminalEditorLocation | { parentTerminal: MaybePromise; } | { splitActiveTerminal: boolean; }; export interface ICreateTerminalOptions { /** * The shell launch config or profile to launch with, when not specified the default terminal * profile will be used. */ config?: IShellLaunchConfig | ITerminalProfile | IExtensionTerminalProfile; /** * The current working directory to start with, this will override IShellLaunchConfig.cwd if * specified. */ cwd?: string | URI; /** * The terminal's resource, passed when the terminal has moved windows. */ resource?: URI; /** * The terminal's location (editor or panel), it's terminal parent (split to the right), or editor group */ location?: ITerminalLocationOptions; /** * This terminal will not wait for contributed profiles to resolve which means it will proceed * when the workbench is not yet loaded. */ skipContributedProfileCheck?: boolean; } export interface TerminalEditorLocation { viewColumn: GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE; preserveFocus?: boolean; auxiliary?: IEditorOptions["auxiliary"]; } /** * An interface that indicates the implementer hosts terminal instances, exposing a common set of * properties and events. */ export interface ITerminalInstanceHost { readonly activeInstance: ITerminalInstance | undefined; readonly instances: readonly ITerminalInstance[]; readonly onDidDisposeInstance: Event; readonly onDidFocusInstance: Event; readonly onDidChangeActiveInstance: Event; readonly onDidChangeInstances: Event; readonly onDidChangeInstanceCapability: Event; setActiveInstance(instance: ITerminalInstance): void; /** * Reveal and focus the instance, regardless of its location. */ focusInstance(instance: ITerminalInstance): Promise; /** * Reveal and focus the active instance, regardless of its location. */ focusActiveInstance(): Promise; /** * Gets an instance from a resource if it exists. This MUST be used instead of getInstanceFromId * when you only know about a terminal's URI. (a URI's instance ID may not be this window's instance ID) */ getInstanceFromResource(resource: UriComponents | undefined): ITerminalInstance | undefined; } /** * Similar to xterm.js' ILinkProvider but using promises and hides xterm.js internals (like buffer * positions, decorations, etc.) from the rest of vscode. This is the interface to use for * workbench integrations. */ export interface ITerminalExternalLinkProvider { provideLinks(instance: ITerminalInstance, line: string): Promise; } export interface ITerminalLink { /** The startIndex of the link in the line. */ startIndex: number; /** The length of the link in the line. */ length: number; /** The descriptive label for what the link does when activated. */ label?: string; /** * Activates the link. * @param text The text of the link. */ activate(text: string): void; } export interface ISearchOptions { /** Whether the find should be done as a regex. */ regex?: boolean; /** Whether only whole words should match. */ wholeWord?: boolean; /** Whether find should pay attention to case. */ caseSensitive?: boolean; /** Whether the search should start at the current search position (not the next row). */ incremental?: boolean; } export interface ITerminalInstance extends IBaseTerminalInstance { /** * The ID of the terminal instance, this is an arbitrary number only used to uniquely identify * terminal instances within a window. */ readonly instanceId: number; /** * A unique URI for this terminal instance with the following encoding: * path: // * fragment: Title * Note that when dragging terminals across windows, this will retain the original workspace ID /instance ID * from the other window. */ readonly resource: URI; readonly cols: number; readonly rows: number; readonly maxCols: number; readonly maxRows: number; readonly fixedCols?: number; readonly fixedRows?: number; readonly domElement: HTMLElement; readonly isVisible: boolean; readonly icon?: TerminalIcon; readonly color?: string; readonly reconnectionProperties?: IReconnectionProperties; readonly processName: string; readonly sequence?: string; readonly staticTitle?: string; readonly progressState?: IProgressState; readonly workspaceFolder?: IWorkspaceFolder; readonly cwd?: string; readonly initialCwd?: string; readonly os?: OperatingSystem; readonly usedShellIntegrationInjection: boolean; readonly shellIntegrationInjectionFailureReason: ShellIntegrationInjectionFailureReason | undefined; readonly injectedArgs: string[] | undefined; readonly extEnvironmentVariableCollection: IMergedEnvironmentVariableCollection | undefined; /** * The underlying disposable store, allowing objects who share the same lifecycle as the * terminal instance but are created externally to be managed by the instance. */ readonly store: DisposableStore; readonly statusList: ITerminalStatusList; /** * The process ID of the shell process, this is undefined when there is no process associated * with this terminal. */ processId: number | undefined; /** * The position of the terminal. */ target: TerminalLocation | undefined; targetRef: IReference; /** * The id of a persistent process. This is defined if this is a terminal created by a pty host * that supports reconnection. */ readonly persistentProcessId: number | undefined; /** * Whether the process should be persisted across reloads. */ readonly shouldPersist: boolean; readonly isDisposed: boolean; /** * Whether the terminal's pty is hosted on a remote. */ readonly hasRemoteAuthority: boolean; /** * The remote authority of the terminal's pty. */ readonly remoteAuthority: string | undefined; /** * Whether an element within this terminal is focused. */ readonly hasFocus: boolean; /** * The ID of the session that this terminal is connected to */ readonly sessionId: string; /** * Get or set the behavior of the terminal when it closes. This was indented only to be called * after reconnecting to a terminal. */ waitOnExit: WaitOnExitValue | undefined; /** * An event that fires when the terminal instance's title changes. */ readonly onTitleChanged: Event; /** * An event that fires when the terminal instance's icon changes. */ readonly onIconChanged: Event<{ instance: ITerminalInstance; userInitiated: boolean; }>; /** * An event that fires when the terminal instance is disposed. */ readonly onDisposed: Event; readonly onProcessIdReady: Event; readonly onProcessReplayComplete: Event; readonly onRequestExtHostProcess: Event; readonly onDimensionsChanged: Event; readonly onMaximumDimensionsChanged: Event; readonly onDidChangeHasChildProcesses: Event; readonly onDidFocus: Event; readonly onDidRequestFocus: Event; readonly onDidBlur: Event; readonly onDidInputData: Event; readonly onDidChangeSelection: Event; readonly onDidExecuteText: Event; readonly onDidChangeTarget: Event; readonly onDidSendText: Event; readonly onDidChangeShellType: Event; readonly onDidChangeVisibility: Event; /** * An event that fires when a terminal is dropped on this instance via drag and drop. */ readonly onRequestAddInstanceToGroup: Event; /** * Attach a listener to the raw data stream coming from the pty, including ANSI escape * sequences. */ readonly onData: Event; readonly onWillData: Event; /** * Attach a listener to the binary data stream coming from xterm and going to pty */ readonly onBinary: Event; /** * Attach a listener to listen for new lines added to this terminal instance. * * @param listener The listener function which takes new line strings added to the terminal, * excluding ANSI escape sequences. The line event will fire when an LF character is added to * the terminal (ie. the line is not wrapped). Note that this means that the line data will * not fire for the last line, until either the line is ended with a LF character of the process * is exited. The lineData string will contain the fully wrapped line, not containing any LF/CR * characters. */ readonly onLineData: Event; /** * Attach a listener that fires when the terminal's pty process exits. The number in the event * is the processes' exit code, an exit code of undefined means the process was killed as a result of * the ITerminalInstance being disposed. */ readonly onExit: Event; /** * The exit code or undefined when the terminal process hasn't yet exited or * the process exit code could not be determined. Use {@link exitReason} to see * why the process has exited. */ readonly exitCode: number | undefined; /** * The reason the terminal process exited, this will be undefined if the process is still * running. */ readonly exitReason: TerminalExitReason | undefined; /** * The xterm.js instance for this terminal. */ readonly xterm?: XtermTerminal; /** * Resolves when the xterm.js instance for this terminal is ready. */ readonly xtermReadyPromise: Promise; /** * Returns an array of data events that have fired within the first 10 seconds. If this is * called 10 seconds after the terminal has existed the result will be undefined. This is useful * when objects that depend on the data events have delayed initialization, like extension * hosts. */ readonly initialDataEvents: string[] | undefined; /** A promise that resolves when the terminal's pty/process have been created. */ readonly processReady: Promise; /** Whether the terminal's process has child processes (ie. is dirty/busy). */ readonly hasChildProcesses: boolean; /** * The title of the terminal. This is either title or the process currently running or an * explicit name given to the terminal instance through the extension API. */ readonly title: string; /** * How the current title was set. */ readonly titleSource: TitleEventSource; /** * The shell type of the terminal. */ readonly shellType: TerminalShellType | undefined; /** * The focus state of the terminal before exiting. */ readonly hadFocusOnExit: boolean; /** * False when the title is set by an API or the user. We check this to make sure we * do not override the title when the process title changes in the terminal. */ isTitleSetByProcess: boolean; /** * The shell launch config used to launch the shell. */ readonly shellLaunchConfig: IShellLaunchConfig; /** * Whether to disable layout for the terminal. This is useful when the size of the terminal is * being manipulating (e.g. adding a split pane) and we want the terminal to ignore particular * resize events. */ disableLayout: boolean; /** * The description of the terminal, this is typically displayed next to {@link title}. */ description: string | undefined; /** * The remote-aware $HOME directory (or Windows equivalent) of the terminal. */ userHome: string | undefined; /** * The nonce used to verify commands coming from shell integration. */ shellIntegrationNonce: string; /** * Registers and returns a marker * @param the y offset from the cursor */ registerMarker(offset?: number): IMarker | undefined; /** * Adds a marker to the buffer, mapping it to an ID if provided. */ addBufferMarker(properties: IMarkProperties): void; /** * * @param startMarkId The ID for the start marker * @param endMarkId The ID for the end marker * @param highlight Whether the buffer from startMarker to endMarker * should be highlighted */ scrollToMark(startMarkId: string, endMarkId?: string, highlight?: boolean): void; /** * Dispose the terminal instance, removing it from the panel/service and freeing up resources. * * @param reason The reason why the terminal is being disposed */ dispose(reason?: TerminalExitReason): void; /** * Informs the process that the terminal is now detached and * then disposes the terminal. * * @param reason The reason why the terminal is being disposed */ detachProcessAndDispose(reason: TerminalExitReason): Promise; /** * When the panel is hidden or a terminal in the editor area becomes inactive, reset the focus context key * to avoid issues like #147180. */ resetFocusContextKey(): void; /** * Focuses the terminal instance when it's ready (the xterm.js instance much exist). This is the * best focus call when the terminal is being shown for example. * when the terminal is being shown. * * @param force Force focus even if there is a selection. */ focusWhenReady(force?: boolean): Promise; /** * Send text to the terminal instance. The text is written to the stdin of the underlying pty * process (shell) of the terminal instance. * * @param text The text to send. * @param shouldExecute Indicates that the text being sent should be executed rather than just inserted in the terminal. * The character(s) added are \n or \r\n, depending on the platform. This defaults to `true`. * @param bracketedPasteMode Whether to wrap the text in the bracketed paste mode sequence when * it's enabled. When true, the shell will treat the text as if it were pasted into the shell, * this may for example select the text and it will also ensure that the text will not be * interpreted as a shell keybinding. */ sendText(text: string, shouldExecute: boolean, bracketedPasteMode?: boolean): Promise; /** * Sends a signal to the terminal instance's process. * * @param signal The signal to send (e.g., 'SIGTERM', 'SIGINT', 'SIGKILL'). */ sendSignal(signal: string): Promise; /** * Sends a path to the terminal instance, preparing it as needed based on the detected shell * running within the terminal. The text is written to the stdin of the underlying pty process * (shell) of the terminal instance. * * @param originalPath The path to send. * @param shouldExecute Indicates that the text being sent should be executed rather than just inserted in the terminal. * The character(s) added are \n or \r\n, depending on the platform. This defaults to `true`. */ sendPath(originalPath: string | URI, shouldExecute: boolean): Promise; runCommand(command: string, shouldExecute?: boolean, commandId?: string): Promise; /** * Takes a path and returns the properly escaped path to send to a given shell. On Windows, this * includes trying to prepare the path for WSL if needed. * * @param originalPath The path to be escaped and formatted. */ preparePathForShell(originalPath: string): Promise; /** * Formats a file system URI for display in UI so that it appears in the terminal shell's format. * @param uri The URI to format. */ getUriLabelForShell(uri: URI): Promise; /** Scroll the terminal buffer down 1 line. */ scrollDownLine(): void; /** Scroll the terminal buffer down 1 page. */ scrollDownPage(): void; /** Scroll the terminal buffer to the bottom. */ scrollToBottom(): void; /** Scroll the terminal buffer up 1 line. */ scrollUpLine(): void; /** Scroll the terminal buffer up 1 page. */ scrollUpPage(): void; /** Scroll the terminal buffer to the top. */ scrollToTop(): void; /** * Clears the terminal buffer, leaving only the prompt line and moving it to the top of the * viewport. */ clearBuffer(): void; /** * Attaches the terminal instance to an element on the DOM, before this is called the terminal * instance process may run in the background but cannot be displayed on the UI. * * @param container The element to attach the terminal instance to. */ attachToElement(container: HTMLElement): void; /** * Detaches the terminal instance from the terminal editor DOM element. */ detachFromElement(): void; /** * Layout the terminal instance. * * @param dimension The dimensions of the container. */ layout(dimension: { width: number; height: number; }): void; /** * Sets whether the terminal instance's element is visible in the DOM. * * @param visible Whether the element is visible. */ setVisible(visible: boolean): void; /** * Immediately kills the terminal's current pty process and launches a new one to replace it. * * @param shell The new launch configuration. */ reuseTerminal(shell: IShellLaunchConfig): Promise; /** * Relaunches the terminal, killing it and reusing the launch config used initially. Any * environment variable changes will be recalculated when this happens. */ relaunch(): void; /** * Sets the terminal instance's dimensions to the values provided via the onDidOverrideDimensions event, * which allows overriding the regular dimensions (fit to the size of the panel). */ setOverrideDimensions(dimensions: ITerminalDimensions): void; /** * Sets the terminal instance's dimensions to the values provided via quick input. */ setFixedDimensions(): Promise; /** * Toggles terminal line wrapping. */ toggleSizeToContentWidth(): Promise; /** * Gets the initial current working directory, fetching it from the backend if required. */ getInitialCwd(): Promise; /** * Gets the current working directory from cwd detection capabilities if available, otherwise * from the backend. This will return the initial cwd if cwd detection is not available (ie. * on Windows when shell integration is disabled). */ getSpeculativeCwd(): Promise; /** * Gets the cwd as a URI that has been validated to exist. */ getCwdResource(): Promise; /** * Sets the title of the terminal to the provided string. If no title is provided, it will reset * to the terminal's title if it was not explicitly set by the user or API. * @param title The new title. */ rename(title?: string): Promise; /** * Sets or triggers a quick pick to change the icon of this terminal. */ changeIcon(icon?: TerminalIcon): Promise; /** * Sets or triggers a quick pick to change the color of the associated terminal tab icon. */ changeColor(color?: string, skipQuickPick?: boolean): Promise; /** * Attempts to detect and kill the process listening on specified port. * If successful, places commandToRun on the command line */ freePortKillProcess(port: string, commandToRun: string): Promise; /** * Update the parent context key service to use for this terminal instance. */ setParentContextKeyService(parentContextKeyService: IContextKeyService): void; /** * Handles a mouse event for the terminal, this may happen on an anscestor of the terminal * instance's element. * @param event The mouse event. * @param contextMenu The context menu to show if needed. * @returns Whether the context menu should be suppressed. */ handleMouseEvent(event: MouseEvent, contextMenu: IMenu): Promise<{ cancelContextMenu: boolean; } | void>; } export declare enum XtermTerminalConstants { SearchHighlightLimit = 20000 } export interface IXtermAttachToElementOptions { /** * Whether GPU rendering should be enabled for this element, defaults to true. */ enableGpu: boolean; } export interface IXtermTerminal extends IDisposable { /** * An object that tracks when commands are run and enables navigating and selecting between * them. */ readonly markTracker: IMarkTracker; /** * Reports the status of shell integration and fires events relating to it. */ readonly shellIntegration: IShellIntegration; readonly decorationAddon: IDecorationAddon; readonly onDidChangeSelection: Event; readonly onDidChangeFindResults: Event<{ resultIndex: number; resultCount: number; }>; readonly onDidRequestRunCommand: Event<{ command: ITerminalCommand; noNewLine?: boolean; }>; readonly onDidRequestCopyAsHtml: Event<{ command: ITerminalCommand; }>; /** * Event fired when focus enters (fires with true) or leaves (false) the terminal. */ readonly onDidChangeFocus: Event; /** * Fires after a search is performed. */ readonly onAfterSearch: Event; /** * Fires before a search is performed. */ readonly onBeforeSearch: Event; /** * Gets a view of the current texture atlas used by the renderers. */ readonly textureAtlas: Promise | undefined; /** * Whether the `disableStdin` option in xterm.js is set. */ readonly isStdinDisabled: boolean; /** * Whether the terminal is currently focused. */ readonly isFocused: boolean; /** * Whether a canvas-based renderer is being used. */ readonly isGpuAccelerated: boolean; /** * The last `onData` input event fired by {@link RawXtermTerminal.onData}. */ readonly lastInputEvent: string | undefined; /** * Attached the terminal to the given element * @param container Container the terminal will be rendered in * @param options Additional options for mounting the terminal in an element */ attachToElement(container: HTMLElement, options?: Partial): void; findResult?: { resultIndex: number; resultCount: number; }; /** * Find the next instance of the term */ findNext(term: string, searchOptions: ISearchOptions): Promise; /** * Find the previous instance of the term */ findPrevious(term: string, searchOptions: ISearchOptions): Promise; /** * Forces the terminal to redraw its viewport. */ forceRedraw(): void; /** * Gets the font metrics of this xterm.js instance. */ getFont(): ITerminalFont; /** * Gets the content between two markers as VT sequences. * @param startMarker The marker to start from. When not provided, will start from 0. * @param endMarker The marker to end at. When not provided, will end at the last line. * @param skipLastLine Whether the last line should be skipped (e.g. when it's the prompt line) */ getRangeAsVT(startMarker?: IXtermMarker, endMarker?: IXtermMarker, skipLastLine?: boolean): Promise; /** * Gets whether there's any terminal selection. */ hasSelection(): boolean; /** * Clears any terminal selection. */ clearSelection(): void; /** * Selects all terminal contents/ */ selectAll(): void; /** * Selects the content between the two markers by their VS Code OSC `SetMarker` * ID. It's a no-op if either of the two markers are not found. * * @param fromMarkerId Start marker ID * @param toMarkerId End marker ID * @param scrollIntoView Whether the terminal should scroll to the start of * the range, defaults tof alse */ selectMarkedRange(fromMarkerId: string, toMarkerId: string, scrollIntoView?: boolean): void; /** * Copies the terminal selection. * @param copyAsHtml Whether to copy selection as HTML, defaults to false. */ copySelection(copyAsHtml?: boolean, command?: ITerminalCommand): void; /** * Focuses the terminal. Warning: {@link ITerminalInstance.focus} should be * preferred when dealing with terminal instances in order to get * accessibility triggers. */ focus(): void; /** Scroll the terminal buffer down 1 line. */ scrollDownLine(): void; /** Scroll the terminal buffer down 1 page. */ scrollDownPage(): void; /** Scroll the terminal buffer to the bottom. */ scrollToBottom(): void; /** Scroll the terminal buffer up 1 line. */ scrollUpLine(): void; /** Scroll the terminal buffer up 1 page. */ scrollUpPage(): void; /** Scroll the terminal buffer to the top. */ scrollToTop(): void; /** Scroll the terminal buffer to a set line */ scrollToLine(line: number, position?: ScrollPosition): void; /** * Clears the terminal buffer, leaving only the prompt line and moving it to the top of the * viewport. */ clearBuffer(): void; /** * Clears the search result decorations */ clearSearchDecorations(): void; /** * Clears the active search result decorations */ clearActiveSearchDecoration(): void; /** * Returns a reverse iterator of buffer lines as strings */ getBufferReverseIterator(): IterableIterator; /** * Gets the contents of the buffer from a start marker (or line 0) to the end marker (or the * last line). */ getContentsAsText(startMarker?: IXtermMarker, endMarker?: IXtermMarker): string; /** * Gets the buffer contents as HTML. */ getContentsAsHtml(): Promise; /** * Refreshes the terminal after it has been moved. */ refresh(): void; getXtermTheme(theme?: IColorTheme): ITheme; } export interface IDetachedXtermTerminal extends IXtermTerminal { /** * Writes data to the terminal. * @param data data to write * @param callback Optional callback that fires when the data was processed * by the parser. */ write(data: string | Uint8Array, callback?: () => void): void; /** * Resizes the terminal. */ resize(columns: number, rows: number): void; /** * Performs a full reset (RIS) of the terminal, clearing all content * and resetting cursor position to the origin. */ reset(): void; /** * Access to the terminal buffer for reading cursor position and content. */ readonly buffer: IBufferSet; /** * The number of columns in the terminal. */ readonly cols: number; } export interface IInternalXtermTerminal { /** * Writes text directly to the terminal, bypassing the process. * * **WARNING:** This should never be used outside of the terminal component and only for * developer purposed inside the terminal component. */ _writeText(data: string): void; } export interface IXtermColorProvider { getBackgroundColor(theme: IColorTheme): Color | undefined; } export interface IRequestAddInstanceToGroupEvent { uri: URI; side: "before" | "after"; } export declare enum LinuxDistro { Unknown = 1, Fedora = 2, Ubuntu = 3 } export declare enum TerminalDataTransfers { Terminals = "Terminals" } export {};