@codingame/monaco-vscode-api 4.4.1 → 4.5.0-improve-code-splitting.1

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

@@ -1,132 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { URI } from '../../../../base/common/uri.js';
-import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { UntitledTextEditorModel } from './untitledTextEditorModel.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { Emitter, Event } from '../../../../base/common/event.js';
-import { ResourceMap } from '../../../../base/common/map.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-var UntitledTextEditorService_1;
-const IUntitledTextEditorService = ( createDecorator('untitledTextEditorService'));
-let UntitledTextEditorService = class UntitledTextEditorService extends Disposable {
-    static { UntitledTextEditorService_1 = this; }
-    static { this.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/; }
-    constructor(instantiationService, configurationService) {
-        super();
-        this.instantiationService = instantiationService;
-        this.configurationService = configurationService;
-        this._onDidChangeDirty = this._register(( new Emitter()));
-        this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeEncoding = this._register(( new Emitter()));
-        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
-        this._onDidCreate = this._register(( new Emitter()));
-        this.onDidCreate = this._onDidCreate.event;
-        this._onWillDispose = this._register(( new Emitter()));
-        this.onWillDispose = this._onWillDispose.event;
-        this._onDidChangeLabel = this._register(( new Emitter()));
-        this.onDidChangeLabel = this._onDidChangeLabel.event;
-        this.mapResourceToModel = ( new ResourceMap());
-    }
-    get(resource) {
-        return this.mapResourceToModel.get(resource);
-    }
-    getValue(resource) {
-        return this.get(resource)?.textEditorModel?.getValue();
-    }
-    async resolve(options) {
-        const model = this.doCreateOrGet(options);
-        await model.resolve();
-        return model;
-    }
-    create(options) {
-        return this.doCreateOrGet(options);
-    }
-    doCreateOrGet(options = Object.create(null)) {
-        const massagedOptions = this.massageOptions(options);
-        if (massagedOptions.untitledResource && ( this.mapResourceToModel.has(massagedOptions.untitledResource))) {
-            return this.mapResourceToModel.get(massagedOptions.untitledResource);
-        }
-        return this.doCreate(massagedOptions);
-    }
-    massageOptions(options) {
-        const massagedOptions = Object.create(null);
-        if (options.associatedResource) {
-            massagedOptions.untitledResource = ( URI.from({
-                scheme: Schemas.untitled,
-                authority: options.associatedResource.authority,
-                fragment: options.associatedResource.fragment,
-                path: options.associatedResource.path,
-                query: options.associatedResource.query
-            }));
-            massagedOptions.associatedResource = options.associatedResource;
-        }
-        else {
-            if (options.untitledResource?.scheme === Schemas.untitled) {
-                massagedOptions.untitledResource = options.untitledResource;
-            }
-        }
-        if (options.languageId) {
-            massagedOptions.languageId = options.languageId;
-        }
-        else if (!massagedOptions.associatedResource) {
-            const configuration = this.configurationService.getValue();
-            if (configuration.files?.defaultLanguage) {
-                massagedOptions.languageId = configuration.files.defaultLanguage;
-            }
-        }
-        massagedOptions.encoding = options.encoding;
-        massagedOptions.initialValue = options.initialValue;
-        return massagedOptions;
-    }
-    doCreate(options) {
-        let untitledResource = options.untitledResource;
-        if (!untitledResource) {
-            let counter = 1;
-            do {
-                untitledResource = ( URI.from({ scheme: Schemas.untitled, path: `Untitled-${counter}` }));
-                counter++;
-            } while (( this.mapResourceToModel.has(untitledResource)));
-        }
-        const model = this._register(this.instantiationService.createInstance(UntitledTextEditorModel, untitledResource, !!options.associatedResource, options.initialValue, options.languageId, options.encoding));
-        this.registerModel(model);
-        return model;
-    }
-    registerModel(model) {
-        const modelListeners = ( new DisposableStore());
-        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
-        modelListeners.add(model.onDidChangeName(() => this._onDidChangeLabel.fire(model)));
-        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
-        modelListeners.add(model.onWillDispose(() => this._onWillDispose.fire(model)));
-        Event.once(model.onWillDispose)(() => {
-            this.mapResourceToModel.delete(model.resource);
-            modelListeners.dispose();
-        });
-        this.mapResourceToModel.set(model.resource, model);
-        this._onDidCreate.fire(model);
-        if (model.isDirty()) {
-            this._onDidChangeDirty.fire(model);
-        }
-    }
-    isUntitledWithAssociatedResource(resource) {
-        return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UntitledTextEditorService_1.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
-    }
-    canDispose(model) {
-        if (model.isDisposed()) {
-            return true;
-        }
-        return this.doCanDispose(model);
-    }
-    async doCanDispose(model) {
-        if (model.isDirty()) {
-            await Event.toPromise(model.onDidChangeDirty);
-            return this.canDispose(model);
-        }
-        return true;
-    }
-};
-UntitledTextEditorService = UntitledTextEditorService_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IConfigurationService))
-], UntitledTextEditorService));
-export { IUntitledTextEditorService, UntitledTextEditorService };

package/vscode/src/vs/workbench/services/userActivity/common/userActivityRegistry.js

