@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution.js

@@ -0,0 +1,264 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Lazy } from '../../../../../base/common/lazy.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { localize2WithPath } from '../../../../../nls.js';
+import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { findInFilesCommand } from '../../../search/browser/searchActionsFind.js';
+import { isDetachedTerminalInstance, ITerminalService } from '../../../terminal/browser/terminal.js';
+import { registerActiveXtermAction, registerActiveInstanceAction } from '../../../terminal/browser/terminalActions.js';
+import { registerTerminalContribution } from '../../../terminal/browser/terminalExtensions.js';
+import { TerminalContextKeys } from '../../../terminal/common/terminalContextKey.js';
+import { TerminalFindWidget } from './terminalFindWidget.js';
+var TerminalFindContribution_1;
+let TerminalFindContribution = class TerminalFindContribution extends Disposable {
+    static { TerminalFindContribution_1 = this; }
+    static { this.ID = 'terminal.find'; }
+    static get(instance) {
+        return instance.getContribution(TerminalFindContribution_1.ID);
+    }
+    get findWidget() { return this._findWidget.value; }
+    constructor(_instance, processManager, widgetManager, instantiationService, terminalService) {
+        super();
+        this._instance = _instance;
+        this._findWidget = ( new Lazy(() => {
+            const findWidget = instantiationService.createInstance(TerminalFindWidget, this._instance);
+            findWidget.focusTracker.onDidFocus(() => {
+                TerminalFindContribution_1.activeFindWidget = this;
+                this._instance.forceScrollbarVisibility();
+                if (!isDetachedTerminalInstance(this._instance)) {
+                    terminalService.setActiveInstance(this._instance);
+                }
+            });
+            findWidget.focusTracker.onDidBlur(() => {
+                TerminalFindContribution_1.activeFindWidget = undefined;
+                this._instance.resetScrollbarVisibility();
+            });
+            if (!this._instance.domElement) {
+                throw new Error('FindWidget expected terminal DOM to be initialized');
+            }
+            this._instance.domElement?.appendChild(findWidget.getDomNode());
+            if (this._lastLayoutDimensions) {
+                findWidget.layout(this._lastLayoutDimensions.width);
+            }
+            return findWidget;
+        }));
+    }
+    layout(_xterm, dimension) {
+        this._lastLayoutDimensions = dimension;
+        this._findWidget.rawValue?.layout(dimension.width);
+    }
+    xtermReady(xterm) {
+        this._register(xterm.onDidChangeFindResults(() => this._findWidget.rawValue?.updateResultCount()));
+    }
+    dispose() {
+        if (TerminalFindContribution_1.activeFindWidget === this) {
+            TerminalFindContribution_1.activeFindWidget = undefined;
+        }
+        super.dispose();
+        this._findWidget.rawValue?.dispose();
+    }
+};
+TerminalFindContribution = TerminalFindContribution_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ITerminalService))
+], TerminalFindContribution));
+registerTerminalContribution(TerminalFindContribution.ID, TerminalFindContribution, true);
+registerActiveXtermAction({
+    id: "workbench.action.terminal.focusFind" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.focusFind',
+        'Focus Find'
+    )),
+    keybinding: {
+        primary: 2048  | 36 ,
+        when: ( ContextKeyExpr.or(TerminalContextKeys.findFocus, TerminalContextKeys.focusInAny)),
+        weight: 200
+    },
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )),
+    run: (_xterm, _accessor, activeInstance) => {
+        const contr = TerminalFindContribution.activeFindWidget || TerminalFindContribution.get(activeInstance);
+        contr?.findWidget.reveal();
+    }
+});
+registerActiveXtermAction({
+    id: "workbench.action.terminal.hideFind" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.hideFind',
+        'Hide Find'
+    )),
+    keybinding: {
+        primary: 9 ,
+        secondary: [1024  | 9 ],
+        when: ( ContextKeyExpr.and(TerminalContextKeys.focusInAny, TerminalContextKeys.findVisible)),
+        weight: 200
+    },
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )),
+    run: (_xterm, _accessor, activeInstance) => {
+        const contr = TerminalFindContribution.activeFindWidget || TerminalFindContribution.get(activeInstance);
+        contr?.findWidget.hide();
+    }
+});
+registerActiveXtermAction({
+    id: "workbench.action.terminal.toggleFindRegex" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.toggleFindRegex',
+        'Toggle Find Using Regex'
+    )),
+    keybinding: {
+        primary: 512  | 48 ,
+        mac: { primary: 2048  | 512  | 48  },
+        when: ( ContextKeyExpr.or(TerminalContextKeys.focusInAny, TerminalContextKeys.findFocus)),
+        weight: 200
+    },
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )),
+    run: (_xterm, _accessor, activeInstance) => {
+        const contr = TerminalFindContribution.activeFindWidget || TerminalFindContribution.get(activeInstance);
+        const state = contr?.findWidget.state;
+        state?.change({ isRegex: !state.isRegex }, false);
+    }
+});
+registerActiveXtermAction({
+    id: "workbench.action.terminal.toggleFindWholeWord" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.toggleFindWholeWord',
+        'Toggle Find Using Whole Word'
+    )),
+    keybinding: {
+        primary: 512  | 53 ,
+        mac: { primary: 2048  | 512  | 53  },
+        when: ( ContextKeyExpr.or(TerminalContextKeys.focusInAny, TerminalContextKeys.findFocus)),
+        weight: 200
+    },
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )),
+    run: (_xterm, _accessor, activeInstance) => {
+        const contr = TerminalFindContribution.activeFindWidget || TerminalFindContribution.get(activeInstance);
+        const state = contr?.findWidget.state;
+        state?.change({ wholeWord: !state.wholeWord }, false);
+    }
+});
+registerActiveXtermAction({
+    id: "workbench.action.terminal.toggleFindCaseSensitive" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.toggleFindCaseSensitive',
+        'Toggle Find Using Case Sensitive'
+    )),
+    keybinding: {
+        primary: 512  | 33 ,
+        mac: { primary: 2048  | 512  | 33  },
+        when: ( ContextKeyExpr.or(TerminalContextKeys.focusInAny, TerminalContextKeys.findFocus)),
+        weight: 200
+    },
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )),
+    run: (_xterm, _accessor, activeInstance) => {
+        const contr = TerminalFindContribution.activeFindWidget || TerminalFindContribution.get(activeInstance);
+        const state = contr?.findWidget.state;
+        state?.change({ matchCase: !state.matchCase }, false);
+    }
+});
+registerActiveXtermAction({
+    id: "workbench.action.terminal.findNext" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.findNext',
+        'Find Next'
+    )),
+    keybinding: [
+        {
+            primary: 61 ,
+            mac: { primary: 2048  | 37 , secondary: [61 ] },
+            when: ( ContextKeyExpr.or(TerminalContextKeys.focusInAny, TerminalContextKeys.findFocus)),
+            weight: 200
+        },
+        {
+            primary: 1024  | 3 ,
+            when: TerminalContextKeys.findInputFocus,
+            weight: 200
+        }
+    ],
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )),
+    run: (_xterm, _accessor, activeInstance) => {
+        const contr = TerminalFindContribution.activeFindWidget || TerminalFindContribution.get(activeInstance);
+        const widget = contr?.findWidget;
+        if (widget) {
+            widget.show();
+            widget.find(false);
+        }
+    }
+});
+registerActiveXtermAction({
+    id: "workbench.action.terminal.findPrevious" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.findPrevious',
+        'Find Previous'
+    )),
+    keybinding: [
+        {
+            primary: 1024  | 61 ,
+            mac: { primary: 2048  | 1024  | 37 , secondary: [1024  | 61 ] },
+            when: ( ContextKeyExpr.or(TerminalContextKeys.focusInAny, TerminalContextKeys.findFocus)),
+            weight: 200
+        },
+        {
+            primary: 3 ,
+            when: TerminalContextKeys.findInputFocus,
+            weight: 200
+        }
+    ],
+    precondition: ( ContextKeyExpr.or(
+        TerminalContextKeys.processSupported,
+        TerminalContextKeys.terminalHasBeenCreated
+    )),
+    run: (_xterm, _accessor, activeInstance) => {
+        const contr = TerminalFindContribution.activeFindWidget || TerminalFindContribution.get(activeInstance);
+        const widget = contr?.findWidget;
+        if (widget) {
+            widget.show();
+            widget.find(true);
+        }
+    }
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.searchWorkspace" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/terminal.find.contribution',
+        'workbench.action.terminal.searchWorkspace',
+        'Search Workspace'
+    )),
+    keybinding: [
+        {
+            primary: 2048  | 1024  | 36 ,
+            when: ( ContextKeyExpr.and(
+                TerminalContextKeys.processSupported,
+                TerminalContextKeys.focus,
+                TerminalContextKeys.textSelected
+            )),
+            weight: 200  + 50
+        }
+    ],
+    run: (activeInstance, c, accessor) => findInFilesCommand(accessor, { query: activeInstance.selection })
+});

