@codingame/monaco-vscode-extension-gallery-service-override 2.2.2 → 3.0.0

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionFeaturesTab.js

@@ -0,0 +1,542 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { $, append, clearNode } from 'vscode/vscode/vs/base/browser/dom';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { SplitView, Sizing } from 'vscode/vscode/vs/base/browser/ui/splitview/splitview';
+import { Extensions, IExtensionFeaturesManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { WorkbenchList } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { getExtensionId } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { Button } from 'vscode/vscode/vs/base/browser/ui/button/button';
+import { defaultButtonStyles, defaultKeybindingLabelStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { renderMarkdown } from 'vscode/vscode/vs/base/browser/markdownRenderer';
+import { getErrorMessage, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { PANEL_SECTION_BORDER } from 'vscode/vscode/vs/workbench/common/theme';
+import { Themable, IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import Severity from 'vscode/vscode/vs/base/common/severity';
+import { errorIcon, warningIcon, infoIcon } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
+import { SeverityIcon } from 'vscode/vscode/vs/platform/severityIcon/browser/severityIcon';
+import { KeybindingLabel } from 'vscode/vscode/vs/base/browser/ui/keybindingLabel/keybindingLabel';
+import { OS } from 'vscode/vscode/vs/base/common/platform';
+import { MarkdownString, isMarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { Color } from 'vscode/vscode/vs/base/common/color';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { fromNow } from 'vscode/vscode/vs/base/common/date';
+import { ResolvedKeybinding } from 'vscode/vscode/vs/base/common/keybindings';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+let RuntimeStatusMarkdownRenderer = class RuntimeStatusMarkdownRenderer extends Disposable {
+    static { this.ID = 'runtimeStatus'; }
+    constructor(extensionService, extensionFeaturesManagementService) {
+        super();
+        this.extensionService = extensionService;
+        this.extensionFeaturesManagementService = extensionFeaturesManagementService;
+        this.type = 'markdown';
+    }
+    shouldRender(manifest) {
+        const extensionId = ( new ExtensionIdentifier(getExtensionId(manifest.publisher, manifest.name)));
+        if (!( this.extensionService.extensions.some(e => ExtensionIdentifier.equals(e.identifier, extensionId)))) {
+            return false;
+        }
+        return !!manifest.main || !!manifest.browser;
+    }
+    render(manifest) {
+        const disposables = ( new DisposableStore());
+        const extensionId = ( new ExtensionIdentifier(getExtensionId(manifest.publisher, manifest.name)));
+        const emitter = disposables.add(( new Emitter()));
+        disposables.add(this.extensionService.onDidChangeExtensionsStatus(e => {
+            if (( e.some(extension => ExtensionIdentifier.equals(extension, extensionId)))) {
+                emitter.fire(this.getActivationData(manifest));
+            }
+        }));
+        disposables.add(this.extensionFeaturesManagementService.onDidChangeAccessData(e => emitter.fire(this.getActivationData(manifest))));
+        return {
+            onDidChange: emitter.event,
+            data: this.getActivationData(manifest),
+            dispose: () => disposables.dispose()
+        };
+    }
+    getActivationData(manifest) {
+        const data = ( new MarkdownString());
+        const extensionId = ( new ExtensionIdentifier(getExtensionId(manifest.publisher, manifest.name)));
+        const status = this.extensionService.getExtensionsStatus()[extensionId.value];
+        if (( this.extensionService.extensions.some(extension => ExtensionIdentifier.equals(extension.identifier, extensionId)))) {
+            data.appendMarkdown(`### ${( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                'activation',
+                "Activation"
+            ))}\n\n`);
+            if (status.activationTimes) {
+                if (status.activationTimes.activationReason.startup) {
+                    data.appendMarkdown(`Activated on Startup: \`${status.activationTimes.activateCallTime}ms\``);
+                }
+                else {
+                    data.appendMarkdown(`Activated by \`${status.activationTimes.activationReason.activationEvent}\` event: \`${status.activationTimes.activateCallTime}ms\``);
+                }
+            }
+            else {
+                data.appendMarkdown('Not yet activated');
+            }
+            if (status.runtimeErrors.length) {
+                data.appendMarkdown(`\n ### ${( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                    'uncaught errors',
+                    "Uncaught Errors ({0})",
+                    status.runtimeErrors.length
+                ))}\n`);
+                for (const error of status.runtimeErrors) {
+                    data.appendMarkdown(`$(${Codicon.error.id}) ${getErrorMessage(error)}\n\n`);
+                }
+            }
+            if (status.messages.length) {
+                data.appendMarkdown(`\n ### ${( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                    'messaages',
+                    "Messages ({0})",
+                    status.messages.length
+                ))}\n`);
+                for (const message of status.messages) {
+                    data.appendMarkdown(`$(${(message.type === Severity.Error ? Codicon.error : message.type === Severity.Warning ? Codicon.warning : Codicon.info).id}) ${message.message}\n\n`);
+                }
+            }
+        }
+        const features = ( Registry.as(Extensions.ExtensionFeaturesRegistry)).getExtensionFeatures();
+        for (const feature of features) {
+            const accessData = this.extensionFeaturesManagementService.getAccessData(extensionId, feature.id);
+            if (accessData) {
+                data.appendMarkdown(`\n ### ${feature.label}\n\n`);
+                const status = accessData?.current?.status;
+                if (status) {
+                    if (status?.severity === Severity.Error) {
+                        data.appendMarkdown(`$(${errorIcon.id}) ${status.message}\n\n`);
+                    }
+                    if (status?.severity === Severity.Warning) {
+                        data.appendMarkdown(`$(${warningIcon.id}) ${status.message}\n\n`);
+                    }
+                }
+                if (accessData?.totalCount) {
+                    if (accessData.current) {
+                        data.appendMarkdown(`${( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                            'last request',
+                            "Last Request: `{0}`",
+                            fromNow(accessData.current.lastAccessed, true, true)
+                        ))}\n\n`);
+                        data.appendMarkdown(`${( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                            'requests count session',
+                            "Requests (Session) : `{0}`",
+                            accessData.current.count
+                        ))}\n\n`);
+                    }
+                    data.appendMarkdown(`${( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'requests count total',
+                        "Requests (Overall): `{0}`",
+                        accessData.totalCount
+                    ))}\n\n`);
+                }
+            }
+        }
+        return data;
+    }
+};
+RuntimeStatusMarkdownRenderer = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IExtensionFeaturesManagementService))
+], RuntimeStatusMarkdownRenderer));
+const runtimeStatusFeature = {
+    id: RuntimeStatusMarkdownRenderer.ID,
+    label: ( localizeWithPath(
+        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+        'runtime',
+        "Runtime Status"
+    )),
+    access: {
+        canToggle: false
+    },
+    renderer: ( new SyncDescriptor(RuntimeStatusMarkdownRenderer)),
+};
+let ExtensionFeaturesTab = class ExtensionFeaturesTab extends Themable {
+    constructor(manifest, feature, themeService, instantiationService) {
+        super(themeService);
+        this.manifest = manifest;
+        this.feature = feature;
+        this.instantiationService = instantiationService;
+        this.featureView = this._register(( new MutableDisposable()));
+        this.layoutParticipants = [];
+        this.extensionId = ( new ExtensionIdentifier(getExtensionId(manifest.publisher, manifest.name)));
+        this.domNode = $('div.subcontent.feature-contributions');
+        this.create();
+    }
+    layout(height, width) {
+        this.layoutParticipants.forEach(participant => participant.layout(height, width));
+    }
+    create() {
+        const features = this.getFeatures();
+        if (features.length === 0) {
+            append($('.no-features'), this.domNode).textContent = ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                'noFeatures',
+                "No features contributed."
+            ));
+            return;
+        }
+        const splitView = ( new SplitView(this.domNode, {
+            orientation: 1 ,
+            proportionalLayout: true
+        }));
+        this.layoutParticipants.push({
+            layout: (height, width) => {
+                splitView.el.style.height = `${height - 14}px`;
+                splitView.layout(width);
+            }
+        });
+        const featuresListContainer = $('.features-list-container');
+        const list = this.createFeaturesList(featuresListContainer);
+        list.splice(0, list.length, features);
+        const featureViewContainer = $('.feature-view-container');
+        this._register(list.onDidChangeSelection(e => {
+            const feature = e.elements[0];
+            if (feature) {
+                this.showFeatureView(feature, featureViewContainer);
+            }
+        }));
+        const index = this.feature ? features.findIndex(f => f.id === this.feature) : 0;
+        list.setSelection([index === -1 ? 0 : index]);
+        splitView.addView({
+            onDidChange: Event.None,
+            element: featuresListContainer,
+            minimumSize: 100,
+            maximumSize: Number.POSITIVE_INFINITY,
+            layout: (width, _, height) => {
+                featuresListContainer.style.width = `${width}px`;
+                list.layout(height, width);
+            }
+        }, 200, undefined, true);
+        splitView.addView({
+            onDidChange: Event.None,
+            element: featureViewContainer,
+            minimumSize: 500,
+            maximumSize: Number.POSITIVE_INFINITY,
+            layout: (width, _, height) => {
+                featureViewContainer.style.width = `${width}px`;
+                this.featureViewDimension = { height, width };
+                this.layoutFeatureView();
+            }
+        }, Sizing.Distribute, undefined, true);
+        splitView.style({
+            separatorBorder: this.theme.getColor(PANEL_SECTION_BORDER)
+        });
+    }
+    createFeaturesList(container) {
+        const renderer = this.instantiationService.createInstance(ExtensionFeatureItemRenderer, this.extensionId);
+        const delegate = ( new ExtensionFeatureItemDelegate());
+        const list = this.instantiationService.createInstance(WorkbenchList, 'ExtensionFeaturesList', append(container, $('.features-list-wrapper')), delegate, [renderer], {
+            multipleSelectionSupport: false,
+            setRowLineHeight: false,
+            horizontalScrolling: false,
+            accessibilityProvider: {
+                getAriaLabel(extensionFeature) {
+                    return extensionFeature?.label ?? '';
+                },
+                getWidgetAriaLabel() {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'extension features list',
+                        "Extension Features"
+                    ));
+                }
+            },
+            openOnSingleClick: true
+        });
+        return list;
+    }
+    layoutFeatureView() {
+        this.featureView.value?.layout(this.featureViewDimension?.height, this.featureViewDimension?.width);
+    }
+    showFeatureView(feature, container) {
+        if (this.featureView.value?.feature.id === feature.id) {
+            return;
+        }
+        clearNode(container);
+        this.featureView.value = this.instantiationService.createInstance(ExtensionFeatureView, this.extensionId, this.manifest, feature);
+        container.appendChild(this.featureView.value.domNode);
+        this.layoutFeatureView();
+    }
+    getFeatures() {
+        const features = ( Registry.as(Extensions.ExtensionFeaturesRegistry))
+            .getExtensionFeatures().filter(feature => {
+            const renderer = this.getRenderer(feature);
+            const shouldRender = renderer?.shouldRender(this.manifest);
+            renderer?.dispose();
+            return shouldRender;
+        }).sort((a, b) => a.label.localeCompare(b.label));
+        const renderer = this.getRenderer(runtimeStatusFeature);
+        if (renderer?.shouldRender(this.manifest)) {
+            features.splice(0, 0, runtimeStatusFeature);
+        }
+        renderer?.dispose();
+        return features;
+    }
+    getRenderer(feature) {
+        return feature.renderer ? this.instantiationService.createInstance(feature.renderer) : undefined;
+    }
+};
+ExtensionFeaturesTab = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, IInstantiationService))
+], ExtensionFeaturesTab));
+class ExtensionFeatureItemDelegate {
+    getHeight() { return 22; }
+    getTemplateId() { return 'extensionFeatureDescriptor'; }
+}
+let ExtensionFeatureItemRenderer = class ExtensionFeatureItemRenderer {
+    constructor(extensionId, extensionFeaturesManagementService) {
+        this.extensionId = extensionId;
+        this.extensionFeaturesManagementService = extensionFeaturesManagementService;
+        this.templateId = 'extensionFeatureDescriptor';
+    }
+    renderTemplate(container) {
+        container.classList.add('extension-feature-list-item');
+        const label = append(container, $('.extension-feature-label'));
+        const disabledElement = append(container, $('.extension-feature-disabled-label'));
+        disabledElement.textContent = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+            'revoked',
+            "No Access"
+        ));
+        const statusElement = append(container, $('.extension-feature-status'));
+        return { label, disabledElement, statusElement, disposables: ( new DisposableStore()) };
+    }
+    renderElement(element, index, templateData) {
+        templateData.disposables.clear();
+        templateData.label.textContent = element.label;
+        templateData.disabledElement.style.display = element.id === runtimeStatusFeature.id || this.extensionFeaturesManagementService.isEnabled(this.extensionId, element.id) ? 'none' : 'inherit';
+        templateData.disposables.add(this.extensionFeaturesManagementService.onDidChangeEnablement(({ extension, featureId, enabled }) => {
+            if (ExtensionIdentifier.equals(extension, this.extensionId) && featureId === element.id) {
+                templateData.disabledElement.style.display = enabled ? 'none' : 'inherit';
+            }
+        }));
+        const statusElementClassName = templateData.statusElement.className;
+        const updateStatus = () => {
+            const accessData = this.extensionFeaturesManagementService.getAccessData(this.extensionId, element.id);
+            if (accessData?.current?.status) {
+                templateData.statusElement.style.display = 'inherit';
+                templateData.statusElement.className = `${statusElementClassName} ${SeverityIcon.className(accessData.current.status.severity)}`;
+            }
+            else {
+                templateData.statusElement.style.display = 'none';
+            }
+        };
+        updateStatus();
+        templateData.disposables.add(this.extensionFeaturesManagementService.onDidChangeAccessData(({ extension, featureId }) => {
+            if (ExtensionIdentifier.equals(extension, this.extensionId) && featureId === element.id) {
+                updateStatus();
+            }
+        }));
+    }
+    disposeElement(element, index, templateData, height) {
+        templateData.disposables.dispose();
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+ExtensionFeatureItemRenderer = ( __decorate([
+    ( __param(1, IExtensionFeaturesManagementService))
+], ExtensionFeatureItemRenderer));
+let ExtensionFeatureView = class ExtensionFeatureView extends Disposable {
+    constructor(extensionId, manifest, feature, openerService, instantiationService, extensionFeaturesManagementService, dialogService) {
+        super();
+        this.extensionId = extensionId;
+        this.manifest = manifest;
+        this.feature = feature;
+        this.openerService = openerService;
+        this.instantiationService = instantiationService;
+        this.extensionFeaturesManagementService = extensionFeaturesManagementService;
+        this.dialogService = dialogService;
+        this.layoutParticipants = [];
+        this.domNode = $('.extension-feature-content');
+        this.create(this.domNode);
+    }
+    create(content) {
+        const header = append(content, $('.feature-header'));
+        const title = append(header, $('.feature-title'));
+        title.textContent = this.feature.label;
+        if (this.feature.access.canToggle) {
+            const actionsContainer = append(header, $('.feature-actions'));
+            const button = ( new Button(actionsContainer, defaultButtonStyles));
+            this.updateButtonLabel(button);
+            this._register(this.extensionFeaturesManagementService.onDidChangeEnablement(({ extension, featureId }) => {
+                if (ExtensionIdentifier.equals(extension, this.extensionId) && featureId === this.feature.id) {
+                    this.updateButtonLabel(button);
+                }
+            }));
+            this._register(button.onDidClick(async () => {
+                const enabled = this.extensionFeaturesManagementService.isEnabled(this.extensionId, this.feature.id);
+                const confirmationResult = await this.dialogService.confirm({
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'accessExtensionFeature',
+                        "Enable '{0}' Feature",
+                        this.feature.label
+                    )),
+                    message: enabled
+                        ? ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'disableAccessExtensionFeatureMessage',
+                        "Would you like to revoke '{0}' extension to access '{1}' feature?",
+                        this.manifest.displayName ?? this.extensionId.value,
+                        this.feature.label
+                    ))
+                        : ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'enableAccessExtensionFeatureMessage',
+                        "Would you like to allow '{0}' extension to access '{1}' feature?",
+                        this.manifest.displayName ?? this.extensionId.value,
+                        this.feature.label
+                    )),
+                    custom: true,
+                    primaryButton: enabled ? ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'revoke',
+                        "Revoke Access"
+                    )) : ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'grant',
+                        "Allow Access"
+                    )),
+                    cancelButton: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+                        'cancel',
+                        "Cancel"
+                    )),
+                });
+                if (confirmationResult.confirmed) {
+                    this.extensionFeaturesManagementService.setEnablement(this.extensionId, this.feature.id, !enabled);
+                }
+            }));
+        }
+        const body = append(content, $('.feature-body'));
+        const bodyContent = $('.feature-body-content');
+        const scrollableContent = this._register(( new DomScrollableElement(bodyContent, {})));
+        append(body, scrollableContent.getDomNode());
+        this.layoutParticipants.push({ layout: () => scrollableContent.scanDomNode() });
+        scrollableContent.scanDomNode();
+        if (this.feature.description) {
+            const description = append(bodyContent, $('.feature-description'));
+            description.textContent = this.feature.description;
+        }
+        const accessData = this.extensionFeaturesManagementService.getAccessData(this.extensionId, this.feature.id);
+        if (accessData?.current?.status) {
+            append(bodyContent, $('.feature-status', undefined, $(`span${ThemeIcon.asCSSSelector(accessData.current.status.severity === Severity.Error ? errorIcon : accessData.current.status.severity === Severity.Warning ? warningIcon : infoIcon)}`, undefined), $('span', undefined, accessData.current.status.message)));
+        }
+        const featureContentElement = append(bodyContent, $('.feature-content'));
+        if (this.feature.renderer) {
+            const renderer = this.instantiationService.createInstance(this.feature.renderer);
+            if (renderer.type === 'table') {
+                this.renderTableData(featureContentElement, renderer);
+            }
+            else if (renderer.type === 'markdown') {
+                this.renderMarkdownData(featureContentElement, renderer);
+            }
+        }
+    }
+    updateButtonLabel(button) {
+        button.label = this.extensionFeaturesManagementService.isEnabled(this.extensionId, this.feature.id) ? ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+            'revoke',
+            "Revoke Access"
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionFeaturesTab',
+            'enable',
+            "Allow Access"
+        ));
+    }
+    renderTableData(container, renderer) {
+        const tableData = this._register(renderer.render(this.manifest));
+        if (tableData.onDidChange) {
+            this._register(tableData.onDidChange(data => {
+                clearNode(container);
+                this.renderTable(data, container);
+            }));
+        }
+        this.renderTable(tableData.data, container);
+    }
+    renderTable(tableData, container) {
+        append(container, $('table', undefined, $('tr', undefined, ...( tableData.headers.map(header => $('th', undefined, header)))), ...( tableData.rows
+            .map(row => {
+            return $('tr', undefined, ...( row.map(rowData => {
+                if (typeof rowData === 'string') {
+                    return $('td', undefined, rowData);
+                }
+                const data = Array.isArray(rowData) ? rowData : [rowData];
+                return $('td', undefined, ...( data.map(item => {
+                    const result = [];
+                    if (isMarkdownString(rowData)) {
+                        const element = $('', undefined);
+                        this.renderMarkdown(rowData, element);
+                        result.push(element);
+                    }
+                    else if (item instanceof ResolvedKeybinding) {
+                        const element = $('');
+                        const kbl = ( new KeybindingLabel(element, OS, defaultKeybindingLabelStyles));
+                        kbl.set(item);
+                        result.push(element);
+                    }
+                    else if (item instanceof Color) {
+                        result.push($('span', { class: 'colorBox', style: 'background-color: ' + Color.Format.CSS.format(item) }, ''));
+                        result.push($('code', undefined, Color.Format.CSS.formatHex(item)));
+                    }
+                    return result;
+                })).flat());
+            })));
+        }))));
+    }
+    renderMarkdownData(container, renderer) {
+        container.classList.add('markdown');
+        const markdownData = this._register(renderer.render(this.manifest));
+        if (markdownData.onDidChange) {
+            this._register(markdownData.onDidChange(data => {
+                clearNode(container);
+                this.renderMarkdown(data, container);
+            }));
+        }
+        this.renderMarkdown(markdownData.data, container);
+    }
+    renderMarkdown(markdown, container) {
+        const { element, dispose } = renderMarkdown({
+            value: markdown.value,
+            isTrusted: markdown.isTrusted,
+            supportThemeIcons: true
+        }, {
+            actionHandler: {
+                callback: (content) => this.openerService.open(content, { allowCommands: !!markdown.isTrusted }).catch(onUnexpectedError),
+                disposables: this._store
+            },
+        });
+        this._register(toDisposable(dispose));
+        append(container, element);
+    }
+    layout(height, width) {
+        this.layoutParticipants.forEach(p => p.layout(height, width));
+    }
+};
+ExtensionFeatureView = ( __decorate([
+    ( __param(3, IOpenerService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IExtensionFeaturesManagementService)),
+    ( __param(6, IDialogService))
+], ExtensionFeatureView));
+
+export { ExtensionFeaturesTab };