@codingame/monaco-vscode-api 2.2.2 → 3.1.0

package/vscode/src/vs/platform/tunnel/common/tunnel.js

@@ -1,5 +1,8 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Emitter } from '../../../base/common/event.js';
+import { IConfigurationService } from '../../configuration/common/configuration.js';
 import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { ILogService } from '../../log/common/log.js';
 const ITunnelService = ( createDecorator('tunnelService'));
 var TunnelProtocol;
 ( (function(TunnelProtocol) {
@@ -12,6 +15,9 @@ var TunnelPrivacyId;
     TunnelPrivacyId["Private"] = "private";
     TunnelPrivacyId["Public"] = "public";
 })(TunnelPrivacyId || (TunnelPrivacyId = {})));
+function isTunnelProvider(addressOrTunnelProvider) {
+    return !!addressOrTunnelProvider.forwardPort;
+}
 var ProvidedOnAutoForward;
 ( (function(ProvidedOnAutoForward) {
     ProvidedOnAutoForward[ProvidedOnAutoForward["Notify"] = 1] = "Notify";
@@ -55,4 +61,264 @@ class DisposableTunnel {
         return this._dispose();
     }
 }
-export { ALL_INTERFACES_ADDRESSES, DisposableTunnel, ITunnelService, LOCALHOST_ADDRESSES, ProvidedOnAutoForward, TunnelPrivacyId, TunnelProtocol, extractLocalHostUriMetaDataForPortMapping, isAllInterfaces, isLocalhost };
+let AbstractTunnelService = class AbstractTunnelService {
+    constructor(logService, configurationService) {
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this._onTunnelOpened = ( new Emitter());
+        this.onTunnelOpened = this._onTunnelOpened.event;
+        this._onTunnelClosed = ( new Emitter());
+        this.onTunnelClosed = this._onTunnelClosed.event;
+        this._onAddedTunnelProvider = ( new Emitter());
+        this.onAddedTunnelProvider = this._onAddedTunnelProvider.event;
+        this._tunnels = ( new Map());
+        this._canElevate = false;
+        this._canChangeProtocol = true;
+        this._privacyOptions = [];
+        this._factoryInProgress = ( new Set());
+    }
+    get hasTunnelProvider() {
+        return !!this._tunnelProvider;
+    }
+    get defaultTunnelHost() {
+        const settingValue = this.configurationService.getValue('remote.localPortHost');
+        return (!settingValue || settingValue === 'localhost') ? '127.0.0.1' : '0.0.0.0';
+    }
+    setTunnelProvider(provider) {
+        this._tunnelProvider = provider;
+        if (!provider) {
+            this._canElevate = false;
+            this._privacyOptions = [];
+            this._onAddedTunnelProvider.fire();
+            return {
+                dispose: () => { }
+            };
+        }
+        this._onAddedTunnelProvider.fire();
+        return {
+            dispose: () => {
+                this._tunnelProvider = undefined;
+                this._canElevate = false;
+                this._privacyOptions = [];
+            }
+        };
+    }
+    setTunnelFeatures(features) {
+        this._canElevate = features.elevation;
+        this._privacyOptions = features.privacyOptions;
+        this._canChangeProtocol = features.protocol;
+    }
+    get canChangeProtocol() {
+        return this._canChangeProtocol;
+    }
+    get canElevate() {
+        return this._canElevate;
+    }
+    get canChangePrivacy() {
+        return this._privacyOptions.length > 0;
+    }
+    get privacyOptions() {
+        return this._privacyOptions;
+    }
+    get tunnels() {
+        return this.getTunnels();
+    }
+    async getTunnels() {
+        const tunnels = [];
+        const tunnelArray = Array.from(( this._tunnels.values()));
+        for (const portMap of tunnelArray) {
+            const portArray = Array.from(( portMap.values()));
+            for (const x of portArray) {
+                const tunnelValue = await x.value;
+                if (tunnelValue && (typeof tunnelValue !== 'string')) {
+                    tunnels.push(tunnelValue);
+                }
+            }
+        }
+        return tunnels;
+    }
+    async dispose() {
+        for (const portMap of ( this._tunnels.values())) {
+            for (const { value } of ( portMap.values())) {
+                await value.then(tunnel => typeof tunnel !== 'string' ? tunnel?.dispose() : undefined);
+            }
+            portMap.clear();
+        }
+        this._tunnels.clear();
+    }
+    setEnvironmentTunnel(remoteHost, remotePort, localAddress, privacy, protocol) {
+        this.addTunnelToMap(remoteHost, remotePort, Promise.resolve({
+            tunnelRemoteHost: remoteHost,
+            tunnelRemotePort: remotePort,
+            localAddress,
+            privacy,
+            protocol,
+            dispose: () => Promise.resolve()
+        }));
+    }
+    async getExistingTunnel(remoteHost, remotePort) {
+        if (isAllInterfaces(remoteHost) || isLocalhost(remoteHost)) {
+            remoteHost = LOCALHOST_ADDRESSES[0];
+        }
+        const existing = this.getTunnelFromMap(remoteHost, remotePort);
+        if (existing) {
+            ++existing.refcount;
+            return existing.value;
+        }
+        return undefined;
+    }
+    openTunnel(addressProvider, remoteHost, remotePort, localHost, localPort, elevateIfNeeded = false, privacy, protocol) {
+        this.logService.trace(`ForwardedPorts: (TunnelService) openTunnel request for ${remoteHost}:${remotePort} on local port ${localPort}.`);
+        const addressOrTunnelProvider = this._tunnelProvider ?? addressProvider;
+        if (!addressOrTunnelProvider) {
+            return undefined;
+        }
+        if (!remoteHost) {
+            remoteHost = 'localhost';
+        }
+        if (!localHost) {
+            localHost = this.defaultTunnelHost;
+        }
+        if (this._tunnelProvider && ( this._factoryInProgress.has(remotePort))) {
+            this.logService.debug(`ForwardedPorts: (TunnelService) Another call to create a tunnel with the same address has occurred before the last one completed. This call will be ignored.`);
+            return;
+        }
+        const resolvedTunnel = this.retainOrCreateTunnel(addressOrTunnelProvider, remoteHost, remotePort, localHost, localPort, elevateIfNeeded, privacy, protocol);
+        if (!resolvedTunnel) {
+            this.logService.trace(`ForwardedPorts: (TunnelService) Tunnel was not created.`);
+            return resolvedTunnel;
+        }
+        return resolvedTunnel.then(tunnel => {
+            if (!tunnel) {
+                this.logService.trace('ForwardedPorts: (TunnelService) New tunnel is undefined.');
+                this.removeEmptyOrErrorTunnelFromMap(remoteHost, remotePort);
+                return undefined;
+            }
+            else if (typeof tunnel === 'string') {
+                this.logService.trace('ForwardedPorts: (TunnelService) The tunnel provider returned an error when creating the tunnel.');
+                this.removeEmptyOrErrorTunnelFromMap(remoteHost, remotePort);
+                return tunnel;
+            }
+            this.logService.trace('ForwardedPorts: (TunnelService) New tunnel established.');
+            const newTunnel = this.makeTunnel(tunnel);
+            if (tunnel.tunnelRemoteHost !== remoteHost || tunnel.tunnelRemotePort !== remotePort) {
+                this.logService.warn('ForwardedPorts: (TunnelService) Created tunnel does not match requirements of requested tunnel. Host or port mismatch.');
+            }
+            if (privacy && tunnel.privacy !== privacy) {
+                this.logService.warn('ForwardedPorts: (TunnelService) Created tunnel does not match requirements of requested tunnel. Privacy mismatch.');
+            }
+            this._onTunnelOpened.fire(newTunnel);
+            return newTunnel;
+        });
+    }
+    makeTunnel(tunnel) {
+        return {
+            tunnelRemotePort: tunnel.tunnelRemotePort,
+            tunnelRemoteHost: tunnel.tunnelRemoteHost,
+            tunnelLocalPort: tunnel.tunnelLocalPort,
+            localAddress: tunnel.localAddress,
+            privacy: tunnel.privacy,
+            protocol: tunnel.protocol,
+            dispose: async () => {
+                this.logService.trace(`ForwardedPorts: (TunnelService) dispose request for ${tunnel.tunnelRemoteHost}:${tunnel.tunnelRemotePort} `);
+                const existingHost = this._tunnels.get(tunnel.tunnelRemoteHost);
+                if (existingHost) {
+                    const existing = existingHost.get(tunnel.tunnelRemotePort);
+                    if (existing) {
+                        existing.refcount--;
+                        await this.tryDisposeTunnel(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort, existing);
+                    }
+                }
+            }
+        };
+    }
+    async tryDisposeTunnel(remoteHost, remotePort, tunnel) {
+        if (tunnel.refcount <= 0) {
+            this.logService.trace(`ForwardedPorts: (TunnelService) Tunnel is being disposed ${remoteHost}:${remotePort}.`);
+            const disposePromise = tunnel.value.then(async (tunnel) => {
+                if (tunnel && (typeof tunnel !== 'string')) {
+                    await tunnel.dispose(true);
+                    this._onTunnelClosed.fire({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort });
+                }
+            });
+            if (( this._tunnels.has(remoteHost))) {
+                this._tunnels.get(remoteHost).delete(remotePort);
+            }
+            return disposePromise;
+        }
+    }
+    async closeTunnel(remoteHost, remotePort) {
+        this.logService.trace(`ForwardedPorts: (TunnelService) close request for ${remoteHost}:${remotePort} `);
+        const portMap = this._tunnels.get(remoteHost);
+        if (portMap && ( portMap.has(remotePort))) {
+            const value = portMap.get(remotePort);
+            value.refcount = 0;
+            await this.tryDisposeTunnel(remoteHost, remotePort, value);
+        }
+    }
+    addTunnelToMap(remoteHost, remotePort, tunnel) {
+        if (!( this._tunnels.has(remoteHost))) {
+            this._tunnels.set(remoteHost, ( new Map()));
+        }
+        this._tunnels.get(remoteHost).set(remotePort, { refcount: 1, value: tunnel });
+    }
+    async removeEmptyOrErrorTunnelFromMap(remoteHost, remotePort) {
+        const hostMap = this._tunnels.get(remoteHost);
+        if (hostMap) {
+            const tunnel = hostMap.get(remotePort);
+            const tunnelResult = tunnel ? await tunnel.value : undefined;
+            if (!tunnelResult || (typeof tunnelResult === 'string')) {
+                hostMap.delete(remotePort);
+            }
+            if (hostMap.size === 0) {
+                this._tunnels.delete(remoteHost);
+            }
+        }
+    }
+    getTunnelFromMap(remoteHost, remotePort) {
+        const hosts = [remoteHost];
+        if (isLocalhost(remoteHost)) {
+            hosts.push(...LOCALHOST_ADDRESSES);
+            hosts.push(...ALL_INTERFACES_ADDRESSES);
+        }
+        else if (isAllInterfaces(remoteHost)) {
+            hosts.push(...ALL_INTERFACES_ADDRESSES);
+        }
+        const existingPortMaps = ( hosts.map(host => this._tunnels.get(host)));
+        for (const map of existingPortMaps) {
+            const existingTunnel = map?.get(remotePort);
+            if (existingTunnel) {
+                return existingTunnel;
+            }
+        }
+        return undefined;
+    }
+    canTunnel(uri) {
+        return !!extractLocalHostUriMetaDataForPortMapping(uri);
+    }
+    createWithProvider(tunnelProvider, remoteHost, remotePort, localPort, elevateIfNeeded, privacy, protocol) {
+        this.logService.trace(`ForwardedPorts: (TunnelService) Creating tunnel with provider ${remoteHost}:${remotePort} on local port ${localPort}.`);
+        const key = remotePort;
+        this._factoryInProgress.add(key);
+        const preferredLocalPort = localPort === undefined ? remotePort : localPort;
+        const creationInfo = { elevationRequired: elevateIfNeeded ? this.isPortPrivileged(preferredLocalPort) : false };
+        const tunnelOptions = { remoteAddress: { host: remoteHost, port: remotePort }, localAddressPort: localPort, privacy, public: privacy ? (privacy !== TunnelPrivacyId.Private) : undefined, protocol };
+        const tunnel = tunnelProvider.forwardPort(tunnelOptions, creationInfo);
+        if (tunnel) {
+            this.addTunnelToMap(remoteHost, remotePort, tunnel);
+            tunnel.finally(() => {
+                this.logService.trace('ForwardedPorts: (TunnelService) Tunnel created by provider.');
+                this._factoryInProgress.delete(key);
+            });
+        }
+        else {
+            this._factoryInProgress.delete(key);
+        }
+        return tunnel;
+    }
+};
+AbstractTunnelService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IConfigurationService))
+], AbstractTunnelService));
+export { ALL_INTERFACES_ADDRESSES, AbstractTunnelService, DisposableTunnel, ITunnelService, LOCALHOST_ADDRESSES, ProvidedOnAutoForward, TunnelPrivacyId, TunnelProtocol, extractLocalHostUriMetaDataForPortMapping, isAllInterfaces, isLocalhost, isTunnelProvider };