package/vscode/src/vs/workbench/contrib/terminalContrib/find/browser/terminalFindWidget.js

@@ -0,0 +1,165 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { addDisposableListener, getWindow } from '../../../../../base/browser/dom.js';
+import { SimpleFindWidget } from '../../../codeEditor/browser/find/simpleFindWidget.js';
+import { IContextViewService, IContextMenuService } from '../../../../../platform/contextview/browser/contextView.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { TerminalContextKeys } from '../../../terminal/common/terminalContextKey.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';
+import { Event } from '../../../../../base/common/event.js';
+import { IClipboardService } from '../../../../../platform/clipboard/common/clipboardService.js';
+import { openContextMenu } from './textInputContextMenu.js';
+const TERMINAL_FIND_WIDGET_INITIAL_WIDTH = 419;
+let TerminalFindWidget = class TerminalFindWidget extends SimpleFindWidget {
+    constructor(_instance, _contextViewService, keybindingService, _contextKeyService, _contextMenuService, _clipboardService, _themeService, _configurationService) {
+        super({
+            showCommonFindToggles: true,
+            checkImeCompletionState: true,
+            showResultCount: true,
+            initialWidth: TERMINAL_FIND_WIDGET_INITIAL_WIDTH,
+            enableSash: true,
+            appendCaseSensitiveActionId: "workbench.action.terminal.toggleFindCaseSensitive" ,
+            appendRegexActionId: "workbench.action.terminal.toggleFindRegex" ,
+            appendWholeWordsActionId: "workbench.action.terminal.toggleFindWholeWord" ,
+            previousMatchActionId: "workbench.action.terminal.findPrevious" ,
+            nextMatchActionId: "workbench.action.terminal.findNext" ,
+            closeWidgetActionId: "workbench.action.terminal.hideFind" ,
+            type: 'Terminal',
+            matchesLimit: 1000
+        }, _contextViewService, _contextKeyService, keybindingService);
+        this._instance = _instance;
+        this._contextKeyService = _contextKeyService;
+        this._themeService = _themeService;
+        this._configurationService = _configurationService;
+        this._register(this.state.onFindReplaceStateChange(() => {
+            this.show();
+        }));
+        this._findInputFocused = TerminalContextKeys.findInputFocus.bindTo(this._contextKeyService);
+        this._findWidgetFocused = TerminalContextKeys.findFocus.bindTo(this._contextKeyService);
+        this._findWidgetVisible = TerminalContextKeys.findVisible.bindTo(this._contextKeyService);
+        const innerDom = this.getDomNode().firstChild;
+        if (innerDom) {
+            this._register(addDisposableListener(innerDom, 'mousedown', (event) => {
+                event.stopPropagation();
+            }));
+            this._register(addDisposableListener(innerDom, 'contextmenu', (event) => {
+                event.stopPropagation();
+            }));
+        }
+        const findInputDomNode = this.getFindInputDomNode();
+        this._register(addDisposableListener(findInputDomNode, 'contextmenu', (event) => {
+            openContextMenu(getWindow(findInputDomNode), event, _clipboardService, _contextMenuService);
+            event.stopPropagation();
+        }));
+        this._register(this._themeService.onDidColorThemeChange(() => {
+            if (this.isVisible()) {
+                this.find(true, true);
+            }
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('workbench.colorCustomizations') && this.isVisible()) {
+                this.find(true, true);
+            }
+        }));
+        this.updateResultCount();
+    }
+    find(previous, update) {
+        const xterm = this._instance.xterm;
+        if (!xterm) {
+            return;
+        }
+        if (previous) {
+            this._findPreviousWithEvent(xterm, this.inputValue, { regex: this._getRegexValue(), wholeWord: this._getWholeWordValue(), caseSensitive: this._getCaseSensitiveValue(), incremental: update });
+        }
+        else {
+            this._findNextWithEvent(xterm, this.inputValue, { regex: this._getRegexValue(), wholeWord: this._getWholeWordValue(), caseSensitive: this._getCaseSensitiveValue() });
+        }
+    }
+    reveal() {
+        const initialInput = this._instance.hasSelection() && !this._instance.selection.includes('\n') ? this._instance.selection : undefined;
+        const inputValue = initialInput ?? this.inputValue;
+        const xterm = this._instance.xterm;
+        if (xterm && inputValue && inputValue !== '') {
+            this._findPreviousWithEvent(xterm, inputValue, { incremental: true, regex: this._getRegexValue(), wholeWord: this._getWholeWordValue(), caseSensitive: this._getCaseSensitiveValue() }).then(foundMatch => {
+                this.updateButtons(foundMatch);
+                this._register(Event.once(xterm.onDidChangeSelection)(() => xterm.clearActiveSearchDecoration()));
+            });
+        }
+        this.updateButtons(false);
+        super.reveal(inputValue);
+        this._findWidgetVisible.set(true);
+    }
+    show() {
+        const initialInput = this._instance.hasSelection() && !this._instance.selection.includes('\n') ? this._instance.selection : undefined;
+        super.show(initialInput);
+        this._findWidgetVisible.set(true);
+    }
+    hide() {
+        super.hide();
+        this._findWidgetVisible.reset();
+        this._instance.focus(true);
+        this._instance.xterm?.clearSearchDecorations();
+    }
+    async _getResultCount() {
+        return this._instance.xterm?.findResult;
+    }
+    _onInputChanged() {
+        const xterm = this._instance.xterm;
+        if (xterm) {
+            this._findPreviousWithEvent(xterm, this.inputValue, { regex: this._getRegexValue(), wholeWord: this._getWholeWordValue(), caseSensitive: this._getCaseSensitiveValue(), incremental: true }).then(foundMatch => {
+                this.updateButtons(foundMatch);
+            });
+        }
+        return false;
+    }
+    _onFocusTrackerFocus() {
+        if ('overrideCopyOnSelection' in this._instance) {
+            this._overrideCopyOnSelectionDisposable = this._instance.overrideCopyOnSelection(false);
+        }
+        this._findWidgetFocused.set(true);
+    }
+    _onFocusTrackerBlur() {
+        this._overrideCopyOnSelectionDisposable?.dispose();
+        this._instance.xterm?.clearActiveSearchDecoration();
+        this._findWidgetFocused.reset();
+    }
+    _onFindInputFocusTrackerFocus() {
+        this._findInputFocused.set(true);
+    }
+    _onFindInputFocusTrackerBlur() {
+        this._findInputFocused.reset();
+    }
+    findFirst() {
+        const instance = this._instance;
+        if (instance.hasSelection()) {
+            instance.clearSelection();
+        }
+        const xterm = instance.xterm;
+        if (xterm) {
+            this._findPreviousWithEvent(xterm, this.inputValue, { regex: this._getRegexValue(), wholeWord: this._getWholeWordValue(), caseSensitive: this._getCaseSensitiveValue() });
+        }
+    }
+    async _findNextWithEvent(xterm, term, options) {
+        return xterm.findNext(term, options).then(foundMatch => {
+            this._register(Event.once(xterm.onDidChangeSelection)(() => xterm.clearActiveSearchDecoration()));
+            return foundMatch;
+        });
+    }
+    async _findPreviousWithEvent(xterm, term, options) {
+        return xterm.findPrevious(term, options).then(foundMatch => {
+            this._register(Event.once(xterm.onDidChangeSelection)(() => xterm.clearActiveSearchDecoration()));
+            return foundMatch;
+        });
+    }
+};
+TerminalFindWidget = ( __decorate([
+    ( __param(1, IContextViewService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IClipboardService)),
+    ( __param(6, IThemeService)),
+    ( __param(7, IConfigurationService))
+], TerminalFindWidget));
+export { TerminalFindWidget };

