@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

package/vscode/src/vs/workbench/browser/window.js

@@ -0,0 +1,381 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { setFullscreen, isSafari } from 'vscode/vscode/vs/base/browser/browser';
+import { getWindowsCount, getWindows, getWindow, getActiveWindow, getWindowById, addDisposableListener, EventType, EventHelper, windowOpenWithSuccess, windowOpenPopup, windowOpenNoOpener } from 'vscode/vscode/vs/base/browser/dom';
+import { DomEmitter } from 'vscode/vscode/vs/base/browser/event';
+import { requestUsbDevice, requestSerialPort, requestHidDevice } from '../../base/browser/deviceAccess.js';
+import { timeout } from 'vscode/vscode/vs/base/common/async';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, dispose, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { matchesScheme, Schemas } from 'vscode/vscode/vs/base/common/network';
+import { isMacintosh, isIOS } from 'vscode/vscode/vs/base/common/platform';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
+import { registerWindowDriver } from '../services/driver/browser/driver.js';
+import { isAuxiliaryWindow, mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { createSingleCallFunction } from 'vscode/vscode/vs/base/common/functional';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+
+var BaseWindow_1;
+let BaseWindow = class BaseWindow extends Disposable {
+    static { BaseWindow_1 = this; }
+    static { this.TIMEOUT_HANDLES = Number.MIN_SAFE_INTEGER; }
+    static { this.TIMEOUT_DISPOSABLES = ( new Map()); }
+    constructor(targetWindow, dom = { getWindowsCount, getWindows }, hostService, environmentService) {
+        super();
+        this.hostService = hostService;
+        this.environmentService = environmentService;
+        this.enableWindowFocusOnElementFocus(targetWindow);
+        this.enableMultiWindowAwareTimeout(targetWindow, dom);
+        this.registerFullScreenListeners(targetWindow.vscodeWindowId);
+    }
+    enableWindowFocusOnElementFocus(targetWindow) {
+        const originalFocus = targetWindow.HTMLElement.prototype.focus;
+        const that = this;
+        targetWindow.HTMLElement.prototype.focus = function (options) {
+            that.onElementFocus(getWindow(this));
+            originalFocus.apply(this, [options]);
+        };
+    }
+    onElementFocus(targetWindow) {
+        const activeWindow = getActiveWindow();
+        if (activeWindow !== targetWindow && activeWindow.document.hasFocus()) {
+            targetWindow.focus();
+            if (!this.environmentService.extensionTestsLocationURI &&
+                !targetWindow.document.hasFocus()) {
+                this.hostService.focus(targetWindow);
+            }
+        }
+    }
+    enableMultiWindowAwareTimeout(targetWindow, dom = { getWindowsCount, getWindows }) {
+        const originalSetTimeout = targetWindow.setTimeout;
+        Object.defineProperty(targetWindow, 'vscodeOriginalSetTimeout', { get: () => originalSetTimeout });
+        const originalClearTimeout = targetWindow.clearTimeout;
+        Object.defineProperty(targetWindow, 'vscodeOriginalClearTimeout', { get: () => originalClearTimeout });
+        targetWindow.setTimeout = function (handler, timeout = 0, ...args) {
+            if (dom.getWindowsCount() === 1 || typeof handler === 'string' || timeout === 0 ) {
+                return originalSetTimeout.apply(this, [handler, timeout, ...args]);
+            }
+            const timeoutDisposables = ( new Set());
+            const timeoutHandle = BaseWindow_1.TIMEOUT_HANDLES++;
+            BaseWindow_1.TIMEOUT_DISPOSABLES.set(timeoutHandle, timeoutDisposables);
+            const handlerFn = createSingleCallFunction(handler, () => {
+                dispose(timeoutDisposables);
+                BaseWindow_1.TIMEOUT_DISPOSABLES.delete(timeoutHandle);
+            });
+            for (const { window, disposables } of dom.getWindows()) {
+                if (isAuxiliaryWindow(window) && window.document.visibilityState === 'hidden') {
+                    continue;
+                }
+                const handle = window.vscodeOriginalSetTimeout.apply(this, [handlerFn, timeout, ...args]);
+                const timeoutDisposable = toDisposable(() => {
+                    window.vscodeOriginalClearTimeout(handle);
+                    timeoutDisposables.delete(timeoutDisposable);
+                });
+                disposables.add(timeoutDisposable);
+                timeoutDisposables.add(timeoutDisposable);
+            }
+            return timeoutHandle;
+        };
+        targetWindow.clearTimeout = function (timeoutHandle) {
+            const timeoutDisposables = typeof timeoutHandle === 'number' ? BaseWindow_1.TIMEOUT_DISPOSABLES.get(timeoutHandle) : undefined;
+            if (timeoutDisposables) {
+                dispose(timeoutDisposables);
+                BaseWindow_1.TIMEOUT_DISPOSABLES.delete(timeoutHandle);
+            }
+            else {
+                originalClearTimeout.apply(this, [timeoutHandle]);
+            }
+        };
+    }
+    registerFullScreenListeners(targetWindowId) {
+        this._register(this.hostService.onDidChangeFullScreen(({ windowId, fullscreen }) => {
+            if (windowId === targetWindowId) {
+                const targetWindow = getWindowById(targetWindowId);
+                if (targetWindow) {
+                    setFullscreen(fullscreen, targetWindow.window);
+                }
+            }
+        }));
+    }
+    static async confirmOnShutdown(accessor, reason) {
+        const dialogService = accessor.get(IDialogService);
+        const configurationService = accessor.get(IConfigurationService);
+        const message = reason === 2  ?
+            (isMacintosh ? ( localizeWithPath(
+            'vs/workbench/browser/window',
+            'quitMessageMac',
+            "Are you sure you want to quit?"
+        )) : ( localizeWithPath(
+            'vs/workbench/browser/window',
+            'quitMessage',
+            "Are you sure you want to exit?"
+        ))) :
+            ( localizeWithPath(
+                'vs/workbench/browser/window',
+                'closeWindowMessage',
+                "Are you sure you want to close the window?"
+            ));
+        const primaryButton = reason === 2  ?
+            (isMacintosh ? ( localizeWithPath(
+            'vs/workbench/browser/window',
+            { key: 'quitButtonLabel', comment: ['&& denotes a mnemonic'] },
+            "&&Quit"
+        )) : ( localizeWithPath(
+            'vs/workbench/browser/window',
+            { key: 'exitButtonLabel', comment: ['&& denotes a mnemonic'] },
+            "&&Exit"
+        ))) :
+            ( localizeWithPath(
+                'vs/workbench/browser/window',
+                { key: 'closeWindowButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Close Window"
+            ));
+        const res = await dialogService.confirm({
+            message,
+            primaryButton,
+            checkbox: {
+                label: ( localizeWithPath('vs/workbench/browser/window', 'doNotAskAgain', "Do not ask me again"))
+            }
+        });
+        if (res.confirmed && res.checkboxChecked) {
+            await configurationService.updateValue('window.confirmBeforeClose', 'never');
+        }
+        return res.confirmed;
+    }
+};
+BaseWindow = BaseWindow_1 = ( __decorate([
+    ( __param(2, IHostService)),
+    ( __param(3, IWorkbenchEnvironmentService))
+], BaseWindow));
+let BrowserWindow = class BrowserWindow extends BaseWindow {
+    constructor(openerService, lifecycleService, dialogService, labelService, productService, browserEnvironmentService, layoutService, instantiationService, hostService) {
+        super(mainWindow, undefined, hostService, browserEnvironmentService);
+        this.openerService = openerService;
+        this.lifecycleService = lifecycleService;
+        this.dialogService = dialogService;
+        this.labelService = labelService;
+        this.productService = productService;
+        this.browserEnvironmentService = browserEnvironmentService;
+        this.layoutService = layoutService;
+        this.instantiationService = instantiationService;
+        this.registerListeners();
+        this.create();
+    }
+    registerListeners() {
+        this._register(this.lifecycleService.onWillShutdown(() => this.onWillShutdown()));
+        const viewport = isIOS && mainWindow.visualViewport ? mainWindow.visualViewport  : mainWindow ;
+        this._register(addDisposableListener(viewport, EventType.RESIZE, () => {
+            this.layoutService.layout();
+            if (isIOS) {
+                mainWindow.scrollTo(0, 0);
+            }
+        }));
+        this._register(addDisposableListener(this.layoutService.mainContainer, EventType.WHEEL, e => e.preventDefault(), { passive: false }));
+        this._register(addDisposableListener(this.layoutService.mainContainer, EventType.CONTEXT_MENU, e => EventHelper.stop(e, true)));
+        this._register(addDisposableListener(this.layoutService.mainContainer, EventType.DROP, e => EventHelper.stop(e, true)));
+    }
+    onWillShutdown() {
+        Event.toPromise(Event.any(Event.once(( new DomEmitter(mainWindow.document.body, EventType.KEY_DOWN, true)).event), Event.once(( new DomEmitter(mainWindow.document.body, EventType.MOUSE_DOWN, true)).event))).then(async () => {
+            await timeout(3000);
+            await this.dialogService.prompt({
+                type: Severity$1.Error,
+                message: ( localizeWithPath(
+                    'vs/workbench/browser/window',
+                    'shutdownError',
+                    "An unexpected error occurred that requires a reload of this page."
+                )),
+                detail: ( localizeWithPath(
+                    'vs/workbench/browser/window',
+                    'shutdownErrorDetail',
+                    "The workbench was unexpectedly disposed while running."
+                )),
+                buttons: [
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/browser/window',
+                            { key: 'reload', comment: ['&& denotes a mnemonic'] },
+                            "&&Reload"
+                        )),
+                        run: () => mainWindow.location.reload()
+                    }
+                ]
+            });
+        });
+    }
+    create() {
+        this.setupOpenHandlers();
+        this.registerLabelFormatters();
+        this.registerCommands();
+        this.setupDriver();
+    }
+    setupDriver() {
+        if (this.environmentService.enableSmokeTestDriver) {
+            registerWindowDriver(this.instantiationService);
+        }
+    }
+    setupOpenHandlers() {
+        this.openerService.setDefaultExternalOpener({
+            openExternal: async (href) => {
+                let isAllowedOpener = false;
+                if (this.browserEnvironmentService.options?.openerAllowedExternalUrlPrefixes) {
+                    for (const trustedPopupPrefix of this.browserEnvironmentService.options.openerAllowedExternalUrlPrefixes) {
+                        if (href.startsWith(trustedPopupPrefix)) {
+                            isAllowedOpener = true;
+                            break;
+                        }
+                    }
+                }
+                if (matchesScheme(href, Schemas.http) || matchesScheme(href, Schemas.https)) {
+                    if (isSafari) {
+                        const opened = windowOpenWithSuccess(href, !isAllowedOpener);
+                        if (!opened) {
+                            await this.dialogService.prompt({
+                                type: Severity$1.Warning,
+                                message: ( localizeWithPath(
+                                    'vs/workbench/browser/window',
+                                    'unableToOpenExternal',
+                                    "The browser interrupted the opening of a new tab or window. Press 'Open' to open it anyway."
+                                )),
+                                detail: href,
+                                buttons: [
+                                    {
+                                        label: ( localizeWithPath(
+                                            'vs/workbench/browser/window',
+                                            { key: 'open', comment: ['&& denotes a mnemonic'] },
+                                            "&&Open"
+                                        )),
+                                        run: () => isAllowedOpener ? windowOpenPopup(href) : windowOpenNoOpener(href)
+                                    },
+                                    {
+                                        label: ( localizeWithPath(
+                                            'vs/workbench/browser/window',
+                                            { key: 'learnMore', comment: ['&& denotes a mnemonic'] },
+                                            "&&Learn More"
+                                        )),
+                                        run: () => this.openerService.open(( URI.parse('https://aka.ms/allow-vscode-popup')))
+                                    }
+                                ],
+                                cancelButton: true
+                            });
+                        }
+                    }
+                    else {
+                        isAllowedOpener
+                            ? windowOpenPopup(href)
+                            : windowOpenNoOpener(href);
+                    }
+                }
+                else {
+                    const invokeProtocolHandler = () => {
+                        this.lifecycleService.withExpectedShutdown({ disableShutdownHandling: true }, () => mainWindow.location.href = href);
+                    };
+                    invokeProtocolHandler();
+                    const showProtocolUrlOpenedDialog = async () => {
+                        const { downloadUrl } = this.productService;
+                        let detail;
+                        const buttons = [
+                            {
+                                label: ( localizeWithPath(
+                                    'vs/workbench/browser/window',
+                                    { key: 'openExternalDialogButtonRetry.v2', comment: ['&& denotes a mnemonic'] },
+                                    "&&Try Again"
+                                )),
+                                run: () => invokeProtocolHandler()
+                            }
+                        ];
+                        if (downloadUrl !== undefined) {
+                            detail = ( localizeWithPath(
+                                'vs/workbench/browser/window',
+                                'openExternalDialogDetail.v2',
+                                "We launched {0} on your computer.\n\nIf {1} did not launch, try again or install it below.",
+                                this.productService.nameLong,
+                                this.productService.nameLong
+                            ));
+                            buttons.push({
+                                label: ( localizeWithPath(
+                                    'vs/workbench/browser/window',
+                                    { key: 'openExternalDialogButtonInstall.v3', comment: ['&& denotes a mnemonic'] },
+                                    "&&Install"
+                                )),
+                                run: async () => {
+                                    await this.openerService.open(( URI.parse(downloadUrl)));
+                                    showProtocolUrlOpenedDialog();
+                                }
+                            });
+                        }
+                        else {
+                            detail = ( localizeWithPath(
+                                'vs/workbench/browser/window',
+                                'openExternalDialogDetailNoInstall',
+                                "We launched {0} on your computer.\n\nIf {1} did not launch, try again below.",
+                                this.productService.nameLong,
+                                this.productService.nameLong
+                            ));
+                        }
+                        await this.hostService.withExpectedShutdown(() => this.dialogService.prompt({
+                            type: Severity$1.Info,
+                            message: ( localizeWithPath(
+                                'vs/workbench/browser/window',
+                                'openExternalDialogTitle',
+                                "All done. You can close this tab now."
+                            )),
+                            detail,
+                            buttons,
+                            cancelButton: true
+                        }));
+                    };
+                    if (matchesScheme(href, this.productService.urlProtocol)) {
+                        await showProtocolUrlOpenedDialog();
+                    }
+                }
+                return true;
+            }
+        });
+    }
+    registerLabelFormatters() {
+        this._register(this.labelService.registerFormatter({
+            scheme: Schemas.vscodeUserData,
+            priority: true,
+            formatting: {
+                label: '(Settings) ${path}',
+                separator: '/',
+            }
+        }));
+    }
+    registerCommands() {
+        CommandsRegistry.registerCommand('workbench.experimental.requestUsbDevice', async (_accessor, options) => {
+            return requestUsbDevice(options);
+        });
+        CommandsRegistry.registerCommand('workbench.experimental.requestSerialPort', async (_accessor, options) => {
+            return requestSerialPort(options);
+        });
+        CommandsRegistry.registerCommand('workbench.experimental.requestHidDevice', async (_accessor, options) => {
+            return requestHidDevice(options);
+        });
+    }
+};
+BrowserWindow = ( __decorate([
+    ( __param(0, IOpenerService)),
+    ( __param(1, ILifecycleService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IBrowserWorkbenchEnvironmentService)),
+    ( __param(6, IWorkbenchLayoutService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IHostService))
+], BrowserWindow));
+
+export { BaseWindow, BrowserWindow };

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution.js