package/vscode/src/vs/platform/window/common/window.js

@@ -23,6 +23,9 @@ function getMenuBarVisibility(configurationService) {
         return menuBarVisibility;
     }
 }
+function hasCustomTitlebar(configurationService, titleBarStyle) {
+    return true;
+}
 function hasNativeTitlebar(configurationService, titleBarStyle) {
     if (!titleBarStyle) {
         titleBarStyle = getTitleBarStyle(configurationService);
@@ -50,4 +53,4 @@ function getTitleBarStyle(configurationService) {
     }
     return isLinux ? "native"  : "custom" ;
 }
-export { WindowMinimumSize, getMenuBarVisibility, getTitleBarStyle, hasNativeTitlebar, isFileToOpen, isFolderToOpen, isWorkspaceToOpen };
+export { WindowMinimumSize, getMenuBarVisibility, getTitleBarStyle, hasCustomTitlebar, hasNativeTitlebar, isFileToOpen, isFolderToOpen, isWorkspaceToOpen };

package/vscode/src/vs/platform/workspace/common/workspace.js

@@ -143,6 +143,7 @@ const WORKSPACE_FILTER = [{ name: ( localizeWithPath(
     'codeWorkspace',
     "Code Workspace"
 )), extensions: [WORKSPACE_EXTENSION] }];
+const UNTITLED_WORKSPACE_NAME = 'workspace.json';
 function isUntitledWorkspace(path, environmentService) {
     return extUriBiasedIgnorePathCase.isEqualOrParent(path, environmentService.untitledWorkspacesHome);
 }
@@ -167,4 +168,4 @@ function hasWorkspaceFileExtension(path) {
     const ext = (typeof path === 'string') ? extname(path) : extname$1(path);
     return ext === WORKSPACE_SUFFIX;
 }
-export { EXTENSION_DEVELOPMENT_EMPTY_WINDOW_WORKSPACE, IWorkspaceContextService, STANDALONE_EDITOR_WORKSPACE_ID, UNKNOWN_EMPTY_WINDOW_WORKSPACE, WORKSPACE_EXTENSION, WORKSPACE_FILTER, WORKSPACE_SUFFIX, Workspace$1 as Workspace, WorkspaceFolder, hasWorkspaceFileExtension, isEmptyWorkspaceIdentifier, isSavedWorkspace, isSingleFolderWorkspaceIdentifier, isStandaloneEditorWorkspace, isTemporaryWorkspace, isUntitledWorkspace, isWorkspace, isWorkspaceFolder, isWorkspaceIdentifier, toWorkspaceFolder, toWorkspaceIdentifier };
+export { EXTENSION_DEVELOPMENT_EMPTY_WINDOW_WORKSPACE, IWorkspaceContextService, STANDALONE_EDITOR_WORKSPACE_ID, UNKNOWN_EMPTY_WINDOW_WORKSPACE, UNTITLED_WORKSPACE_NAME, WORKSPACE_EXTENSION, WORKSPACE_FILTER, WORKSPACE_SUFFIX, Workspace$1 as Workspace, WorkspaceFolder, hasWorkspaceFileExtension, isEmptyWorkspaceIdentifier, isSavedWorkspace, isSingleFolderWorkspaceIdentifier, isStandaloneEditorWorkspace, isTemporaryWorkspace, isUntitledWorkspace, isWorkspace, isWorkspaceFolder, isWorkspaceIdentifier, toWorkspaceFolder, toWorkspaceIdentifier };

package/vscode/src/vs/workbench/api/browser/statusBarExtensionPoint.js

@@ -214,10 +214,10 @@ const statusBarItemsSchema = {
         }
     ]
 };
