@codingame/monaco-vscode-api 1.83.8 → 1.83.9

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

@@ -1,272 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ExtensionIdentifierMap } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
-import { ILogService } from 'monaco-editor/esm/vs/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

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

@@ -1,78 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IProductService } from 'monaco-editor/esm/vs/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/remoteConsoleUtil.js

@@ -1,47 +0,0 @@
-import { parse } from '../../../../base/common/console.js';
-function logRemoteEntry(logService, entry, label = null) {
-    const args = parse(entry).args;
-    let firstArg = args.shift();
-    if (typeof firstArg !== 'string') {
-        return;
-    }
-    if (!entry.severity) {
-        entry.severity = 'info';
-    }
-    if (label) {
-        if (!/^\[/.test(label)) {
-            label = `[${label}]`;
-        }
-        if (!/ $/.test(label)) {
-            label = `${label} `;
-        }
-        firstArg = label + firstArg;
-    }
-    switch (entry.severity) {
-        case 'log':
-        case 'info':
-            logService.info(firstArg, ...args);
-            break;
-        case 'warn':
-            logService.warn(firstArg, ...args);
-            break;
-        case 'error':
-            logService.error(firstArg, ...args);
-            break;
-    }
-}
-function logRemoteEntryIfError(logService, entry, label) {
-    const args = parse(entry).args;
-    const firstArg = args.shift();
-    if (typeof firstArg !== 'string' || entry.severity !== 'error') {
-        return;
-    }
-    if (!/^\[/.test(label)) {
-        label = `[${label}]`;
-    }
-    if (!/ $/.test(label)) {
-        label = `${label} `;
-    }
-    logService.error(label + firstArg, ...args);
-}
-export { logRemoteEntry, logRemoteEntryIfError };