@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/platform/terminal/common/terminalRecorder.js

@@ -0,0 +1,66 @@
+class TerminalRecorder {
+    constructor(cols, rows) {
+        this._totalDataLength = 0;
+        this._entries = [{ cols, rows, data: [] }];
+    }
+    handleResize(cols, rows) {
+        if (this._entries.length > 0) {
+            const lastEntry = this._entries[this._entries.length - 1];
+            if (lastEntry.data.length === 0) {
+                this._entries.pop();
+            }
+        }
+        if (this._entries.length > 0) {
+            const lastEntry = this._entries[this._entries.length - 1];
+            if (lastEntry.cols === cols && lastEntry.rows === rows) {
+                return;
+            }
+            if (lastEntry.cols === 0 && lastEntry.rows === 0) {
+                lastEntry.cols = cols;
+                lastEntry.rows = rows;
+                return;
+            }
+        }
+        this._entries.push({ cols, rows, data: [] });
+    }
+    handleData(data) {
+        const lastEntry = this._entries[this._entries.length - 1];
+        lastEntry.data.push(data);
+        this._totalDataLength += data.length;
+        while (this._totalDataLength > 1048576 ) {
+            const firstEntry = this._entries[0];
+            const remainingToDelete = this._totalDataLength - 1048576 ;
+            if (remainingToDelete >= firstEntry.data[0].length) {
+                this._totalDataLength -= firstEntry.data[0].length;
+                firstEntry.data.shift();
+                if (firstEntry.data.length === 0) {
+                    this._entries.shift();
+                }
+            }
+            else {
+                firstEntry.data[0] = firstEntry.data[0].substr(remainingToDelete);
+                this._totalDataLength -= remainingToDelete;
+            }
+        }
+    }
+    generateReplayEventSync() {
+        this._entries.forEach((entry) => {
+            if (entry.data.length > 0) {
+                entry.data = [entry.data.join('')];
+            }
+        });
+        return {
+            events: ( this._entries.map(
+                entry => ({ cols: entry.cols, rows: entry.rows, data: entry.data[0] ?? '' })
+            )),
+            commands: {
+                isWindowsPty: false,
+                commands: []
+            }
+        };
+    }
+    async generateReplayEvent() {
+        return this.generateReplayEventSync();
+    }
+}
+export { TerminalRecorder };

package/vscode/src/vs/platform/update/common/update.config.contribution.js

@@ -0,0 +1,98 @@
+import { isWindows, isWeb } from '../../../base/common/platform.js';
+import { localizeWithPath } from '../../../nls.js';
+import { Extensions } from '../../configuration/common/configurationRegistry.js';
+import { Registry } from '../../registry/common/platform.js';
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'update',
+    order: 15,
+    title: ( localizeWithPath(
+        'vs/platform/update/common/update.config.contribution',
+        'updateConfigurationTitle',
+        "Update"
+    )),
+    type: 'object',
+    properties: {
+        'update.mode': {
+            type: 'string',
+            enum: ['none', 'manual', 'start', 'default'],
+            default: 'default',
+            scope: 1 ,
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'updateMode',
+                "Configure whether you receive automatic updates. Requires a restart after change. The updates are fetched from a Microsoft online service."
+            )),
+            tags: ['usesOnlineServices'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'none',
+                    "Disable updates."
+                )),
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'manual',
+                    "Disable automatic background update checks. Updates will be available if you manually check for updates."
+                )),
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'start',
+                    "Check for updates only on startup. Disable automatic background update checks."
+                )),
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'default',
+                    "Enable automatic update checks. Code will check for updates automatically and periodically."
+                ))
+            ],
+            policy: {
+                name: 'UpdateMode',
+                minimumVersion: '1.67',
+            }
+        },
+        'update.channel': {
+            type: 'string',
+            default: 'default',
+            scope: 1 ,
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'updateMode',
+                "Configure whether you receive automatic updates. Requires a restart after change. The updates are fetched from a Microsoft online service."
+            )),
+            deprecationMessage: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'deprecated',
+                "This setting is deprecated, please use '{0}' instead.",
+                'update.mode'
+            ))
+        },
+        'update.enableWindowsBackgroundUpdates': {
+            type: 'boolean',
+            default: true,
+            scope: 1 ,
+            title: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'enableWindowsBackgroundUpdatesTitle',
+                "Enable Background Updates on Windows"
+            )),
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'enableWindowsBackgroundUpdates',
+                "Enable to download and install new VS Code versions in the background on Windows."
+            )),
+            included: isWindows && !isWeb
+        },
+        'update.showReleaseNotes': {
+            type: 'boolean',
+            default: true,
+            scope: 1 ,
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'showReleaseNotes',
+                "Show Release Notes after an update. The Release Notes are fetched from a Microsoft online service."
+            )),
+            tags: ['usesOnlineServices']
+        }
+    }
+});

