@codingame/monaco-vscode-api 23.3.0 → 24.1.1

package/vscode/src/vs/platform/extensionManagement/common/extensionEnablementService.js

@@ -0,0 +1,145 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { isUndefinedOrNull } from '../../../base/common/types.js';
+import { InstallOperation, DISABLED_EXTENSIONS_STORAGE_PATH } from './extensionManagement.js';
+import { IExtensionManagementService } from './extensionManagement.service.js';
+import { areSameExtensions } from './extensionManagementUtil.js';
+import { StorageScope, StorageTarget } from '../../storage/common/storage.js';
+import { IStorageService } from '../../storage/common/storage.service.js';
+
+let GlobalExtensionEnablementService = class GlobalExtensionEnablementService extends Disposable {
+    constructor(storageService, extensionManagementService) {
+        super();
+        this._onDidChangeEnablement = ( new Emitter());
+        this.onDidChangeEnablement = this._onDidChangeEnablement.event;
+        this.storageManager = this._register(( new StorageManager(storageService)));
+        this._register(this.storageManager.onDidChange(extensions => this._onDidChangeEnablement.fire({ extensions, source: 'storage' })));
+        this._register(extensionManagementService.onDidInstallExtensions(e => e.forEach(({ local, operation }) => {
+            if (local && operation === InstallOperation.Migrate) {
+                this._removeFromDisabledExtensions(local.identifier);
+            }
+        })));
+    }
+    async enableExtension(extension, source) {
+        if (this._removeFromDisabledExtensions(extension)) {
+            this._onDidChangeEnablement.fire({ extensions: [extension], source });
+            return true;
+        }
+        return false;
+    }
+    async disableExtension(extension, source) {
+        if (this._addToDisabledExtensions(extension)) {
+            this._onDidChangeEnablement.fire({ extensions: [extension], source });
+            return true;
+        }
+        return false;
+    }
+    getDisabledExtensions() {
+        return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH);
+    }
+    async getDisabledExtensionsAsync() {
+        return this.getDisabledExtensions();
+    }
+    _addToDisabledExtensions(identifier) {
+        const disabledExtensions = this.getDisabledExtensions();
+        if (disabledExtensions.every(e => !areSameExtensions(e, identifier))) {
+            disabledExtensions.push(identifier);
+            this._setDisabledExtensions(disabledExtensions);
+            return true;
+        }
+        return false;
+    }
+    _removeFromDisabledExtensions(identifier) {
+        const disabledExtensions = this.getDisabledExtensions();
+        for (let index = 0; index < disabledExtensions.length; index++) {
+            const disabledExtension = disabledExtensions[index];
+            if (areSameExtensions(disabledExtension, identifier)) {
+                disabledExtensions.splice(index, 1);
+                this._setDisabledExtensions(disabledExtensions);
+                return true;
+            }
+        }
+        return false;
+    }
+    _setDisabledExtensions(disabledExtensions) {
+        this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions);
+    }
+    _getExtensions(storageId) {
+        return this.storageManager.get(storageId, StorageScope.PROFILE);
+    }
+    _setExtensions(storageId, extensions) {
+        this.storageManager.set(storageId, extensions, StorageScope.PROFILE);
+    }
+};
+GlobalExtensionEnablementService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IExtensionManagementService))
+], GlobalExtensionEnablementService));
+class StorageManager extends Disposable {
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this.storage = Object.create(null);
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(storageService.onDidChangeValue(StorageScope.PROFILE, undefined, this._store)(e => this.onDidStorageChange(e)));
+    }
+    get(key, scope) {
+        let value;
+        if (scope === StorageScope.PROFILE) {
+            if (isUndefinedOrNull(this.storage[key])) {
+                this.storage[key] = this._get(key, scope);
+            }
+            value = this.storage[key];
+        }
+        else {
+            value = this._get(key, scope);
+        }
+        return JSON.parse(value);
+    }
+    set(key, value, scope) {
+        const newValue = JSON.stringify(( value.map(({ id, uuid }) => ({ id, uuid }))));
+        const oldValue = this._get(key, scope);
+        if (oldValue !== newValue) {
+            if (scope === StorageScope.PROFILE) {
+                if (value.length) {
+                    this.storage[key] = newValue;
+                }
+                else {
+                    delete this.storage[key];
+                }
+            }
+            this._set(key, value.length ? newValue : undefined, scope);
+        }
+    }
+    onDidStorageChange(storageChangeEvent) {
+        if (!isUndefinedOrNull(this.storage[storageChangeEvent.key])) {
+            const newValue = this._get(storageChangeEvent.key, storageChangeEvent.scope);
+            if (newValue !== this.storage[storageChangeEvent.key]) {
+                const oldValues = this.get(storageChangeEvent.key, storageChangeEvent.scope);
+                delete this.storage[storageChangeEvent.key];
+                const newValues = this.get(storageChangeEvent.key, storageChangeEvent.scope);
+                const added = oldValues.filter(oldValue => !( newValues.some(newValue => areSameExtensions(oldValue, newValue))));
+                const removed = newValues.filter(newValue => !( oldValues.some(oldValue => areSameExtensions(oldValue, newValue))));
+                if (added.length || removed.length) {
+                    this._onDidChange.fire([...added, ...removed]);
+                }
+            }
+        }
+    }
+    _get(key, scope) {
+        return this.storageService.get(key, scope, '[]');
+    }
+    _set(key, value, scope) {
+        if (value) {
+            this.storageService.store(key, value, scope, StorageTarget.MACHINE);
+        }
+        else {
+            this.storageService.remove(key, scope);
+        }
+    }
+}
+
+export { GlobalExtensionEnablementService, StorageManager };