-const statusBarItemsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const statusBarItemsExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'statusBarItems',
     jsonSchema: statusBarItemsSchema,
-}));
+});
 let StatusBarItemsExtensionPoint = class StatusBarItemsExtensionPoint {
     constructor(statusBarItemsService) {
         const contributions = ( new DisposableStore());

package/vscode/src/vs/workbench/api/browser/viewsExtensionPoint.js

@@ -8,11 +8,11 @@ import { SyncDescriptor } from '../../../platform/instantiation/common/descripto
 import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
 import { Registry } from '../../../platform/registry/common/platform.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
-import { Extensions as Extensions$1 } from '../../browser/panecomposite.js';
+import { Extensions as Extensions$2 } from '../../browser/panecomposite.js';
 import { RawCustomTreeViewContextKey, TreeViewPane, CustomTreeView } from '../../browser/parts/views/treeView.js';
 import { ViewPaneContainer } from '../../browser/parts/views/viewPaneContainer.js';
-import { Extensions as Extensions$2 } from '../../common/contributions.js';
-import { Extensions, ResolvableTreeItem } from '../../common/views.js';
+import { registerWorkbenchContribution2 } from '../../common/contributions.js';
+import { Extensions as Extensions$1, ResolvableTreeItem } from '../../common/views.js';
 import { VIEWLET_ID as VIEWLET_ID$3 } from '../../contrib/debug/common/debug.js';
 import { VIEWLET_ID as VIEWLET_ID$1 } from '../../contrib/files/common/files.js';
 import { VIEWLET_ID } from '../../contrib/remote/browser/remoteExplorer.js';
@@ -28,6 +28,8 @@ import { CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { AsyncDataTree } from '../../../base/browser/ui/tree/asyncDataTree.js';
 import { ITreeViewsService } from '../../services/views/browser/treeViewsService.js';
 import { ILogService } from '../../../platform/log/common/log.js';
+import { Extensions } from '../../services/extensionManagement/common/extensionFeatures.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
 const viewsContainerSchema = {
     type: 'object',
     properties: {
@@ -327,11 +329,11 @@ const viewsContribution = {
         default: []
     }
 };
-const viewsContainersExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const viewsContainersExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'viewsContainers',
     jsonSchema: viewsContainersContribution
-}));
-const viewsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+});
+const viewsExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'views',
     deps: [viewsContainersExtensionPoint],
     jsonSchema: viewsContribution,
