@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.d.ts

@@ -0,0 +1,162 @@
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { ExtensionIdentifier, IExtensionDescription, IExtension, IExtensionContributions } from '../../../../platform/extensions/common/extensions.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { ResolverResult } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.service.js';
+import { IRemoteExtensionsScannerService } from '../../../../platform/remote/common/remoteExtensionsScanner.service.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService } from '../../extensionManagement/common/extensionManagement.service.js';
+import { ExtensionDescriptionRegistrySnapshot } from './extensionDescriptionRegistry.js';
+import { IExtensionHostKindPicker, ExtensionHostKind } from './extensionHostKind.js';
+import { IExtensionHostManager } from './extensionHostManagers.js';
+import { IExtensionManifestPropertiesService } from './extensionManifestPropertiesService.service.js';
+import { ExtensionRunningLocation } from './extensionRunningLocation.js';
+import { ExtensionRunningLocationTracker } from './extensionRunningLocationTracker.js';
+import { IWillActivateEvent, IResponsiveStateChangeEvent, WillStopExtensionHostsEvent, IExtensionHost, ActivationKind, ExtensionActivationReason, ExtensionPointContribution, IExtensionsStatus } from './extensions.js';
+import { IExtensionService } from './extensions.service.js';
+import { ExtensionsProposedApi } from './extensionsProposedApi.js';
+import { IExtensionPoint } from './extensionsRegistry.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.service.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.service.js';
+
+declare abstract class AbstractExtensionService extends Disposable implements IExtensionService {
+    protected readonly _extensionsProposedApi: ExtensionsProposedApi;
+    protected readonly _extensionHostFactory: IExtensionHostFactory;
+    protected readonly _extensionHostKindPicker: IExtensionHostKindPicker;
+    protected readonly _instantiationService: IInstantiationService;
+    protected readonly _notificationService: INotificationService;
+    protected readonly _environmentService: IWorkbenchEnvironmentService;
+    protected readonly _telemetryService: ITelemetryService;
+    protected readonly _extensionEnablementService: IWorkbenchExtensionEnablementService;
+    protected readonly _fileService: IFileService;
+    protected readonly _productService: IProductService;
+    protected readonly _extensionManagementService: IWorkbenchExtensionManagementService;
+    private readonly _contextService;
+    private readonly _configurationService;
+    private readonly _extensionManifestPropertiesService;
+    protected readonly _logService: ILogService;
+    protected readonly _remoteAgentService: IRemoteAgentService;
+    protected readonly _remoteExtensionsScannerService: IRemoteExtensionsScannerService;
+    private readonly _lifecycleService;
+    protected readonly _remoteAuthorityResolverService: IRemoteAuthorityResolverService;
+    private readonly _dialogService;
+    _serviceBrand: undefined;
+    private readonly _onDidRegisterExtensions;
+    readonly onDidRegisterExtensions: Event<void>;
+    private readonly _onDidChangeExtensionsStatus;
+    readonly onDidChangeExtensionsStatus: Event<ExtensionIdentifier[]>;
+    private readonly _onDidChangeExtensions;
+    readonly onDidChangeExtensions: Event<{
+        readonly added: ReadonlyArray<IExtensionDescription>;
+        readonly removed: ReadonlyArray<IExtensionDescription>;
+    }>;
+    private readonly _onWillActivateByEvent;
+    readonly onWillActivateByEvent: Event<IWillActivateEvent>;
+    private readonly _onDidChangeResponsiveChange;
+    readonly onDidChangeResponsiveChange: Event<IResponsiveStateChangeEvent>;
+    private readonly _onWillStop;
+    readonly onWillStop: Event<WillStopExtensionHostsEvent>;
+    private readonly _activationEventReader;
+    private readonly _registry;
+    private readonly _installedExtensionsReady;
+    private readonly _extensionStatus;
+    private readonly _allRequestedActivateEvents;
+    private readonly _runningLocations;
+    private readonly _remoteCrashTracker;
+    private _deltaExtensionsQueue;
+    private _inHandleDeltaExtensions;
+    private _extensionHostManagers;
+    private _resolveAuthorityAttempt;
+    constructor(_extensionsProposedApi: ExtensionsProposedApi, _extensionHostFactory: IExtensionHostFactory, _extensionHostKindPicker: IExtensionHostKindPicker, _instantiationService: IInstantiationService, _notificationService: INotificationService, _environmentService: IWorkbenchEnvironmentService, _telemetryService: ITelemetryService, _extensionEnablementService: IWorkbenchExtensionEnablementService, _fileService: IFileService, _productService: IProductService, _extensionManagementService: IWorkbenchExtensionManagementService, _contextService: IWorkspaceContextService, _configurationService: IConfigurationService, _extensionManifestPropertiesService: IExtensionManifestPropertiesService, _logService: ILogService, _remoteAgentService: IRemoteAgentService, _remoteExtensionsScannerService: IRemoteExtensionsScannerService, _lifecycleService: ILifecycleService, _remoteAuthorityResolverService: IRemoteAuthorityResolverService, _dialogService: IDialogService);
+    protected _getExtensionHostManagers(kind: ExtensionHostKind): IExtensionHostManager[];
+    private _getExtensionHostManagerByRunningLocation;
+    protected _handleDeltaExtensions(item: DeltaExtensionsQueueItem): Promise<void>;
+    private _deltaExtensions;
+    private _updateExtensionsOnExtHosts;
+    private _updateExtensionsOnExtHost;
+    canAddExtension(extension: IExtensionDescription): boolean;
+    private _canAddExtension;
+    canRemoveExtension(extension: IExtensionDescription): boolean;
+    private _activateAddedExtensionIfNeeded;
+    protected _initialize(): Promise<void>;
+    private _processExtensions;
+    private _handleExtensionTests;
+    private findTestExtensionHost;
+    private _releaseBarrier;
+    protected _resolveAuthorityInitial(remoteAuthority: string): Promise<ResolverResult>;
+    protected _resolveAuthorityAgain(): Promise<void>;
+    private _resolveAuthorityWithLogging;
+    protected _resolveAuthorityOnExtensionHosts(kind: ExtensionHostKind, remoteAuthority: string): Promise<ResolverResult>;
+    stopExtensionHosts(reason: string): Promise<boolean>;
+    protected _doStopExtensionHosts(): void;
+    private _doStopExtensionHostsWithVeto;
+    private _startExtensionHostsIfNecessary;
+    private _createExtensionHostManager;
+    protected _doCreateExtensionHostManager(extensionHost: IExtensionHost, initialActivationEvents: string[]): IExtensionHostManager;
+    private _onExtensionHostCrashOrExit;
+    protected _onExtensionHostCrashed(extensionHost: IExtensionHostManager, code: number, signal: string | null): void;
+    private _getExtensionHostExitInfoWithTimeout;
+    private _onRemoteExtensionHostCrashed;
+    protected _logExtensionHostCrash(extensionHost: IExtensionHostManager): void;
+    startExtensionHosts(updates?: {
+        toAdd: IExtension[];
+        toRemove: string[];
+    }): Promise<void>;
+    activateByEvent(activationEvent: string, activationKind?: ActivationKind): Promise<void>;
+    private _activateByEvent;
+    activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    activationEventIsDone(activationEvent: string): boolean;
+    whenInstalledExtensionsRegistered(): Promise<boolean>;
+    get extensions(): IExtensionDescription[];
+    protected _getExtensionRegistrySnapshotWhenReady(): Promise<ExtensionDescriptionRegistrySnapshot>;
+    getExtension(id: string): Promise<IExtensionDescription | undefined>;
+    readExtensionPointContributions<T extends IExtensionContributions[keyof IExtensionContributions]>(extPoint: IExtensionPoint<T>): Promise<ExtensionPointContribution<T>[]>;
+    getExtensionsStatus(): {
+        [id: string]: IExtensionsStatus;
+    };
+    getInspectPorts(extensionHostKind: ExtensionHostKind, tryEnableInspector: boolean): Promise<number[]>;
+    setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    private _safeInvokeIsEnabled;
+    private _doHandleExtensionPoints;
+    private _getOrCreateExtensionStatus;
+    private _handleExtensionPointMessage;
+    private static _handleExtensionPoint;
+    private _acquireInternalAPI;
+    _activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    private _onWillActivateExtension;
+    private _onDidActivateExtension;
+    private _onDidActivateExtensionError;
+    private _onExtensionRuntimeError;
+    protected abstract _resolveExtensions(): Promise<ResolvedExtensions>;
+    protected abstract _scanSingleExtension(extension: IExtension): Promise<IExtensionDescription | null>;
+    protected abstract _onExtensionHostExit(code: number): void;
+    protected abstract _resolveAuthority(remoteAuthority: string): Promise<ResolverResult>;
+}
+declare class ResolvedExtensions {
+    readonly local: IExtensionDescription[];
+    readonly remote: IExtensionDescription[];
+    readonly hasLocalProcess: boolean;
+    readonly allowRemoteExtensionsInLocalWebWorker: boolean;
+    constructor(local: IExtensionDescription[], remote: IExtensionDescription[], hasLocalProcess: boolean, allowRemoteExtensionsInLocalWebWorker: boolean);
+}
+interface IExtensionHostFactory {
+    createExtensionHost(runningLocations: ExtensionRunningLocationTracker, runningLocation: ExtensionRunningLocation, isInitialStart: boolean): IExtensionHost | null;
+}
+declare class DeltaExtensionsQueueItem {
+    readonly toAdd: IExtension[];
+    readonly toRemove: string[] | IExtension[];
+    constructor(toAdd: IExtension[], toRemove: string[] | IExtension[]);
+}
+
+export { AbstractExtensionService, DeltaExtensionsQueueItem, type IExtensionHostFactory, ResolvedExtensions };

