@codingame/monaco-vscode-user-data-sync-service-override 4.4.0 → 4.5.0-improve-code-splitting.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-user-data-sync-service-override",
-  "version": "4.4.0",
+  "version": "4.5.0-improve-code-splitting.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -17,7 +17,15 @@
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js"
+    }
+  },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.4.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.5.0-improve-code-splitting.1"
   }
 }

package/userDataSync.js

@@ -1,35 +1,38 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { IUserDataSyncStoreManagementService, IUserDataAutoSyncService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService, IUserDataSyncUtilService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
-import { IUserDataSyncAccountService, UserDataSyncAccountService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount';
-import { IUserDataSyncMachinesService, UserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
+import { IUserDataSyncStoreManagementService, IUserDataAutoSyncService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService, IUserDataSyncUtilService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
+import { UserDataSyncAccountService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncAccount.js';
+import { IUserDataSyncAccountService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service';
+import { UserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
+import { IUserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines.service';
 import { UserDataSyncStoreManagementService, UserDataSyncStoreService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncStoreService';
 import { UserDataAutoSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataAutoSyncService.js';
 import { WebUserDataSyncEnablementService } from './vscode/src/vs/workbench/services/userDataSync/browser/webUserDataSyncEnablementService.js';
 import { UserDataSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncService.js';
 import { UserDataSyncLogService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLog.js';
 import { BrowserUserDataProfilesService } from './vscode/src/vs/platform/userDataProfile/browser/userDataProfile.js';
-import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { UserDataSyncResourceProviderService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncResourceProvider.js';
 import { UserDataSyncLocalStoreService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLocalStoreService.js';
 import { UserDataSyncWorkbenchService } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.js';
-import { IUserDataSyncWorkbenchService } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync';
+import { IUserDataSyncWorkbenchService } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync.service';
 import './vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.js';
-import { IUserDataInitializationService, UserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit';
+import { UserDataInitializationService } from './vscode/src/vs/workbench/services/userData/browser/userDataInit.js';
+import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit.service';
 import { UserDataSyncInitializer } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncInit.js';
 import { UserDataProfileInitializer } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileInit.js';
-import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
-import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { IUserDataProfileService, IUserDataProfileImportExportService, IUserDataProfileManagementService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IUserDataProfileService, IUserDataProfileImportExportService, IUserDataProfileManagementService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import { mark } from 'vscode/vscode/vs/base/common/performance';
 import { timeout } from 'vscode/vscode/vs/base/common/async';
-import { IWorkbenchConfigurationService } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { IWorkbenchConfigurationService } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration.service';
 import { UserDataSyncUtilService } from './vscode/src/vs/workbench/services/userDataSync/common/userDataSyncUtil.js';
 import { UserDataProfileImportExportService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService.js';
 import { UserDataProfileManagementService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileManagement.js';

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

@@ -1,10 +1,10 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { BroadcastDataChannel } from 'vscode/vscode/vs/base/browser/broadcast';
 import { revive } from 'vscode/vscode/vs/base/common/marshalling';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { UserDataProfilesService, reviveProfile } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
 
 let BrowserUserDataProfilesService = class BrowserUserDataProfilesService extends UserDataProfilesService {

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

@@ -0,0 +1,5 @@
+import { createDecorator } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+const IUserDataProfileStorageService = ( createDecorator('IUserDataProfileStorageService'));
+
+export { IUserDataProfileStorageService };

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

@@ -0,0 +1,331 @@
+import { deepClone, equals } from 'vscode/vscode/vs/base/common/objects';
+import { semverExports } from 'vscode/external/vscode-semver/semver.js';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+
+function merge(localExtensions, remoteExtensions, lastSyncExtensions, skippedExtensions, ignoredExtensions, lastSyncBuiltinExtensions) {
+    const added = [];
+    const removed = [];
+    const updated = [];
+    if (!remoteExtensions) {
+        const remote = localExtensions.filter(({ identifier }) => ignoredExtensions.every(id => id.toLowerCase() !== identifier.id.toLowerCase()));
+        return {
+            local: {
+                added,
+                removed,
+                updated,
+            },
+            remote: remote.length > 0 ? {
+                added: remote,
+                updated: [],
+                removed: [],
+                all: remote
+            } : null
+        };
+    }
+    localExtensions = ( localExtensions.map(massageIncomingExtension));
+    remoteExtensions = ( remoteExtensions.map(massageIncomingExtension));
+    lastSyncExtensions = lastSyncExtensions ? ( lastSyncExtensions.map(massageIncomingExtension)) : null;
+    const uuids = ( new Map());
+    const addUUID = (identifier) => { if (identifier.uuid) {
+        uuids.set(identifier.id.toLowerCase(), identifier.uuid);
+    } };
+    localExtensions.forEach(({ identifier }) => addUUID(identifier));
+    remoteExtensions.forEach(({ identifier }) => addUUID(identifier));
+    lastSyncExtensions?.forEach(({ identifier }) => addUUID(identifier));
+    skippedExtensions?.forEach(({ identifier }) => addUUID(identifier));
+    lastSyncBuiltinExtensions?.forEach(identifier => addUUID(identifier));
+    const getKey = (extension) => {
+        const uuid = extension.identifier.uuid || uuids.get(extension.identifier.id.toLowerCase());
+        return uuid ? `uuid:${uuid}` : `id:${extension.identifier.id.toLowerCase()}`;
+    };
+    const addExtensionToMap = (map, extension) => {
+        map.set(getKey(extension), extension);
+        return map;
+    };
+    const localExtensionsMap = localExtensions.reduce(addExtensionToMap, ( new Map()));
+    const remoteExtensionsMap = remoteExtensions.reduce(addExtensionToMap, ( new Map()));
+    const newRemoteExtensionsMap = remoteExtensions.reduce((map, extension) => addExtensionToMap(map, deepClone(extension)), ( new Map()));
+    const lastSyncExtensionsMap = lastSyncExtensions ? lastSyncExtensions.reduce(addExtensionToMap, ( new Map())) : null;
+    const skippedExtensionsMap = skippedExtensions.reduce(addExtensionToMap, ( new Map()));
+    const ignoredExtensionsSet = ignoredExtensions.reduce((set, id) => {
+        const uuid = uuids.get(id.toLowerCase());
+        return set.add(uuid ? `uuid:${uuid}` : `id:${id.toLowerCase()}`);
+    }, ( new Set()));
+    const lastSyncBuiltinExtensionsSet = lastSyncBuiltinExtensions ? lastSyncBuiltinExtensions.reduce((set, { id, uuid }) => {
+        uuid = uuid ?? uuids.get(id.toLowerCase());
+        return set.add(uuid ? `uuid:${uuid}` : `id:${id.toLowerCase()}`);
+    }, ( new Set())) : null;
+    const localToRemote = compare(localExtensionsMap, remoteExtensionsMap, ignoredExtensionsSet, false);
+    if (localToRemote.added.size > 0 || localToRemote.removed.size > 0 || localToRemote.updated.size > 0) {
+        const baseToLocal = compare(lastSyncExtensionsMap, localExtensionsMap, ignoredExtensionsSet, false);
+        const baseToRemote = compare(lastSyncExtensionsMap, remoteExtensionsMap, ignoredExtensionsSet, true);
+        const merge = (key, localExtension, remoteExtension, preferred) => {
+            let pinned, version, preRelease;
+            if (localExtension.installed) {
+                pinned = preferred.pinned;
+                preRelease = preferred.preRelease;
+                if (pinned) {
+                    version = preferred.version;
+                }
+            }
+            else {
+                pinned = remoteExtension.pinned;
+                preRelease = remoteExtension.preRelease;
+                if (pinned) {
+                    version = remoteExtension.version;
+                }
+            }
+            if (pinned === undefined ) {
+                pinned = localExtension.pinned;
+                if (pinned) {
+                    version = localExtension.version;
+                }
+            }
+            if (preRelease === undefined ) {
+                preRelease = localExtension.preRelease;
+            }
+            return {
+                ...preferred,
+                installed: localExtension.installed || remoteExtension.installed,
+                pinned,
+                preRelease,
+                version: version ?? (remoteExtension.version && (!localExtension.installed || semverExports.gt(remoteExtension.version, localExtension.version)) ? remoteExtension.version : localExtension.version),
+                state: mergeExtensionState(localExtension, remoteExtension, lastSyncExtensionsMap?.get(key)),
+            };
+        };
+        for (const key of ( baseToRemote.removed.values())) {
+            const localExtension = localExtensionsMap.get(key);
+            if (!localExtension) {
+                continue;
+            }
+            const baseExtension = assertIsDefined(lastSyncExtensionsMap?.get(key));
+            const wasAnInstalledExtensionDuringLastSync = lastSyncBuiltinExtensionsSet && !( lastSyncBuiltinExtensionsSet.has(key)) && baseExtension.installed;
+            if (localExtension.installed && wasAnInstalledExtensionDuringLastSync ) {
+                removed.push(localExtension.identifier);
+            }
+            else {
+                newRemoteExtensionsMap.set(key, localExtension);
+            }
+        }
+        for (const key of ( baseToRemote.added.values())) {
+            const remoteExtension = assertIsDefined(remoteExtensionsMap.get(key));
+            const localExtension = localExtensionsMap.get(key);
+            if (localExtension) {
+                if (( localToRemote.updated.has(key))) {
+                    const mergedExtension = merge(key, localExtension, remoteExtension, remoteExtension);
+                    if (!areSame(localExtension, remoteExtension, false, false)) {
+                        updated.push(massageOutgoingExtension(mergedExtension, key));
+                    }
+                    newRemoteExtensionsMap.set(key, mergedExtension);
+                }
+            }
+            else {
+                if (remoteExtension.installed) {
+                    added.push(massageOutgoingExtension(remoteExtension, key));
+                }
+            }
+        }
+        for (const key of ( baseToRemote.updated.values())) {
+            const remoteExtension = assertIsDefined(remoteExtensionsMap.get(key));
+            const baseExtension = assertIsDefined(lastSyncExtensionsMap?.get(key));
+            const localExtension = localExtensionsMap.get(key);
+            if (localExtension) {
+                const wasAnInstalledExtensionDuringLastSync = lastSyncBuiltinExtensionsSet && !( lastSyncBuiltinExtensionsSet.has(key)) && baseExtension.installed;
+                if (wasAnInstalledExtensionDuringLastSync && localExtension.installed && !remoteExtension.installed) {
+                    removed.push(localExtension.identifier);
+                }
+                else {
+                    const mergedExtension = merge(key, localExtension, remoteExtension, remoteExtension);
+                    updated.push(massageOutgoingExtension(mergedExtension, key));
+                    newRemoteExtensionsMap.set(key, mergedExtension);
+                }
+            }
+            else if (remoteExtension.installed) {
+                added.push(massageOutgoingExtension(remoteExtension, key));
+            }
+        }
+        for (const key of ( baseToLocal.added.values())) {
+            if (( baseToRemote.added.has(key))) {
+                continue;
+            }
+            newRemoteExtensionsMap.set(key, assertIsDefined(localExtensionsMap.get(key)));
+        }
+        for (const key of ( baseToLocal.updated.values())) {
+            if (( baseToRemote.removed.has(key))) {
+                continue;
+            }
+            if (( baseToRemote.updated.has(key))) {
+                continue;
+            }
+            const localExtension = assertIsDefined(localExtensionsMap.get(key));
+            const remoteExtension = assertIsDefined(remoteExtensionsMap.get(key));
+            newRemoteExtensionsMap.set(key, merge(key, localExtension, remoteExtension, localExtension));
+        }
+        for (const key of ( baseToLocal.removed.values())) {
+            if (( baseToRemote.updated.has(key))) {
+                continue;
+            }
+            if (( baseToRemote.removed.has(key))) {
+                continue;
+            }
+            if (( skippedExtensionsMap.has(key))) {
+                continue;
+            }
+            if (!assertIsDefined(remoteExtensionsMap.get(key)).installed) {
+                continue;
+            }
+            if (!lastSyncBuiltinExtensionsSet) {
+                continue;
+            }
+            if (( lastSyncBuiltinExtensionsSet.has(key)) || !assertIsDefined(lastSyncExtensionsMap?.get(key)).installed) {
+                continue;
+            }
+            newRemoteExtensionsMap.delete(key);
+        }
+    }
+    const remote = [];
+    const remoteChanges = compare(remoteExtensionsMap, newRemoteExtensionsMap, ( new Set()), true);
+    const hasRemoteChanges = remoteChanges.added.size > 0 || remoteChanges.updated.size > 0 || remoteChanges.removed.size > 0;
+    if (hasRemoteChanges) {
+        newRemoteExtensionsMap.forEach((value, key) => remote.push(massageOutgoingExtension(value, key)));
+    }
+    return {
+        local: { added, removed, updated },
+        remote: hasRemoteChanges ? {
+            added: ( [...remoteChanges.added].map(id => newRemoteExtensionsMap.get(id))),
+            updated: ( [...remoteChanges.updated].map(id => newRemoteExtensionsMap.get(id))),
+            removed: ( [...remoteChanges.removed].map(id => remoteExtensionsMap.get(id))),
+            all: remote
+        } : null
+    };
+}
+function compare(from, to, ignoredExtensions, checkVersionProperty) {
+    const fromKeys = from ? [...( from.keys())].filter(key => !( ignoredExtensions.has(key))) : [];
+    const toKeys = [...( to.keys())].filter(key => !( ignoredExtensions.has(key)));
+    const added = toKeys.filter(key => !fromKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
+    const removed = fromKeys.filter(key => !toKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
+    const updated = ( new Set());
+    for (const key of fromKeys) {
+        if (( removed.has(key))) {
+            continue;
+        }
+        const fromExtension = from.get(key);
+        const toExtension = to.get(key);
+        if (!toExtension || !areSame(fromExtension, toExtension, checkVersionProperty, true)) {
+            updated.add(key);
+        }
+    }
+    return { added, removed, updated };
+}
+function areSame(fromExtension, toExtension, checkVersionProperty, checkInstalledProperty) {
+    if (fromExtension.disabled !== toExtension.disabled) {
+        return false;
+    }
+    if (!!fromExtension.isApplicationScoped !== !!toExtension.isApplicationScoped) {
+        return false;
+    }
+    if (checkInstalledProperty && fromExtension.installed !== toExtension.installed) {
+        return false;
+    }
+    if (fromExtension.installed && toExtension.installed) {
+        if (fromExtension.preRelease !== toExtension.preRelease) {
+            return false;
+        }
+        if (fromExtension.pinned !== toExtension.pinned) {
+            return false;
+        }
+        if (toExtension.pinned && fromExtension.version !== toExtension.version) {
+            return false;
+        }
+    }
+    if (!isSameExtensionState(fromExtension.state, toExtension.state)) {
+        return false;
+    }
+    if ((checkVersionProperty && fromExtension.version !== toExtension.version)) {
+        return false;
+    }
+    return true;
+}
+function mergeExtensionState(localExtension, remoteExtension, lastSyncExtension) {
+    const localState = localExtension.state;
+    const remoteState = remoteExtension.state;
+    const baseState = lastSyncExtension?.state;
+    if (!remoteExtension.version) {
+        return localState;
+    }
+    if (localState && semverExports.gt(localExtension.version, remoteExtension.version)) {
+        return localState;
+    }
+    if (remoteState && semverExports.gt(remoteExtension.version, localExtension.version)) {
+        return remoteState;
+    }
+    if (!localState) {
+        return remoteState;
+    }
+    if (!remoteState) {
+        return localState;
+    }
+    const mergedState = deepClone(localState);
+    const baseToRemote = baseState ? compareExtensionState(baseState, remoteState) : { added: ( Object.keys(remoteState)).reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
+    const baseToLocal = baseState ? compareExtensionState(baseState, localState) : { added: ( Object.keys(localState)).reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
+    for (const key of [...( baseToRemote.added.values()), ...( baseToRemote.updated.values())]) {
+        mergedState[key] = remoteState[key];
+    }
+    for (const key of ( baseToRemote.removed.values())) {
+        if (!( baseToLocal.updated.has(key))) {
+            delete mergedState[key];
+        }
+    }
+    return mergedState;
+}
+function compareExtensionState(from, to) {
+    const fromKeys = ( Object.keys(from));
+    const toKeys = ( Object.keys(to));
+    const added = toKeys.filter(key => !fromKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
+    const removed = fromKeys.filter(key => !toKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
+    const updated = ( new Set());
+    for (const key of fromKeys) {
+        if (( removed.has(key))) {
+            continue;
+        }
+        const value1 = from[key];
+        const value2 = to[key];
+        if (!equals(value1, value2)) {
+            updated.add(key);
+        }
+    }
+    return { added, removed, updated };
+}
+function isSameExtensionState(a = {}, b = {}) {
+    const { added, removed, updated } = compareExtensionState(a, b);
+    return added.size === 0 && removed.size === 0 && updated.size === 0;
+}
+function massageIncomingExtension(extension) {
+    return { ...extension, ...{ disabled: !!extension.disabled, installed: !!extension.installed } };
+}
+function massageOutgoingExtension(extension, key) {
+    const massagedExtension = {
+        ...extension,
+        identifier: {
+            id: extension.identifier.id,
+            uuid: key.startsWith('uuid:') ? key.substring('uuid:'.length) : undefined
+        },
+        preRelease: !!extension.preRelease,
+        pinned: !!extension.pinned,
+    };
+    if (!extension.disabled) {
+        delete massagedExtension.disabled;
+    }
+    if (!extension.installed) {
+        delete massagedExtension.installed;
+    }
+    if (!extension.state) {
+        delete massagedExtension.state;
+    }
+    if (!extension.isApplicationScoped) {
+        delete massagedExtension.isApplicationScoped;
+    }
+    return massagedExtension;
+}
+
+export { merge };