@codingame/monaco-vscode-extensions-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/services/extensions/common/extensionRunningLocationTracker.js

@@ -1,274 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ExtensionIdentifierMap } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { determineExtensionHostKinds } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
-import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
-import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
-
-let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
-    get maxLocalProcessAffinity() {
-        return this._maxLocalProcessAffinity;
-    }
-    get maxLocalWebWorkerAffinity() {
-        return this._maxLocalWebWorkerAffinity;
-    }
-    constructor(_registry, _extensionHostKindPicker, _environmentService, _configurationService, _logService, _extensionManifestPropertiesService) {
-        this._registry = _registry;
-        this._extensionHostKindPicker = _extensionHostKindPicker;
-        this._environmentService = _environmentService;
-        this._configurationService = _configurationService;
-        this._logService = _logService;
-        this._extensionManifestPropertiesService = _extensionManifestPropertiesService;
-        this._runningLocation = ( new ExtensionIdentifierMap());
-        this._maxLocalProcessAffinity = 0;
-        this._maxLocalWebWorkerAffinity = 0;
-    }
-    set(extensionId, runningLocation) {
-        this._runningLocation.set(extensionId, runningLocation);
-    }
-    readExtensionKinds(extensionDescription) {
-        if (extensionDescription.isUnderDevelopment && this._environmentService.extensionDevelopmentKind) {
-            return this._environmentService.extensionDevelopmentKind;
-        }
-        return this._extensionManifestPropertiesService.getExtensionKind(extensionDescription);
-    }
-    getRunningLocation(extensionId) {
-        return this._runningLocation.get(extensionId) || null;
-    }
-    filterByRunningLocation(extensions, desiredRunningLocation) {
-        return filterExtensionDescriptions(extensions, this._runningLocation, extRunningLocation => desiredRunningLocation.equals(extRunningLocation));
-    }
-    filterByExtensionHostKind(extensions, desiredExtensionHostKind) {
-        return filterExtensionDescriptions(extensions, this._runningLocation, extRunningLocation => extRunningLocation.kind === desiredExtensionHostKind);
-    }
-    filterByExtensionHostManager(extensions, extensionHostManager) {
-        return filterExtensionDescriptions(extensions, this._runningLocation, extRunningLocation => extensionHostManager.representsRunningLocation(extRunningLocation));
-    }
-    _computeAffinity(inputExtensions, extensionHostKind, isInitialAllocation) {
-        const extensions = ( new ExtensionIdentifierMap());
-        for (const extension of inputExtensions) {
-            if (extension.main || extension.browser) {
-                extensions.set(extension.identifier, extension);
-            }
-        }
-        for (const extension of this._registry.getAllExtensionDescriptions()) {
-            if (extension.main || extension.browser) {
-                const runningLocation = this._runningLocation.get(extension.identifier);
-                if (runningLocation && runningLocation.kind === extensionHostKind) {
-                    extensions.set(extension.identifier, extension);
-                }
-            }
-        }
-        const groups = ( new ExtensionIdentifierMap());
-        let groupNumber = 0;
-        for (const [_, extension] of extensions) {
-            groups.set(extension.identifier, ++groupNumber);
-        }
-        const changeGroup = (from, to) => {
-            for (const [key, group] of groups) {
-                if (group === from) {
-                    groups.set(key, to);
-                }
-            }
-        };
-        for (const [_, extension] of extensions) {
-            if (!extension.extensionDependencies) {
-                continue;
-            }
-            const myGroup = groups.get(extension.identifier);
-            for (const depId of extension.extensionDependencies) {
-                const depGroup = groups.get(depId);
-                if (!depGroup) {
-                    continue;
-                }
-                if (depGroup === myGroup) {
-                    continue;
-                }
-                changeGroup(depGroup, myGroup);
-            }
-        }
-        const resultingAffinities = ( new Map());
-        let lastAffinity = 0;
-        for (const [_, extension] of extensions) {
-            const runningLocation = this._runningLocation.get(extension.identifier);
-            if (runningLocation) {
-                const group = groups.get(extension.identifier);
-                resultingAffinities.set(group, runningLocation.affinity);
-                lastAffinity = Math.max(lastAffinity, runningLocation.affinity);
-            }
-        }
-        if (!this._environmentService.isExtensionDevelopment) {
-            const configuredAffinities = this._configurationService.getValue('extensions.experimental.affinity') || {};
-            const configuredExtensionIds = ( Object.keys(configuredAffinities));
-            const configuredAffinityToResultingAffinity = ( new Map());
-            for (const extensionId of configuredExtensionIds) {
-                const configuredAffinity = configuredAffinities[extensionId];
-                if (typeof configuredAffinity !== 'number' || configuredAffinity <= 0 || Math.floor(configuredAffinity) !== configuredAffinity) {
-                    this._logService.info(`Ignoring configured affinity for '${extensionId}' because the value is not a positive integer.`);
-                    continue;
-                }
-                const group = groups.get(extensionId);
-                if (!group) {
-                    continue;
-                }
-                const affinity1 = resultingAffinities.get(group);
-                if (affinity1) {
-                    configuredAffinityToResultingAffinity.set(configuredAffinity, affinity1);
-                    continue;
-                }
-                const affinity2 = configuredAffinityToResultingAffinity.get(configuredAffinity);
-                if (affinity2) {
-                    resultingAffinities.set(group, affinity2);
-                    continue;
-                }
-                if (!isInitialAllocation) {
-                    this._logService.info(`Ignoring configured affinity for '${extensionId}' because extension host(s) are already running. Reload window.`);
-                    continue;
-                }
-                const affinity3 = ++lastAffinity;
-                configuredAffinityToResultingAffinity.set(configuredAffinity, affinity3);
-                resultingAffinities.set(group, affinity3);
-            }
-        }
-        const result = ( new ExtensionIdentifierMap());
-        for (const extension of inputExtensions) {
-            const group = groups.get(extension.identifier) || 0;
-            const affinity = resultingAffinities.get(group) || 0;
-            result.set(extension.identifier, affinity);
-        }
-        if (lastAffinity > 0 && isInitialAllocation) {
-            for (let affinity = 1; affinity <= lastAffinity; affinity++) {
-                const extensionIds = [];
-                for (const extension of inputExtensions) {
-                    if (result.get(extension.identifier) === affinity) {
-                        extensionIds.push(extension.identifier);
-                    }
-                }
-                this._logService.info(`Placing extension(s) ${( extensionIds.map(e => e.value)).join(', ')} on a separate extension host.`);
-            }
-        }
-        return { affinities: result, maxAffinity: lastAffinity };
-    }
-    computeRunningLocation(localExtensions, remoteExtensions, isInitialAllocation) {
-        return this._doComputeRunningLocation(this._runningLocation, localExtensions, remoteExtensions, isInitialAllocation).runningLocation;
-    }
-    _doComputeRunningLocation(existingRunningLocation, localExtensions, remoteExtensions, isInitialAllocation) {
-        localExtensions = localExtensions.filter(extension => !( existingRunningLocation.has(extension.identifier)));
-        remoteExtensions = remoteExtensions.filter(extension => !( existingRunningLocation.has(extension.identifier)));
-        const extensionHostKinds = determineExtensionHostKinds(localExtensions, remoteExtensions, (extension) => this.readExtensionKinds(extension), (extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference) => this._extensionHostKindPicker.pickExtensionHostKind(extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference));
-        const extensions = ( new ExtensionIdentifierMap());
-        for (const extension of localExtensions) {
-            extensions.set(extension.identifier, extension);
-        }
-        for (const extension of remoteExtensions) {
-            extensions.set(extension.identifier, extension);
-        }
-        const result = ( new ExtensionIdentifierMap());
-        const localProcessExtensions = [];
-        const localWebWorkerExtensions = [];
-        for (const [extensionIdKey, extensionHostKind] of extensionHostKinds) {
-            let runningLocation = null;
-            if (extensionHostKind === 1 ) {
-                const extensionDescription = extensions.get(extensionIdKey);
-                if (extensionDescription) {
-                    localProcessExtensions.push(extensionDescription);
-                }
-            }
-            else if (extensionHostKind === 2 ) {
-                const extensionDescription = extensions.get(extensionIdKey);
-                if (extensionDescription) {
-                    localWebWorkerExtensions.push(extensionDescription);
-                }
-            }
-            else if (extensionHostKind === 3 ) {
-                runningLocation = ( new RemoteRunningLocation());
-            }
-            result.set(extensionIdKey, runningLocation);
-        }
-        const { affinities, maxAffinity } = this._computeAffinity(localProcessExtensions, 1 , isInitialAllocation);
-        for (const extension of localProcessExtensions) {
-            const affinity = affinities.get(extension.identifier) || 0;
-            result.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
-        }
-        const { affinities: localWebWorkerAffinities, maxAffinity: maxLocalWebWorkerAffinity } = this._computeAffinity(localWebWorkerExtensions, 2 , isInitialAllocation);
-        for (const extension of localWebWorkerExtensions) {
-            const affinity = localWebWorkerAffinities.get(extension.identifier) || 0;
-            result.set(extension.identifier, ( new LocalWebWorkerRunningLocation(affinity)));
-        }
-        for (const [extensionIdKey, runningLocation] of existingRunningLocation) {
-            if (runningLocation) {
-                result.set(extensionIdKey, runningLocation);
-            }
-        }
-        return { runningLocation: result, maxLocalProcessAffinity: maxAffinity, maxLocalWebWorkerAffinity: maxLocalWebWorkerAffinity };
-    }
-    initializeRunningLocation(localExtensions, remoteExtensions) {
-        const { runningLocation, maxLocalProcessAffinity, maxLocalWebWorkerAffinity } = this._doComputeRunningLocation(this._runningLocation, localExtensions, remoteExtensions, true);
-        this._runningLocation = runningLocation;
-        this._maxLocalProcessAffinity = maxLocalProcessAffinity;
-        this._maxLocalWebWorkerAffinity = maxLocalWebWorkerAffinity;
-    }
-    deltaExtensions(toAdd, toRemove) {
-        const removedRunningLocation = ( new ExtensionIdentifierMap());
-        for (const extensionId of toRemove) {
-            const extensionKey = extensionId;
-            removedRunningLocation.set(extensionKey, this._runningLocation.get(extensionKey) || null);
-            this._runningLocation.delete(extensionKey);
-        }
-        this._updateRunningLocationForAddedExtensions(toAdd);
-        return removedRunningLocation;
-    }
-    _updateRunningLocationForAddedExtensions(toAdd) {
-        const localProcessExtensions = [];
-        const localWebWorkerExtensions = [];
-        for (const extension of toAdd) {
-            const extensionKind = this.readExtensionKinds(extension);
-            const isRemote = extension.extensionLocation.scheme === Schemas.vscodeRemote;
-            const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(extension.identifier, extensionKind, !isRemote, isRemote, 0 );
-            let runningLocation = null;
-            if (extensionHostKind === 1 ) {
-                localProcessExtensions.push(extension);
-            }
-            else if (extensionHostKind === 2 ) {
-                localWebWorkerExtensions.push(extension);
-            }
-            else if (extensionHostKind === 3 ) {
-                runningLocation = ( new RemoteRunningLocation());
-            }
-            this._runningLocation.set(extension.identifier, runningLocation);
-        }
-        const { affinities } = this._computeAffinity(localProcessExtensions, 1 , false);
-        for (const extension of localProcessExtensions) {
-            const affinity = affinities.get(extension.identifier) || 0;
-            this._runningLocation.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
-        }
-        const { affinities: webWorkerExtensionsAffinities } = this._computeAffinity(localWebWorkerExtensions, 2 , false);
-        for (const extension of localWebWorkerExtensions) {
-            const affinity = webWorkerExtensionsAffinities.get(extension.identifier) || 0;
-            this._runningLocation.set(extension.identifier, ( new LocalWebWorkerRunningLocation(affinity)));
-        }
-    }
-};
-ExtensionRunningLocationTracker = ( __decorate([
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IExtensionManifestPropertiesService))
-], ExtensionRunningLocationTracker));
-function filterExtensionDescriptions(extensions, runningLocation, predicate) {
-    return extensions.filter((ext) => {
-        const extRunningLocation = runningLocation.get(ext.identifier);
-        return extRunningLocation && predicate(extRunningLocation);
-    });
-}
-function filterExtensionIdentifiers(extensions, runningLocation, predicate) {
-    return extensions.filter((ext) => {
-        const extRunningLocation = runningLocation.get(ext);
-        return extRunningLocation && predicate(extRunningLocation);
-    });
-}
-
-export { ExtensionRunningLocationTracker, filterExtensionDescriptions, filterExtensionIdentifiers };