package/vscode/src/vs/workbench/services/extensions/common/extensionDescriptionRegistry.d.ts

@@ -0,0 +1,18 @@
+import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+
+interface IReadOnlyExtensionDescriptionRegistry {
+    containsActivationEvent(activationEvent: string): boolean;
+    containsExtension(extensionId: ExtensionIdentifier): boolean;
+    getExtensionDescriptionsForActivationEvent(activationEvent: string): IExtensionDescription[];
+    getAllExtensionDescriptions(): IExtensionDescription[];
+    getExtensionDescription(extensionId: ExtensionIdentifier | string): IExtensionDescription | undefined;
+    getExtensionDescriptionByUUID(uuid: string): IExtensionDescription | undefined;
+    getExtensionDescriptionByIdOrUUID(extensionId: ExtensionIdentifier | string, uuid: string | undefined): IExtensionDescription | undefined;
+}
+declare class ExtensionDescriptionRegistrySnapshot {
+    readonly versionId: number;
+    readonly extensions: readonly IExtensionDescription[];
+    constructor(versionId: number, extensions: readonly IExtensionDescription[]);
+}
+
+export { ExtensionDescriptionRegistrySnapshot, type IReadOnlyExtensionDescriptionRegistry };

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

@@ -190,7 +190,7 @@ class LockableExtensionDescriptionRegistry {
     }
     deltaExtensions(acquiredLock, toAdd, toRemove) {
         if (!acquiredLock.isAcquiredFor(this)) {
-            throw new Error('Lock is not held');
+            throw ( new Error('Lock is not held'));
         }
         return this._actual.deltaExtensions(toAdd, toRemove);
     }

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManagers.d.ts

