@codingame/monaco-vscode-api 1.83.7 → 1.83.9

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

@@ -1,8 +1,179 @@
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IConfigurationService, ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IRemoteAuthorityResolverService, TunnelDescription } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { TunnelProtocol, ITunnelService, RemoteTunnel, PortAttributesProvider, TunnelPrivacyId, ProvidedOnAutoForward } from '../../../../platform/tunnel/common/tunnel.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+
+interface Tunnel {
+    remoteHost: string;
+    remotePort: number;
+    localAddress: string;
+    localUri: URI;
+    protocol: TunnelProtocol;
+    localPort?: number;
+    name?: string;
+    closeable?: boolean;
+    privacy: TunnelPrivacyId | string;
+    runningProcess: string | undefined;
+    hasRunningProcess?: boolean;
+    pid: number | undefined;
+    source: {
+        source: TunnelSource;
+        description: string;
+    };
+}
+declare enum TunnelCloseReason {
+    Other = "Other",
+    User = "User",
+    AutoForwardEnd = "AutoForwardEnd"
+}
+declare enum TunnelSource {
+    User = 0,
+    Auto = 1,
+    Extension = 2
+}
+interface TunnelProperties {
+    remote: {
+        host: string;
+        port: number;
+    };
+    local?: number;
+    name?: string;
+    source?: {
+        source: TunnelSource;
+        description: string;
+    };
+    elevateIfNeeded?: boolean;
+    privacy?: string;
+}
 interface CandidatePort {
     host: string;
     port: number;
     detail?: string;
     pid?: number;
 }
+declare enum OnPortForward {
+    Notify = "notify",
+    OpenBrowser = "openBrowser",
+    OpenBrowserOnce = "openBrowserOnce",
+    OpenPreview = "openPreview",
+    Silent = "silent",
+    Ignore = "ignore"
+}
+interface Attributes {
+    label: string | undefined;
+    onAutoForward: OnPortForward | undefined;
+    elevateIfNeeded: boolean | undefined;
+    requireLocalPort: boolean | undefined;
+    protocol: TunnelProtocol | undefined;
+}
+declare class PortsAttributes extends Disposable {
+    private readonly configurationService;
+    private static SETTING;
+    private static DEFAULTS;
+    private static RANGE;
+    private static HOST_AND_PORT;
+    private portsAttributes;
+    private defaultPortAttributes;
+    private _onDidChangeAttributes;
+    readonly onDidChangeAttributes: Event<void>;
+    constructor(configurationService: IConfigurationService);
+    private updateAttributes;
+    getAttributes(port: number, host: string, commandLine?: string): Attributes | undefined;
+    private hasStartEnd;
+    private hasHostAndPort;
+    private findNextIndex;
+    private readSetting;
+    private sortAttributes;
+    private getOtherAttributes;
+    static providedActionToAction(providedAction: ProvidedOnAutoForward | undefined): OnPortForward | undefined;
+    addAttributes(port: number, attributes: Partial<Attributes>, target: ConfigurationTarget): Promise<void>;
+}
+declare class TunnelModel extends Disposable {
+    private readonly tunnelService;
+    private readonly storageService;
+    private readonly configurationService;
+    private readonly environmentService;
+    private readonly remoteAuthorityResolverService;
+    private readonly workspaceContextService;
+    private readonly logService;
+    private readonly dialogService;
+    private readonly extensionService;
+    private readonly contextKeyService;
+    readonly forwarded: Map<string, Tunnel>;
+    private readonly inProgress;
+    readonly detected: Map<string, Tunnel>;
+    private remoteTunnels;
+    private _onForwardPort;
+    onForwardPort: Event<Tunnel | void>;
+    private _onClosePort;
+    onClosePort: Event<{
+        host: string;
+        port: number;
+    }>;
+    private _onPortName;
+    onPortName: Event<{
+        host: string;
+        port: number;
+    }>;
+    private _candidates;
+    private _onCandidatesChanged;
+    onCandidatesChanged: Event<Map<string, {
+        host: string;
+        port: number;
+    }>>;
+    private _candidateFilter;
+    private tunnelRestoreValue;
+    private _onEnvironmentTunnelsSet;
+    onEnvironmentTunnelsSet: Event<void>;
+    private _environmentTunnelsSet;
+    readonly configPortsAttributes: PortsAttributes;
+    private restoreListener;
+    private knownPortsRestoreValue;
+    private restoreComplete;
+    private onRestoreComplete;
+    private unrestoredExtensionTunnels;
+    private sessionCachedProperties;
+    private portAttributesProviders;
+    constructor(tunnelService: ITunnelService, storageService: IStorageService, configurationService: IConfigurationService, environmentService: IWorkbenchEnvironmentService, remoteAuthorityResolverService: IRemoteAuthorityResolverService, workspaceContextService: IWorkspaceContextService, logService: ILogService, dialogService: IDialogService, extensionService: IExtensionService, contextKeyService: IContextKeyService);
+    private extensionHasActivationEvent;
+    private checkExtensionActivationEvents;
+    private onTunnelClosed;
+    private makeLocalUri;
+    private getStorageKey;
+    private getTunnelRestoreValue;
+    restoreForwarded(): Promise<void>;
+    private storeForwarded;
+    private mismatchCooldown;
+    private showPortMismatchModalIfNeeded;
+    forward(tunnelProperties: TunnelProperties, attributes?: Attributes | null): Promise<RemoteTunnel | string | undefined>;
+    private doForward;
+    private mergeCachedAndUnrestoredProperties;
+    private mergeAttributesIntoExistingTunnel;
+    name(host: string, port: number, name: string): Promise<void>;
+    close(host: string, port: number, reason: TunnelCloseReason): Promise<void>;
+    address(host: string, port: number): string | undefined;
+    get environmentTunnelsSet(): boolean;
+    addEnvironmentTunnels(tunnels: TunnelDescription[] | undefined): void;
+    setCandidateFilter(filter: ((candidates: CandidatePort[]) => Promise<CandidatePort[]>) | undefined): void;
+    setCandidates(candidates: CandidatePort[]): Promise<void>;
+    private updateInResponseToCandidates;
+    get candidates(): CandidatePort[];
+    get candidatesOrUndefined(): CandidatePort[] | undefined;
+    private updateAttributes;
+    getAttributes(forwardedPorts: {
+        host: string;
+        port: number;
+    }[], checkProviders?: boolean): Promise<Map<number, Attributes> | undefined>;
+    addAttributesProvider(provider: PortAttributesProvider): void;
+}
 