package/vscode/src/vs/workbench/services/extensions/common/extensionStorageMigration.js

@@ -1,58 +0,0 @@
-import { getErrorMessage } from 'vscode/vscode/vs/base/common/errors';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
-import { IExtensionStorageService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionStorage';
-import { IFileService, FileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-
-async function migrateExtensionStorage(fromExtensionId, toExtensionId, global, instantionService) {
-    return instantionService.invokeFunction(async (serviceAccessor) => {
-        const environmentService = serviceAccessor.get(IEnvironmentService);
-        const userDataProfilesService = serviceAccessor.get(IUserDataProfilesService);
-        const extensionStorageService = serviceAccessor.get(IExtensionStorageService);
-        const storageService = serviceAccessor.get(IStorageService);
-        const uriIdentityService = serviceAccessor.get(IUriIdentityService);
-        const fileService = serviceAccessor.get(IFileService);
-        const workspaceContextService = serviceAccessor.get(IWorkspaceContextService);
-        const logService = serviceAccessor.get(ILogService);
-        const storageMigratedKey = `extensionStorage.migrate.${fromExtensionId}-${toExtensionId}`;
-        const migrateLowerCaseStorageKey = fromExtensionId.toLowerCase() === toExtensionId.toLowerCase() ? `extension.storage.migrateFromLowerCaseKey.${fromExtensionId.toLowerCase()}` : undefined;
-        if (fromExtensionId === toExtensionId) {
-            return;
-        }
-        const getExtensionStorageLocation = (extensionId, global) => {
-            if (global) {
-                return uriIdentityService.extUri.joinPath(userDataProfilesService.defaultProfile.globalStorageHome, extensionId.toLowerCase() );
-            }
-            return uriIdentityService.extUri.joinPath(environmentService.workspaceStorageHome, workspaceContextService.getWorkspace().id, extensionId);
-        };
-        const storageScope = global ? 0  : 1 ;
-        if (!storageService.getBoolean(storageMigratedKey, storageScope, false) && !(migrateLowerCaseStorageKey && storageService.getBoolean(migrateLowerCaseStorageKey, storageScope, false))) {
-            logService.info(`Migrating ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}...`);
-            const value = extensionStorageService.getExtensionState(fromExtensionId, global);
-            if (value) {
-                extensionStorageService.setExtensionState(toExtensionId, value, global);
-                extensionStorageService.setExtensionState(fromExtensionId, undefined, global);
-            }
-            const fromPath = getExtensionStorageLocation(fromExtensionId, global);
-            const toPath = getExtensionStorageLocation(toExtensionId, global);
-            if (!uriIdentityService.extUri.isEqual(fromPath, toPath)) {
-                try {
-                    await fileService.move(fromPath, toPath, true);
-                }
-                catch (error) {
-                    if (error.code !== FileSystemProviderErrorCode.FileNotFound) {
-                        logService.info(`Error while migrating ${global ? 'global' : 'workspace'} file storage from '${fromExtensionId}' to '${toExtensionId}'`, getErrorMessage(error));
-                    }
-                }
-            }
-            logService.info(`Migrated ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}`);
-            storageService.store(storageMigratedKey, true, storageScope, 1 );
-        }
-    });
-}
-
-export { migrateExtensionStorage };

package/vscode/src/vs/workbench/services/extensions/common/extensionsProposedApi.js

@@ -1,80 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { isNonEmptyArray } from 'vscode/vscode/vs/base/common/arrays';
-import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { allApiProposals } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsApiProposals';
-
-let ExtensionsProposedApi = class ExtensionsProposedApi {
-    constructor(_logService, _environmentService, productService) {
-        this._logService = _logService;
-        this._environmentService = _environmentService;
-        this._envEnabledExtensions = ( new Set(( (_environmentService.extensionEnabledProposedApi ?? []).map(id => ExtensionIdentifier.toKey(id)))));
-        this._envEnablesProposedApiForAll =
-            !_environmentService.isBuilt ||
-                (_environmentService.isExtensionDevelopment && productService.quality !== 'stable') ||
-                (this._envEnabledExtensions.size === 0 && Array.isArray(_environmentService.extensionEnabledProposedApi));
-        this._productEnabledExtensions = ( new Map());
-        if (productService.extensionEnabledApiProposals) {
-            for (const [k, value] of Object.entries(productService.extensionEnabledApiProposals)) {
-                const key = ExtensionIdentifier.toKey(k);
-                const proposalNames = value.filter(name => {
-                    if (!allApiProposals[name]) {
-                        _logService.warn(`Via 'product.json#extensionEnabledApiProposals' extension '${key}' wants API proposal '${name}' but that proposal DOES NOT EXIST. Likely, the proposal has been finalized (check 'vscode.d.ts') or was abandoned.`);
-                        return false;
-                    }
-                    return true;
-                });
-                this._productEnabledExtensions.set(key, proposalNames);
-            }
-        }
-    }
-    updateEnabledApiProposals(extensions) {
-        for (const extension of extensions) {
-            this.doUpdateEnabledApiProposals(extension);
-        }
-    }
-    doUpdateEnabledApiProposals(_extension) {
-        const extension = _extension;
-        const key = ExtensionIdentifier.toKey(_extension.identifier);
-        if (isNonEmptyArray(extension.enabledApiProposals)) {
-            extension.enabledApiProposals = extension.enabledApiProposals.filter(name => {
-                const result = Boolean(allApiProposals[name]);
-                if (!result) {
-                    this._logService.error(`Extension '${key}' wants API proposal '${name}' but that proposal DOES NOT EXIST. Likely, the proposal has been finalized (check 'vscode.d.ts') or was abandoned.`);
-                }
-                return result;
-            });
-        }
-        if (( this._productEnabledExtensions.has(key))) {
-            const productEnabledProposals = this._productEnabledExtensions.get(key);
-            const productSet = ( new Set(productEnabledProposals));
-            const extensionSet = ( new Set(extension.enabledApiProposals));
-            const diff = ( new Set([...extensionSet].filter(a => !( productSet.has(a)))));
-            if (diff.size > 0) {
-                this._logService.error(`Extension '${key}' appears in product.json but enables LESS API proposals than the extension wants.\npackage.json (LOSES): ${[...extensionSet].join(', ')}\nproduct.json (WINS): ${[...productSet].join(', ')}`);
-                if (this._environmentService.isExtensionDevelopment) {
-                    this._logService.error(`Proceeding with EXTRA proposals (${[...diff].join(', ')}) because extension is in development mode. Still, this EXTENSION WILL BE BROKEN unless product.json is updated.`);
-                    productEnabledProposals.push(...diff);
-                }
-            }
-            extension.enabledApiProposals = productEnabledProposals;
-            return;
-        }
-        if (this._envEnablesProposedApiForAll || ( this._envEnabledExtensions.has(key))) {
-            return;
-        }
-        if (!extension.isBuiltin && isNonEmptyArray(extension.enabledApiProposals)) {
-            this._logService.error(`Extension '${extension.identifier.value} CANNOT USE these API proposals '${extension.enabledApiProposals?.join(', ') || '*'}'. You MUST start in extension development mode or use the --enable-proposed-api command line flag`);
-            extension.enabledApiProposals = [];
-        }
-    }
-};
-ExtensionsProposedApi = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IProductService))
-], ExtensionsProposedApi));
-
-export { ExtensionsProposedApi };