@@ -0,0 +1,39 @@
+import { Event } from '../../../../base/common/event.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { ExtensionHostKind } from './extensionHostKind.js';
+import { IExtensionDescriptionDelta } from './extensionHostProtocol.js';
+import { IResolveAuthorityResult } from './extensionHostProxy.js';
+import { ExtensionRunningLocation } from './extensionRunningLocation.js';
+import { ExtensionHostStartup, ExtensionActivationReason, ActivationKind } from './extensions.js';
+import { ResponsiveState } from './rpcProtocol.js';
+
+interface IExtensionHostManager {
+    readonly pid: number | null;
+    readonly kind: ExtensionHostKind;
+    readonly startup: ExtensionHostStartup;
+    readonly friendyName: string;
+    readonly onDidExit: Event<[number, string | null]>;
+    readonly onDidChangeResponsiveState: Event<ResponsiveState>;
+    dispose(): void;
+    ready(): Promise<void>;
+    representsRunningLocation(runningLocation: ExtensionRunningLocation): boolean;
+    deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    containsExtension(extensionId: ExtensionIdentifier): boolean;
+    activate(extension: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    activationEventIsDone(activationEvent: string): boolean;
+    getInspectPort(tryEnableInspector: boolean): Promise<number>;
+    resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult>;
+    /**
+     * Returns `null` if no resolver for `remoteAuthority` is found.
+     */
+    getCanonicalURI(remoteAuthority: string, uri: URI): Promise<URI | null>;
+    start(extensionRegistryVersionId: number, allExtensions: readonly IExtensionDescription[], myExtensions: ExtensionIdentifier[]): Promise<void>;
+    extensionTestsExecute(): Promise<number>;
+    setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+}
+
+export type { IExtensionHostManager };

package/vscode/src/vs/workbench/services/extensions/common/extensionHostProxy.d.ts

@@ -0,0 +1,17 @@
+import { RemoteAuthorityResolverErrorCode, ResolverResult } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+
+interface IResolveAuthorityErrorResult {
+    type: 'error';
+    error: {
+        message: string | undefined;
+        code: RemoteAuthorityResolverErrorCode;
+        detail: any;
+    };
+}
+interface IResolveAuthorityOKResult {
+    type: 'ok';
+    value: ResolverResult;
+}
+type IResolveAuthorityResult = IResolveAuthorityErrorResult | IResolveAuthorityOKResult;
+
+export type { IResolveAuthorityErrorResult, IResolveAuthorityOKResult, IResolveAuthorityResult };

package/vscode/src/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service.d.ts

@@ -0,0 +1,20 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { IExtensionManifest, IExtensionIdentifier, ExtensionUntrustedWorkspaceSupportType, ExtensionVirtualWorkspaceSupportType } from '../../../../platform/extensions/common/extensions.js';
+import { ExtensionKind } from '../../../../platform/environment/common/environment.js';
+
+declare const IExtensionManifestPropertiesService: ServiceIdentifier<IExtensionManifestPropertiesService>;
+interface IExtensionManifestPropertiesService {
+    readonly _serviceBrand: undefined;
+    prefersExecuteOnUI(manifest: IExtensionManifest): boolean;
+    prefersExecuteOnWorkspace(manifest: IExtensionManifest): boolean;
+    prefersExecuteOnWeb(manifest: IExtensionManifest): boolean;
+    canExecuteOnUI(manifest: IExtensionManifest): boolean;
+    canExecuteOnWorkspace(manifest: IExtensionManifest): boolean;
+    canExecuteOnWeb(manifest: IExtensionManifest): boolean;
+    getExtensionKind(manifest: IExtensionManifest): ExtensionKind[];
+    getUserConfiguredExtensionKind(extensionIdentifier: IExtensionIdentifier): ExtensionKind[] | undefined;
+    getExtensionUntrustedWorkspaceSupportType(manifest: IExtensionManifest): ExtensionUntrustedWorkspaceSupportType;
+    getExtensionVirtualWorkspaceSupportType(manifest: IExtensionManifest): ExtensionVirtualWorkspaceSupportType;
+}
+
+export { IExtensionManifestPropertiesService };

package/vscode/src/vs/workbench/services/extensions/common/extensionRunningLocationTracker.d.ts

@@ -0,0 +1,45 @@
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ExtensionKind } from '../../../../platform/environment/common/environment.js';
+import { ExtensionIdentifier, IExtensionDescription, ExtensionIdentifierMap } from '../../../../platform/extensions/common/extensions.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { IReadOnlyExtensionDescriptionRegistry } from './extensionDescriptionRegistry.js';
+import { IExtensionHostKindPicker, ExtensionHostKind } from './extensionHostKind.js';
+import { IExtensionHostManager } from './extensionHostManagers.js';
+import { IExtensionManifestPropertiesService } from './extensionManifestPropertiesService.service.js';
+import { ExtensionRunningLocation } from './extensionRunningLocation.js';
+
+declare class ExtensionRunningLocationTracker {
+    private readonly _registry;
+    private readonly _extensionHostKindPicker;
+    private readonly _environmentService;
+    private readonly _configurationService;
+    private readonly _logService;
+    private readonly _extensionManifestPropertiesService;
+    private _runningLocation;
+    private _maxLocalProcessAffinity;
+    private _maxLocalWebWorkerAffinity;
+    get maxLocalProcessAffinity(): number;
+    get maxLocalWebWorkerAffinity(): number;
+    constructor(_registry: IReadOnlyExtensionDescriptionRegistry, _extensionHostKindPicker: IExtensionHostKindPicker, _environmentService: IWorkbenchEnvironmentService, _configurationService: IConfigurationService, _logService: ILogService, _extensionManifestPropertiesService: IExtensionManifestPropertiesService);
+    set(extensionId: ExtensionIdentifier, runningLocation: ExtensionRunningLocation): void;
+    readExtensionKinds(extensionDescription: IExtensionDescription): ExtensionKind[];
+    getRunningLocation(extensionId: ExtensionIdentifier): ExtensionRunningLocation | null;
+    filterByRunningLocation(extensions: readonly IExtensionDescription[], desiredRunningLocation: ExtensionRunningLocation): IExtensionDescription[];
+    filterByExtensionHostKind(extensions: readonly IExtensionDescription[], desiredExtensionHostKind: ExtensionHostKind): IExtensionDescription[];
+    filterByExtensionHostManager(extensions: readonly IExtensionDescription[], extensionHostManager: IExtensionHostManager): IExtensionDescription[];
+    private _computeAffinity;
+    computeRunningLocation(localExtensions: IExtensionDescription[], remoteExtensions: IExtensionDescription[], isInitialAllocation: boolean): ExtensionIdentifierMap<ExtensionRunningLocation | null>;
+    private _doComputeRunningLocation;
+    initializeRunningLocation(localExtensions: IExtensionDescription[], remoteExtensions: IExtensionDescription[]): void;
+    /**
+     * Returns the running locations for the removed extensions.
+     */
+    deltaExtensions(toAdd: IExtensionDescription[], toRemove: ExtensionIdentifier[]): ExtensionIdentifierMap<ExtensionRunningLocation | null>;
+    /**
+     * Update `this._runningLocation` with running locations for newly enabled/installed extensions.
+     */
+    private _updateRunningLocationForAddedExtensions;
+}
+
+export { ExtensionRunningLocationTracker };

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