package/vscode/src/vs/platform/extensionManagement/common/extensionManagement.d.ts

@@ -54,7 +54,7 @@ export interface IGalleryExtensionAssets {
         IGalleryExtensionAsset
     ][];
 }
-export declare function isIExtensionIdentifier(thing: any): thing is IExtensionIdentifier;
+export declare function isIExtensionIdentifier(obj: unknown): obj is IExtensionIdentifier;
 export interface IExtensionIdentifier {
     id: string;
     uuid?: string;
@@ -102,8 +102,8 @@ export interface IGalleryExtension {
     detailsLink?: string;
     ratingLink?: string;
     supportLink?: string;
-    telemetryData?: any;
-    queryContext?: IStringDictionary<any>;
+    telemetryData?: IStringDictionary<unknown>;
+    queryContext?: IStringDictionary<unknown>;
 }
 export type InstallSource = "gallery" | "vsix" | "resource";
 export interface IGalleryMetadata {
@@ -251,7 +251,7 @@ export interface InstallExtensionResult {
     readonly source?: URI | IGalleryExtension;
     readonly local?: ILocalExtension;
     readonly error?: Error;
-    readonly context?: IStringDictionary<any>;
+    readonly context?: IStringDictionary<unknown>;
     readonly profileLocation: URI;
     readonly applicationScoped?: boolean;
     readonly workspaceScoped?: boolean;
@@ -380,7 +380,7 @@ export type InstallOptions = {
     /**
      * Context passed through to InstallExtensionResult
      */
-    context?: IStringDictionary<any>;
+    context?: IStringDictionary<unknown>;
 };
 export type UninstallOptions = {
     readonly profileLocation?: URI;

package/vscode/src/vs/platform/extensionManagement/common/extensionManagement.js

@@ -113,8 +113,9 @@ function isTargetPlatformCompatible(extensionTargetPlatform, allTargetPlatforms,
     }
     return false;
 }
-function isIExtensionIdentifier(thing) {
-    return thing
+function isIExtensionIdentifier(obj) {
+    const thing = obj;
+    return !!thing
         && typeof thing === 'object'
         && typeof thing.id === 'string'
         && (!thing.uuid || typeof thing.uuid === 'string');
@@ -269,8 +270,8 @@ async function computeSize(location, fileService) {
     }
     return stat.size ?? 0;
 }
-const ExtensionsLocalizedLabel = ( localize2(1810, "Extensions"));
-const PreferencesLocalizedLabel = ( localize2(1811, 'Preferences'));
+const ExtensionsLocalizedLabel = ( localize2(1822, "Extensions"));
+const PreferencesLocalizedLabel = ( localize2(1823, 'Preferences'));
 const AllowedExtensionsConfigKey = 'extensions.allowed';
 const VerifyExtensionSignatureConfigKey = 'extensions.verifySignature';
 const ExtensionRequestsTimeoutConfigKey = 'extensions.requestTimeout';
@@ -278,24 +279,24 @@ const ExtensionRequestsTimeoutConfigKey = 'extensions.requestTimeout';
     .registerConfiguration({
     id: 'extensions',
     order: 30,
-    title: ( localize(1812, "Extensions")),
+    title: ( localize(1824, "Extensions")),
     type: 'object',
     properties: {
         [AllowedExtensionsConfigKey]: {
             type: 'object',
             markdownDescription: ( localize(
-                1813,
+                1825,
                 "Specify a list of extensions that are allowed to use. This helps maintain a secure and consistent development environment by restricting the use of unauthorized extensions. For more information on how to configure this setting, please visit the [Configure Allowed Extensions](https://code.visualstudio.com/docs/setup/enterprise#_configure-allowed-extensions) section."
             )),
             default: '*',
             defaultSnippets: [{
                     body: {},
-                    description: ( localize(1814, "No extensions are allowed.")),
+                    description: ( localize(1826, "No extensions are allowed.")),
                 }, {
                     body: {
                         '*': true
                     },
-                    description: ( localize(1815, "All extensions are allowed.")),
+                    description: ( localize(1827, "All extensions are allowed.")),
                 }],
             scope: ConfigurationScope.APPLICATION,
             policy: {
@@ -306,7 +307,7 @@ const ExtensionRequestsTimeoutConfigKey = 'extensions.requestTimeout';
                     description: {
                         key: 'extensions.allowed.policy',
                         value: ( localize(
-                            1816,
+                            1828,
                             "Specify a list of extensions that are allowed to use. This helps maintain a secure and consistent development environment by restricting the use of unauthorized extensions. More information: https://code.visualstudio.com/docs/setup/enterprise#_configure-allowed-extensions"
                         )),
                     }
@@ -319,11 +320,11 @@ const ExtensionRequestsTimeoutConfigKey = 'extensions.requestTimeout';
                         {
                             type: ['boolean', 'string'],
                             enum: [true, false, 'stable'],
-                            description: ( localize(1817, "Allow or disallow the extension.")),
+                            description: ( localize(1829, "Allow or disallow the extension.")),
                             enumDescriptions: [
-                                ( localize(1818, "Extension is allowed.")),
-                                ( localize(1819, "Extension is not allowed.")),
-                                ( localize(1820, "Allow only stable versions of the extension.")),
+                                ( localize(1830, "Extension is allowed.")),
+                                ( localize(1831, "Extension is not allowed.")),
+                                ( localize(1832, "Allow only stable versions of the extension.")),
                             ],
                         },
                         {
@@ -332,7 +333,7 @@ const ExtensionRequestsTimeoutConfigKey = 'extensions.requestTimeout';
                                 type: 'string',
                             },
                             description: ( localize(
-                                1821,
+                                1833,
                                 "Allow or disallow specific versions of the extension. To specifcy a platform specific version, use the format `platform@1.2.3`, e.g. `win32-x64@1.2.3`. Supported platforms are `win32-x64`, `win32-arm64`, `linux-x64`, `linux-arm64`, `linux-armhf`, `alpine-x64`, `alpine-arm64`, `darwin-x64`, `darwin-arm64`"
                             )),
                         },
@@ -341,20 +342,20 @@ const ExtensionRequestsTimeoutConfigKey = 'extensions.requestTimeout';
                 '([a-z0-9A-Z][a-z0-9-A-Z]*)$': {
                     type: ['boolean', 'string'],
                     enum: [true, false, 'stable'],
-                    description: ( localize(1822, "Allow or disallow all extensions from the publisher.")),
+                    description: ( localize(1834, "Allow or disallow all extensions from the publisher.")),
                     enumDescriptions: [
-                        ( localize(1823, "All extensions from the publisher are allowed.")),
-                        ( localize(1824, "All extensions from the publisher are not allowed.")),
-                        ( localize(1825, "Allow only stable versions of the extensions from the publisher.")),
+                        ( localize(1835, "All extensions from the publisher are allowed.")),
+                        ( localize(1836, "All extensions from the publisher are not allowed.")),
+                        ( localize(1837, "Allow only stable versions of the extensions from the publisher.")),
                     ],
                 },
                 '\\*': {
                     type: 'boolean',
                     enum: [true, false],
-                    description: ( localize(1826, "Allow or disallow all extensions.")),
+                    description: ( localize(1838, "Allow or disallow all extensions.")),
                     enumDescriptions: [
-                        ( localize(1827, "Allow all extensions.")),
-                        ( localize(1828, "Disallow all extensions."))
+                        ( localize(1839, "Allow all extensions.")),
+                        ( localize(1840, "Disallow all extensions."))
                     ],
                 }
             }

package/vscode/src/vs/platform/extensionManagement/common/extensionManagement.service.d.ts

@@ -1,7 +1,7 @@
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { Event } from "../../../base/common/event.js";
 import { IMarkdownString } from "../../../base/common/htmlContent.js";
-import { IPager } from "@codingame/monaco-vscode-2eda793f-4b5b-58e8-83c5-1bfd3bad15f1-common/vscode/vs/base/common/paging";
+import { IPager } from "../../../base/common/paging.js";
 import { URI } from "../../../base/common/uri.js";
 import { TargetPlatform, IExtensionManifest, type ExtensionType, type IExtension } from "../../extensions/common/extensions.js";
 import { IQueryOptions, IGalleryExtension, IExtensionInfo, IExtensionQueryOptions, IProductVersion, IExtensionIdentifier, IGalleryExtensionVersion, InstallOperation, StatisticType, ITranslation, IExtensionsControlManifest, type DidUninstallExtensionEvent, type DidUpdateExtensionMetadata, type IExtensionManagementParticipant, type ILocalExtension, type InstallExtensionEvent, type InstallExtensionInfo, type InstallExtensionResult, type InstallOptions, type Metadata, type UninstallExtensionEvent, type UninstallExtensionInfo, type UninstallOptions, type IConfigBasedExtensionTip, type IExecutableBasedExtensionTip, type AllowedExtensionsConfigValueType } from "./extensionManagement.js";

package/vscode/src/vs/platform/extensionManagement/common/extensionManagementUtil.d.ts

@@ -2,6 +2,7 @@ import { IExtensionIdentifier, IGalleryExtension, ILocalExtension, MaliciousExte
 import { ExtensionIdentifier, IExtension, TargetPlatform } from "../../extensions/common/extensions.js";
 import { IFileService } from "../../files/common/files.service.js";
 import { ILogService } from "../../log/common/log.service.js";
+import { TelemetryTrustedValue } from "../../telemetry/common/telemetryUtils.js";
 export declare function areSameExtensions(a: IExtensionIdentifier, b: IExtensionIdentifier): boolean;
 export declare class ExtensionKey {
     readonly identifier: IExtensionIdentifier;
@@ -12,7 +13,7 @@ export declare class ExtensionKey {
     readonly id: string;
     constructor(identifier: IExtensionIdentifier, version: string, targetPlatform?: TargetPlatform);
     toString(): string;
-    equals(o: any): boolean;
+    equals(o: unknown): boolean;
 }
 export declare function getIdAndVersion(id: string): [
     string,
@@ -31,7 +32,18 @@ export declare function getLocalExtensionTelemetryData(extension: ILocalExtensio
     publisherDisplayName: string | undefined;
     dependencies: boolean | undefined;
 };
-export declare function getGalleryExtensionTelemetryData(extension: IGalleryExtension): any;
+export declare function getGalleryExtensionTelemetryData(extension: IGalleryExtension): {
+    id: TelemetryTrustedValue<string>;
+    name: TelemetryTrustedValue<string>;
+    extensionVersion: string;
+    galleryId: string;
+    publisherId: string;
+    publisherName: string;
+    publisherDisplayName: string;
+    isPreReleaseVersion: boolean;
+    dependencies: boolean;
+    isSigned: boolean;
+};
 export declare const BetterMergeId: ExtensionIdentifier;
 export declare function getExtensionDependencies(installedExtensions: ReadonlyArray<IExtension>, extension: IExtension): IExtension[];
 export declare function computeTargetPlatform(fileService: IFileService, logService: ILogService): Promise<TargetPlatform>;

package/vscode/src/vs/platform/extensionManagement/common/extensionNls.js

@@ -28,7 +28,7 @@ function replaceNLStrings(logger, extensionManifest, messages, originalMessages)
                 const originalMessage = typeof original === 'string' ? original : original?.message;
                 if (!message) {
                     if (!originalMessage) {
-                        logger.warn(`[${extensionManifest.name}]: ${( localize(1860, "Couldn't find message for key {0}.", messageKey))}`);
+                        logger.warn(`[${extensionManifest.name}]: ${( localize(1872, "Couldn't find message for key {0}.", messageKey))}`);
                     }
                     return;
                 }

package/vscode/src/vs/platform/extensionManagement/common/extensionStorage.d.ts

@@ -0,0 +1,39 @@
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { IStorageService } from "../../storage/common/storage.service.js";
+import { IProductService } from "../../product/common/productService.service.js";
+import { ILogService } from "../../log/common/log.service.js";
+import { IExtension } from "../../extensions/common/extensions.js";
+import { IStringDictionary } from "../../../base/common/collections.js";
+import { IGalleryExtension } from "./extensionManagement.js";
+import { IExtensionManagementService } from "./extensionManagement.service.js";
+import { IExtensionStorageService } from "./extensionStorage.service.js";
+export interface IExtensionIdWithVersion {
+    id: string;
+    version: string;
+}
+export declare class ExtensionStorageService extends Disposable implements IExtensionStorageService {
+    private readonly storageService;
+    private readonly productService;
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private static LARGE_STATE_WARNING_THRESHOLD;
+    private static toKey;
+    private static fromKey;
+    static removeOutdatedExtensionVersions(extensionManagementService: IExtensionManagementService, storageService: IStorageService): Promise<void>;
+    private static readAllExtensionsWithKeysForSync;
+    private readonly _onDidChangeExtensionStorageToSync;
+    readonly onDidChangeExtensionStorageToSync: import("../../../base/common/event.js").Event<void>;
+    private readonly extensionsWithKeysForSync;
+    constructor(storageService: IStorageService, productService: IProductService, logService: ILogService);
+    private onDidChangeStorageValue;
+    private getExtensionId;
+    getExtensionState(extension: IExtension | IGalleryExtension | string, global: boolean): IStringDictionary<unknown> | undefined;
+    getExtensionStateRaw(extension: IExtension | IGalleryExtension | string, global: boolean): string | undefined;
+    setExtensionState(extension: IExtension | IGalleryExtension | string, state: IStringDictionary<unknown> | undefined, global: boolean): void;
+    setKeysForSync(extensionIdWithVersion: IExtensionIdWithVersion, keys: string[]): void;
+    getKeysForSync(extensionIdWithVersion: IExtensionIdWithVersion): string[] | undefined;
+    addToMigrationList(from: string, to: string): void;
+    getSourceExtensionToMigrate(toExtensionId: string): string | undefined;
+    private get migrationList();
+    private set migrationList(value);
+}

package/vscode/src/vs/platform/extensionManagement/common/extensionStorage.js

@@ -0,0 +1,175 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { StorageScope, StorageTarget } from '../../storage/common/storage.js';
+import { IStorageService } from '../../storage/common/storage.service.js';
+import { adoptToGalleryExtensionId, areSameExtensions, getExtensionId } from './extensionManagementUtil.js';
+import { IProductService } from '../../product/common/productService.service.js';
+import { distinct } from '../../../base/common/arrays.js';
+import { ILogService } from '../../log/common/log.service.js';
+import { isString } from '../../../base/common/types.js';
+
+var ExtensionStorageService_1;
+const EXTENSION_KEYS_ID_VERSION_REGEX = /^extensionKeys\/([^.]+\..+)@(\d+\.\d+\.\d+(-.*)?)$/;
+let ExtensionStorageService = class ExtensionStorageService extends Disposable {
+    static { ExtensionStorageService_1 = this; }
+    static { this.LARGE_STATE_WARNING_THRESHOLD = 512 * 1024; }
+    static toKey(extension) {
+        return `extensionKeys/${adoptToGalleryExtensionId(extension.id)}@${extension.version}`;
+    }
+    static fromKey(key) {
+        const matches = EXTENSION_KEYS_ID_VERSION_REGEX.exec(key);
+        if (matches && matches[1]) {
+            return { id: matches[1], version: matches[2] };
+        }
+        return undefined;
+    }
+    static async removeOutdatedExtensionVersions(extensionManagementService, storageService) {
+        const extensions = await extensionManagementService.getInstalled();
+        const extensionVersionsToRemove = [];
+        for (const [id, versions] of ExtensionStorageService_1.readAllExtensionsWithKeysForSync(storageService)) {
+            const extensionVersion = extensions.find(e => areSameExtensions(e.identifier, { id }))?.manifest.version;
+            for (const version of versions) {
+                if (extensionVersion !== version) {
+                    extensionVersionsToRemove.push(ExtensionStorageService_1.toKey({ id, version }));
+                }
+            }
+        }
+        for (const key of extensionVersionsToRemove) {
+            storageService.remove(key, StorageScope.PROFILE);
+        }
+    }
+    static readAllExtensionsWithKeysForSync(storageService) {
+        const extensionsWithKeysForSync = ( new Map());
+        const keys = ( storageService.keys(StorageScope.PROFILE, StorageTarget.MACHINE));
+        for (const key of keys) {
+            const extensionIdWithVersion = ExtensionStorageService_1.fromKey(key);
+            if (extensionIdWithVersion) {
+                let versions = extensionsWithKeysForSync.get(extensionIdWithVersion.id.toLowerCase());
+                if (!versions) {
+                    extensionsWithKeysForSync.set(extensionIdWithVersion.id.toLowerCase(), versions = []);
+                }
+                versions.push(extensionIdWithVersion.version);
+            }
+        }
+        return extensionsWithKeysForSync;
+    }
+    constructor(storageService, productService, logService) {
+        super();
+        this.storageService = storageService;
+        this.productService = productService;
+        this.logService = logService;
+        this._onDidChangeExtensionStorageToSync = this._register(( new Emitter()));
+        this.onDidChangeExtensionStorageToSync = this._onDidChangeExtensionStorageToSync.event;
+        this.extensionsWithKeysForSync = ExtensionStorageService_1.readAllExtensionsWithKeysForSync(storageService);
+        this._register(this.storageService.onDidChangeValue(StorageScope.PROFILE, undefined, this._store)(e => this.onDidChangeStorageValue(e)));
+    }
+    onDidChangeStorageValue(e) {
+        if (( this.extensionsWithKeysForSync.has(e.key.toLowerCase()))) {
+            this._onDidChangeExtensionStorageToSync.fire();
+            return;
+        }
+        const extensionIdWithVersion = ExtensionStorageService_1.fromKey(e.key);
+        if (extensionIdWithVersion) {
+            if (this.storageService.get(e.key, StorageScope.PROFILE) === undefined) {
+                this.extensionsWithKeysForSync.delete(extensionIdWithVersion.id.toLowerCase());
+            }
+            else {
+                let versions = this.extensionsWithKeysForSync.get(extensionIdWithVersion.id.toLowerCase());
+                if (!versions) {
+                    this.extensionsWithKeysForSync.set(extensionIdWithVersion.id.toLowerCase(), versions = []);
+                }
+                versions.push(extensionIdWithVersion.version);
+                this._onDidChangeExtensionStorageToSync.fire();
+            }
+            return;
+        }
+    }
+    getExtensionId(extension) {
+        if (isString(extension)) {
+            return extension;
+        }
+        const publisher = extension.manifest ? extension.manifest.publisher : extension.publisher;
+        const name = extension.manifest ? extension.manifest.name : extension.name;
+        return getExtensionId(publisher, name);
+    }
+    getExtensionState(extension, global) {
+        const extensionId = this.getExtensionId(extension);
+        const jsonValue = this.getExtensionStateRaw(extension, global);
+        if (jsonValue) {
+            try {
+                return JSON.parse(jsonValue);
+            }
+            catch (error) {
+                this.logService.error(`[mainThreadStorage] unexpected error parsing storage contents (extensionId: ${extensionId}, global: ${global}): ${error}`);
+            }
+        }
+        return undefined;
+    }
+    getExtensionStateRaw(extension, global) {
+        const extensionId = this.getExtensionId(extension);
+        const rawState = this.storageService.get(extensionId, global ? StorageScope.PROFILE : StorageScope.WORKSPACE);
+        if (rawState && rawState?.length > ExtensionStorageService_1.LARGE_STATE_WARNING_THRESHOLD) {
+            this.logService.warn(`[mainThreadStorage] large extension state detected (extensionId: ${extensionId}, global: ${global}): ${rawState.length / 1024}kb. Consider to use 'storageUri' or 'globalStorageUri' to store this data on disk instead.`);
+        }
+        return rawState;
+    }
+    setExtensionState(extension, state, global) {
+        const extensionId = this.getExtensionId(extension);
+        if (state === undefined) {
+            this.storageService.remove(extensionId, global ? StorageScope.PROFILE : StorageScope.WORKSPACE);
+        }
+        else {
+            this.storageService.store(extensionId, JSON.stringify(state), global ? StorageScope.PROFILE : StorageScope.WORKSPACE, StorageTarget.MACHINE );
+        }
+    }
+    setKeysForSync(extensionIdWithVersion, keys) {
+        this.storageService.store(ExtensionStorageService_1.toKey(extensionIdWithVersion), JSON.stringify(keys), StorageScope.PROFILE, StorageTarget.MACHINE);
+    }
+    getKeysForSync(extensionIdWithVersion) {
+        const extensionKeysForSyncFromProduct = this.productService.extensionSyncedKeys?.[extensionIdWithVersion.id.toLowerCase()];
+        const extensionKeysForSyncFromStorageValue = this.storageService.get(ExtensionStorageService_1.toKey(extensionIdWithVersion), StorageScope.PROFILE);
+        const extensionKeysForSyncFromStorage = extensionKeysForSyncFromStorageValue ? JSON.parse(extensionKeysForSyncFromStorageValue) : undefined;
+        return extensionKeysForSyncFromStorage && extensionKeysForSyncFromProduct
+            ? distinct([...extensionKeysForSyncFromStorage, ...extensionKeysForSyncFromProduct])
+            : (extensionKeysForSyncFromStorage || extensionKeysForSyncFromProduct);
+    }
+    addToMigrationList(from, to) {
+        if (from !== to) {
+            const migrationList = this.migrationList.filter(entry => !entry.includes(from) && !entry.includes(to));
+            migrationList.push([from, to]);
+            this.migrationList = migrationList;
+        }
+    }
+    getSourceExtensionToMigrate(toExtensionId) {
+        const entry = this.migrationList.find(([, to]) => toExtensionId === to);
+        return entry ? entry[0] : undefined;
+    }
+    get migrationList() {
+        const value = this.storageService.get('extensionStorage.migrationList', StorageScope.APPLICATION, '[]');
+        try {
+            const migrationList = JSON.parse(value);
+            if (Array.isArray(migrationList)) {
+                return migrationList;
+            }
+        }
+        catch (error) {  }
+        return [];
+    }
+    set migrationList(migrationList) {
+        if (migrationList.length) {
+            this.storageService.store('extensionStorage.migrationList', JSON.stringify(migrationList), StorageScope.APPLICATION, StorageTarget.MACHINE);
+        }
+        else {
+            this.storageService.remove('extensionStorage.migrationList', StorageScope.APPLICATION);
+        }
+    }
+};
+ExtensionStorageService = ExtensionStorageService_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IProductService)),
+    ( __param(2, ILogService))
+], ExtensionStorageService));
+
+export { ExtensionStorageService };

package/vscode/src/vs/platform/extensionManagement/common/extensionStorage.service.d.ts

@@ -2,13 +2,13 @@ import { IStringDictionary } from "../../../base/common/collections.js";
 import { Event } from "../../../base/common/event.js";
 import { IExtension } from "../../extensions/common/extensions.js";
 import { IGalleryExtension } from "./extensionManagement.js";
-import { IExtensionIdWithVersion } from "@codingame/monaco-vscode-cecd476b-6f89-54b7-b016-fe6fdaa6675e-common/vscode/vs/platform/extensionManagement/common/extensionStorage";
+import { IExtensionIdWithVersion } from "./extensionStorage.js";
 export declare const IExtensionStorageService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IExtensionStorageService>;
 export interface IExtensionStorageService {
     readonly _serviceBrand: undefined;
-    getExtensionState(extension: IExtension | IGalleryExtension | string, global: boolean): IStringDictionary<any> | undefined;
+    getExtensionState(extension: IExtension | IGalleryExtension | string, global: boolean): IStringDictionary<unknown> | undefined;
     getExtensionStateRaw(extension: IExtension | IGalleryExtension | string, global: boolean): string | undefined;
-    setExtensionState(extension: IExtension | IGalleryExtension | string, state: IStringDictionary<any> | undefined, global: boolean): void;
+    setExtensionState(extension: IExtension | IGalleryExtension | string, state: object | undefined, global: boolean): void;
     readonly onDidChangeExtensionStorageToSync: Event<void>;
     setKeysForSync(extensionIdWithVersion: IExtensionIdWithVersion, keys: string[]): void;
     getKeysForSync(extensionIdWithVersion: IExtensionIdWithVersion): string[] | undefined;

package/vscode/src/vs/platform/extensionManagement/common/extensionsProfileScannerService.js

@@ -321,19 +321,22 @@ AbstractExtensionsProfileScannerService = ( __decorate([
     ( __param(3, IUriIdentityService)),
     ( __param(4, ILogService))
 ], AbstractExtensionsProfileScannerService));
-function isStoredProfileExtension(candidate) {
+function isStoredProfileExtension(obj) {
+    const candidate = obj;
     return isObject(candidate)
         && isIExtensionIdentifier(candidate.identifier)
-        && (isUriComponents(candidate.location) || (isString(candidate.location) && candidate.location))
+        && (isUriComponents(candidate.location) || (isString(candidate.location) && !!candidate.location))
         && (isUndefined(candidate.relativeLocation) || isString(candidate.relativeLocation))
-        && candidate.version && isString(candidate.version);
+        && !!candidate.version
+        && isString(candidate.version);
 }
-function isUriComponents(thing) {
-    if (!thing) {
+function isUriComponents(obj) {
+    if (!obj) {
         return false;
     }
-    return isString(thing.path) &&
-        isString(thing.scheme);
+    const thing = obj;
+    return typeof thing?.path === 'string' &&
+        typeof thing?.scheme === 'string';
 }
 
 export { AbstractExtensionsProfileScannerService, ExtensionsProfileScanningError, ExtensionsProfileScanningErrorCode };