package/vscode/src/vs/workbench/services/extensions/common/extensionsUtil.js

@@ -1,64 +0,0 @@
-import { ExtensionIdentifierMap } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { semverExports } from '../../../../../../../external/vscode-semver/semver.js';
-
-function dedupExtensions(system, user, development, logService) {
-    const result = ( new ExtensionIdentifierMap());
-    system.forEach((systemExtension) => {
-        const extension = result.get(systemExtension.identifier);
-        if (extension) {
-            logService.warn(( localizeWithPath(
-                'vs/workbench/services/extensions/common/extensionsUtil',
-                'overwritingExtension',
-                "Overwriting extension {0} with {1}.",
-                extension.extensionLocation.fsPath,
-                systemExtension.extensionLocation.fsPath
-            )));
-        }
-        result.set(systemExtension.identifier, systemExtension);
-    });
-    user.forEach((userExtension) => {
-        const extension = result.get(userExtension.identifier);
-        if (extension) {
-            if (extension.isBuiltin) {
-                if (semverExports.gte(extension.version, userExtension.version)) {
-                    logService.warn(`Skipping extension ${userExtension.extensionLocation.path} in favour of the builtin extension ${extension.extensionLocation.path}.`);
-                    return;
-                }
-                userExtension.isBuiltin = true;
-            }
-            else {
-                logService.warn(( localizeWithPath(
-                    'vs/workbench/services/extensions/common/extensionsUtil',
-                    'overwritingExtension',
-                    "Overwriting extension {0} with {1}.",
-                    extension.extensionLocation.fsPath,
-                    userExtension.extensionLocation.fsPath
-                )));
-            }
-        }
-        else if (userExtension.isBuiltin) {
-            logService.warn(`Skipping obsolete builtin extension ${userExtension.extensionLocation.path}`);
-            return;
-        }
-        result.set(userExtension.identifier, userExtension);
-    });
-    development.forEach(developedExtension => {
-        logService.info(( localizeWithPath(
-            'vs/workbench/services/extensions/common/extensionsUtil',
-            'extensionUnderDevelopment',
-            "Loading development extension at {0}",
-            developedExtension.extensionLocation.fsPath
-        )));
-        const extension = result.get(developedExtension.identifier);
-        if (extension) {
-            if (extension.isBuiltin) {
-                developedExtension.isBuiltin = true;
-            }
-        }
-        result.set(developedExtension.identifier, developedExtension);
-    });
-    return Array.from(( result.values()));
-}
-
-export { dedupExtensions };

