@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

package/vscode/src/vs/workbench/services/layout/browser/layoutService.js

@@ -12,6 +12,12 @@ var Parts;
     Parts["EDITOR_PART"] = "workbench.parts.editor";
     Parts["STATUSBAR_PART"] = "workbench.parts.statusbar";
 })(Parts || (Parts = {})));
+var Position;
+( (function(Position) {
+    Position[Position["LEFT"] = 0] = "LEFT";
+    Position[Position["RIGHT"] = 1] = "RIGHT";
+    Position[Position["BOTTOM"] = 2] = "BOTTOM";
+})(Position || (Position = {})));
 function positionToString(position) {
     switch (position) {
         case 0 : return 'left';
@@ -20,4 +26,12 @@ function positionToString(position) {
         default: return 'bottom';
     }
 }
-export { IWorkbenchLayoutService, Parts, positionToString };
+const positionsByString = {
+    [positionToString(0 )]: 0 ,
+    [positionToString(1 )]: 1 ,
+    [positionToString(2 )]: 2
+};
+function positionFromString(str) {
+    return positionsByString[str];
+}
+export { IWorkbenchLayoutService, Parts, Position, positionFromString, positionToString };

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.d.ts

@@ -1,10 +1,10 @@
 import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
 import { Event } from '../../../../base/common/event.js';
-import { RemoteTunnel, TunnelProtocol } from '../../../../platform/tunnel/common/tunnel.js';
 import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { RemoteTunnel, TunnelProtocol } from '../../../../platform/tunnel/common/tunnel.js';
 import { IEditableData } from '../../../common/views.js';
 import { TunnelInformation, TunnelPrivacy } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
-import { URI } from '../../../../base/common/uri.js';
 import { TunnelModel, TunnelProperties, Attributes, TunnelCloseReason, CandidatePort, TunnelSource } from './tunnelModel.js';
 import { IExtensionPointUser } from '../../extensions/common/extensionsRegistry.js';
 import { IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.js

@@ -1,9 +1,20 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITunnelService } from '../../../../platform/tunnel/common/tunnel.js';
+import { TunnelModel } from './tunnelModel.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 const IRemoteExplorerService = ( createDecorator('remoteExplorerService'));
+const REMOTE_EXPLORER_TYPE_KEY = 'remote.explorerType';
 const TUNNEL_VIEW_ID = '~remote.forwardedPorts';
+const TUNNEL_VIEW_CONTAINER_ID = '~remote.forwardedPortsContainer';
 const PORT_AUTO_FORWARD_SETTING = 'remote.autoForwardPorts';
 const PORT_AUTO_SOURCE_SETTING = 'remote.autoForwardPortsSource';
+const PORT_AUTO_SOURCE_SETTING_PROCESS = 'process';
 const PORT_AUTO_SOURCE_SETTING_OUTPUT = 'output';
+const PORT_AUTO_SOURCE_SETTING_HYBRID = 'hybrid';
 var TunnelType;
 ( (function(TunnelType) {
     TunnelType["Candidate"] = "Candidate";
@@ -18,4 +29,181 @@ var TunnelEditId;
     TunnelEditId[TunnelEditId["Label"] = 2] = "Label";
     TunnelEditId[TunnelEditId["LocalPort"] = 3] = "LocalPort";
 })(TunnelEditId || (TunnelEditId = {})));
-export { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, TUNNEL_VIEW_ID, TunnelEditId, TunnelType };
+const getStartedWalkthrough = {
+    type: 'object',
+    required: ['id'],
+    properties: {
+        id: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/services/remote/common/remoteExplorerService',
+                'getStartedWalkthrough.id',
+                'The ID of a Get Started walkthrough to open.'
+            )),
+            type: 'string'
+        },
+    }
+};
+const remoteHelpExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'remoteHelp',
+    jsonSchema: {
+        description: ( nls.localizeWithPath(
+            'vs/workbench/services/remote/common/remoteExplorerService',
+            'RemoteHelpInformationExtPoint',
+            'Contributes help information for Remote'
+        )),
+        type: 'object',
+        properties: {
+            'getStarted': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.getStarted',
+                    "The url, or a command that returns the url, to your project's Getting Started page, or a walkthrough ID contributed by your project's extension"
+                )),
+                oneOf: [
+                    { type: 'string' },
+                    getStartedWalkthrough
+                ]
+            },
+            'documentation': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.documentation',
+                    "The url, or a command that returns the url, to your project's documentation page"
+                )),
+                type: 'string'
+            },
+            'feedback': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.feedback',
+                    "The url, or a command that returns the url, to your project's feedback reporter"
+                )),
+                type: 'string',
+                markdownDeprecationMessage: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.feedback.deprecated',
+                    "Use {0} instead",
+                    '`reportIssue`'
+                ))
+            },
+            'reportIssue': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.reportIssue',
+                    "The url, or a command that returns the url, to your project's issue reporter"
+                )),
+                type: 'string'
+            },
+            'issues': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.issues',
+                    "The url, or a command that returns the url, to your project's issues list"
+                )),
+                type: 'string'
+            }
+        }
+    }
+}));
+let RemoteExplorerService = class RemoteExplorerService {
+    constructor(storageService, tunnelService, instantiationService) {
+        this.storageService = storageService;
+        this.tunnelService = tunnelService;
+        this._targetType = [];
+        this._onDidChangeTargetType = ( new Emitter());
+        this.onDidChangeTargetType = this._onDidChangeTargetType.event;
+        this._onDidChangeHelpInformation = ( new Emitter());
+        this.onDidChangeHelpInformation = this._onDidChangeHelpInformation.event;
+        this._helpInformation = [];
+        this._onDidChangeEditable = ( new Emitter());
+        this.onDidChangeEditable = this._onDidChangeEditable.event;
+        this._onEnabledPortsFeatures = ( new Emitter());
+        this.onEnabledPortsFeatures = this._onEnabledPortsFeatures.event;
+        this._portsFeaturesEnabled = false;
+        this.namedProcesses = ( new Map());
+        this._tunnelModel = instantiationService.createInstance(TunnelModel);
+        remoteHelpExtPoint.setHandler((extensions) => {
+            this._helpInformation.push(...extensions);
+            this._onDidChangeHelpInformation.fire(extensions);
+        });
+    }
+    get helpInformation() {
+        return this._helpInformation;
+    }
+    set targetType(name) {
+        const current = this._targetType.length > 0 ? this._targetType[0] : '';
+        const newName = name.length > 0 ? name[0] : '';
+        if (current !== newName) {
+            this._targetType = name;
+            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( this._targetType.toString()), 1 , 1 );
+            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( this._targetType.toString()), 0 , 0 );
+            this._onDidChangeTargetType.fire(this._targetType);
+        }
+    }
+    get targetType() {
+        return this._targetType;
+    }
+    get tunnelModel() {
+        return this._tunnelModel;
+    }
+    forward(tunnelProperties, attributes) {
+        return this.tunnelModel.forward(tunnelProperties, attributes);
+    }
+    close(remote, reason) {
+        return this.tunnelModel.close(remote.host, remote.port, reason);
+    }
+    setTunnelInformation(tunnelInformation) {
+        if (tunnelInformation?.features) {
+            this.tunnelService.setTunnelFeatures(tunnelInformation.features);
+        }
+        this.tunnelModel.addEnvironmentTunnels(tunnelInformation?.environmentTunnels);
+    }
+    setEditable(tunnelItem, editId, data) {
+        if (!data) {
+            this._editable = undefined;
+        }
+        else {
+            this._editable = { tunnelItem, data, editId };
+        }
+        this._onDidChangeEditable.fire(tunnelItem ? { tunnel: tunnelItem, editId } : undefined);
+    }
+    getEditableData(tunnelItem, editId) {
+        return (this._editable &&
+            ((!tunnelItem && (tunnelItem === this._editable.tunnelItem)) ||
+                (tunnelItem && (this._editable.tunnelItem?.remotePort === tunnelItem.remotePort) && (this._editable.tunnelItem.remoteHost === tunnelItem.remoteHost)
+                    && (this._editable.editId === editId)))) ?
+            this._editable.data : undefined;
+    }
+    setCandidateFilter(filter) {
+        if (!filter) {
+            return {
+                dispose: () => { }
+            };
+        }
+        this.tunnelModel.setCandidateFilter(filter);
+        return {
+            dispose: () => {
+                this.tunnelModel.setCandidateFilter(undefined);
+            }
+        };
+    }
+    onFoundNewCandidates(candidates) {
+        this.tunnelModel.setCandidates(candidates);
+    }
+    restore() {
+        return this.tunnelModel.restoreForwarded();
+    }
+    enablePortsFeatures() {
+        this._portsFeaturesEnabled = true;
+        this._onEnabledPortsFeatures.fire();
+    }
+    get portsFeaturesEnabled() {
+        return this._portsFeaturesEnabled;
+    }
+};
+RemoteExplorerService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ITunnelService)),
+    ( __param(2, IInstantiationService))
+], RemoteExplorerService));
+export { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_HYBRID, PORT_AUTO_SOURCE_SETTING_OUTPUT, PORT_AUTO_SOURCE_SETTING_PROCESS, REMOTE_EXPLORER_TYPE_KEY, RemoteExplorerService, TUNNEL_VIEW_CONTAINER_ID, TUNNEL_VIEW_ID, TunnelEditId, TunnelType };

