@codingame/monaco-vscode-api 3.0.0 → 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/workbench/api/common/extHost.api.impl.js

@@ -529,7 +529,7 @@ function createApiFactoryAndRegisterActors(accessor) {
                 const interalSelector = LanguageSelector.from(selector);
                 let notebook;
                 if (targetsNotebooks(interalSelector)) {
-                    notebook = extHostNotebook.notebookDocuments.find(value => Boolean(value.getCell(document.uri)))?.apiNotebook;
+                    notebook = extHostNotebook.notebookDocuments.find(value => value.apiNotebook.getCells().find(c => c.document === document))?.apiNotebook;
                 }
                 return score(interalSelector, document.uri, document.languageId, true, notebook?.uri, notebook?.notebookType);
             },

package/vscode/src/vs/workbench/api/common/extHostNotebookDocument.js

@@ -2,7 +2,7 @@ import { Schemas } from '../../../base/common/network.js';
 import { URI } from '../../../base/common/uri.js';
 import { NotebookCellOutput, NotebookCellExecutionSummary, NotebookCellKind, NotebookCellOutputItem } from './extHostTypeConverters.js';
 import { NotebookRange } from './extHostTypes.js';
-import { isTextStreamMime, compressOutputItemStreams, NotebookCellsChangeType, CellUri } from '../../contrib/notebook/common/notebookCommon.js';
+import { isTextStreamMime, compressOutputItemStreams, NotebookCellsChangeType } from '../../contrib/notebook/common/notebookCommon.js';
 class RawContentChangeEvent {
     constructor(start, deletedCount, deletedItems, items) {
         this.start = start;
@@ -357,16 +357,6 @@ class ExtHostNotebookDocument {
         return this._cells[index];
     }
     getCell(cellHandle) {
-        if (URI.isUri(cellHandle)) {
-            const data = CellUri.parse(cellHandle);
-            if (!data) {
-                return undefined;
-            }
-            if (( data.notebook.toString()) !== ( this.uri.toString())) {
-                return undefined;
-            }
-            cellHandle = data.handle;
-        }
         return this._cells.find(cell => cell.handle === cellHandle);
     }
     getCellIndex(cell) {