package/vscode/src/vs/workbench/services/extensions/common/lazyCreateExtensionHostManager.js

@@ -1,161 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Barrier } from 'vscode/vscode/vs/base/common/async';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { RemoteAuthorityResolverErrorCode } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
-import { friendlyExtHostName, ExtensionHostManager } from './extensionHostManager.js';
-import { ExtensionHostExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-
-let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extends Disposable {
-    get pid() {
-        if (this._actual) {
-            return this._actual.pid;
-        }
-        return null;
-    }
-    get kind() {
-        return this._extensionHost.runningLocation.kind;
-    }
-    get startup() {
-        return this._extensionHost.startup;
-    }
-    get friendyName() {
-        return friendlyExtHostName(this.kind, this.pid);
-    }
-    constructor(extensionHost, _internalExtensionService, _instantiationService, _logService) {
-        super();
-        this._internalExtensionService = _internalExtensionService;
-        this._instantiationService = _instantiationService;
-        this._logService = _logService;
-        this._onDidChangeResponsiveState = this._register(( new Emitter()));
-        this.onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
-        this._extensionHost = extensionHost;
-        this.onDidExit = extensionHost.onExit;
-        this._startCalled = ( new Barrier());
-        this._actual = null;
-        this._lazyStartExtensions = null;
-    }
-    _createActual(reason) {
-        this._logService.info(`Creating lazy extension host (${this.friendyName}). Reason: ${reason}`);
-        this._actual = this._register(this._instantiationService.createInstance(ExtensionHostManager, this._extensionHost, [], this._internalExtensionService));
-        this._register(this._actual.onDidChangeResponsiveState((e) => this._onDidChangeResponsiveState.fire(e)));
-        return this._actual;
-    }
-    async _getOrCreateActualAndStart(reason) {
-        if (this._actual) {
-            return this._actual;
-        }
-        const actual = this._createActual(reason);
-        await actual.start(this._lazyStartExtensions.versionId, this._lazyStartExtensions.allExtensions, this._lazyStartExtensions.myExtensions);
-        return actual;
-    }
-    async ready() {
-        await this._startCalled.wait();
-        if (this._actual) {
-            await this._actual.ready();
-        }
-    }
-    representsRunningLocation(runningLocation) {
-        return this._extensionHost.runningLocation.equals(runningLocation);
-    }
-    async deltaExtensions(extensionsDelta) {
-        await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.deltaExtensions(extensionsDelta);
-        }
-        this._lazyStartExtensions.delta(extensionsDelta);
-        if (extensionsDelta.myToAdd.length > 0) {
-            const actual = this._createActual(`contains ${extensionsDelta.myToAdd.length} new extension(s) (installed or enabled): ${( extensionsDelta.myToAdd.map(extId => extId.value))}`);
-            await actual.start(this._lazyStartExtensions.versionId, this._lazyStartExtensions.allExtensions, this._lazyStartExtensions.myExtensions);
-            return;
-        }
-    }
-    containsExtension(extensionId) {
-        return this._extensionHost.extensions?.containsExtension(extensionId) ?? false;
-    }
-    async activate(extension, reason) {
-        await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.activate(extension, reason);
-        }
-        return false;
-    }
-    async activateByEvent(activationEvent, activationKind) {
-        if (activationKind === 1 ) {
-            if (this._actual) {
-                return this._actual.activateByEvent(activationEvent, activationKind);
-            }
-            return;
-        }
-        await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.activateByEvent(activationEvent, activationKind);
-        }
-    }
-    activationEventIsDone(activationEvent) {
-        if (!this._startCalled.isOpen()) {
-            return false;
-        }
-        if (this._actual) {
-            return this._actual.activationEventIsDone(activationEvent);
-        }
-        return true;
-    }
-    async getInspectPort(tryEnableInspector) {
-        await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.getInspectPort(tryEnableInspector);
-        }
-        return 0;
-    }
-    async resolveAuthority(remoteAuthority, resolveAttempt) {
-        await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.resolveAuthority(remoteAuthority, resolveAttempt);
-        }
-        return {
-            type: 'error',
-            error: {
-                message: `Cannot resolve authority`,
-                code: RemoteAuthorityResolverErrorCode.Unknown,
-                detail: undefined
-            }
-        };
-    }
-    async getCanonicalURI(remoteAuthority, uri) {
-        await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.getCanonicalURI(remoteAuthority, uri);
-        }
-        throw new Error(`Cannot resolve canonical URI`);
-    }
-    async start(extensionRegistryVersionId, allExtensions, myExtensions) {
-        if (myExtensions.length > 0) {
-            const actual = this._createActual(`contains ${myExtensions.length} extension(s): ${( myExtensions.map(extId => extId.value))}.`);
-            const result = actual.start(extensionRegistryVersionId, allExtensions, myExtensions);
-            this._startCalled.open();
-            return result;
-        }
-        this._lazyStartExtensions = ( new ExtensionHostExtensions(extensionRegistryVersionId, allExtensions, myExtensions));
-        this._startCalled.open();
-    }
-    async extensionTestsExecute() {
-        await this._startCalled.wait();
-        const actual = await this._getOrCreateActualAndStart(`execute tests.`);
-        return actual.extensionTestsExecute();
-    }
-    async setRemoteEnvironment(env) {
-        await this._startCalled.wait();
-        if (this._actual) {
-            return this._actual.setRemoteEnvironment(env);
-        }
-    }
-};
-LazyCreateExtensionHostManager = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ILogService))
-], LazyCreateExtensionHostManager));
-
-export { LazyCreateExtensionHostManager };