package/vscode/src/vs/platform/url/common/urlService.js

@@ -0,0 +1,20 @@
+import { first } from '../../../base/common/async.js';
+import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import '../../../base/common/path.js';
+import '../../../base/common/platform.js';
+import '../../instantiation/common/instantiation.js';
+class AbstractURLService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.handlers = ( new Set());
+    }
+    open(uri, options) {
+        const handlers = [...( this.handlers.values())];
+        return first(( handlers.map(h => () => h.handleURL(uri, options))), undefined, false).then(val => val || false);
+    }
+    registerHandler(handler) {
+        this.handlers.add(handler);
+        return toDisposable(() => this.handlers.delete(handler));
+    }
+}
+export { AbstractURLService };

package/vscode/src/vs/platform/userDataProfile/browser/userDataProfile.js

@@ -0,0 +1,93 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { BroadcastDataChannel } from '../../../base/browser/broadcast.js';
+import { revive } from '../../../base/common/marshalling.js';
+import { IEnvironmentService } from '../../environment/common/environment.js';
+import { IFileService } from '../../files/common/files.js';
+import { ILogService } from '../../log/common/log.js';
+import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';
+import { UserDataProfilesService, reviveProfile } from '../common/userDataProfile.js';
+let BrowserUserDataProfilesService = class BrowserUserDataProfilesService extends UserDataProfilesService {
+    constructor(environmentService, fileService, uriIdentityService, logService) {
+        super(environmentService, fileService, uriIdentityService, logService);
+        this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`${UserDataProfilesService.PROFILES_KEY}.changes`)));
+        this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
+            try {
+                this._profilesObject = undefined;
+                const added = ( changes.added.map(p => reviveProfile(p, this.profilesHome.scheme)));
+                const removed = ( changes.removed.map(p => reviveProfile(p, this.profilesHome.scheme)));
+                const updated = ( changes.updated.map(p => reviveProfile(p, this.profilesHome.scheme)));
+                this.updateTransientProfiles(added.filter(a => a.isTransient), removed.filter(a => a.isTransient), updated.filter(a => a.isTransient));
+                this._onDidChangeProfiles.fire({
+                    added,
+                    removed,
+                    updated,
+                    all: this.profiles
+                });
+            }
+            catch (error) {  }
+        }));
+    }
+    updateTransientProfiles(added, removed, updated) {
+        if (added.length) {
+            this.transientProfilesObject.profiles.push(...added);
+        }
+        if (removed.length || updated.length) {
+            const allTransientProfiles = this.transientProfilesObject.profiles;
+            this.transientProfilesObject.profiles = [];
+            for (const profile of allTransientProfiles) {
+                if (( removed.some(p => profile.id === p.id))) {
+                    continue;
+                }
+                this.transientProfilesObject.profiles.push(updated.find(p => profile.id === p.id) ?? profile);
+            }
+        }
+    }
+    getStoredProfiles() {
+        try {
+            const value = localStorage.getItem(UserDataProfilesService.PROFILES_KEY);
+            if (value) {
+                return revive(JSON.parse(value));
+            }
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        return [];
+    }
+    triggerProfilesChanges(added, removed, updated) {
+        super.triggerProfilesChanges(added, removed, updated);
+        this.changesBroadcastChannel.postData({ added, removed, updated });
+    }
+    saveStoredProfiles(storedProfiles) {
+        localStorage.setItem(UserDataProfilesService.PROFILES_KEY, JSON.stringify(storedProfiles));
+    }
+    getStoredProfileAssociations() {
+        const migrateKey = 'profileAssociationsMigration';
+        try {
+            const value = localStorage.getItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY);
+            if (value) {
+                let associations = JSON.parse(value);
+                if (!localStorage.getItem(migrateKey)) {
+                    associations = this.migrateStoredProfileAssociations(associations);
+                    this.saveStoredProfileAssociations(associations);
+                    localStorage.setItem(migrateKey, 'true');
+                }
+                return associations;
+            }
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        return {};
+    }
+    saveStoredProfileAssociations(storedProfileAssociations) {
+        localStorage.setItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY, JSON.stringify(storedProfileAssociations));
+    }
+};
+BrowserUserDataProfilesService = ( __decorate([
+    ( __param(0, IEnvironmentService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, ILogService))
+], BrowserUserDataProfilesService));
+export { BrowserUserDataProfilesService };

