@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

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

@@ -0,0 +1,259 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { CallHierarchyProviderRegistry, CallHierarchyModel } from '../common/callHierarchy.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { CallHierarchyTreePeekWidget } from './callHierarchyPeek.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { registerEditorContribution, EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { PeekContext } from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { registerAction2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+const _ctxHasCallHierarchyProvider = ( new RawContextKey('editorHasCallHierarchyProvider', false, ( localize(
+    'editorHasCallHierarchyProvider',
+    'Whether a call hierarchy provider is available'
+))));
+const _ctxCallHierarchyVisible = ( new RawContextKey('callHierarchyVisible', false, ( localize('callHierarchyVisible', 'Whether call hierarchy peek is currently showing'))));
+const _ctxCallHierarchyDirection = ( new RawContextKey(
+    'callHierarchyDirection',
+    undefined,
+    { type: 'string', description: ( localize(
+        'callHierarchyDirection',
+        'Whether call hierarchy shows incoming or outgoing calls'
+    )) }
+));
+function sanitizedDirection(candidate) {
+    return candidate === "outgoingCalls"  || candidate === "incomingCalls"
+        ? candidate
+        : "incomingCalls" ;
+}
+let CallHierarchyController = class CallHierarchyController {
+    static get(editor) {
+        return editor.getContribution(CallHierarchyController.Id);
+    }
+    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._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.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._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(( localize('no.item', "No results")));
+            }
+        }).catch(err => {
+            if (isCancellationError(err)) {
+                this.endCallHierarchy();
+                return;
+            }
+            this._widget.showMessage(( localize('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.Id = 'callHierarchy';
+CallHierarchyController._StorageDirection = 'callHierarchy/defaultDirection';
+CallHierarchyController = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, IInstantiationService))
+], CallHierarchyController));
+registerEditorContribution(CallHierarchyController.Id, CallHierarchyController, 0 );
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showCallHierarchy',
+            title: { value: ( localize('title', "Peek Call Hierarchy")), original: 'Peek Call Hierarchy' },
+            menu: {
+                id: MenuId.EditorContextPeek,
+                group: 'navigation',
+                order: 1000,
+                when: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor)),
+            },
+            keybinding: {
+                when: EditorContextKeys.editorTextFocus,
+                weight: 200 ,
+                primary: 1024  + 512  + 38
+            },
+            precondition: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor))
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return CallHierarchyController.get(editor)?.startCallHierarchyFromEditor();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showIncomingCalls',
+            title: { value: ( localize('title.incoming', "Show Incoming Calls")), original: 'Show Incoming Calls' },
+            icon: ( registerIcon('callhierarchy-incoming', Codicon.callIncoming, ( localize(
+                '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: { value: ( localize('title.outgoing', "Show Outgoing Calls")), original: 'Show Outgoing Calls' },
+            icon: ( registerIcon('callhierarchy-outgoing', Codicon.callOutgoing, ( localize(
+                '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: { value: ( localize('title.refocus', "Refocus Call Hierarchy")), original: '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: ( localize('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();
+    }
+});

package/dist/vscode/vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek.js

@@ -0,0 +1,337 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/callHierarchy.css";
+import * as peekView from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { VirtualDelegate, CallRenderer, DataSource, Sorter, AccessibilityProvider, IdentityProvider } from './callHierarchyTree.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
+import { Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { EmbeddedCodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/embeddedCodeEditorWidget.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { themeColorFromId, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { TreeMouseEventTarget } from 'monaco-editor/esm/vs/base/browser/ui/tree/tree.js';
+import { MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+class LayoutInfo {
+    static store(info, storageService) {
+        storageService.store('callHierarchyPeekLayout', JSON.stringify(info), 0 , 1 );
+    }
+    static retrieve(storageService) {
+        const value = storageService.get('callHierarchyPeekLayout', 0 , '{}');
+        const defaultInfo = { ratio: 0.7, height: 17 };
+        try {
+            return { ...defaultInfo, ...JSON.parse(value) };
+        }
+        catch {
+            return defaultInfo;
+        }
+    }
+    constructor(ratio, height) {
+        this.ratio = ratio;
+        this.height = height;
+    }
+}
+class CallHierarchyTree extends WorkbenchAsyncDataTree {
+}
+let CallHierarchyTreePeekWidget = class CallHierarchyTreePeekWidget extends peekView.PeekViewWidget {
+    constructor(editor, _where, _direction, themeService, _peekViewService, _editorService, _textModelService, _storageService, _menuService, _contextKeyService, _instantiationService) {
+        super(editor, { showFrame: true, showArrow: true, isResizeable: true, isAccessible: true }, _instantiationService);
+        this._where = _where;
+        this._direction = _direction;
+        this._peekViewService = _peekViewService;
+        this._editorService = _editorService;
+        this._textModelService = _textModelService;
+        this._storageService = _storageService;
+        this._menuService = _menuService;
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._treeViewStates = ( new Map());
+        this._previewDisposable = ( new DisposableStore());
+        this.create();
+        this._peekViewService.addExclusiveWidget(editor, this);
+        this._applyTheme(themeService.getColorTheme());
+        this._disposables.add(themeService.onDidColorThemeChange(this._applyTheme, this));
+        this._disposables.add(this._previewDisposable);
+    }
+    dispose() {
+        LayoutInfo.store(this._layoutInfo, this._storageService);
+        this._splitView.dispose();
+        this._tree.dispose();
+        this._editor.dispose();
+        super.dispose();
+    }
+    get direction() {
+        return this._direction;
+    }
+    _applyTheme(theme) {
+        const borderColor = theme.getColor(peekView.peekViewBorder) || Color.transparent;
+        this.style({
+            arrowColor: borderColor,
+            frameColor: borderColor,
+            headerBackgroundColor: theme.getColor(peekView.peekViewTitleBackground) || Color.transparent,
+            primaryHeadingColor: theme.getColor(peekView.peekViewTitleForeground),
+            secondaryHeadingColor: theme.getColor(peekView.peekViewTitleInfoForeground)
+        });
+    }
+    _fillHead(container) {
+        super._fillHead(container, true);
+        const menu = this._menuService.createMenu(CallHierarchyTreePeekWidget.TitleMenu, this._contextKeyService);
+        const updateToolbar = () => {
+            const actions = [];
+            createAndFillInActionBarActions(menu, undefined, actions);
+            this._actionbarWidget.clear();
+            this._actionbarWidget.push(actions, { label: false, icon: true });
+        };
+        this._disposables.add(menu);
+        this._disposables.add(menu.onDidChange(updateToolbar));
+        updateToolbar();
+    }
+    _fillBody(parent) {
+        this._layoutInfo = LayoutInfo.retrieve(this._storageService);
+        this._dim = ( new Dimension(0, 0));
+        this._parent = parent;
+        parent.classList.add('call-hierarchy');
+        const message = document.createElement('div');
+        message.classList.add('message');
+        parent.appendChild(message);
+        this._message = message;
+        this._message.tabIndex = 0;
+        const container = document.createElement('div');
+        container.classList.add('results');
+        parent.appendChild(container);
+        this._splitView = ( new SplitView(container, { orientation: 1  }));
+        const editorContainer = document.createElement('div');
+        editorContainer.classList.add('editor');
+        container.appendChild(editorContainer);
+        const editorOptions = {
+            scrollBeyondLastLine: false,
+            scrollbar: {
+                verticalScrollbarSize: 14,
+                horizontal: 'auto',
+                useShadows: true,
+                verticalHasArrows: false,
+                horizontalHasArrows: false,
+                alwaysConsumeMouseWheel: false
+            },
+            overviewRulerLanes: 2,
+            fixedOverflowWidgets: true,
+            minimap: {
+                enabled: false
+            }
+        };
+        this._editor = this._instantiationService.createInstance(EmbeddedCodeEditorWidget, editorContainer, editorOptions, {}, this.editor);
+        const treeContainer = document.createElement('div');
+        treeContainer.classList.add('tree');
+        container.appendChild(treeContainer);
+        const options = {
+            sorter: new Sorter(),
+            accessibilityProvider: new AccessibilityProvider(() => this._direction),
+            identityProvider: new IdentityProvider(() => this._direction),
+            expandOnlyOnTwistieClick: true,
+            overrideStyles: {
+                listBackground: peekView.peekViewResultsBackground
+            }
+        };
+        this._tree = this._instantiationService.createInstance(CallHierarchyTree, 'CallHierarchyPeek', treeContainer, new VirtualDelegate(), [this._instantiationService.createInstance(CallRenderer)], this._instantiationService.createInstance(DataSource, () => this._direction), options);
+        this._splitView.addView({
+            onDidChange: Event.None,
+            element: editorContainer,
+            minimumSize: 200,
+            maximumSize: Number.MAX_VALUE,
+            layout: (width) => {
+                if (this._dim.height) {
+                    this._editor.layout({ height: this._dim.height, width });
+                }
+            }
+        }, Sizing.Distribute);
+        this._splitView.addView({
+            onDidChange: Event.None,
+            element: treeContainer,
+            minimumSize: 100,
+            maximumSize: Number.MAX_VALUE,
+            layout: (width) => {
+                if (this._dim.height) {
+                    this._tree.layout(this._dim.height, width);
+                }
+            }
+        }, Sizing.Distribute);
+        this._disposables.add(this._splitView.onDidSashChange(() => {
+            if (this._dim.width) {
+                this._layoutInfo.ratio = this._splitView.getViewSize(0) / this._dim.width;
+            }
+        }));
+        this._disposables.add(this._tree.onDidChangeFocus(this._updatePreview, this));
+        this._disposables.add(this._editor.onMouseDown(e => {
+            const { event, target } = e;
+            if (event.detail !== 2) {
+                return;
+            }
+            const [focus] = this._tree.getFocus();
+            if (!focus) {
+                return;
+            }
+            this.dispose();
+            this._editorService.openEditor({
+                resource: focus.item.uri,
+                options: { selection: target.range }
+            });
+        }));
+        this._disposables.add(this._tree.onMouseDblClick(e => {
+            if (e.target === TreeMouseEventTarget.Twistie) {
+                return;
+            }
+            if (e.element) {
+                this.dispose();
+                this._editorService.openEditor({
+                    resource: e.element.item.uri,
+                    options: { selection: e.element.item.selectionRange, pinned: true }
+                });
+            }
+        }));
+        this._disposables.add(this._tree.onDidChangeSelection(e => {
+            const [element] = e.elements;
+            if (element && e.browserEvent instanceof KeyboardEvent) {
+                this.dispose();
+                this._editorService.openEditor({
+                    resource: element.item.uri,
+                    options: { selection: element.item.selectionRange, pinned: true }
+                });
+            }
+        }));
+    }
+    async _updatePreview() {
+        const [element] = this._tree.getFocus();
+        if (!element) {
+            return;
+        }
+        this._previewDisposable.clear();
+        const options = {
+            description: 'call-hierarchy-decoration',
+            stickiness: 1 ,
+            className: 'call-decoration',
+            overviewRuler: {
+                color: themeColorFromId(peekView.peekViewEditorMatchHighlight),
+                position: OverviewRulerLane.Center
+            },
+        };
+        let previewUri;
+        if (this._direction === "outgoingCalls" ) {
+            previewUri = element.parent ? element.parent.item.uri : element.model.root.uri;
+        }
+        else {
+            previewUri = element.item.uri;
+        }
+        const value = await this._textModelService.createModelReference(previewUri);
+        this._editor.setModel(value.object.textEditorModel);
+        const decorations = [];
+        let fullRange;
+        let locations = element.locations;
+        if (!locations) {
+            locations = [{ uri: element.item.uri, range: element.item.selectionRange }];
+        }
+        for (const loc of locations) {
+            if (( loc.uri.toString()) === ( previewUri.toString())) {
+                decorations.push({ range: loc.range, options });
+                fullRange = !fullRange ? loc.range : Range.plusRange(loc.range, fullRange);
+            }
+        }
+        if (fullRange) {
+            this._editor.revealRangeInCenter(fullRange, 1 );
+            const decorationsCollection = this._editor.createDecorationsCollection(decorations);
+            this._previewDisposable.add(toDisposable(() => decorationsCollection.clear()));
+        }
+        this._previewDisposable.add(value);
+        const title = this._direction === "outgoingCalls"
+            ? ( localize('callFrom', "Calls from '{0}'", element.model.root.name))
+            : ( localize('callsTo', "Callers of '{0}'", element.model.root.name));
+        this.setTitle(title);
+    }
+    showLoading() {
+        this._parent.dataset['state'] = "loading" ;
+        this.setTitle(( localize('title.loading', "Loading...")));
+        this._show();
+    }
+    showMessage(message) {
+        this._parent.dataset['state'] = "message" ;
+        this.setTitle('');
+        this.setMetaTitle('');
+        this._message.innerText = message;
+        this._show();
+        this._message.focus();
+    }
+    async showModel(model) {
+        this._show();
+        const viewState = this._treeViewStates.get(this._direction);
+        await this._tree.setInput(model, viewState);
+        const root = this._tree.getNode(model).children[0];
+        await this._tree.expand(root.element);
+        if (root.children.length === 0) {
+            this.showMessage(this._direction === "outgoingCalls"
+                ? ( localize('empt.callsFrom', "No calls from '{0}'", model.root.name))
+                : ( localize('empt.callsTo', "No callers of '{0}'", model.root.name)));
+        }
+        else {
+            this._parent.dataset['state'] = "data" ;
+            if (!viewState || this._tree.getFocus().length === 0) {
+                this._tree.setFocus([root.children[0].element]);
+            }
+            this._tree.domFocus();
+            this._updatePreview();
+        }
+    }
+    getModel() {
+        return this._tree.getInput();
+    }
+    getFocused() {
+        return this._tree.getFocus()[0];
+    }
+    async updateDirection(newDirection) {
+        const model = this._tree.getInput();
+        if (model && newDirection !== this._direction) {
+            this._treeViewStates.set(this._direction, this._tree.getViewState());
+            this._direction = newDirection;
+            await this.showModel(model);
+        }
+    }
+    _show() {
+        if (!this._isShowing) {
+            this.editor.revealLineInCenterIfOutsideViewport(this._where.lineNumber, 0 );
+            super.show(Range.fromPositions(this._where), this._layoutInfo.height);
+        }
+    }
+    _onWidth(width) {
+        if (this._dim) {
+            this._doLayoutBody(this._dim.height, width);
+        }
+    }
+    _doLayoutBody(height, width) {
+        if (this._dim.height !== height || this._dim.width !== width) {
+            super._doLayoutBody(height, width);
+            this._dim = ( new Dimension(width, height));
+            this._layoutInfo.height = this._viewZone ? this._viewZone.heightInLines : this._layoutInfo.height;
+            this._splitView.layout(width);
+            this._splitView.resizeView(0, width * this._layoutInfo.ratio);
+        }
+    }
+};
+CallHierarchyTreePeekWidget.TitleMenu = ( new MenuId('callhierarchy/title'));
+CallHierarchyTreePeekWidget = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, peekView.IPeekViewService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IInstantiationService))
+], CallHierarchyTreePeekWidget));
+export { CallHierarchyTreePeekWidget };