@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

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

@@ -1,247 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { registerEditorContribution, EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.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 { PeekContext } from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { registerAction2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { TypeHierarchyTreePeekWidget } from './typeHierarchyPeek.js';
-import { TypeHierarchyProviderRegistry, TypeHierarchyModel } from '../common/typeHierarchy.js';
-var TypeHierarchyController_1;
-const _ctxHasTypeHierarchyProvider = ( new RawContextKey('editorHasTypeHierarchyProvider', false, ( localize(
-    'editorHasTypeHierarchyProvider',
-    'Whether a type hierarchy provider is available'
-))));
-const _ctxTypeHierarchyVisible = ( new RawContextKey('typeHierarchyVisible', false, ( localize('typeHierarchyVisible', 'Whether type hierarchy peek is currently showing'))));
-const _ctxTypeHierarchyDirection = ( new RawContextKey(
-    'typeHierarchyDirection',
-    undefined,
-    { type: 'string', description: ( localize(
-        'typeHierarchyDirection',
-        'whether type hierarchy shows super types or subtypes'
-    )) }
-));
-function sanitizedDirection(candidate) {
-    return candidate === "subtypes"  || candidate === "supertypes"
-        ? candidate
-        : "subtypes" ;
-}
-let TypeHierarchyController = class TypeHierarchyController {
-    static { TypeHierarchyController_1 = this; }
-    static { this.Id = 'typeHierarchy'; }
-    static get(editor) {
-        return editor.getContribution(TypeHierarchyController_1.Id);
-    }
-    static { this._storageDirectionKey = 'typeHierarchy/defaultDirection'; }
-    constructor(_editor, _contextKeyService, _storageService, _editorService, _instantiationService) {
-        this._editor = _editor;
-        this._contextKeyService = _contextKeyService;
-        this._storageService = _storageService;
-        this._editorService = _editorService;
-        this._instantiationService = _instantiationService;
-        this._disposables = ( new DisposableStore());
-        this._sessionDisposables = ( new DisposableStore());
-        this._ctxHasProvider = _ctxHasTypeHierarchyProvider.bindTo(this._contextKeyService);
-        this._ctxIsVisible = _ctxTypeHierarchyVisible.bindTo(this._contextKeyService);
-        this._ctxDirection = _ctxTypeHierarchyDirection.bindTo(this._contextKeyService);
-        this._disposables.add(Event.any(_editor.onDidChangeModel, _editor.onDidChangeModelLanguage, TypeHierarchyProviderRegistry.onDidChange)(() => {
-            this._ctxHasProvider.set(_editor.hasModel() && ( TypeHierarchyProviderRegistry.has(_editor.getModel())));
-        }));
-        this._disposables.add(this._sessionDisposables);
-    }
-    dispose() {
-        this._disposables.dispose();
-    }
-    async startTypeHierarchyFromEditor() {
-        this._sessionDisposables.clear();
-        if (!this._editor.hasModel()) {
-            return;
-        }
-        const document = this._editor.getModel();
-        const position = this._editor.getPosition();
-        if (!( TypeHierarchyProviderRegistry.has(document))) {
-            return;
-        }
-        const cts = ( new CancellationTokenSource());
-        const model = TypeHierarchyModel.create(document, position, cts.token);
-        const direction = sanitizedDirection(this._storageService.get(TypeHierarchyController_1._storageDirectionKey, 0 , "subtypes" ));
-        this._showTypeHierarchyWidget(position, direction, model, cts);
-    }
-    _showTypeHierarchyWidget(position, direction, model, cts) {
-        this._ctxIsVisible.set(true);
-        this._ctxDirection.set(direction);
-        Event.any(this._editor.onDidChangeModel, this._editor.onDidChangeModelLanguage)(this.endTypeHierarchy, this, this._sessionDisposables);
-        this._widget = this._instantiationService.createInstance(TypeHierarchyTreePeekWidget, this._editor, position, direction);
-        this._widget.showLoading();
-        this._sessionDisposables.add(this._widget.onDidClose(() => {
-            this.endTypeHierarchy();
-            this._storageService.store(TypeHierarchyController_1._storageDirectionKey, 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.endTypeHierarchy();
-                return;
-            }
-            this._widget.showMessage(( localize('error', "Failed to show type hierarchy")));
-        });
-    }
-    async startTypeHierarchyFromTypeHierarchy() {
-        if (!this._widget) {
-            return;
-        }
-        const model = this._widget.getModel();
-        const typeItem = this._widget.getFocused();
-        if (!typeItem || !model) {
-            return;
-        }
-        const newEditor = await this._editorService.openCodeEditor({ resource: typeItem.item.uri }, this._editor);
-        if (!newEditor) {
-            return;
-        }
-        const newModel = model.fork(typeItem.item);
-        this._sessionDisposables.clear();
-        TypeHierarchyController_1.get(newEditor)?._showTypeHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
-    }
-    showSupertypes() {
-        this._widget?.updateDirection("supertypes" );
-        this._ctxDirection.set("supertypes" );
-    }
-    showSubtypes() {
-        this._widget?.updateDirection("subtypes" );
-        this._ctxDirection.set("subtypes" );
-    }
-    endTypeHierarchy() {
-        this._sessionDisposables.clear();
-        this._ctxIsVisible.set(false);
-        this._editor.focus();
-    }
-};
-TypeHierarchyController = TypeHierarchyController_1 = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, ICodeEditorService)),
-    ( __param(4, IInstantiationService))
-], TypeHierarchyController));
-registerEditorContribution(TypeHierarchyController.Id, TypeHierarchyController, 0 );
-registerAction2(class PeekTypeHierarchyAction extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.showTypeHierarchy',
-            title: { value: ( localize('title', "Peek Type Hierarchy")), original: 'Peek Type Hierarchy' },
-            menu: {
-                id: MenuId.EditorContextPeek,
-                group: 'navigation',
-                order: 1000,
-                when: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
-            },
-            precondition: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
-            f1: true
-        });
-    }
-    async runEditorCommand(_accessor, editor) {
-        return TypeHierarchyController.get(editor)?.startTypeHierarchyFromEditor();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.showSupertypes',
-            title: { value: ( localize('title.supertypes', "Show Supertypes")), original: 'Show Supertypes' },
-            icon: Codicon.typeHierarchySuper,
-            precondition: ( ContextKeyExpr.and(_ctxTypeHierarchyVisible, ( _ctxTypeHierarchyDirection.isEqualTo("subtypes" )))),
-            keybinding: {
-                weight: 200 ,
-                primary: 1024  + 512  + 38 ,
-            },
-            menu: {
-                id: TypeHierarchyTreePeekWidget.TitleMenu,
-                when: ( _ctxTypeHierarchyDirection.isEqualTo("subtypes" )),
-                order: 1,
-            }
-        });
-    }
-    runEditorCommand(_accessor, editor) {
-        return TypeHierarchyController.get(editor)?.showSupertypes();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.showSubtypes',
-            title: { value: ( localize('title.subtypes', "Show Subtypes")), original: 'Show Subtypes' },
-            icon: Codicon.typeHierarchySub,
-            precondition: ( ContextKeyExpr.and(_ctxTypeHierarchyVisible, ( _ctxTypeHierarchyDirection.isEqualTo("supertypes" )))),
-            keybinding: {
-                weight: 200 ,
-                primary: 1024  + 512  + 38 ,
-            },
-            menu: {
-                id: TypeHierarchyTreePeekWidget.TitleMenu,
-                when: ( _ctxTypeHierarchyDirection.isEqualTo("supertypes" )),
-                order: 1,
-            }
-        });
-    }
-    runEditorCommand(_accessor, editor) {
-        return TypeHierarchyController.get(editor)?.showSubtypes();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.refocusTypeHierarchy',
-            title: { value: ( localize('title.refocusTypeHierarchy', "Refocus Type Hierarchy")), original: 'Refocus Type Hierarchy' },
-            precondition: _ctxTypeHierarchyVisible,
-            keybinding: {
-                weight: 200 ,
-                primary: 1024  + 3
-            }
-        });
-    }
-    async runEditorCommand(_accessor, editor) {
-        return TypeHierarchyController.get(editor)?.startTypeHierarchyFromTypeHierarchy();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.closeTypeHierarchy',
-            title: ( localize('close', 'Close')),
-            icon: Codicon.close,
-            precondition: _ctxTypeHierarchyVisible,
-            keybinding: {
-                weight: 200  + 10,
-                primary: 9 ,
-                when: ContextKeyExpr.not('config.editor.stablePeek')
-            },
-            menu: {
-                id: TypeHierarchyTreePeekWidget.TitleMenu,
-                order: 1000
-            }
-        });
-    }
-    runEditorCommand(_accessor, editor) {
-        return TypeHierarchyController.get(editor)?.endTypeHierarchy();
-    }
-});