package/vscode/src/vs/workbench/contrib/terminalContrib/find/browser/textInputContextMenu.js

@@ -0,0 +1,61 @@
+import { getActiveWindow } from '../../../../../base/browser/dom.js';
+import { StandardMouseEvent } from '../../../../../base/browser/mouseEvent.js';
+import { Action, Separator } from '../../../../../base/common/actions.js';
+import { isNative } from '../../../../../base/common/platform.js';
+import { localizeWithPath } from '../../../../../nls.js';
+function openContextMenu(targetWindow, event, clipboardService, contextMenuService) {
+    const standardEvent = ( new StandardMouseEvent(targetWindow, event));
+    const actions = [];
+    actions.push(
+    (
+    new Action('undo', ( localizeWithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/textInputContextMenu',
+        'undo',
+        "Undo"
+    )), undefined, true, async () => getActiveWindow().document.execCommand('undo'))), ( new Action('redo', ( localizeWithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/textInputContextMenu',
+        'redo',
+        "Redo"
+    )), undefined, true, async () => getActiveWindow().document.execCommand('redo'))), ( new Separator()),
+    (
+    new Action('editor.action.clipboardCutAction', ( localizeWithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/textInputContextMenu',
+        'cut',
+        "Cut"
+    )), undefined, true, async () => getActiveWindow().document.execCommand('cut'))), ( new Action('editor.action.clipboardCopyAction', ( localizeWithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/textInputContextMenu',
+        'copy',
+        "Copy"
+    )), undefined, true, async () => getActiveWindow().document.execCommand('copy'))), ( new Action('editor.action.clipboardPasteAction', ( localizeWithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/textInputContextMenu',
+        'paste',
+        "Paste"
+    )), undefined, true, async (element) => {
+        if (isNative) {
+            getActiveWindow().document.execCommand('paste');
+        }
+        else {
+            const clipboardText = await clipboardService.readText();
+            if (element instanceof HTMLTextAreaElement ||
+                element instanceof HTMLInputElement) {
+                const selectionStart = element.selectionStart || 0;
+                const selectionEnd = element.selectionEnd || 0;
+                element.value = `${element.value.substring(0, selectionStart)}${clipboardText}${element.value.substring(selectionEnd, element.value.length)}`;
+                element.selectionStart = selectionStart + clipboardText.length;
+                element.selectionEnd = element.selectionStart;
+            }
+        }
+    })), ( new Separator()),
+    (
+    new Action('editor.action.selectAll', ( localizeWithPath(
+        'vs/workbench/contrib/terminalContrib/find/browser/textInputContextMenu',
+        'selectAll',
+        "Select All"
+    )), undefined, true, async () => getActiveWindow().document.execCommand('selectAll'))));
+    contextMenuService.showContextMenu({
+        getAnchor: () => standardEvent,
+        getActions: () => actions,
+        getActionsContext: () => event.target,
+    });
+}
+export { openContextMenu };

