@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,272 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ExtensionIdentifierMap } from '../../../../platform/extensions/common/extensions.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { determineExtensionHostKinds } from './extensionHostKind.js';
+import { IExtensionManifestPropertiesService } from './extensionManifestPropertiesService.js';
+import { LocalProcessRunningLocation, LocalWebWorkerRunningLocation, RemoteRunningLocation } from './extensionRunningLocation.js';
+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

@@ -0,0 +1,56 @@
+import { getErrorMessage } from '../../../../base/common/errors.js';
+import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
+import { IExtensionStorageService } from '../../../../platform/extensionManagement/common/extensionStorage.js';
+import { IFileService, FileSystemProviderErrorCode } from '../../../../platform/files/common/files.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+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

@@ -0,0 +1,78 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { allApiProposals } from './extensionsApiProposals.js';
+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

@@ -0,0 +1,62 @@
+import { ExtensionIdentifierMap } from '../../../../platform/extensions/common/extensions.js';
+import { localizeWithPath } from '../../../../nls.js';
+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

@@ -0,0 +1,159 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Barrier } from '../../../../base/common/async.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { RemoteAuthorityResolverErrorCode } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { friendlyExtHostName, ExtensionHostManager } from './extensionHostManager.js';
+import { ExtensionHostExtensions } from './extensions.js';
+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 };