@@ -1,15 +0,0 @@
-class UserActivityRegistry {
-    constructor() {
-        this.todo = [];
-        this.add = (ctor) => {
-            this.todo.push(ctor);
-        };
-    }
-    take(userActivityService, instantiation) {
-        this.add = ctor => instantiation.createInstance(ctor, userActivityService);
-        this.todo.forEach(this.add);
-        this.todo = [];
-    }
-}
-const userActivityRegistry = ( new UserActivityRegistry());
-export { userActivityRegistry };

package/vscode/src/vs/workbench/services/userActivity/common/userActivityService.js

@@ -1,37 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { RunOnceScheduler, runWhenGlobalIdle } from '../../../../base/common/async.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
-import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { userActivityRegistry } from './userActivityRegistry.js';
-const IUserActivityService = ( createDecorator('IUserActivityService'));
-let UserActivityService = class UserActivityService extends Disposable {
-    constructor(instantiationService) {
-        super();
-        this.markInactive = this._register(( new RunOnceScheduler(() => {
-            this.isActive = false;
-            this.changeEmitter.fire(false);
-        }, 10_000)));
-        this.changeEmitter = this._register(( new Emitter()));
-        this.active = 0;
-        this.isActive = true;
-        this.onDidChangeIsActive = this.changeEmitter.event;
-        this._register(runWhenGlobalIdle(() => userActivityRegistry.take(this, instantiationService)));
-    }
-    markActive() {
-        if (++this.active === 1) {
-            this.isActive = true;
-            this.changeEmitter.fire(true);
-            this.markInactive.cancel();
-        }
-        return toDisposable(() => {
-            if (--this.active === 0) {
-                this.markInactive.schedule();
-            }
-        });
-    }
-};
-UserActivityService = ( __decorate([
-    ( __param(0, IInstantiationService))
-], UserActivityService));
-export { IUserActivityService, UserActivityService };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.d.ts

@@ -1,15 +0,0 @@
-import { ServiceIdentifier, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-
-interface IUserDataInitializer {
-    requiresInitialization(): Promise<boolean>;
-    whenInitializationFinished(): Promise<void>;
-    initializeRequiredResources(): Promise<void>;
-    initializeInstalledExtensions(instantiationService: IInstantiationService): Promise<void>;
-    initializeOtherResources(instantiationService: IInstantiationService): Promise<void>;
-}
-declare const IUserDataInitializationService: ServiceIdentifier<IUserDataInitializationService>;
-interface IUserDataInitializationService extends IUserDataInitializer {
-    _serviceBrand: any;
-}
-
-export { IUserDataInitializationService, type IUserDataInitializer };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.js

@@ -1,60 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { Extensions } from '../../../common/contributions.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { isWeb } from '../../../../base/common/platform.js';
-import { IExtensionService } from '../../extensions/common/extensions.js';
-import { mark } from '../../../../base/common/performance.js';
-const IUserDataInitializationService = ( createDecorator('IUserDataInitializationService'));
-class UserDataInitializationService {
-    constructor(initializers = []) {
-        this.initializers = initializers;
-    }
-    async whenInitializationFinished() {
-        if (await this.requiresInitialization()) {
-            await Promise.all(( this.initializers.map(initializer => initializer.whenInitializationFinished())));
-        }
-    }
-    async requiresInitialization() {
-        return ( (await Promise.all(( this.initializers.map(initializer => initializer.requiresInitialization())))).some(result => result));
-    }
-    async initializeRequiredResources() {
-        if (await this.requiresInitialization()) {
-            await Promise.all(( this.initializers.map(initializer => initializer.initializeRequiredResources())));
-        }
-    }
-    async initializeOtherResources(instantiationService) {
-        if (await this.requiresInitialization()) {
-            await Promise.all(( this.initializers.map(initializer => initializer.initializeOtherResources(instantiationService))));
-        }
-    }
-    async initializeInstalledExtensions(instantiationService) {
-        if (await this.requiresInitialization()) {
-            await Promise.all(( this.initializers.map(
-                initializer => initializer.initializeInstalledExtensions(instantiationService)
-            )));
-        }
-    }
-}
-let InitializeOtherResourcesContribution = class InitializeOtherResourcesContribution {
-    constructor(userDataInitializeService, instantiationService, extensionService) {
-        extensionService.whenInstalledExtensionsRegistered().then(() => this.initializeOtherResource(userDataInitializeService, instantiationService));
-    }
-    async initializeOtherResource(userDataInitializeService, instantiationService) {
-        if (await userDataInitializeService.requiresInitialization()) {
-            mark('code/willInitOtherUserData');
-            await userDataInitializeService.initializeOtherResources(instantiationService);
-            mark('code/didInitOtherUserData');
-        }
-    }
-};
-InitializeOtherResourcesContribution = ( __decorate([
-    ( __param(0, IUserDataInitializationService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IExtensionService))
-], InitializeOtherResourcesContribution));
-if (isWeb) {
-    const workbenchRegistry = ( Registry.as(Extensions.Workbench));
-    workbenchRegistry.registerWorkbenchContribution(InitializeOtherResourcesContribution, 3 );
-}
-export { IUserDataInitializationService, UserDataInitializationService };

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

@@ -1,150 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
-import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { IUserDataProfileService } from './userDataProfile.js';
-import { distinct } from '../../../../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 };