package/vscode/src/vs/workbench/contrib/terminalContrib/highlight/browser/terminal.highlight.contribution.js

@@ -0,0 +1,36 @@
+import { addDisposableListener } from '../../../../../base/browser/dom.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { registerTerminalContribution } from '../../../terminal/browser/terminalExtensions.js';
+class TerminalHighlightContribution extends Disposable {
+    static { this.ID = 'terminal.highlight'; }
+    static get(instance) {
+        return instance.getContribution(TerminalHighlightContribution.ID);
+    }
+    constructor(_instance, processManager, widgetManager) {
+        super();
+        this._instance = _instance;
+    }
+    xtermOpen(xterm) {
+        const screenElement = xterm.raw.element.querySelector('.xterm-screen');
+        this._register(addDisposableListener(screenElement, 'mousemove', (e) => {
+            if (e.target.tagName !== 'CANVAS') {
+                return;
+            }
+            const rect = xterm.raw.element?.getBoundingClientRect();
+            if (!rect) {
+                return;
+            }
+            const mouseCursorY = Math.floor(e.offsetY / (rect.height / xterm.raw.rows));
+            const command = this._instance.capabilities.get(2 )?.getCommandForLine(xterm.raw.buffer.active.viewportY + mouseCursorY);
+            if (command && 'getOutput' in command) {
+                xterm.markTracker.showCommandGuide(command);
+            }
+            else {
+                xterm.markTracker.showCommandGuide(undefined);
+            }
+        }));
+        this._register(addDisposableListener(screenElement, 'mouseout', () => xterm.markTracker.showCommandGuide(undefined)));
+        this._register(xterm.raw.onData(() => xterm.markTracker.showCommandGuide(undefined)));
+    }
+}
+registerTerminalContribution(TerminalHighlightContribution.ID, TerminalHighlightContribution, false);