@@ -47,7 +47,9 @@ class ExtensionHostExtensions {
     }
     set(versionId, allExtensions, myExtensions) {
         if (this._versionId > versionId) {
-            throw new Error(`ExtensionHostExtensions: invalid versionId ${versionId} (current: ${this._versionId})`);
+            throw ( new Error(
+                `ExtensionHostExtensions: invalid versionId ${versionId} (current: ${this._versionId})`
+            ));
         }
         const toRemove = [];
         const toAdd = [];
@@ -173,7 +175,9 @@ function isProposedApiEnabled(extension, proposal) {
 }
 function checkProposedApiEnabled(extension, proposal) {
     if (!isProposedApiEnabled(extension, proposal)) {
-        throw new Error(`Extension '${extension.identifier.value}' CANNOT use API proposal: ${proposal}.\nIts package.json#enabledApiProposals-property declares: ${extension.enabledApiProposals?.join(', ') ?? '[]'} but NOT ${proposal}.\n The missing proposal MUST be added and you must start in extension development mode or use the following command line switch: --enable-proposed-api ${extension.identifier.value}`);
+        throw ( new Error(
+            `Extension '${extension.identifier.value}' CANNOT use API proposal: ${proposal}.\nIts package.json#enabledApiProposals-property declares: ${extension.enabledApiProposals?.join(', ') ?? '[]'} but NOT ${proposal}.\n The missing proposal MUST be added and you must start in extension development mode or use the following command line switch: --enable-proposed-api ${extension.identifier.value}`
+        ));
     }
 }
 class ActivationTimes {

package/vscode/src/vs/workbench/services/extensions/common/extensionsProposedApi.d.ts

@@ -0,0 +1,17 @@
+import { IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+
+declare class ExtensionsProposedApi {
+    private readonly _logService;
+    private readonly _environmentService;
+    private readonly _envEnablesProposedApiForAll;
+    private readonly _envEnabledExtensions;
+    private readonly _productEnabledExtensions;
+    constructor(_logService: ILogService, _environmentService: IWorkbenchEnvironmentService, productService: IProductService);
+    updateEnabledApiProposals(extensions: IExtensionDescription[]): void;
+    private doUpdateEnabledApiProposals;
+}
+
+export { ExtensionsProposedApi };