@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -1,7 +1,7 @@
 
 
 function extHostNamedCustomer(id) {
-    return function (ctor) {
+    return function(ctor) {
         ExtHostCustomersRegistryImpl.INSTANCE.registerNamedCustomer(id, ctor);
     };
 }
@@ -9,7 +9,7 @@ function extHostCustomer(ctor) {
     ExtHostCustomersRegistryImpl.INSTANCE.registerCustomer(ctor);
 }
 var ExtHostCustomersRegistry;
-(function (ExtHostCustomersRegistry) {
+(function(ExtHostCustomersRegistry) {
     function getNamedCustomers() {
         return ExtHostCustomersRegistryImpl.INSTANCE.getNamedCustomers();
     }
@@ -20,7 +20,9 @@ var ExtHostCustomersRegistry;
     ExtHostCustomersRegistry.getCustomers = getCustomers;
 })(ExtHostCustomersRegistry || (ExtHostCustomersRegistry = {}));
 class ExtHostCustomersRegistryImpl {
-    static { this.INSTANCE = ( new ExtHostCustomersRegistryImpl()); }
+    static {
+        this.INSTANCE = ( new ExtHostCustomersRegistryImpl());
+    }
     constructor() {
         this._namedCustomers = [];
         this._customers = [];

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

@@ -34,7 +34,6 @@ export declare class ExtensionHostManager extends Disposable implements IExtensi
     private readonly _customers;
     private readonly _extensionHost;
     private _proxy;
-    private _hasStarted;
     get pid(): number | null;
     get kind(): ExtensionHostKind;
     get startup(): ExtensionHostStartup;

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

@@ -34,7 +34,15 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     get friendyName() {
         return friendlyExtHostName(this.kind, this.pid);
     }
-    constructor(extensionHost, initialActivationEvents, _internalExtensionService, _instantiationService, _environmentService, _telemetryService, _logService) {
+    constructor(
+        extensionHost,
+        initialActivationEvents,
+        _internalExtensionService,
+        _instantiationService,
+        _environmentService,
+        _telemetryService,
+        _logService
+    ) {
         super();
         this._internalExtensionService = _internalExtensionService;
         this._instantiationService = _instantiationService;
@@ -43,7 +51,6 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         this._logService = _logService;
         this._onDidChangeResponsiveState = this._register(( new Emitter()));
         this.onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
-        this._hasStarted = false;
         this._cachedActivationEvents = ( new Map());
         this._resolvedActivationEvents = ( new Set());
         this._rpcProtocol = null;
@@ -52,25 +59,26 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         this.onDidExit = this._extensionHost.onExit;
         const startingTelemetryEvent = {
             time: Date.now(),
-            action: 'starting',
+            action: "starting",
             kind: extensionHostKindToString(this.kind)
         };
-        this._telemetryService.publicLog2('extensionHostStartup', startingTelemetryEvent);
-        this._proxy = this._extensionHost.start().then((protocol) => {
-            this._hasStarted = true;
+        this._telemetryService.publicLog2("extensionHostStartup", startingTelemetryEvent);
+        this._proxy = this._extensionHost.start().then(protocol => {
             const successTelemetryEvent = {
                 time: Date.now(),
-                action: 'success',
+                action: "success",
                 kind: extensionHostKindToString(this.kind)
             };
-            this._telemetryService.publicLog2('extensionHostStartup', successTelemetryEvent);
+            this._telemetryService.publicLog2("extensionHostStartup", successTelemetryEvent);
             return this._createExtensionHostCustomers(this.kind, protocol);
-        }, (err) => {
-            this._logService.error(`Error received from starting extension host (kind: ${extensionHostKindToString(this.kind)})`);
+        }, err => {
+            this._logService.error(
+                `Error received from starting extension host (kind: ${extensionHostKindToString(this.kind)})`
+            );
             this._logService.error(err);
             const failureTelemetryEvent = {
                 time: Date.now(),
-                action: 'error',
+                action: "error",
                 kind: extensionHostKindToString(this.kind)
             };
             if (err && err.name) {
@@ -82,11 +90,13 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             if (err && err.stack) {
                 failureTelemetryEvent.errorStack = err.stack;
             }
-            this._telemetryService.publicLog2('extensionHostStartup', failureTelemetryEvent);
+            this._telemetryService.publicLog2("extensionHostStartup", failureTelemetryEvent);
             return null;
         });
         this._proxy.then(() => {
-            initialActivationEvents.forEach((activationEvent) => this.activateByEvent(activationEvent, ActivationKind.Normal));
+            initialActivationEvents.forEach(
+                activationEvent => this.activateByEvent(activationEvent, ActivationKind.Normal)
+            );
             this._register(registerLatencyTestProvider({
                 measure: () => this.measure()
             }));
@@ -102,8 +112,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             const customer = this._customers[i];
             try {
                 customer.dispose();
-            }
-            catch (err) {
+            } catch (err) {
                 onUnexpectedError(err);
             }
         }
@@ -165,29 +174,30 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         let logger = null;
         if (this._environmentService.logExtensionHostCommunication) {
             logger = ( new RPCLogger(kind));
-        }
-        else if (TelemetryRPCLogger.isEnabled()) {
+        } else if (TelemetryRPCLogger.isEnabled()) {
             logger = ( new TelemetryRPCLogger(this._telemetryService));
         }
         this._rpcProtocol = ( new RPCProtocol(protocol, logger));
-        this._register(this._rpcProtocol.onDidChangeResponsiveState((responsiveState) => this._onDidChangeResponsiveState.fire(responsiveState)));
+        this._register(
+            this._rpcProtocol.onDidChangeResponsiveState(responsiveState => this._onDidChangeResponsiveState.fire(responsiveState))
+        );
         let extensionHostProxy = null;
         let mainProxyIdentifiers = [];
         const extHostContext = {
             remoteAuthority: this._extensionHost.remoteAuthority,
             extensionHostKind: this.kind,
-            getProxy: (identifier) => ( this._rpcProtocol.getProxy(identifier)),
+            getProxy: identifier => ( this._rpcProtocol.getProxy(identifier)),
             set: (identifier, instance) => this._rpcProtocol.set(identifier, instance),
             dispose: () => this._rpcProtocol.dispose(),
-            assertRegistered: (identifiers) => this._rpcProtocol.assertRegistered(identifiers),
+            assertRegistered: identifiers => this._rpcProtocol.assertRegistered(identifiers),
             drain: () => this._rpcProtocol.drain(),
             internalExtensionService: this._internalExtensionService,
-            _setExtensionHostProxy: (value) => {
+            _setExtensionHostProxy: value => {
                 extensionHostProxy = value;
             },
-            _setAllMainProxyIdentifiers: (value) => {
+            _setAllMainProxyIdentifiers: value => {
                 mainProxyIdentifiers = value;
-            },
+            }
         };
         const namedCustomers = ExtHostCustomersRegistry.getNamedCustomers();
         for (let i = 0, len = namedCustomers.length; i < len; i++) {
@@ -196,8 +206,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
                 const instance = this._instantiationService.createInstance(ctor, extHostContext);
                 this._customers.push(instance);
                 this._rpcProtocol.set(id, instance);
-            }
-            catch (err) {
+            } catch (err) {
                 this._logService.error(`Cannot instantiate named customer: '${id.sid}'`);
                 this._logService.error(err);
                 onUnexpectedError(err);
@@ -208,8 +217,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             try {
                 const instance = this._instantiationService.createInstance(ctor, extHostContext);
                 this._customers.push(instance);
-            }
-            catch (err) {
+            } catch (err) {
                 this._logService.error(err);
                 onUnexpectedError(err);
             }
@@ -228,9 +236,6 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         return proxy.activate(extension, reason);
     }
     activateByEvent(activationEvent, activationKind) {
-        if (activationKind === ActivationKind.Immediate && !this._hasStarted) {
-            return Promise.resolve();
-        }
         if (!( this._cachedActivationEvents.has(activationEvent))) {
             this._cachedActivationEvents.set(activationEvent, this._activateByEvent(activationEvent, activationKind));
         }
@@ -269,14 +274,14 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     async resolveAuthority(remoteAuthority, resolveAttempt) {
         const sw = StopWatch.create(false);
         const prefix = () => `[${extensionHostKindToString(this._extensionHost.runningLocation.kind)}${this._extensionHost.runningLocation.affinity}][resolveAuthority(${getRemoteAuthorityPrefix(remoteAuthority)},${resolveAttempt})][${sw.elapsed()}ms] `;
-        const logInfo = (msg) => this._logService.info(`${prefix()}${msg}`);
+        const logInfo = msg => this._logService.info(`${prefix()}${msg}`);
         const logError = (msg, err = undefined) => this._logService.error(`${prefix()}${msg}`, err);
         logInfo(`obtaining proxy...`);
         const proxy = await this._proxy;
         if (!proxy) {
             logError(`no proxy`);
             return {
-                type: 'error',
+                type: "error",
                 error: {
                     message: `Cannot resolve authority`,
                     code: RemoteAuthorityResolverErrorCode.Unknown,
@@ -287,22 +292,20 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         logInfo(`invoking...`);
         const intervalLogger = ( new IntervalTimer());
         try {
-            intervalLogger.cancelAndSet(() => logInfo('waiting...'), 1000);
+            intervalLogger.cancelAndSet(() => logInfo("waiting..."), 1000);
             const resolverResult = await proxy.resolveAuthority(remoteAuthority, resolveAttempt);
             intervalLogger.dispose();
-            if (resolverResult.type === 'ok') {
+            if (resolverResult.type === "ok") {
                 logInfo(`returned ${resolverResult.value.authority.connectTo}`);
-            }
-            else {
+            } else {
                 logError(`returned an error`, resolverResult.error);
             }
             return resolverResult;
-        }
-        catch (err) {
+        } catch (err) {
             intervalLogger.dispose();
             logError(`returned an error`, err);
             return {
-                type: 'error',
+                type: "error",
                 error: {
                     message: err.message,
                     code: RemoteAuthorityResolverErrorCode.Unknown,
@@ -329,7 +332,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     async extensionTestsExecute() {
         const proxy = await this._proxy;
         if (!proxy) {
-            throw ( new Error('Could not obtain Extension Host Proxy'));
+            throw ( new Error("Could not obtain Extension Host Proxy"));
         }
         return proxy.extensionTestsExecute();
     }
@@ -358,12 +361,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         return proxy.setRemoteEnvironment(env);
     }
 };
-ExtensionHostManager = ExtensionHostManager_1 = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, ILogService))
-], ExtensionHostManager));
+ExtensionHostManager = ExtensionHostManager_1 = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, IWorkbenchEnvironmentService)), ( __param(5, ITelemetryService)), ( __param(6, ILogService))], ExtensionHostManager));
 function friendlyExtHostName(kind, pid) {
     if (pid) {
         return `${extensionHostKindToString(kind)} pid: ${pid}`;
@@ -371,16 +369,16 @@ function friendlyExtHostName(kind, pid) {
     return `${extensionHostKindToString(kind)}`;
 }
 const colorTables = [
-    ['#2977B1', '#FC802D', '#34A13A', '#D3282F', '#9366BA'],
-    ['#8B564C', '#E177C0', '#7F7F7F', '#BBBE3D', '#2EBECD']
+    ["#2977B1", "#FC802D", "#34A13A", "#D3282F", "#9366BA"],
+    ["#8B564C", "#E177C0", "#7F7F7F", "#BBBE3D", "#2EBECD"]
 ];
 function prettyWithoutArrays(data) {
     if (Array.isArray(data)) {
         return data;
     }
-    if (data && typeof data === 'object' && typeof data.toString === 'function') {
+    if (data && typeof data === "object" && typeof data.toString === "function") {
         const result = ( data.toString());
-        if (result !== '[object Object]') {
+        if (result !== "[object Object]") {
             return result;
         }
     }
@@ -402,23 +400,28 @@ class RPCLogger {
         data = pretty(data);
         const colorTable = colorTables[initiator];
         const color = colorTable[req % colorTable.length] ;
-        let args = [`%c[${extensionHostKindToString(this._kind)}][${direction}]%c[${String(totalLength).padStart(7)}]%c[len: ${String(msgLength).padStart(5)}]%c${String(req).padStart(5)} - ${str}`, 'color: darkgreen', 'color: grey', 'color: grey', `color: ${color}`];
+        let args = [
+            `%c[${extensionHostKindToString(this._kind)}][${direction}]%c[${String(totalLength).padStart(7)}]%c[len: ${String(msgLength).padStart(5)}]%c${String(req).padStart(5)} - ${str}`,
+            "color: darkgreen",
+            "color: grey",
+            "color: grey",
+            `color: ${color}`
+        ];
         if (/\($/.test(str)) {
             args = args.concat(data);
-            args.push(')');
-        }
-        else {
+            args.push(")");
+        } else {
             args.push(data);
         }
         console.log.apply(console, args);
     }
     logIncoming(msgLength, req, initiator, str, data) {
         this._totalIncoming += msgLength;
-        this._log('Ext \u2192 Win', this._totalIncoming, msgLength, req, initiator, str, data);
+        this._log("Ext → Win", this._totalIncoming, msgLength, req, initiator, str, data);
     }
     logOutgoing(msgLength, req, initiator, str, data) {
         this._totalOutgoing += msgLength;
-        this._log('Win \u2192 Ext', this._totalOutgoing, msgLength, req, initiator, str, data);
+        this._log("Win → Ext", this._totalOutgoing, msgLength, req, initiator, str, data);
     }
 }
 let TelemetryRPCLogger = class TelemetryRPCLogger {
@@ -431,33 +434,31 @@ let TelemetryRPCLogger = class TelemetryRPCLogger {
     }
     logIncoming(msgLength, req, initiator, str) {
         if (initiator === RequestInitiator.LocalSide && /^receiveReply(Err)?:/.test(str)) {
-            const requestStr = this._pendingRequests.get(req) ?? 'unknown_reply';
+            const requestStr = this._pendingRequests.get(req) ?? "unknown_reply";
             this._pendingRequests.delete(req);
-            this._telemetryService.publicLog2('extensionhost.incoming', {
+            this._telemetryService.publicLog2("extensionhost.incoming", {
                 type: `${str} ${requestStr}`,
                 length: msgLength
             });
         }
         if (initiator === RequestInitiator.OtherSide && /^receiveRequest /.test(str)) {
-            this._telemetryService.publicLog2('extensionhost.incoming', {
+            this._telemetryService.publicLog2("extensionhost.incoming", {
                 type: `${str}`,
                 length: msgLength
             });
         }
     }
     logOutgoing(msgLength, req, initiator, str) {
-        if (initiator === RequestInitiator.LocalSide && str.startsWith('request: ')) {
+        if (initiator === RequestInitiator.LocalSide && str.startsWith("request: ")) {
             this._pendingRequests.set(req, str);
-            this._telemetryService.publicLog2('extensionhost.outgoing', {
+            this._telemetryService.publicLog2("extensionhost.outgoing", {
                 type: str,
                 length: msgLength
             });
         }
     }
 };
-TelemetryRPCLogger = ( __decorate([
-    ( __param(0, ITelemetryService))
-], TelemetryRPCLogger));
+TelemetryRPCLogger = ( __decorate([( __param(0, ITelemetryService))], TelemetryRPCLogger));
 const providers = [];
 function registerLatencyTestProvider(provider) {
     providers.push(provider);
@@ -478,8 +479,8 @@ function getLatencyTestProviders() {
 registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     constructor() {
         super({
-            id: 'editor.action.measureExtHostLatency',
-            title: ( localize2(14007, "Measure Extension Host Latency")),
+            id: "editor.action.measureExtHostLatency",
+            title: ( localize2(14394, "Measure Extension Host Latency")),
             category: Categories.Developer,
             f1: true
         });
@@ -487,11 +488,17 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     async run(accessor) {
         const editorService = accessor.get(IEditorService);
         const measurements = await Promise.all(( getLatencyTestProviders().map(provider => provider.measure())));
-        editorService.openEditor({ resource: undefined, contents: ( measurements.map(MeasureExtHostLatencyAction._print)).join('\n\n'), options: { pinned: true } });
+        editorService.openEditor({
+            resource: undefined,
+            contents: ( measurements.map(MeasureExtHostLatencyAction._print)).join("\n\n"),
+            options: {
+                pinned: true
+            }
+        });
     }
     static _print(m) {
         if (!m) {
-            return '';
+            return "";
         }
         return `${m.remoteAuthority ? `Authority: ${m.remoteAuthority}\n` : ``}Roundtrip latency: ${m.latency.toFixed(3)}ms\nUp: ${MeasureExtHostLatencyAction._printSpeed(m.up)}\nDown: ${MeasureExtHostLatencyAction._printSpeed(m.down)}\n`;
     }