@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.7

package/dist/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser.js

@@ -1,27 +0,0 @@
-import { NOTEBOOK_EDITOR_ID } from '../common/notebookCommon.js';
-import { isCompositeNotebookEditorInput } from '../common/notebookEditorInput.js';
-const IPYNB_VIEW_TYPE = 'jupyter-notebook';
-const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
-const KERNEL_RECOMMENDATIONS = ( new Map());
-KERNEL_RECOMMENDATIONS.set(IPYNB_VIEW_TYPE, ( new Map()));
-KERNEL_RECOMMENDATIONS.get(IPYNB_VIEW_TYPE)?.set('python', {
-    extensionIds: [
-        'ms-python.python',
-        JUPYTER_EXTENSION_ID
-    ],
-    displayName: 'Python + Jupyter',
-});
-function getNotebookEditorFromEditorPane(editorPane) {
-    if (!editorPane) {
-        return;
-    }
-    if (editorPane.getId() === NOTEBOOK_EDITOR_ID) {
-        return editorPane.getControl();
-    }
-    const input = editorPane.input;
-    if (input && isCompositeNotebookEditorInput(input)) {
-        return editorPane.getControl().notebookEditor;
-    }
-    return undefined;
-}
-export { IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID, KERNEL_RECOMMENDATIONS, getNotebookEditorFromEditorPane };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput.js