@@ -346,14 +348,15 @@ const viewsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         }
     }
-}));
+});
 const CUSTOM_VIEWS_START_ORDER = 7;
 let ViewsExtensionHandler = class ViewsExtensionHandler {
+    static { this.ID = 'workbench.contrib.viewsExtensionHandler'; }
     constructor(instantiationService, logService) {
         this.instantiationService = instantiationService;
         this.logService = logService;
-        this.viewContainersRegistry = ( Registry.as(Extensions.ViewContainersRegistry));
-        this.viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+        this.viewContainersRegistry = ( Registry.as(Extensions$1.ViewContainersRegistry));
+        this.viewsRegistry = ( Registry.as(Extensions$1.ViewsRegistry));
         this.handleAndRegisterCustomViewContainers();
         this.handleAndRegisterCustomViews();
         let showTreeHoverCancellation = ( new CancellationTokenSource());
@@ -411,7 +414,7 @@ let ViewsExtensionHandler = class ViewsExtensionHandler {
         });
     }
     addCustomViewContainers(extensionPoints, existingViewContainers) {
-        const viewContainersRegistry = ( Registry.as(Extensions.ViewContainersRegistry));
+        const viewContainersRegistry = ( Registry.as(Extensions$1.ViewContainersRegistry));
         let activityBarOrder = CUSTOM_VIEWS_START_ORDER + viewContainersRegistry.all.filter(v => !!v.extensionId && viewContainersRegistry.getViewContainerLocation(v) === 0 ).length;
         let panelOrder = 5 + viewContainersRegistry.all.filter(v => !!v.extensionId && viewContainersRegistry.getViewContainerLocation(v) === 1 ).length + 1;
         for (const { value, collector, description } of extensionPoints) {
@@ -431,7 +434,7 @@ let ViewsExtensionHandler = class ViewsExtensionHandler {
         }
     }
     removeCustomViewContainers(extensionPoints) {
-        const viewContainersRegistry = ( Registry.as(Extensions.ViewContainersRegistry));
+        const viewContainersRegistry = ( Registry.as(Extensions$1.ViewContainersRegistry));
         const removedExtensions = extensionPoints.reduce((result, e) => { result.add(e.description.identifier); return result; }, ( new ExtensionIdentifierSet()));
         for (const viewContainer of viewContainersRegistry.all) {
             if (viewContainer.extensionId && ( removedExtensions.has(viewContainer.extensionId))) {
@@ -539,7 +542,7 @@ let ViewsExtensionHandler = class ViewsExtensionHandler {
     }
     deregisterCustomViewContainer(viewContainer) {
         this.viewContainersRegistry.deregisterViewContainer(viewContainer);
-        ( Registry.as(Extensions$1.Viewlets)).deregisterPaneComposite(viewContainer.id);
+        ( Registry.as(Extensions$2.Viewlets)).deregisterPaneComposite(viewContainer.id);
     }
     handleAndRegisterCustomViews() {
         viewsExtensionPoint.setHandler((extensions, { added, removed }) => {
@@ -783,6 +786,119 @@ ViewsExtensionHandler = ( __decorate([
     ( __param(0, IInstantiationService)),
     ( __param(1, ILogService))
 ], ViewsExtensionHandler));
-const workbenchRegistry = ( Registry.as(Extensions$2.Workbench));
-workbenchRegistry.registerWorkbenchContribution(ViewsExtensionHandler, 1 );
+class ViewContainersDataRenderer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.type = 'table';
+    }
+    shouldRender(manifest) {
+        return !!manifest.contributes?.viewsContainers;
+    }
+    render(manifest) {
+        const contrib = manifest.contributes?.viewsContainers || {};
+        const viewContainers = ( Object.keys(contrib)).reduce((result, location) => {
+            const viewContainersForLocation = contrib[location];
+            result.push(...( viewContainersForLocation.map(viewContainer => ({ ...viewContainer, location }))));
+            return result;
+        }, []);
+        if (!viewContainers.length) {
+            return { data: { headers: [], rows: [] }, dispose: () => { } };
+        }
+        const headers = [
+            ( localizeWithPath('vs/workbench/api/browser/viewsExtensionPoint', 'view container id', "ID")),
+            ( localizeWithPath(
+                'vs/workbench/api/browser/viewsExtensionPoint',
+                'view container title',
+                "Title"
+            )),
+            ( localizeWithPath(
+                'vs/workbench/api/browser/viewsExtensionPoint',
+                'view container location',
+                "Where"
+            )),
+        ];
+        const rows = ( viewContainers
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map(viewContainer => {
+            return [
+                viewContainer.id,
+                viewContainer.title,
+                viewContainer.location
+            ];
+        }));
+        return {
+            data: {
+                headers,
+                rows
+            },
+            dispose: () => { }
+        };
+    }
+}
+class ViewsDataRenderer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.type = 'table';
+    }
+    shouldRender(manifest) {
+        return !!manifest.contributes?.views;
+    }
+    render(manifest) {
+        const contrib = manifest.contributes?.views || {};
+        const views = ( Object.keys(contrib)).reduce((result, location) => {
+            const viewsForLocation = contrib[location];
+            result.push(...( viewsForLocation.map(view => ({ ...view, location }))));
+            return result;
+        }, []);
+        if (!views.length) {
+            return { data: { headers: [], rows: [] }, dispose: () => { } };
+        }
+        const headers = [
+            ( localizeWithPath('vs/workbench/api/browser/viewsExtensionPoint', 'view id', "ID")),
+            ( localizeWithPath('vs/workbench/api/browser/viewsExtensionPoint', 'view name title', "Name")),
+            ( localizeWithPath(
+                'vs/workbench/api/browser/viewsExtensionPoint',
+                'view container location',
+                "Where"
+            )),
+        ];
+        const rows = ( views
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map(view => {
+            return [
+                view.id,
+                view.name,
+                view.location
+            ];
+        }));
+        return {
+            data: {
+                headers,
+                rows
+            },
+            dispose: () => { }
+        };
+    }
+}
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: 'viewsContainers',
+    label: ( localizeWithPath(
+        'vs/workbench/api/browser/viewsExtensionPoint',
+        'viewsContainers',
+        "View Containers"
+    )),
+    access: {
+        canToggle: false
+    },
+    renderer: ( new SyncDescriptor(ViewContainersDataRenderer)),
+});
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: 'views',
+    label: ( localizeWithPath('vs/workbench/api/browser/viewsExtensionPoint', 'views', "Views")),
+    access: {
+        canToggle: false
+    },
+    renderer: ( new SyncDescriptor(ViewsDataRenderer)),
+});
+registerWorkbenchContribution2(ViewsExtensionHandler.ID, ViewsExtensionHandler, 1 );
 export { viewsContainersContribution };