@codingame/monaco-vscode-api 1.78.5-next.0 → 1.78.5

package/dist/vscode/vs/platform/userDataProfile/common/userDataProfile.js

@@ -1,427 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
-import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { joinPath, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { toFileOperationResult, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';
-import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { escapeRegExpCharacters } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
-const IUserDataProfilesService = ( createDecorator('IUserDataProfilesService'));
-function toUserDataProfile(id, name, location, profilesCacheHome, options) {
-    return {
-        id,
-        name,
-        location,
-        isDefault: false,
-        shortName: options?.shortName,
-        globalStorageHome: joinPath(location, 'globalStorage'),
-        settingsResource: joinPath(location, 'settings.json'),
-        keybindingsResource: joinPath(location, 'keybindings.json'),
-        tasksResource: joinPath(location, 'tasks.json'),
-        snippetsHome: joinPath(location, 'snippets'),
-        extensionsResource: joinPath(location, 'extensions.json'),
-        cacheHome: joinPath(profilesCacheHome, id),
-        useDefaultFlags: options?.useDefaultFlags,
-        isTransient: options?.transient
-    };
-}
-let UserDataProfilesService = class UserDataProfilesService extends Disposable {
-    get defaultProfile() { return this.profiles[0]; }
-    get profiles() { return [...this.profilesObject.profiles, ...this.transientProfilesObject.profiles]; }
-    constructor(environmentService, fileService, uriIdentityService, logService) {
-        super();
-        this.environmentService = environmentService;
-        this.fileService = fileService;
-        this.uriIdentityService = uriIdentityService;
-        this.logService = logService;
-        this.enabled = true;
-        this._onDidChangeProfiles = this._register(( new Emitter()));
-        this.onDidChangeProfiles = this._onDidChangeProfiles.event;
-        this._onWillCreateProfile = this._register(( new Emitter()));
-        this.onWillCreateProfile = this._onWillCreateProfile.event;
-        this._onWillRemoveProfile = this._register(( new Emitter()));
-        this.onWillRemoveProfile = this._onWillRemoveProfile.event;
-        this._onDidResetWorkspaces = this._register(( new Emitter()));
-        this.onDidResetWorkspaces = this._onDidResetWorkspaces.event;
-        this.profileCreationPromises = ( new Map());
-        this.transientProfilesObject = {
-            profiles: [],
-            workspaces: ( new ResourceMap()),
-            emptyWindows: ( new Map())
-        };
-        this.profilesHome = joinPath(this.environmentService.userRoamingDataHome, 'profiles');
-        this.profilesCacheHome = joinPath(this.environmentService.cacheHome, 'CachedProfilesData');
-    }
-    init() {
-        this._profilesObject = undefined;
-    }
-    setEnablement(enabled) {
-        if (this.enabled !== enabled) {
-            this._profilesObject = undefined;
-            this.enabled = enabled;
-        }
-    }
-    isEnabled() {
-        return this.enabled;
-    }
-    get profilesObject() {
-        if (!this._profilesObject) {
-            const profiles = [];
-            if (this.enabled) {
-                try {
-                    for (const storedProfile of this.getStoredProfiles()) {
-                        if (!storedProfile.name || !isString(storedProfile.name) || !storedProfile.location) {
-                            this.logService.warn('Skipping the invalid stored profile', storedProfile.location || storedProfile.name);
-                            continue;
-                        }
-                        profiles.push(toUserDataProfile(basename(storedProfile.location), storedProfile.name, storedProfile.location, this.profilesCacheHome, { shortName: storedProfile.shortName, useDefaultFlags: storedProfile.useDefaultFlags }));
-                    }
-                }
-                catch (error) {
-                    this.logService.error(error);
-                }
-            }
-            const workspaces = ( new ResourceMap());
-            const emptyWindows = ( new Map());
-            const defaultProfile = this.createDefaultProfile();
-            profiles.unshift({ ...defaultProfile, extensionsResource: this.getDefaultProfileExtensionsLocation() ?? defaultProfile.extensionsResource, isDefault: true });
-            if (profiles.length) {
-                try {
-                    const profileAssociaitions = this.getStoredProfileAssociations();
-                    if (profileAssociaitions.workspaces) {
-                        for (const [workspacePath, profileId] of Object.entries(profileAssociaitions.workspaces)) {
-                            const workspace = ( URI.parse(workspacePath));
-                            const profile = profiles.find(p => p.id === profileId);
-                            if (profile) {
-                                workspaces.set(workspace, profile);
-                            }
-                        }
-                    }
-                    if (profileAssociaitions.emptyWindows) {
-                        for (const [windowId, profileId] of Object.entries(profileAssociaitions.emptyWindows)) {
-                            const profile = profiles.find(p => p.id === profileId);
-                            if (profile) {
-                                emptyWindows.set(windowId, profile);
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    this.logService.error(error);
-                }
-            }
-            this._profilesObject = { profiles, workspaces, emptyWindows };
-        }
-        return this._profilesObject;
-    }
-    createDefaultProfile() {
-        return toUserDataProfile('__default__profile__', ( localize('defaultProfile', "Default")), this.environmentService.userRoamingDataHome, this.profilesCacheHome);
-    }
-    async createTransientProfile(workspaceIdentifier) {
-        const namePrefix = `Temp`;
-        const nameRegEx = ( new RegExp(`${escapeRegExpCharacters(namePrefix)}\\s(\\d+)`));
-        let nameIndex = 0;
-        for (const profile of this.profiles) {
-            const matches = nameRegEx.exec(profile.name);
-            const index = matches ? parseInt(matches[1]) : 0;
-            nameIndex = index > nameIndex ? index : nameIndex;
-        }
-        const name = `${namePrefix} ${nameIndex + 1}`;
-        return this.createProfile(( hash(generateUuid()).toString(16)), name, { transient: true }, workspaceIdentifier);
-    }
-    async createNamedProfile(name, options, workspaceIdentifier) {
-        return this.createProfile(( hash(generateUuid()).toString(16)), name, options, workspaceIdentifier);
-    }
-    async createProfile(id, name, options, workspaceIdentifier) {
-        if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
-        }
-        const profile = await this.doCreateProfile(id, name, options);
-        if (workspaceIdentifier) {
-            await this.setProfileForWorkspace(workspaceIdentifier, profile);
-        }
-        return profile;
-    }
-    async doCreateProfile(id, name, options) {
-        if (!isString(name) || !name) {
-            throw new Error('Name of the profile is mandatory and must be of type `string`');
-        }
-        let profileCreationPromise = this.profileCreationPromises.get(name);
-        if (!profileCreationPromise) {
-            profileCreationPromise = (async () => {
-                try {
-                    const existing = this.profiles.find(p => p.name === name || p.id === id);
-                    if (existing) {
-                        return existing;
-                    }
-                    const profile = toUserDataProfile(id, name, joinPath(this.profilesHome, id), this.profilesCacheHome, options);
-                    await this.fileService.createFolder(profile.location);
-                    const joiners = [];
-                    this._onWillCreateProfile.fire({
-                        profile,
-                        join(promise) {
-                            joiners.push(promise);
-                        }
-                    });
-                    await Promises.settled(joiners);
-                    this.updateProfiles([profile], [], []);
-                    return profile;
-                }
-                finally {
-                    this.profileCreationPromises.delete(name);
-                }
-            })();
-            this.profileCreationPromises.set(name, profileCreationPromise);
-        }
-        return profileCreationPromise;
-    }
-    async updateProfile(profileToUpdate, options) {
-        if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
-        }
-        let profile = this.profiles.find(p => p.id === profileToUpdate.id);
-        if (!profile) {
-            throw new Error(`Profile '${profileToUpdate.name}' does not exist`);
-        }
-        profile = toUserDataProfile(profile.id, options.name ?? profile.name, profile.location, this.profilesCacheHome, { shortName: options.shortName ?? profile.shortName, transient: options.transient ?? profile.isTransient, useDefaultFlags: options.useDefaultFlags ?? profile.useDefaultFlags });
-        this.updateProfiles([], [], [profile]);
-        return profile;
-    }
-    async removeProfile(profileToRemove) {
-        if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
-        }
-        if (profileToRemove.isDefault) {
-            throw new Error('Cannot remove default profile');
-        }
-        const profile = this.profiles.find(p => p.id === profileToRemove.id);
-        if (!profile) {
-            throw new Error(`Profile '${profileToRemove.name}' does not exist`);
-        }
-        const joiners = [];
-        this._onWillRemoveProfile.fire({
-            profile,
-            join(promise) {
-                joiners.push(promise);
-            }
-        });
-        try {
-            await Promise.allSettled(joiners);
-        }
-        catch (error) {
-            this.logService.error(error);
-        }
-        for (const windowId of [...( this.profilesObject.emptyWindows.keys())]) {
-            if (profile.id === this.profilesObject.emptyWindows.get(windowId)?.id) {
-                this.profilesObject.emptyWindows.delete(windowId);
-            }
-        }
-        for (const workspace of [...( this.profilesObject.workspaces.keys())]) {
-            if (profile.id === this.profilesObject.workspaces.get(workspace)?.id) {
-                this.profilesObject.workspaces.delete(workspace);
-            }
-        }
-        this.updateStoredProfileAssociations();
-        this.updateProfiles([], [profile], []);
-        try {
-            await this.fileService.del(profile.cacheHome, { recursive: true });
-        }
-        catch (error) {
-            if (toFileOperationResult(error) !== 1 ) {
-                this.logService.error(error);
-            }
-        }
-        try {
-            if (this.profiles.length === 1) {
-                await this.fileService.del(this.profilesHome, { recursive: true });
-            }
-            else {
-                await this.fileService.del(profile.location, { recursive: true });
-            }
-        }
-        catch (error) {
-            this.logService.error(error);
-        }
-    }
-    async setProfileForWorkspace(workspaceIdentifier, profileToSet) {
-        if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
-        }
-        const profile = this.profiles.find(p => p.id === profileToSet.id);
-        if (!profile) {
-            throw new Error(`Profile '${profileToSet.name}' does not exist`);
-        }
-        this.updateWorkspaceAssociation(workspaceIdentifier, profile);
-    }
-    unsetWorkspace(workspaceIdentifier, transient) {
-        if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
-        }
-        this.updateWorkspaceAssociation(workspaceIdentifier, undefined, transient);
-    }
-    async resetWorkspaces() {
-        this.transientProfilesObject.workspaces.clear();
-        this.transientProfilesObject.emptyWindows.clear();
-        this.profilesObject.workspaces.clear();
-        this.profilesObject.emptyWindows.clear();
-        this.updateStoredProfileAssociations();
-        this._onDidResetWorkspaces.fire();
-    }
-    async cleanUp() {
-        if (!this.enabled) {
-            return;
-        }
-        if (await this.fileService.exists(this.profilesHome)) {
-            const stat = await this.fileService.resolve(this.profilesHome);
-            await Promise.all(( (stat.children || [])
-                .filter(child => child.isDirectory && this.profiles.every(p => !this.uriIdentityService.extUri.isEqual(p.location, child.resource)))
-                .map(child => this.fileService.del(child.resource, { recursive: true }))));
-        }
-    }
-    async cleanUpTransientProfiles() {
-        if (!this.enabled) {
-            return;
-        }
-        const unAssociatedTransientProfiles = this.transientProfilesObject.profiles.filter(p => !this.isProfileAssociatedToWorkspace(p));
-        await Promise.allSettled(( unAssociatedTransientProfiles.map(p => this.removeProfile(p))));
-    }
-    getProfileForWorkspace(workspaceIdentifier) {
-        const workspace = this.getWorkspace(workspaceIdentifier);
-        return URI.isUri(workspace) ? this.transientProfilesObject.workspaces.get(workspace) ?? this.profilesObject.workspaces.get(workspace) : this.transientProfilesObject.emptyWindows.get(workspace) ?? this.profilesObject.emptyWindows.get(workspace);
-    }
-    getWorkspace(workspaceIdentifier) {
-        if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {
-            return workspaceIdentifier.uri;
-        }
-        if (isWorkspaceIdentifier(workspaceIdentifier)) {
-            return workspaceIdentifier.configPath;
-        }
-        return workspaceIdentifier.id;
-    }
-    isProfileAssociatedToWorkspace(profile) {
-        if (( [...( this.transientProfilesObject.emptyWindows.values())].some(
-            windowProfile => this.uriIdentityService.extUri.isEqual(windowProfile.location, profile.location)
-        ))) {
-            return true;
-        }
-        if (( [...( this.transientProfilesObject.workspaces.values())].some(
-            workspaceProfile => this.uriIdentityService.extUri.isEqual(workspaceProfile.location, profile.location)
-        ))) {
-            return true;
-        }
-        if (( [...( this.profilesObject.emptyWindows.values())].some(
-            windowProfile => this.uriIdentityService.extUri.isEqual(windowProfile.location, profile.location)
-        ))) {
-            return true;
-        }
-        if (( [...( this.profilesObject.workspaces.values())].some(
-            workspaceProfile => this.uriIdentityService.extUri.isEqual(workspaceProfile.location, profile.location)
-        ))) {
-            return true;
-        }
-        return false;
-    }
-    updateProfiles(added, removed, updated) {
-        const allProfiles = [...this.profiles, ...added];
-        const storedProfiles = [];
-        this.transientProfilesObject.profiles = [];
-        for (let profile of allProfiles) {
-            if (profile.isDefault) {
-                continue;
-            }
-            if (( removed.some(p => profile.id === p.id))) {
-                continue;
-            }
-            profile = updated.find(p => profile.id === p.id) ?? profile;
-            if (profile.isTransient) {
-                this.transientProfilesObject.profiles.push(profile);
-            }
-            else {
-                storedProfiles.push({ location: profile.location, name: profile.name, shortName: profile.shortName, useDefaultFlags: profile.useDefaultFlags });
-            }
-        }
-        this.saveStoredProfiles(storedProfiles);
-        this._profilesObject = undefined;
-        this.triggerProfilesChanges(added, removed, updated);
-    }
-    triggerProfilesChanges(added, removed, updated) {
-        this._onDidChangeProfiles.fire({ added, removed, updated, all: this.profiles });
-    }
-    updateWorkspaceAssociation(workspaceIdentifier, newProfile, transient) {
-        transient = newProfile?.isTransient ? true : transient;
-        if (!transient) {
-            this.updateWorkspaceAssociation(workspaceIdentifier, undefined, true);
-        }
-        const workspace = this.getWorkspace(workspaceIdentifier);
-        const profilesObject = transient ? this.transientProfilesObject : this.profilesObject;
-        if (URI.isUri(workspace)) {
-            profilesObject.workspaces.delete(workspace);
-            if (newProfile) {
-                profilesObject.workspaces.set(workspace, newProfile);
-            }
-        }
-        else {
-            profilesObject.emptyWindows.delete(workspace);
-            if (newProfile) {
-                profilesObject.emptyWindows.set(workspace, newProfile);
-            }
-        }
-        if (!transient) {
-            this.updateStoredProfileAssociations();
-        }
-    }
-    updateStoredProfileAssociations() {
-        const workspaces = {};
-        for (const [workspace, profile] of this.profilesObject.workspaces.entries()) {
-            workspaces[( workspace.toString())] = profile.id;
-        }
-        const emptyWindows = {};
-        for (const [windowId, profile] of this.profilesObject.emptyWindows.entries()) {
-            emptyWindows[( windowId.toString())] = profile.id;
-        }
-        this.saveStoredProfileAssociations({ workspaces, emptyWindows });
-        this._profilesObject = undefined;
-    }
-    migrateStoredProfileAssociations(storedProfileAssociations) {
-        const workspaces = {};
-        const defaultProfile = this.createDefaultProfile();
-        if (storedProfileAssociations.workspaces) {
-            for (const [workspace, location] of Object.entries(storedProfileAssociations.workspaces)) {
-                const uri = ( URI.parse(location));
-                workspaces[workspace] = this.uriIdentityService.extUri.isEqual(uri, defaultProfile.location) ? defaultProfile.id : this.uriIdentityService.extUri.basename(uri);
-            }
-        }
-        const emptyWindows = {};
-        if (storedProfileAssociations.emptyWindows) {
-            for (const [workspace, location] of Object.entries(storedProfileAssociations.emptyWindows)) {
-                const uri = ( URI.parse(location));
-                emptyWindows[workspace] = this.uriIdentityService.extUri.isEqual(uri, defaultProfile.location) ? defaultProfile.id : this.uriIdentityService.extUri.basename(uri);
-            }
-        }
-        return { workspaces, emptyWindows };
-    }
-    getStoredProfiles() { return []; }
-    saveStoredProfiles(storedProfiles) { throw new Error('not implemented'); }
-    getStoredProfileAssociations() { return {}; }
-    saveStoredProfileAssociations(storedProfileAssociations) { throw new Error('not implemented'); }
-    getDefaultProfileExtensionsLocation() { return undefined; }
-};
-UserDataProfilesService.PROFILES_KEY = 'userDataProfiles';
-UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY = 'profileAssociations';
-UserDataProfilesService = ( __decorate([
-    ( __param(0, IEnvironmentService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, ILogService))
-], UserDataProfilesService));
-export { IUserDataProfilesService, UserDataProfilesService, toUserDataProfile };