@@ -1,249 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
-import { SimpleNotebookProviderInfo, INotebookService } from './notebookService.js';
-import { joinPath, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
-import { INotebookEditorModelResolverService } from './notebookEditorModelResolverService.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { AbstractResourceEditorInput } from '../../../common/editor/resourceEditorInput.js';
-import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-let NotebookEditorInput = class NotebookEditorInput extends AbstractResourceEditorInput {
-    static create(instantiationService, resource, viewType, options = {}) {
-        return instantiationService.createInstance(NotebookEditorInput, resource, viewType, options);
-    }
-    constructor(resource, viewType, options, _notebookService, _notebookModelResolverService, _fileDialogService, _instantiationService, labelService, fileService) {
-        super(resource, undefined, labelService, fileService);
-        this.viewType = viewType;
-        this.options = options;
-        this._notebookService = _notebookService;
-        this._notebookModelResolverService = _notebookModelResolverService;
-        this._fileDialogService = _fileDialogService;
-        this._instantiationService = _instantiationService;
-        this._editorModelReference = null;
-        this._defaultDirtyState = false;
-        this._defaultDirtyState = !!options.startDirty;
-        this._sideLoadedListener = _notebookService.onDidAddNotebookDocument(e => {
-            if (e.viewType === this.viewType && ( e.uri.toString()) === ( this.resource.toString())) {
-                this.resolve().catch(onUnexpectedError);
-            }
-        });
-    }
-    dispose() {
-        this._sideLoadedListener.dispose();
-        this._editorModelReference?.dispose();
-        this._editorModelReference = null;
-        super.dispose();
-    }
-    get typeId() {
-        return NotebookEditorInput.ID;
-    }
-    get editorId() {
-        return this.viewType;
-    }
-    get capabilities() {
-        let capabilities = 0 ;
-        if (this.resource.scheme === Schemas.untitled) {
-            capabilities |= 4 ;
-        }
-        if (this._editorModelReference) {
-            if (this._editorModelReference.object.isReadonly()) {
-                capabilities |= 2 ;
-            }
-        }
-        else {
-            if (this.fileService.hasCapability(this.resource, 2048 )) {
-                capabilities |= 2 ;
-            }
-        }
-        if (!((capabilities & 2) )) {
-            capabilities |= 128 ;
-        }
-        return capabilities;
-    }
-    getDescription(verbosity = 1 ) {
-        if (!this.hasCapability(4 ) || this._editorModelReference?.object.hasAssociatedFilePath()) {
-            return super.getDescription(verbosity);
-        }
-        return undefined;
-    }
-    isDirty() {
-        if (!this._editorModelReference) {
-            return this._defaultDirtyState;
-        }
-        return this._editorModelReference.object.isDirty();
-    }
-    async save(group, options) {
-        if (this._editorModelReference) {
-            if (this.hasCapability(4 )) {
-                return this.saveAs(group, options);
-            }
-            else {
-                await this._editorModelReference.object.save(options);
-            }
-            return this;
-        }
-        return undefined;
-    }
-    async saveAs(group, options) {
-        if (!this._editorModelReference) {
-            return undefined;
-        }
-        const provider = this._notebookService.getContributedNotebookType(this.viewType);
-        if (!provider) {
-            return undefined;
-        }
-        const pathCandidate = this.hasCapability(4 ) ? await this._suggestName(provider, this.labelService.getUriBasenameLabel(this.resource)) : this._editorModelReference.object.resource;
-        let target;
-        if (this._editorModelReference.object.hasAssociatedFilePath()) {
-            target = pathCandidate;
-        }
-        else {
-            target = await this._fileDialogService.pickFileToSave(pathCandidate, options?.availableFileSystems);
-            if (!target) {
-                return undefined;
-            }
-        }
-        if (!provider.matches(target)) {
-            const patterns = ( provider.selectors.map(pattern => {
-                if (typeof pattern === 'string') {
-                    return pattern;
-                }
-                if (glob.isRelativePattern(pattern)) {
-                    return `${pattern} (base ${pattern.base})`;
-                }
-                if (pattern.exclude) {
-                    return `${pattern.include} (exclude: ${pattern.exclude})`;
-                }
-                else {
-                    return `${pattern.include}`;
-                }
-            })).join(', ');
-            throw new Error(`File name ${target} is not supported by ${provider.providerDisplayName}.\n\nPlease make sure the file name matches following patterns:\n${patterns}`);
-        }
-        return await this._editorModelReference.object.saveAs(target);
-    }
-    async _suggestName(provider, suggestedFilename) {
-        const firstSelector = provider.selectors[0];
-        let selectorStr = firstSelector && typeof firstSelector === 'string' ? firstSelector : undefined;
-        if (!selectorStr && firstSelector) {
-            const include = firstSelector.include;
-            if (typeof include === 'string') {
-                selectorStr = include;
-            }
-        }
-        if (selectorStr) {
-            const matches = /^\*\.([A-Za-z_-]*)$/.exec(selectorStr);
-            if (matches && matches.length > 1) {
-                const fileExt = matches[1];
-                if (!suggestedFilename.endsWith(fileExt)) {
-                    return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename + '.' + fileExt);
-                }
-            }
-        }
-        return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename);
-    }
-    async rename(group, target) {
-        if (this._editorModelReference) {
-            const contributedNotebookProviders = this._notebookService.getContributedNotebookTypes(target);
-            if (contributedNotebookProviders.find(provider => provider.id === this._editorModelReference.object.viewType)) {
-                return this._move(group, target);
-            }
-        }
-        return undefined;
-    }
-    _move(_group, newResource) {
-        const editorInput = NotebookEditorInput.create(this._instantiationService, newResource, this.viewType);
-        return { editor: editorInput };
-    }
-    async revert(_group, options) {
-        if (this._editorModelReference && this._editorModelReference.object.isDirty()) {
-            await this._editorModelReference.object.revert(options);
-        }
-    }
-    async resolve(_options, perf) {
-        if (!(await this._notebookService.canResolve(this.viewType))) {
-            return null;
-        }
-        perf?.mark('extensionActivated');
-        this._sideLoadedListener.dispose();
-        if (!this._editorModelReference) {
-            const ref = await this._notebookModelResolverService.resolve(this.resource, this.viewType);
-            if (this._editorModelReference) {
-                ref.dispose();
-                return this._editorModelReference.object;
-            }
-            this._editorModelReference = ref;
-            if (this.isDisposed()) {
-                this._editorModelReference.dispose();
-                this._editorModelReference = null;
-                return null;
-            }
-            this._register(this._editorModelReference.object.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
-            this._register(this._editorModelReference.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
-            if (this._editorModelReference.object.isDirty()) {
-                this._onDidChangeDirty.fire();
-            }
-        }
-        else {
-            this._editorModelReference.object.load();
-        }
-        if (this.options._backupId) {
-            const info = await this._notebookService.withNotebookDataProvider(this._editorModelReference.object.notebook.viewType);
-            if (!(info instanceof SimpleNotebookProviderInfo)) {
-                throw new Error('CANNOT open file notebook with this provider');
-            }
-            const data = await info.serializer.dataToNotebook(VSBuffer.fromString(JSON.stringify({ __webview_backup: this.options._backupId })));
-            this._editorModelReference.object.notebook.applyEdits([
-                {
-                    editType: 1 ,
-                    index: 0,
-                    count: this._editorModelReference.object.notebook.length,
-                    cells: data.cells
-                }
-            ], true, undefined, () => undefined, undefined, false);
-            if (this.options._workingCopy) {
-                this.options._backupId = undefined;
-                this.options._workingCopy = undefined;
-                this.options.startDirty = undefined;
-            }
-        }
-        return this._editorModelReference.object;
-    }
-    toUntyped() {
-        return {
-            resource: this.preferredResource,
-            options: {
-                override: this.viewType
-            }
-        };
-    }
-    matches(otherInput) {
-        if (super.matches(otherInput)) {
-            return true;
-        }
-        if (otherInput instanceof NotebookEditorInput) {
-            return this.viewType === otherInput.viewType && isEqual(this.resource, otherInput.resource);
-        }
-        return false;
-    }
-};
-NotebookEditorInput.ID = 'workbench.input.notebook';
-NotebookEditorInput = ( __decorate([
-    ( __param(3, INotebookService)),
-    ( __param(4, INotebookEditorModelResolverService)),
-    ( __param(5, IFileDialogService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, ILabelService)),
-    ( __param(8, IFileService))
-], NotebookEditorInput));
-function isCompositeNotebookEditorInput(thing) {
-    return !!thing
-        && typeof thing === 'object'
-        && Array.isArray(thing.editorInputs)
-        && (thing.editorInputs.every(input => input instanceof NotebookEditorInput));
-}
-export { NotebookEditorInput, isCompositeNotebookEditorInput };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.js

@@ -1,3 +0,0 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const INotebookEditorModelResolverService = ( createDecorator('INotebookModelResolverService'));
-export { INotebookEditorModelResolverService };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookService.js

@@ -1,10 +0,0 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const INotebookService = ( createDecorator('notebookService'));
-class SimpleNotebookProviderInfo {
-    constructor(viewType, serializer, extensionData) {
-        this.viewType = viewType;
-        this.serializer = serializer;
-        this.extensionData = extensionData;
-    }
-}
-export { INotebookService, SimpleNotebookProviderInfo };

package/dist/vscode/vs/workbench/contrib/remote/browser/remoteExplorer.js

@@ -1,186 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { OnPortForward, AutoTunnelSource, makeAddress } from '../../../services/remote/common/remoteExplorerService.js';
-import { OpenPortInPreviewAction, OpenPortInBrowserAction, TunnelPanel, openPreviewEnabledContext } from './tunnelView.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
-const VIEWLET_ID = 'workbench.view.remote';
-class OnAutoForwardedAction extends Disposable {
-    constructor(notificationService, remoteExplorerService, openerService, externalOpenerService, tunnelService, hostService, logService, contextKeyService) {
-        super();
-        this.notificationService = notificationService;
-        this.remoteExplorerService = remoteExplorerService;
-        this.openerService = openerService;
-        this.externalOpenerService = externalOpenerService;
-        this.tunnelService = tunnelService;
-        this.hostService = hostService;
-        this.logService = logService;
-        this.contextKeyService = contextKeyService;
-        this.alreadyOpenedOnce = ( new Set());
-        this.lastNotifyTime = ( new Date());
-        this.lastNotifyTime.setFullYear(this.lastNotifyTime.getFullYear() - 1);
-    }
-    async doAction(tunnels) {
-        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Starting action for ${tunnels[0]?.tunnelRemotePort}`);
-        this.doActionTunnels = tunnels;
-        const tunnel = await this.portNumberHeuristicDelay();
-        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Heuristic chose ${tunnel?.tunnelRemotePort}`);
-        if (tunnel) {
-            const allAttributes = await this.remoteExplorerService.tunnelModel.getAttributes([{ port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost }]);
-            const attributes = allAttributes?.get(tunnel.tunnelRemotePort)?.onAutoForward;
-            this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) onAutoForward action is ${attributes}`);
-            switch (attributes) {
-                case OnPortForward.OpenBrowserOnce: {
-                    if (( this.alreadyOpenedOnce.has(tunnel.localAddress))) {
-                        break;
-                    }
-                    this.alreadyOpenedOnce.add(tunnel.localAddress);
-                }
-                case OnPortForward.OpenBrowser: {
-                    const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-                    await OpenPortInBrowserAction.run(this.remoteExplorerService.tunnelModel, this.openerService, address);
-                    break;
-                }
-                case OnPortForward.OpenPreview: {
-                    const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-                    await OpenPortInPreviewAction.run(this.remoteExplorerService.tunnelModel, this.openerService, this.externalOpenerService, address);
-                    break;
-                }
-                case OnPortForward.Silent: break;
-                default: {
-                    const elapsed = ( new Date()).getTime() - this.lastNotifyTime.getTime();
-                    this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) time elapsed since last notification ${elapsed} ms`);
-                    if (elapsed > OnAutoForwardedAction.NOTIFY_COOL_DOWN) {
-                        await this.showNotification(tunnel);
-                    }
-                }
-            }
-        }
-    }
-    hide(removedPorts) {
-        if (this.doActionTunnels) {
-            this.doActionTunnels = this.doActionTunnels.filter(value => !removedPorts.includes(value.tunnelRemotePort));
-        }
-        if (this.lastShownPort && removedPorts.indexOf(this.lastShownPort) >= 0) {
-            this.lastNotification?.close();
-        }
-    }
-    async portNumberHeuristicDelay() {
-        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Starting heuristic delay`);
-        if (!this.doActionTunnels || this.doActionTunnels.length === 0) {
-            return;
-        }
-        this.doActionTunnels = this.doActionTunnels.sort((a, b) => a.tunnelRemotePort - b.tunnelRemotePort);
-        const firstTunnel = this.doActionTunnels.shift();
-        if (firstTunnel.tunnelRemotePort % 1000 === 0) {
-            this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Heuristic chose tunnel because % 1000: ${firstTunnel.tunnelRemotePort}`);
-            this.newerTunnel = firstTunnel;
-            return firstTunnel;
-        }
-        else if (firstTunnel.tunnelRemotePort < 10000 && firstTunnel.tunnelRemotePort !== 9229) {
-            this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Heuristic chose tunnel because < 10000: ${firstTunnel.tunnelRemotePort}`);
-            this.newerTunnel = firstTunnel;
-            return firstTunnel;
-        }
-        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Waiting for "better" tunnel than ${firstTunnel.tunnelRemotePort}`);
-        this.newerTunnel = undefined;
-        return ( new Promise(resolve => {
-            setTimeout(() => {
-                if (this.newerTunnel) {
-                    resolve(undefined);
-                }
-                else if (this.doActionTunnels?.includes(firstTunnel)) {
-                    resolve(firstTunnel);
-                }
-                else {
-                    resolve(undefined);
-                }
-            }, 3000);
-        }));
-    }
-    basicMessage(tunnel) {
-        return ( nls.localize(
-            'remote.tunnelsView.automaticForward',
-            "Your application running on port {0} is available.  ",
-            tunnel.tunnelRemotePort
-        ));
-    }
-    linkMessage() {
-        return ( nls.localize(
-            { key: 'remote.tunnelsView.notificationLink2', comment: ['[See all forwarded ports]({0}) is a link. Only translate `See all forwarded ports`. Do not change brackets and parentheses or {0}'] },
-            "[See all forwarded ports]({0})",
-            `command:${TunnelPanel.ID}.focus`
-        ));
-    }
-    async showNotification(tunnel) {
-        if (!(await this.hostService.hadLastFocus())) {
-            return;
-        }
-        this.lastNotification?.close();
-        let message = this.basicMessage(tunnel);
-        const choices = [this.openBrowserChoice(tunnel)];
-        if (!isWeb || openPreviewEnabledContext.getValue(this.contextKeyService)) {
-            choices.push(this.openPreviewChoice(tunnel));
-        }
-        if ((tunnel.tunnelLocalPort !== tunnel.tunnelRemotePort) && this.tunnelService.canElevate && this.tunnelService.isPortPrivileged(tunnel.tunnelRemotePort)) {
-            message += ( nls.localize(
-                'remote.tunnelsView.elevationMessage',
-                "You'll need to run as superuser to use port {0} locally.  ",
-                tunnel.tunnelRemotePort
-            ));
-            choices.unshift(this.elevateChoice(tunnel));
-        }
-        message += this.linkMessage();
-        this.lastNotification = this.notificationService.prompt(Severity.Info, message, choices, { neverShowAgain: { id: 'remote.tunnelsView.autoForwardNeverShow', isSecondary: true } });
-        this.lastShownPort = tunnel.tunnelRemotePort;
-        this.lastNotifyTime = ( new Date());
-        this.lastNotification.onDidClose(() => {
-            this.lastNotification = undefined;
-            this.lastShownPort = undefined;
-        });
-    }
-    openBrowserChoice(tunnel) {
-        const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-        return {
-            label: OpenPortInBrowserAction.LABEL,
-            run: () => OpenPortInBrowserAction.run(this.remoteExplorerService.tunnelModel, this.openerService, address)
-        };
-    }
-    openPreviewChoice(tunnel) {
-        const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-        return {
-            label: OpenPortInPreviewAction.LABEL,
-            run: () => OpenPortInPreviewAction.run(this.remoteExplorerService.tunnelModel, this.openerService, this.externalOpenerService, address)
-        };
-    }
-    elevateChoice(tunnel) {
-        return {
-            label: ( nls.localize(
-                'remote.tunnelsView.elevationButton',
-                "Use Port {0} as Sudo...",
-                tunnel.tunnelRemotePort
-            )),
-            run: async () => {
-                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort });
-                const newTunnel = await this.remoteExplorerService.forward({
-                    remote: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort },
-                    local: tunnel.tunnelRemotePort,
-                    elevateIfNeeded: true,
-                    source: AutoTunnelSource
-                });
-                if (!newTunnel) {
-                    return;
-                }
-                this.lastNotification?.close();
-                this.lastShownPort = newTunnel.tunnelRemotePort;
-                this.lastNotification = this.notificationService.prompt(Severity.Info, this.basicMessage(newTunnel) + this.linkMessage(), [this.openBrowserChoice(newTunnel), this.openPreviewChoice(tunnel)], { neverShowAgain: { id: 'remote.tunnelsView.autoForwardNeverShow', isSecondary: true } });
-                this.lastNotification.onDidClose(() => {
-                    this.lastNotification = undefined;
-                    this.lastShownPort = undefined;
-                });
-            }
-        };
-    }
-}
-OnAutoForwardedAction.NOTIFY_COOL_DOWN = 5000;
-export { VIEWLET_ID };