package/vscode/src/vs/workbench/contrib/terminalContrib/links/browser/terminal.links.contribution.js

@@ -0,0 +1,132 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../../base/common/event.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { localize2WithPath } from '../../../../../nls.js';
+import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { accessibleViewIsShown, accessibleViewCurrentProviderId } from '../../../accessibility/browser/accessibilityConfiguration.js';
+import { isDetachedTerminalInstance } from '../../../terminal/browser/terminal.js';
+import { registerActiveInstanceAction } from '../../../terminal/browser/terminalActions.js';
+import { registerTerminalContribution } from '../../../terminal/browser/terminalExtensions.js';
+import { isTerminalProcessManager } from '../../../terminal/common/terminal.js';
+import { TerminalContextKeys } from '../../../terminal/common/terminalContextKey.js';
+import { terminalStrings } from '../../../terminal/common/terminalStrings.js';
+import { ITerminalLinkProviderService } from './links.js';
+import { TerminalLinkManager } from './terminalLinkManager.js';
+import { TerminalLinkQuickpick } from './terminalLinkQuickpick.js';
+import { TerminalLinkResolver } from './terminalLinkResolver.js';
+var TerminalLinkContribution_1;
+let TerminalLinkContribution = class TerminalLinkContribution extends DisposableStore {
+    static { TerminalLinkContribution_1 = this; }
+    static { this.ID = 'terminal.link'; }
+    static get(instance) {
+        return instance.getContribution(TerminalLinkContribution_1.ID);
+    }
+    constructor(_instance, _processManager, _widgetManager, _instantiationService, _terminalLinkProviderService) {
+        super();
+        this._instance = _instance;
+        this._processManager = _processManager;
+        this._widgetManager = _widgetManager;
+        this._instantiationService = _instantiationService;
+        this._terminalLinkProviderService = _terminalLinkProviderService;
+        this._linkResolver = this._instantiationService.createInstance(TerminalLinkResolver);
+    }
+    xtermReady(xterm) {
+        const linkManager = this._linkManager = this.add(this._instantiationService.createInstance(TerminalLinkManager, xterm.raw, this._processManager, this._instance.capabilities, this._linkResolver));
+        if (isTerminalProcessManager(this._processManager)) {
+            const disposable = linkManager.add(Event.once(this._processManager.onProcessReady)(() => {
+                linkManager.setWidgetManager(this._widgetManager);
+                this.delete(disposable);
+            }));
+        }
+        else {
+            linkManager.setWidgetManager(this._widgetManager);
+        }
+        if (!isDetachedTerminalInstance(this._instance)) {
+            for (const linkProvider of this._terminalLinkProviderService.linkProviders) {
+                linkManager.externalProvideLinksCb = linkProvider.provideLinks.bind(linkProvider, this._instance);
+            }
+            linkManager.add(this._terminalLinkProviderService.onDidAddLinkProvider(e => {
+                linkManager.externalProvideLinksCb = e.provideLinks.bind(e, this._instance);
+            }));
+        }
+        linkManager.add(this._terminalLinkProviderService.onDidRemoveLinkProvider(() => linkManager.externalProvideLinksCb = undefined));
+    }
+    async showLinkQuickpick(extended) {
+        if (!this._terminalLinkQuickpick) {
+            this._terminalLinkQuickpick = this.add(this._instantiationService.createInstance(TerminalLinkQuickpick));
+            this._terminalLinkQuickpick.onDidRequestMoreLinks(() => {
+                this.showLinkQuickpick(true);
+            });
+        }
+        const links = await this._getLinks();
+        return await this._terminalLinkQuickpick.show(this._instance, links);
+    }
+    async _getLinks() {
+        if (!this._linkManager) {
+            throw new Error('terminal links are not ready, cannot generate link quick pick');
+        }
+        return this._linkManager.getLinks();
+    }
+    async openRecentLink(type) {
+        if (!this._linkManager) {
+            throw new Error('terminal links are not ready, cannot open a link');
+        }
+        this._linkManager.openRecentLink(type);
+    }
+};
+TerminalLinkContribution = TerminalLinkContribution_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ITerminalLinkProviderService))
+], TerminalLinkContribution));
+registerTerminalContribution(TerminalLinkContribution.ID, TerminalLinkContribution, true);
+const category = terminalStrings.actionCategory;
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.openDetectedLink" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/links/browser/terminal.links.contribution',
+        'workbench.action.terminal.openDetectedLink',
+        'Open Detected Link...'
+    )),
+    f1: true,
+    category,
+    precondition: TerminalContextKeys.terminalHasBeenCreated,
+    keybinding: [{
+            primary: 2048  | 1024  | 45 ,
+            weight: 200  + 1,
+            when: TerminalContextKeys.focus
+        }, {
+            primary: 2048  | 1024  | 37 ,
+            weight: 200  + 1,
+            when: ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(
+                accessibleViewCurrentProviderId.key,
+                "terminal"
+            ))))
+        },
+    ],
+    run: (activeInstance) => TerminalLinkContribution.get(activeInstance)?.showLinkQuickpick()
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.openUrlLink" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/links/browser/terminal.links.contribution',
+        'workbench.action.terminal.openLastUrlLink',
+        'Open Last URL Link'
+    )),
+    f1: true,
+    category,
+    precondition: TerminalContextKeys.terminalHasBeenCreated,
+    run: (activeInstance) => TerminalLinkContribution.get(activeInstance)?.openRecentLink('url')
+});
+registerActiveInstanceAction({
+    id: "workbench.action.terminal.openFileLink" ,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/terminalContrib/links/browser/terminal.links.contribution',
+        'workbench.action.terminal.openLastLocalFileLink',
+        'Open Last Local File Link'
+    )),
+    f1: true,
+    category,
+    precondition: TerminalContextKeys.terminalHasBeenCreated,
+    run: (activeInstance) => TerminalLinkContribution.get(activeInstance)?.openRecentLink('localFile')
+});