package/vscode/src/vs/workbench/services/workingCopy/common/resourceWorkingCopy.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+let ResourceWorkingCopy = class ResourceWorkingCopy extends Disposable {
+    constructor(resource, fileService) {
+        super();
+        this.resource = resource;
+        this.fileService = fileService;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this.orphaned = false;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+    }
+    isOrphaned() {
+        return this.orphaned;
+    }
+    async onDidFilesChange(e) {
+        let fileEventImpactsUs = false;
+        let newInOrphanModeGuess;
+        if (this.orphaned) {
+            const fileWorkingCopyResourceAdded = e.contains(this.resource, 1 );
+            if (fileWorkingCopyResourceAdded) {
+                newInOrphanModeGuess = false;
+                fileEventImpactsUs = true;
+            }
+        }
+        else {
+            const fileWorkingCopyResourceDeleted = e.contains(this.resource, 2 );
+            if (fileWorkingCopyResourceDeleted) {
+                newInOrphanModeGuess = true;
+                fileEventImpactsUs = true;
+            }
+        }
+        if (fileEventImpactsUs && this.orphaned !== newInOrphanModeGuess) {
+            let newInOrphanModeValidated = false;
+            if (newInOrphanModeGuess) {
+                await timeout(100, CancellationToken.None);
+                if (this.isDisposed()) {
+                    newInOrphanModeValidated = true;
+                }
+                else {
+                    const exists = await this.fileService.exists(this.resource);
+                    newInOrphanModeValidated = !exists;
+                }
+            }
+            if (this.orphaned !== newInOrphanModeValidated && !this.isDisposed()) {
+                this.setOrphaned(newInOrphanModeValidated);
+            }
+        }
+    }
+    setOrphaned(orphaned) {
+        if (this.orphaned !== orphaned) {
+            this.orphaned = orphaned;
+            this._onDidChangeOrphaned.fire();
+        }
+    }
+    isDisposed() {
+        return this._store.isDisposed;
+    }
+    dispose() {
+        this.orphaned = false;
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+    isModified() {
+        return this.isDirty();
+    }
+};
+ResourceWorkingCopy = ( __decorate([
+    ( __param(1, IFileService))
+], ResourceWorkingCopy));
+export { ResourceWorkingCopy };

package/assets/fake.html

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-	<meta charset="UTF-8">
-	<meta name="viewport" content="width=device-width, initial-scale=1.0">
-	<title>Fake</title>
-</head>
-<body>
-</body>
-</html>