package/vscode/src/vs/platform/userDataProfile/common/userDataProfileStorageService.js

@@ -0,0 +1,8 @@
+import '../../../base/common/lifecycle.js';
+import '../../../base/parts/storage/common/storage.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import '../../storage/common/storage.js';
+import '../../../base/common/event.js';
+import './userDataProfile.js';
+const IUserDataProfileStorageService = ( createDecorator('IUserDataProfileStorageService'));
+export { IUserDataProfileStorageService };

package/vscode/src/vs/platform/userDataSync/common/extensionsSync.js

@@ -0,0 +1,256 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Promises } from '../../../base/common/async.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { getErrorMessage } from '../../../base/common/errors.js';
+import '../../../base/common/event.js';
+import { toFormattedString } from '../../../base/common/jsonFormatter.js';
+import { DisposableStore } from '../../../base/common/lifecycle.js';
+import { compare } from '../../../base/common/strings.js';
+import '../../../base/common/path.js';
+import '../../../base/common/platform.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { GlobalExtensionEnablementService } from '../../extensionManagement/common/extensionEnablementService.js';
+import { ExtensionManagementError, ExtensionManagementErrorCode, EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT, EXTENSION_INSTALL_SYNC_CONTEXT, IExtensionManagementService, IExtensionGalleryService } from '../../extensionManagement/common/extensionManagement.js';
+import { areSameExtensions } from '../../extensionManagement/common/extensionManagementUtil.js';
+import { ExtensionStorageService } from '../../extensionManagement/common/extensionStorage.js';
+import { isApplicationScopedExtension } from '../../extensions/common/extensions.js';
+import '../../files/common/files.js';
+import { ServiceCollection } from '../../instantiation/common/serviceCollection.js';
+import '../../log/common/log.js';
+import { IStorageService } from '../../storage/common/storage.js';
+import '../../userDataProfile/common/userDataProfile.js';
+import { getSyncResourceLogLabel } from './abstractSynchronizer.js';
+import '../../../../../../external/vscode-semver/semver.js';
+import { IIgnoredExtensionsManagementService } from './ignoredExtensions.js';
+import { IUserDataSyncLogService } from './userDataSync.js';
+import { IUserDataProfileStorageService } from '../../userDataProfile/common/userDataProfileStorageService.js';
+function parseExtensions(syncData) {
+    return JSON.parse(syncData.content);
+}
+function stringify(extensions, format) {
+    extensions.sort((e1, e2) => {
+        if (!e1.identifier.uuid && e2.identifier.uuid) {
+            return -1;
+        }
+        if (e1.identifier.uuid && !e2.identifier.uuid) {
+            return 1;
+        }
+        return compare(e1.identifier.id, e2.identifier.id);
+    });
+    return format ? toFormattedString(extensions, {}) : JSON.stringify(extensions);
+}
+let LocalExtensionsProvider = class LocalExtensionsProvider {
+    constructor(extensionManagementService, userDataProfileStorageService, extensionGalleryService, ignoredExtensionsManagementService, instantiationService, logService) {
+        this.extensionManagementService = extensionManagementService;
+        this.userDataProfileStorageService = userDataProfileStorageService;
+        this.extensionGalleryService = extensionGalleryService;
+        this.ignoredExtensionsManagementService = ignoredExtensionsManagementService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+    }
+    async getLocalExtensions(profile) {
+        const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
+        const ignoredExtensions = this.ignoredExtensionsManagementService.getIgnoredExtensions(installedExtensions);
+        const localExtensions = await this.withProfileScopedServices(profile, async (extensionEnablementService, extensionStorageService) => {
+            const disabledExtensions = extensionEnablementService.getDisabledExtensions();
+            return ( installedExtensions
+                .map(extension => {
+                const { identifier, isBuiltin, manifest, preRelease, pinned, isApplicationScoped } = extension;
+                const syncExntesion = { identifier, preRelease, version: manifest.version, pinned: !!pinned };
+                if (isApplicationScoped && !isApplicationScopedExtension(manifest)) {
+                    syncExntesion.isApplicationScoped = isApplicationScoped;
+                }
+                if (( disabledExtensions.some(disabledExtension => areSameExtensions(disabledExtension, identifier)))) {
+                    syncExntesion.disabled = true;
+                }
+                if (!isBuiltin) {
+                    syncExntesion.installed = true;
+                }
+                try {
+                    const keys = extensionStorageService.getKeysForSync({ id: identifier.id, version: manifest.version });
+                    if (keys) {
+                        const extensionStorageState = extensionStorageService.getExtensionState(extension, true) || {};
+                        syncExntesion.state = ( Object.keys(extensionStorageState)).reduce((state, key) => {
+                            if (keys.includes(key)) {
+                                state[key] = extensionStorageState[key];
+                            }
+                            return state;
+                        }, {});
+                    }
+                }
+                catch (error) {
+                    this.logService.info(`${getSyncResourceLogLabel("extensions" , profile)}: Error while parsing extension state`, getErrorMessage(error));
+                }
+                return syncExntesion;
+            }));
+        });
+        return { localExtensions, ignoredExtensions };
+    }
+    async updateLocalExtensions(added, removed, updated, skippedExtensions, profile) {
+        const syncResourceLogLabel = getSyncResourceLogLabel("extensions" , profile);
+        const extensionsToInstall = [];
+        const syncExtensionsToInstall = ( new Map());
+        const removeFromSkipped = [];
+        const addToSkipped = [];
+        const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
+        if (added.length || updated.length) {
+            await this.withProfileScopedServices(profile, async (extensionEnablementService, extensionStorageService) => {
+                await Promises.settled(( [...added, ...updated].map(async (e) => {
+                    const installedExtension = installedExtensions.find(installed => areSameExtensions(installed.identifier, e.identifier));
+                    if (installedExtension && installedExtension.isBuiltin) {
+                        if (e.state && installedExtension.manifest.version === e.version) {
+                            this.updateExtensionState(e.state, installedExtension, installedExtension.manifest.version, extensionStorageService);
+                        }
+                        const isDisabled = ( extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier)));
+                        if (isDisabled !== !!e.disabled) {
+                            if (e.disabled) {
+                                this.logService.trace(`${syncResourceLogLabel}: Disabling extension...`, e.identifier.id);
+                                await extensionEnablementService.disableExtension(e.identifier);
+                                this.logService.info(`${syncResourceLogLabel}: Disabled extension`, e.identifier.id);
+                            }
+                            else {
+                                this.logService.trace(`${syncResourceLogLabel}: Enabling extension...`, e.identifier.id);
+                                await extensionEnablementService.enableExtension(e.identifier);
+                                this.logService.info(`${syncResourceLogLabel}: Enabled extension`, e.identifier.id);
+                            }
+                        }
+                        removeFromSkipped.push(e.identifier);
+                        return;
+                    }
+                    const version = e.pinned ? e.version : undefined;
+                    const extension = (await this.extensionGalleryService.getExtensions([{ ...e.identifier, version, preRelease: version ? undefined : e.preRelease }], CancellationToken.None))[0];
+                    if (e.state &&
+                        ((installedExtension ? installedExtension.manifest.version === e.version  : !!extension) )) {
+                        this.updateExtensionState(e.state, installedExtension || extension, installedExtension?.manifest.version, extensionStorageService);
+                    }
+                    if (extension) {
+                        try {
+                            const isDisabled = ( extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier)));
+                            if (isDisabled !== !!e.disabled) {
+                                if (e.disabled) {
+                                    this.logService.trace(`${syncResourceLogLabel}: Disabling extension...`, e.identifier.id, extension.version);
+                                    await extensionEnablementService.disableExtension(extension.identifier);
+                                    this.logService.info(`${syncResourceLogLabel}: Disabled extension`, e.identifier.id, extension.version);
+                                }
+                                else {
+                                    this.logService.trace(`${syncResourceLogLabel}: Enabling extension...`, e.identifier.id, extension.version);
+                                    await extensionEnablementService.enableExtension(extension.identifier);
+                                    this.logService.info(`${syncResourceLogLabel}: Enabled extension`, e.identifier.id, extension.version);
+                                }
+                            }
+                            if (!installedExtension
+                                || installedExtension.preRelease !== e.preRelease
+                                || installedExtension.pinned !== e.pinned
+                                || (version && installedExtension.manifest.version !== version)
+                            ) {
+                                if (await this.extensionManagementService.canInstall(extension)) {
+                                    extensionsToInstall.push({
+                                        extension, options: {
+                                            isMachineScoped: false ,
+                                            donotIncludePackAndDependencies: true,
+                                            installGivenVersion: e.pinned && !!e.version,
+                                            installPreReleaseVersion: e.preRelease,
+                                            profileLocation: profile.extensionsResource,
+                                            isApplicationScoped: e.isApplicationScoped,
+                                            context: { [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true, [EXTENSION_INSTALL_SYNC_CONTEXT]: true }
+                                        }
+                                    });
+                                    syncExtensionsToInstall.set(extension.identifier.id.toLowerCase(), e);
+                                }
+                                else {
+                                    this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension because it cannot be installed.`, extension.displayName || extension.identifier.id);
+                                    addToSkipped.push(e);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            addToSkipped.push(e);
+                            this.logService.error(error);
+                            this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension`, extension.displayName || extension.identifier.id);
+                        }
+                    }
+                    else {
+                        addToSkipped.push(e);
+                        this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension because the extension is not found.`, e.identifier.id);
+                    }
+                })));
+            });
+        }
+        if (removed.length) {
+            const extensionsToRemove = installedExtensions.filter(({ identifier, isBuiltin }) => !isBuiltin && ( removed.some(r => areSameExtensions(identifier, r))));
+            await Promises.settled(( extensionsToRemove.map(async (extensionToRemove) => {
+                this.logService.trace(`${syncResourceLogLabel}: Uninstalling local extension...`, extensionToRemove.identifier.id);
+                await this.extensionManagementService.uninstall(extensionToRemove, { donotIncludePack: true, donotCheckDependents: true, profileLocation: profile.extensionsResource });
+                this.logService.info(`${syncResourceLogLabel}: Uninstalled local extension.`, extensionToRemove.identifier.id);
+                removeFromSkipped.push(extensionToRemove.identifier);
+            })));
+        }
+        const results = await this.extensionManagementService.installGalleryExtensions(extensionsToInstall);
+        for (const { identifier, local, error, source } of results) {
+            const gallery = source;
+            if (local) {
+                this.logService.info(`${syncResourceLogLabel}: Installed extension.`, identifier.id, gallery.version);
+                removeFromSkipped.push(identifier);
+            }
+            else {
+                const e = syncExtensionsToInstall.get(identifier.id.toLowerCase());
+                if (e) {
+                    addToSkipped.push(e);
+                    this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension`, gallery.displayName || gallery.identifier.id);
+                }
+                if (error instanceof ExtensionManagementError && [ExtensionManagementErrorCode.Incompatible, ExtensionManagementErrorCode.IncompatibleTargetPlatform].includes(error.code)) {
+                    this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension because the compatible extension is not found.`, gallery.displayName || gallery.identifier.id);
+                }
+                else if (error) {
+                    this.logService.error(error);
+                }
+            }
+        }
+        const newSkippedExtensions = [];
+        for (const skippedExtension of skippedExtensions) {
+            if (!( removeFromSkipped.some(e => areSameExtensions(e, skippedExtension.identifier)))) {
+                newSkippedExtensions.push(skippedExtension);
+            }
+        }
+        for (const skippedExtension of addToSkipped) {
+            if (!( newSkippedExtensions.some(e => areSameExtensions(e.identifier, skippedExtension.identifier)))) {
+                newSkippedExtensions.push(skippedExtension);
+            }
+        }
+        return newSkippedExtensions;
+    }
+    updateExtensionState(state, extension, version, extensionStorageService) {
+        const extensionState = extensionStorageService.getExtensionState(extension, true) || {};
+        const keys = version ? extensionStorageService.getKeysForSync({ id: extension.identifier.id, version }) : undefined;
+        if (keys) {
+            keys.forEach(key => { extensionState[key] = state[key]; });
+        }
+        else {
+            ( Object.keys(state)).forEach(key => extensionState[key] = state[key]);
+        }
+        extensionStorageService.setExtensionState(extension, extensionState, true);
+    }
+    async withProfileScopedServices(profile, fn) {
+        return this.userDataProfileStorageService.withProfileScopedStorageService(profile, async (storageService) => {
+            const disposables = ( new DisposableStore());
+            const instantiationService = this.instantiationService.createChild(( new ServiceCollection([IStorageService, storageService])));
+            const extensionEnablementService = disposables.add(instantiationService.createInstance(GlobalExtensionEnablementService));
+            const extensionStorageService = disposables.add(instantiationService.createInstance(ExtensionStorageService));
+            try {
+                return await fn(extensionEnablementService, extensionStorageService);
+            }
+            finally {
+                disposables.dispose();
+            }
+        });
+    }
+};
+LocalExtensionsProvider = ( __decorate([
+    ( __param(0, IExtensionManagementService)),
+    ( __param(1, IUserDataProfileStorageService)),
+    ( __param(2, IExtensionGalleryService)),
+    ( __param(3, IIgnoredExtensionsManagementService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IUserDataSyncLogService))
+], LocalExtensionsProvider));
+export { LocalExtensionsProvider, parseExtensions, stringify };

package/vscode/src/vs/platform/userDataSync/common/globalStateSync.js

@@ -0,0 +1,120 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from '../../../base/common/buffer.js';
+import { getErrorMessage } from '../../../base/common/errors.js';
+import '../../../base/common/event.js';
+import { parse } from '../../../base/common/json.js';
+import { toFormattedString } from '../../../base/common/jsonFormatter.js';
+import '../../../base/common/platform.js';
+import '../../../base/common/path.js';
+import '../../instantiation/common/instantiation.js';
+import { IEnvironmentService } from '../../environment/common/environment.js';
+import { IFileService } from '../../files/common/files.js';
+import '../../log/common/log.js';
+import '../../storage/common/storage.js';
+import { getSyncResourceLogLabel } from './abstractSynchronizer.js';
+import { edit } from './content.js';
+import { IUserDataSyncLogService } from './userDataSync.js';
+import '../../userDataProfile/common/userDataProfile.js';
+import { IUserDataProfileStorageService } from '../../userDataProfile/common/userDataProfileStorageService.js';
+const argvStoragePrefx = 'globalState.argv.';
+const argvProperties = ['locale'];
+function stringify(globalState, format) {
+    const storageKeys = globalState.storage ? ( Object.keys(globalState.storage)).sort() : [];
+    const storage = {};
+    storageKeys.forEach(key => storage[key] = globalState.storage[key]);
+    globalState.storage = storage;
+    return format ? toFormattedString(globalState, {}) : JSON.stringify(globalState);
+}
+let LocalGlobalStateProvider = class LocalGlobalStateProvider {
+    constructor(fileService, environmentService, userDataProfileStorageService, logService) {
+        this.fileService = fileService;
+        this.environmentService = environmentService;
+        this.userDataProfileStorageService = userDataProfileStorageService;
+        this.logService = logService;
+    }
+    async getLocalGlobalState(profile) {
+        const storage = {};
+        if (profile.isDefault) {
+            const argvContent = await this.getLocalArgvContent();
+            const argvValue = parse(argvContent);
+            for (const argvProperty of argvProperties) {
+                if (argvValue[argvProperty] !== undefined) {
+                    storage[`${argvStoragePrefx}${argvProperty}`] = { version: 1, value: argvValue[argvProperty] };
+                }
+            }
+        }
+        const storageData = await this.userDataProfileStorageService.readStorageData(profile);
+        for (const [key, value] of storageData) {
+            if (value.value && value.target === 0 ) {
+                storage[key] = { version: 1, value: value.value };
+            }
+        }
+        return { storage };
+    }
+    async getLocalArgvContent() {
+        try {
+            this.logService.debug('GlobalStateSync#getLocalArgvContent', this.environmentService.argvResource);
+            const content = await this.fileService.readFile(this.environmentService.argvResource);
+            this.logService.debug('GlobalStateSync#getLocalArgvContent - Resolved', this.environmentService.argvResource);
+            return ( content.value.toString());
+        }
+        catch (error) {
+            this.logService.debug(getErrorMessage(error));
+        }
+        return '{}';
+    }
+    async writeLocalGlobalState({ added, removed, updated }, profile) {
+        const syncResourceLogLabel = getSyncResourceLogLabel("globalState" , profile);
+        const argv = {};
+        const updatedStorage = ( new Map());
+        const storageData = await this.userDataProfileStorageService.readStorageData(profile);
+        const handleUpdatedStorage = (keys, storage) => {
+            for (const key of keys) {
+                if (key.startsWith(argvStoragePrefx)) {
+                    argv[key.substring(argvStoragePrefx.length)] = storage ? storage[key].value : undefined;
+                    continue;
+                }
+                if (storage) {
+                    const storageValue = storage[key];
+                    if (storageValue.value !== storageData.get(key)?.value) {
+                        updatedStorage.set(key, storageValue.value);
+                    }
+                }
+                else {
+                    if (storageData.get(key) !== undefined) {
+                        updatedStorage.set(key, undefined);
+                    }
+                }
+            }
+        };
+        handleUpdatedStorage(( Object.keys(added)), added);
+        handleUpdatedStorage(( Object.keys(updated)), updated);
+        handleUpdatedStorage(removed);
+        if (( Object.keys(argv)).length) {
+            this.logService.trace(`${syncResourceLogLabel}: Updating locale...`);
+            const argvContent = await this.getLocalArgvContent();
+            let content = argvContent;
+            for (const argvProperty of ( Object.keys(argv))) {
+                content = edit(content, [argvProperty], argv[argvProperty], {});
+            }
+            if (argvContent !== content) {
+                this.logService.trace(`${syncResourceLogLabel}: Updating locale...`);
+                await this.fileService.writeFile(this.environmentService.argvResource, VSBuffer.fromString(content));
+                this.logService.info(`${syncResourceLogLabel}: Updated locale.`);
+            }
+            this.logService.info(`${syncResourceLogLabel}: Updated locale`);
+        }
+        if (updatedStorage.size) {
+            this.logService.trace(`${syncResourceLogLabel}: Updating global state...`);
+            await this.userDataProfileStorageService.updateStorageData(profile, updatedStorage, 0 );
+            this.logService.info(`${syncResourceLogLabel}: Updated global state`, [...( updatedStorage.keys())]);
+        }
+    }
+};
+LocalGlobalStateProvider = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IEnvironmentService)),
+    ( __param(2, IUserDataProfileStorageService)),
+    ( __param(3, IUserDataSyncLogService))
+], LocalGlobalStateProvider));
+export { LocalGlobalStateProvider, stringify };