@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IWorkbenchExtensionEnablementService } from '../../../services/extensionManagement/common/extensionManagement.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+let ExtensionEnablementWorkspaceTrustTransitionParticipant = class ExtensionEnablementWorkspaceTrustTransitionParticipant extends Disposable {
+    constructor(extensionService, hostService, environmentService, extensionEnablementService, workspaceTrustEnablementService, workspaceTrustManagementService) {
+        super();
+        if (workspaceTrustEnablementService.isWorkspaceTrustEnabled()) {
+            workspaceTrustManagementService.workspaceTrustInitialized.then(() => {
+                const workspaceTrustTransitionParticipant = new (class {
+                    async participate(trusted) {
+                        if (trusted) {
+                            await extensionEnablementService.updateExtensionsEnablementsWhenWorkspaceTrustChanges();
+                        }
+                        else {
+                            if (environmentService.remoteAuthority) {
+                                hostService.reload();
+                            }
+                            else {
+                                const stopped = await extensionService.stopExtensionHosts(( localizeWithPath(
+                                    'vs/workbench/contrib/extensions/browser/extensionEnablementWorkspaceTrustTransitionParticipant',
+                                    'restartExtensionHost.reason',
+                                    "Restarting extension host due to workspace trust change."
+                                )));
+                                await extensionEnablementService.updateExtensionsEnablementsWhenWorkspaceTrustChanges();
+                                if (stopped) {
+                                    extensionService.startExtensionHosts();
+                                }
+                            }
+                        }
+                    }
+                });
+                this._register(workspaceTrustManagementService.addWorkspaceTrustTransitionParticipant(workspaceTrustTransitionParticipant));
+            });
+        }
+    }
+};
+ExtensionEnablementWorkspaceTrustTransitionParticipant = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IHostService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IWorkbenchExtensionEnablementService)),
+    ( __param(4, IWorkspaceTrustEnablementService)),
+    ( __param(5, IWorkspaceTrustManagementService))
+], ExtensionEnablementWorkspaceTrustTransitionParticipant));
+export { ExtensionEnablementWorkspaceTrustTransitionParticipant };

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

@@ -0,0 +1,543 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { $, append, clearNode } from '../../../../base/browser/dom.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { Sizing, SplitView } from '../../../../base/browser/ui/splitview/splitview.js';
+import { Extensions, IExtensionFeaturesManagementService } from '../../../services/extensionManagement/common/extensionFeatures.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { WorkbenchList } from '../../../../platform/list/browser/listService.js';
+import { getExtensionId } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { defaultKeybindingLabelStyles, defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { renderMarkdown } from '../../../../base/browser/markdownRenderer.js';
+import { getErrorMessage, onUnexpectedError } from '../../../../base/common/errors.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { PANEL_SECTION_BORDER } from '../../../common/theme.js';
+import { Themable, IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { DomScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { errorIcon, warningIcon, infoIcon } from './extensionsIcons.js';
+import { SeverityIcon } from '../../../../platform/severityIcon/browser/severityIcon.js';
+import { KeybindingLabel } from '../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { OS } from '../../../../base/common/platform.js';
+import { MarkdownString, isMarkdownString } from '../../../../base/common/htmlContent.js';
+import { Color } from '../../../../base/common/color.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
+import { fromNow } from '../../../../base/common/date.js';
+import { ResolvedKeybinding } from '../../../../base/common/keybindings.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+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$1.Error ? Codicon.error : message.type === Severity$1.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$1.Error) {
+                        data.appendMarkdown(`$(${errorIcon.id}) ${status.message}\n\n`);
+                    }
+                    if (status?.severity === Severity$1.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$1.Error ? errorIcon : accessData.current.status.severity === Severity$1.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));
+        const tableDisposable = this._register(( new MutableDisposable()));
+        if (tableData.onDidChange) {
+            this._register(tableData.onDidChange(data => {
+                clearNode(container);
+                tableDisposable.value = this.renderTable(data, container);
+            }));
+        }
+        tableDisposable.value = this.renderTable(tableData.data, container);
+    }
+    renderTable(tableData, container) {
+        const disposables = ( new DisposableStore());
+        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 = disposables.add(( 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());
+            })));
+        }))));
+        return disposables;
+    }
+    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 };