@@ -0,0 +1,300 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { CallHierarchyProviderRegistry, CallHierarchyModel } from 'vscode/vscode/vs/workbench/contrib/callHierarchy/common/callHierarchy';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { CallHierarchyTreePeekWidget } from './callHierarchyPeek.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { registerEditorContribution, EditorAction2 } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { PeekContext } from 'vscode/vscode/vs/editor/contrib/peekView/browser/peekView';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { registerAction2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { registerIcon } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+
+var CallHierarchyController_1;
+const _ctxHasCallHierarchyProvider = ( new RawContextKey('editorHasCallHierarchyProvider', false, ( localizeWithPath(
+    'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+    'editorHasCallHierarchyProvider',
+    'Whether a call hierarchy provider is available'
+))));
+const _ctxCallHierarchyVisible = ( new RawContextKey('callHierarchyVisible', false, ( localizeWithPath(
+    'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+    'callHierarchyVisible',
+    'Whether call hierarchy peek is currently showing'
+))));
+const _ctxCallHierarchyDirection = ( new RawContextKey(
+    'callHierarchyDirection',
+    undefined,
+    { type: 'string', description: ( localizeWithPath(
+        'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+        'callHierarchyDirection',
+        'Whether call hierarchy shows incoming or outgoing calls'
+    )) }
+));
+function sanitizedDirection(candidate) {
+    return candidate === "outgoingCalls"  || candidate === "incomingCalls"
+        ? candidate
+        : "incomingCalls" ;
+}
+let CallHierarchyController = class CallHierarchyController {
+    static { CallHierarchyController_1 = this; }
+    static { this.Id = 'callHierarchy'; }
+    static get(editor) {
+        return editor.getContribution(CallHierarchyController_1.Id);
+    }
+    static { this._StorageDirection = 'callHierarchy/defaultDirection'; }
+    constructor(_editor, _contextKeyService, _storageService, _editorService, _instantiationService) {
+        this._editor = _editor;
+        this._contextKeyService = _contextKeyService;
+        this._storageService = _storageService;
+        this._editorService = _editorService;
+        this._instantiationService = _instantiationService;
+        this._dispoables = ( new DisposableStore());
+        this._sessionDisposables = ( new DisposableStore());
+        this._ctxIsVisible = _ctxCallHierarchyVisible.bindTo(this._contextKeyService);
+        this._ctxHasProvider = _ctxHasCallHierarchyProvider.bindTo(this._contextKeyService);
+        this._ctxDirection = _ctxCallHierarchyDirection.bindTo(this._contextKeyService);
+        this._dispoables.add(Event.any(_editor.onDidChangeModel, _editor.onDidChangeModelLanguage, CallHierarchyProviderRegistry.onDidChange)(() => {
+            this._ctxHasProvider.set(_editor.hasModel() && ( CallHierarchyProviderRegistry.has(_editor.getModel())));
+        }));
+        this._dispoables.add(this._sessionDisposables);
+    }
+    dispose() {
+        this._ctxHasProvider.reset();
+        this._ctxIsVisible.reset();
+        this._dispoables.dispose();
+    }
+    async startCallHierarchyFromEditor() {
+        this._sessionDisposables.clear();
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const document = this._editor.getModel();
+        const position = this._editor.getPosition();
+        if (!( CallHierarchyProviderRegistry.has(document))) {
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        const model = CallHierarchyModel.create(document, position, cts.token);
+        const direction = sanitizedDirection(this._storageService.get(CallHierarchyController_1._StorageDirection, 0 , "incomingCalls" ));
+        this._showCallHierarchyWidget(position, direction, model, cts);
+    }
+    async startCallHierarchyFromCallHierarchy() {
+        if (!this._widget) {
+            return;
+        }
+        const model = this._widget.getModel();
+        const call = this._widget.getFocused();
+        if (!call || !model) {
+            return;
+        }
+        const newEditor = await this._editorService.openCodeEditor({ resource: call.item.uri }, this._editor);
+        if (!newEditor) {
+            return;
+        }
+        const newModel = model.fork(call.item);
+        this._sessionDisposables.clear();
+        CallHierarchyController_1.get(newEditor)?._showCallHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
+    }
+    _showCallHierarchyWidget(position, direction, model, cts) {
+        this._ctxIsVisible.set(true);
+        this._ctxDirection.set(direction);
+        Event.any(this._editor.onDidChangeModel, this._editor.onDidChangeModelLanguage)(this.endCallHierarchy, this, this._sessionDisposables);
+        this._widget = this._instantiationService.createInstance(CallHierarchyTreePeekWidget, this._editor, position, direction);
+        this._widget.showLoading();
+        this._sessionDisposables.add(this._widget.onDidClose(() => {
+            this.endCallHierarchy();
+            this._storageService.store(CallHierarchyController_1._StorageDirection, this._widget.direction, 0 , 0 );
+        }));
+        this._sessionDisposables.add({ dispose() { cts.dispose(true); } });
+        this._sessionDisposables.add(this._widget);
+        model.then(model => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (model) {
+                this._sessionDisposables.add(model);
+                this._widget.showModel(model);
+            }
+            else {
+                this._widget.showMessage(( localizeWithPath(
+                    'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                    'no.item',
+                    "No results"
+                )));
+            }
+        }).catch(err => {
+            if (isCancellationError(err)) {
+                this.endCallHierarchy();
+                return;
+            }
+            this._widget.showMessage(( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'error',
+                "Failed to show call hierarchy"
+            )));
+        });
+    }
+    showOutgoingCalls() {
+        this._widget?.updateDirection("outgoingCalls" );
+        this._ctxDirection.set("outgoingCalls" );
+    }
+    showIncomingCalls() {
+        this._widget?.updateDirection("incomingCalls" );
+        this._ctxDirection.set("incomingCalls" );
+    }
+    endCallHierarchy() {
+        this._sessionDisposables.clear();
+        this._ctxIsVisible.set(false);
+        this._editor.focus();
+    }
+};
+CallHierarchyController = CallHierarchyController_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, IInstantiationService))
+], CallHierarchyController));
+registerEditorContribution(CallHierarchyController.Id, CallHierarchyController, 0 );
+registerAction2(class PeekCallHierarchyAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showCallHierarchy',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'title',
+                'Peek Call Hierarchy'
+            )),
+            menu: {
+                id: MenuId.EditorContextPeek,
+                group: 'navigation',
+                order: 1000,
+                when: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor, ( EditorContextKeys.isInEmbeddedEditor.toNegated()))),
+            },
+            keybinding: {
+                when: EditorContextKeys.editorTextFocus,
+                weight: 200 ,
+                primary: 1024  + 512  + 38
+            },
+            precondition: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor)),
+            f1: true
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return CallHierarchyController.get(editor)?.startCallHierarchyFromEditor();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showIncomingCalls',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'title.incoming',
+                'Show Incoming Calls'
+            )),
+            icon: registerIcon('callhierarchy-incoming', Codicon.callIncoming, ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'showIncomingCallsIcons',
+                'Icon for incoming calls in the call hierarchy view.'
+            ))),
+            precondition: ( ContextKeyExpr.and(_ctxCallHierarchyVisible, ( _ctxCallHierarchyDirection.isEqualTo("outgoingCalls" )))),
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 512  + 38 ,
+            },
+            menu: {
+                id: CallHierarchyTreePeekWidget.TitleMenu,
+                when: ( _ctxCallHierarchyDirection.isEqualTo("outgoingCalls" )),
+                order: 1,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return CallHierarchyController.get(editor)?.showIncomingCalls();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showOutgoingCalls',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'title.outgoing',
+                'Show Outgoing Calls'
+            )),
+            icon: registerIcon('callhierarchy-outgoing', Codicon.callOutgoing, ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'showOutgoingCallsIcon',
+                'Icon for outgoing calls in the call hierarchy view.'
+            ))),
+            precondition: ( ContextKeyExpr.and(_ctxCallHierarchyVisible, ( _ctxCallHierarchyDirection.isEqualTo("incomingCalls" )))),
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 512  + 38 ,
+            },
+            menu: {
+                id: CallHierarchyTreePeekWidget.TitleMenu,
+                when: ( _ctxCallHierarchyDirection.isEqualTo("incomingCalls" )),
+                order: 1
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return CallHierarchyController.get(editor)?.showOutgoingCalls();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.refocusCallHierarchy',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'title.refocus',
+                'Refocus Call Hierarchy'
+            )),
+            precondition: _ctxCallHierarchyVisible,
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 3
+            }
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return CallHierarchyController.get(editor)?.startCallHierarchyFromCallHierarchy();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.closeCallHierarchy',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution',
+                'close',
+                'Close'
+            )),
+            icon: Codicon.close,
+            precondition: _ctxCallHierarchyVisible,
+            keybinding: {
+                weight: 200  + 10,
+                primary: 9 ,
+                when: ContextKeyExpr.not('config.editor.stablePeek')
+            },
+            menu: {
+                id: CallHierarchyTreePeekWidget.TitleMenu,
+                order: 1000
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return CallHierarchyController.get(editor)?.endCallHierarchy();
+    }
+});