package/dist/vscode/vs/workbench/contrib/remote/browser/remoteIcons.js

@@ -1,23 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-const privatePortIcon = ( registerIcon('private-ports-view-icon', Codicon.lock, ( nls.localize('privatePortIcon', 'Icon representing a private remote port.'))));
-const forwardPortIcon = ( registerIcon('ports-forward-icon', Codicon.plus, ( nls.localize('forwardPortIcon', 'Icon for the forward action.'))));
-const stopForwardIcon = ( registerIcon('ports-stop-forward-icon', Codicon.x, ( nls.localize('stopForwardIcon', 'Icon for the stop forwarding action.'))));
-const openBrowserIcon = ( registerIcon('ports-open-browser-icon', Codicon.globe, ( nls.localize('openBrowserIcon', 'Icon for the open browser action.'))));
-const openPreviewIcon = ( registerIcon('ports-open-preview-icon', Codicon.openPreview, ( nls.localize('openPreviewIcon', 'Icon for the open preview action.'))));
-const copyAddressIcon = ( registerIcon('ports-copy-address-icon', Codicon.clippy, ( nls.localize('copyAddressIcon', 'Icon for the copy local address action.'))));
-const labelPortIcon = ( registerIcon('ports-label-icon', Codicon.tag, ( nls.localize('labelPortIcon', 'Icon for the label port action.'))));
-const forwardedPortWithoutProcessIcon = ( registerIcon(
- 'ports-forwarded-without-process-icon',
- Codicon.circleOutline,
- ( nls.localize(
-  'forwardedPortWithoutProcessIcon',
-  'Icon for forwarded ports that don\'t have a running process.'
- ))
-));
-const forwardedPortWithProcessIcon = ( registerIcon('ports-forwarded-with-process-icon', Codicon.circleFilled, ( nls.localize(
- 'forwardedPortWithProcessIcon',
- 'Icon for forwarded ports that do have a running process.'
-))));
-export { copyAddressIcon, forwardPortIcon, forwardedPortWithProcessIcon, forwardedPortWithoutProcessIcon, labelPortIcon, openBrowserIcon, openPreviewIcon, privatePortIcon, stopForwardIcon };