package/vscode/src/vs/workbench/contrib/typeHierarchy/browser/typeHierarchyPeek.js

@@ -1,334 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/typeHierarchy.css.js';
-import { Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
-import { TreeMouseEventTarget } from 'monaco-editor/esm/vs/base/browser/ui/tree/tree.js';
-import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { EmbeddedCodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/embeddedCodeEditorWidget.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import * as peekView from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.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 { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { themeColorFromId, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { VirtualDelegate, TypeRenderer, DataSource, Sorter, AccessibilityProvider, IdentityProvider } from './typeHierarchyTree.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-var TypeHierarchyTreePeekWidget_1;
-class LayoutInfo {
-    static store(info, storageService) {
-        storageService.store('typeHierarchyPeekLayout', JSON.stringify(info), 0 , 1 );
-    }
-    static retrieve(storageService) {
-        const value = storageService.get('typeHierarchyPeekLayout', 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 TypeHierarchyTree extends WorkbenchAsyncDataTree {
-}
-let TypeHierarchyTreePeekWidget = class TypeHierarchyTreePeekWidget extends peekView.PeekViewWidget {
-    static { TypeHierarchyTreePeekWidget_1 = this; }
-    static { this.TitleMenu = ( new MenuId('typehierarchy/title')); }
-    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(TypeHierarchyTreePeekWidget_1.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('type-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(TypeHierarchyTree, 'TypeHierarchyPeek', treeContainer, new VirtualDelegate(), [this._instantiationService.createInstance(TypeRenderer)], 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: 'type-hierarchy-decoration',
-            stickiness: 1 ,
-            className: 'type-decoration',
-            overviewRuler: {
-                color: themeColorFromId(peekView.peekViewEditorMatchHighlight),
-                position: OverviewRulerLane.Center
-            },
-        };
-        let previewUri;
-        if (this._direction === "supertypes" ) {
-            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;
-        const loc = { uri: element.item.uri, range: element.item.selectionRange };
-        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 === "supertypes"
-            ? ( localize('supertypes', "Supertypes of '{0}'", element.model.root.name))
-            : ( localize('subtypes', "Subtypes 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 === "supertypes"
-                ? ( localize('empt.supertypes', "No supertypes of '{0}'", model.root.name))
-                : ( localize('empt.subtypes', "No subtypes 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);
-        }
-    }
-};
-TypeHierarchyTreePeekWidget = TypeHierarchyTreePeekWidget_1 = ( __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))
-], TypeHierarchyTreePeekWidget));
-export { TypeHierarchyTreePeekWidget };