-export type { CandidatePort };
+export { type Attributes, type CandidatePort, OnPortForward, PortsAttributes, type Tunnel, TunnelCloseReason, TunnelModel, type TunnelProperties, TunnelSource };

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorHandler.js

@@ -1,14 +1,65 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { ITextEditorService } from '../../textfile/common/textEditorService.js';
-import { isEqual, toLocalResource } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { toLocalResource, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
 import { IPathService } from '../../path/common/pathService.js';
 import { UntitledTextEditorInput } from './untitledTextEditorInput.js';
 import { NO_TYPE_ID } from '../../workingCopy/common/workingCopy.js';
 import { IWorkingCopyEditorService } from '../../workingCopy/common/workingCopyEditorService.js';
 import { IUntitledTextEditorService } from './untitledTextEditorService.js';
+let UntitledTextEditorInputSerializer = class UntitledTextEditorInputSerializer {
+    constructor(filesConfigurationService, environmentService, pathService) {
+        this.filesConfigurationService = filesConfigurationService;
+        this.environmentService = environmentService;
+        this.pathService = pathService;
+    }
+    canSerialize(editorInput) {
+        return this.filesConfigurationService.isHotExitEnabled && !editorInput.isDisposed();
+    }
+    serialize(editorInput) {
+        if (!this.filesConfigurationService.isHotExitEnabled || editorInput.isDisposed()) {
+            return undefined;
+        }
+        const untitledTextEditorInput = editorInput;
+        let resource = untitledTextEditorInput.resource;
+        if (untitledTextEditorInput.model.hasAssociatedFilePath) {
+            resource = toLocalResource(resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+        }
+        let languageId;
+        const languageIdCandidate = untitledTextEditorInput.getLanguageId();
+        if (languageIdCandidate !== PLAINTEXT_LANGUAGE_ID) {
+            languageId = languageIdCandidate;
+        }
+        else if (untitledTextEditorInput.model.hasLanguageSetExplicitly) {
+            languageId = languageIdCandidate;
+        }
+        const serialized = {
+            resourceJSON: resource.toJSON(),
+            modeId: languageId,
+            encoding: untitledTextEditorInput.getEncoding()
+        };
+        return JSON.stringify(serialized);
+    }
+    deserialize(instantiationService, serializedEditorInput) {
+        return instantiationService.invokeFunction(accessor => {
+            const deserialized = JSON.parse(serializedEditorInput);
+            const resource = URI.revive(deserialized.resourceJSON);
+            const languageId = deserialized.modeId;
+            const encoding = deserialized.encoding;
+            return accessor.get(ITextEditorService).createTextEditor({ resource, languageId, encoding, forceUntitled: true });
+        });
+    }
+};
+UntitledTextEditorInputSerializer = ( __decorate([
+    ( __param(0, IFilesConfigurationService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IPathService))
+], UntitledTextEditorInputSerializer));
 let UntitledTextEditorWorkingCopyEditorHandler = class UntitledTextEditorWorkingCopyEditorHandler extends Disposable {
     constructor(workingCopyEditorService, environmentService, pathService, textEditorService, untitledTextEditorService) {
         super();
@@ -45,4 +96,4 @@ UntitledTextEditorWorkingCopyEditorHandler = ( __decorate([
     ( __param(3, ITextEditorService)),
     ( __param(4, IUntitledTextEditorService))
 ], UntitledTextEditorWorkingCopyEditorHandler));
-export { UntitledTextEditorWorkingCopyEditorHandler };
+export { UntitledTextEditorInputSerializer, UntitledTextEditorWorkingCopyEditorHandler };

package/vscode/src/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles.js

@@ -0,0 +1,150 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUserDataProfileService } from './userDataProfile.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { UserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfileIpc.js';
+const associatedRemoteProfilesKey = 'associatedRemoteProfiles';
+const IRemoteUserDataProfilesService = ( createDecorator('IRemoteUserDataProfilesService'));
+let RemoteUserDataProfilesService = class RemoteUserDataProfilesService extends Disposable {
+    constructor(environmentService, remoteAgentService, userDataProfilesService, userDataProfileService, storageService, logService) {
+        super();
+        this.environmentService = environmentService;
+        this.remoteAgentService = remoteAgentService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.userDataProfileService = userDataProfileService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.initPromise = this.init();
+    }
+    async init() {
+        const connection = this.remoteAgentService.getConnection();
+        if (!connection) {
+            return;
+        }
+        const environment = await this.remoteAgentService.getEnvironment();
+        if (!environment) {
+            return;
+        }
+        this.remoteUserDataProfilesService = ( new UserDataProfilesService(
+            environment.profiles.all,
+            environment.profiles.home,
+            connection.getChannel('userDataProfiles')
+        ));
+        this._register(this.userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeLocalProfiles(e)));
+        const remoteProfile = await this.getAssociatedRemoteProfile(this.userDataProfileService.currentProfile, this.remoteUserDataProfilesService);
+        if (!remoteProfile.isDefault) {
+            this.setAssociatedRemoteProfiles([...this.getAssociatedRemoteProfiles(), remoteProfile.id]);
+        }
+        this.cleanUp();
+    }
+    async onDidChangeLocalProfiles(e) {
+        for (const profile of e.removed) {
+            const remoteProfile = this.remoteUserDataProfilesService?.profiles.find(p => p.id === profile.id);
+            if (remoteProfile) {
+                await this.remoteUserDataProfilesService?.removeProfile(remoteProfile);
+            }
+        }
+    }
+    async getRemoteProfiles() {
+        await this.initPromise;
+        if (!this.remoteUserDataProfilesService) {
+            throw new Error('Remote profiles service not available in the current window');
+        }
+        return this.remoteUserDataProfilesService.profiles;
+    }
+    async getRemoteProfile(localProfile) {
+        await this.initPromise;
+        if (!this.remoteUserDataProfilesService) {
+            throw new Error('Remote profiles service not available in the current window');
+        }
+        return this.getAssociatedRemoteProfile(localProfile, this.remoteUserDataProfilesService);
+    }
+    async getAssociatedRemoteProfile(localProfile, remoteUserDataProfilesService) {
+        if (localProfile.isDefault) {
+            return remoteUserDataProfilesService.defaultProfile;
+        }
+        let profile = remoteUserDataProfilesService.profiles.find(p => p.id === localProfile.id);
+        if (!profile) {
+            profile = await remoteUserDataProfilesService.createProfile(localProfile.id, localProfile.name, {
+                shortName: localProfile.shortName,
+                transient: localProfile.isTransient,
+                useDefaultFlags: localProfile.useDefaultFlags,
+            });
+            this.setAssociatedRemoteProfiles([...this.getAssociatedRemoteProfiles(), this.userDataProfileService.currentProfile.id]);
+        }
+        return profile;
+    }
+    getAssociatedRemoteProfiles() {
+        if (this.environmentService.remoteAuthority) {
+            const remotes = this.parseAssociatedRemoteProfiles();
+            return remotes[this.environmentService.remoteAuthority] ?? [];
+        }
+        return [];
+    }
+    setAssociatedRemoteProfiles(profiles) {
+        if (this.environmentService.remoteAuthority) {
+            const remotes = this.parseAssociatedRemoteProfiles();
+            profiles = distinct(profiles);
+            if (profiles.length) {
+                remotes[this.environmentService.remoteAuthority] = profiles;
+            }
+            else {
+                delete remotes[this.environmentService.remoteAuthority];
+            }
+            if (( Object.keys(remotes)).length) {
+                this.storageService.store(associatedRemoteProfilesKey, JSON.stringify(remotes), -1 , 1 );
+            }
+            else {
+                this.storageService.remove(associatedRemoteProfilesKey, -1 );
+            }
+        }
+    }
+    parseAssociatedRemoteProfiles() {
+        if (this.environmentService.remoteAuthority) {
+            const value = this.storageService.get(associatedRemoteProfilesKey, -1 );
+            try {
+                return value ? JSON.parse(value) : {};
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        return {};
+    }
+    async cleanUp() {
+        const associatedRemoteProfiles = [];
+        for (const profileId of this.getAssociatedRemoteProfiles()) {
+            const remoteProfile = this.remoteUserDataProfilesService?.profiles.find(p => p.id === profileId);
+            if (!remoteProfile) {
+                continue;
+            }
+            const localProfile = this.userDataProfilesService.profiles.find(p => p.id === profileId);
+            if (localProfile) {
+                if (localProfile.name !== remoteProfile.name || localProfile.shortName !== remoteProfile.shortName) {
+                    await this.remoteUserDataProfilesService?.updateProfile(remoteProfile, { name: localProfile.name, shortName: localProfile.shortName });
+                }
+                associatedRemoteProfiles.push(profileId);
+                continue;
+            }
+            if (remoteProfile) {
+                await this.remoteUserDataProfilesService?.removeProfile(remoteProfile);
+            }
+        }
+        this.setAssociatedRemoteProfiles(associatedRemoteProfiles);
+    }
+};
+RemoteUserDataProfilesService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IUserDataProfilesService)),
+    ( __param(3, IUserDataProfileService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, ILogService))
+], RemoteUserDataProfilesService));
+export { IRemoteUserDataProfilesService, RemoteUserDataProfilesService };

package/vscode/src/vs/workbench/services/userDataSync/common/userDataSync.js

@@ -1,4 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { localizeWithPath } 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';
@@ -8,4 +9,5 @@ registerIcon('settings-sync-view-icon', Codicon.sync, ( localizeWithPath(
     'syncViewIcon',
     'View icon of the Settings Sync view.'
 )));
-export { IUserDataSyncWorkbenchService };
+const CONTEXT_SYNC_ENABLEMENT = ( new RawContextKey('syncEnabled', false));
+export { CONTEXT_SYNC_ENABLEMENT, IUserDataSyncWorkbenchService };

package/vscode/src/vs/workbench/services/workspaces/browser/workspaces.js

@@ -5,7 +5,13 @@ function getWorkspaceIdentifier(workspaceUri) {
         configPath: workspaceUri
     };
 }
+function getSingleFolderWorkspaceIdentifier(folderUri) {
+    return {
+        id: getWorkspaceId(folderUri),
+        uri: folderUri
+    };
+}
 function getWorkspaceId(uri) {
     return ( hash(( uri.toString())).toString(16));
 }
-export { getWorkspaceIdentifier };
+export { getSingleFolderWorkspaceIdentifier, getWorkspaceIdentifier };