@codingame/monaco-vscode-lifecycle-service-override 4.4.1 → 4.5.0

package/lifecycle.js

@@ -1,7 +1,8 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { BrowserLifecycleService } from './vscode/src/vs/workbench/services/lifecycle/browser/lifecycleService.js';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { ITimerService, TimerService } from 'vscode/vscode/vs/workbench/services/timer/browser/timerService';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { TimerService } from './vscode/src/vs/workbench/services/timer/browser/timerService.js';
+import { ITimerService } from 'vscode/vscode/vs/workbench/services/timer/browser/timerService.service';
 
 function getServiceOverride() {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-lifecycle-service-override",
-  "version": "4.4.1",
+  "version": "4.5.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -17,7 +17,15 @@
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js"
+    }
+  },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.4.1"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.5.0"
   }
 }

package/vscode/src/vs/workbench/services/lifecycle/browser/lifecycleService.js

@@ -1,10 +1,11 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { AbstractLifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycleService';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { addDisposableListener, EventType } from 'vscode/vscode/vs/base/browser/dom';
-import { IStorageService, WillSaveStateReason } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { WillSaveStateReason } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';

package/vscode/src/vs/workbench/services/timer/browser/timerService.js

@@ -0,0 +1,243 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { getMarks } from 'vscode/vscode/vs/base/common/performance';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IUpdateService } from 'vscode/vscode/vs/platform/update/common/update.service';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { Barrier, timeout } from 'vscode/vscode/vs/base/common/async';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
+import { TelemetryTrustedValue } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { createBlobWorker } from 'vscode/vscode/vs/base/browser/defaultWorkerFactory';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { TerminalExtensions } from 'vscode/vscode/vs/platform/terminal/common/terminal';
+
+class PerfMarks {
+    constructor() {
+        this._entries = [];
+    }
+    setMarks(source, entries) {
+        this._entries.push([source, entries]);
+    }
+    getDuration(from, to) {
+        const fromEntry = this._findEntry(from);
+        if (!fromEntry) {
+            return 0;
+        }
+        const toEntry = this._findEntry(to);
+        if (!toEntry) {
+            return 0;
+        }
+        return toEntry.startTime - fromEntry.startTime;
+    }
+    _findEntry(name) {
+        for (const [, marks] of this._entries) {
+            for (let i = marks.length - 1; i >= 0; i--) {
+                if (marks[i].name === name) {
+                    return marks[i];
+                }
+            }
+        }
+    }
+    getEntries() {
+        return this._entries.slice(0);
+    }
+}
+let AbstractTimerService = class AbstractTimerService {
+    constructor(_lifecycleService, _contextService, _extensionService, _updateService, _paneCompositeService, _editorService, _accessibilityService, _telemetryService, layoutService) {
+        this._lifecycleService = _lifecycleService;
+        this._contextService = _contextService;
+        this._extensionService = _extensionService;
+        this._updateService = _updateService;
+        this._paneCompositeService = _paneCompositeService;
+        this._editorService = _editorService;
+        this._accessibilityService = _accessibilityService;
+        this._telemetryService = _telemetryService;
+        this._barrier = ( new Barrier());
+        this._marks = ( new PerfMarks());
+        this._rndValueShouldSendTelemetry = Math.random() < .05;
+        Promise.all([
+            this._extensionService.whenInstalledExtensionsRegistered(),
+            _lifecycleService.when(3 ),
+            layoutService.whenRestored,
+            Promise.all(( Array.from(( ( Registry.as(TerminalExtensions.Backend)).backends.values())).map(e => e.whenReady)))
+        ]).then(() => {
+            this.setPerformanceMarks('renderer', getMarks());
+            return this._computeStartupMetrics();
+        }).then(metrics => {
+            this._startupMetrics = metrics;
+            this._reportStartupTimes(metrics);
+            this._barrier.open();
+        });
+        this.perfBaseline = this._barrier.wait()
+            .then(() => this._lifecycleService.when(4 ))
+            .then(() => timeout(this._startupMetrics.timers.ellapsedRequire))
+            .then(() => {
+            const jsSrc = ( (function () {
+                let tooSlow = false;
+                function fib(n) {
+                    if (tooSlow) {
+                        return 0;
+                    }
+                    if (performance.now() - t1 >= 1000) {
+                        tooSlow = true;
+                    }
+                    if (n <= 2) {
+                        return n;
+                    }
+                    return fib(n - 1) + fib(n - 2);
+                }
+                const t1 = performance.now();
+                fib(24);
+                const value = Math.round(performance.now() - t1);
+                postMessage({ value: tooSlow ? -1 : value });
+            }).toString());
+            const blob = ( new Blob([`(${jsSrc})();`], { type: 'application/javascript' }));
+            const blobUrl = URL.createObjectURL(blob);
+            const worker = createBlobWorker(blobUrl, { name: 'perfBaseline' });
+            return ( new Promise(resolve => {
+                worker.onmessage = e => resolve(e.data.value);
+            })).finally(() => {
+                worker.terminate();
+                URL.revokeObjectURL(blobUrl);
+            });
+        });
+    }
+    whenReady() {
+        return this._barrier.wait();
+    }
+    get startupMetrics() {
+        if (!this._startupMetrics) {
+            throw new Error('illegal state, MUST NOT access startupMetrics before whenReady has resolved');
+        }
+        return this._startupMetrics;
+    }
+    setPerformanceMarks(source, marks) {
+        const codeMarks = marks.filter(mark => mark.name.startsWith('code/'));
+        this._marks.setMarks(source, codeMarks);
+        this._reportPerformanceMarks(source, codeMarks);
+    }
+    getPerformanceMarks() {
+        return this._marks.getEntries();
+    }
+    getDuration(from, to) {
+        return this._marks.getDuration(from, to);
+    }
+    _reportStartupTimes(metrics) {
+        this._telemetryService.publicLog('startupTimeVaried', metrics);
+    }
+    _shouldReportPerfMarks() {
+        return this._rndValueShouldSendTelemetry;
+    }
+    _reportPerformanceMarks(source, marks) {
+        if (!this._shouldReportPerfMarks()) {
+            return;
+        }
+        for (const mark of marks) {
+            this._telemetryService.publicLog2('startup.timer.mark', {
+                source,
+                name: ( new TelemetryTrustedValue(mark.name)),
+                startTime: mark.startTime
+            });
+        }
+    }
+    async _computeStartupMetrics() {
+        const initialStartup = this._isInitialStartup();
+        let startMark;
+        if (isWeb) {
+            startMark = 'code/timeOrigin';
+        }
+        else {
+            startMark = initialStartup ? 'code/didStartMain' : 'code/willOpenNewWindow';
+        }
+        const activeViewlet = this._paneCompositeService.getActivePaneComposite(0 );
+        const activePanel = this._paneCompositeService.getActivePaneComposite(1 );
+        const info = {
+            version: 2,
+            ellapsed: this._marks.getDuration(startMark, 'code/didStartWorkbench'),
+            isLatestVersion: Boolean(await this._updateService.isLatestVersion()),
+            didUseCachedData: this._didUseCachedData(),
+            windowKind: this._lifecycleService.startupKind,
+            windowCount: await this._getWindowCount(),
+            viewletId: activeViewlet?.getId(),
+            editorIds: ( this._editorService.visibleEditors.map(input => input.typeId)),
+            panelId: activePanel ? activePanel.getId() : undefined,
+            timers: {
+                ellapsedAppReady: initialStartup ? this._marks.getDuration('code/didStartMain', 'code/mainAppReady') : undefined,
+                ellapsedNlsGeneration: initialStartup ? this._marks.getDuration('code/willGenerateNls', 'code/didGenerateNls') : undefined,
+                ellapsedLoadMainBundle: initialStartup ? this._marks.getDuration('code/willLoadMainBundle', 'code/didLoadMainBundle') : undefined,
+                ellapsedCrashReporter: initialStartup ? this._marks.getDuration('code/willStartCrashReporter', 'code/didStartCrashReporter') : undefined,
+                ellapsedMainServer: initialStartup ? this._marks.getDuration('code/willStartMainServer', 'code/didStartMainServer') : undefined,
+                ellapsedWindowCreate: initialStartup ? this._marks.getDuration('code/willCreateCodeWindow', 'code/didCreateCodeWindow') : undefined,
+                ellapsedWindowRestoreState: initialStartup ? this._marks.getDuration('code/willRestoreCodeWindowState', 'code/didRestoreCodeWindowState') : undefined,
+                ellapsedBrowserWindowCreate: initialStartup ? this._marks.getDuration('code/willCreateCodeBrowserWindow', 'code/didCreateCodeBrowserWindow') : undefined,
+                ellapsedWindowMaximize: initialStartup ? this._marks.getDuration('code/willMaximizeCodeWindow', 'code/didMaximizeCodeWindow') : undefined,
+                ellapsedWindowLoad: initialStartup ? this._marks.getDuration('code/mainAppReady', 'code/willOpenNewWindow') : undefined,
+                ellapsedWindowLoadToRequire: this._marks.getDuration('code/willOpenNewWindow', 'code/willLoadWorkbenchMain'),
+                ellapsedRequire: this._marks.getDuration('code/willLoadWorkbenchMain', 'code/didLoadWorkbenchMain'),
+                ellapsedWaitForWindowConfig: this._marks.getDuration('code/willWaitForWindowConfig', 'code/didWaitForWindowConfig'),
+                ellapsedStorageInit: this._marks.getDuration('code/willInitStorage', 'code/didInitStorage'),
+                ellapsedSharedProcesConnected: this._marks.getDuration('code/willConnectSharedProcess', 'code/didConnectSharedProcess'),
+                ellapsedWorkspaceServiceInit: this._marks.getDuration('code/willInitWorkspaceService', 'code/didInitWorkspaceService'),
+                ellapsedRequiredUserDataInit: this._marks.getDuration('code/willInitRequiredUserData', 'code/didInitRequiredUserData'),
+                ellapsedOtherUserDataInit: this._marks.getDuration('code/willInitOtherUserData', 'code/didInitOtherUserData'),
+                ellapsedExtensions: this._marks.getDuration('code/willLoadExtensions', 'code/didLoadExtensions'),
+                ellapsedEditorRestore: this._marks.getDuration('code/willRestoreEditors', 'code/didRestoreEditors'),
+                ellapsedViewletRestore: this._marks.getDuration('code/willRestoreViewlet', 'code/didRestoreViewlet'),
+                ellapsedPanelRestore: this._marks.getDuration('code/willRestorePanel', 'code/didRestorePanel'),
+                ellapsedWorkbenchContributions: this._marks.getDuration('code/willCreateWorkbenchContributions/1', 'code/didCreateWorkbenchContributions/2'),
+                ellapsedWorkbench: this._marks.getDuration('code/willStartWorkbench', 'code/didStartWorkbench'),
+                ellapsedExtensionsReady: this._marks.getDuration(startMark, 'code/didLoadExtensions'),
+                ellapsedRenderer: this._marks.getDuration('code/didStartRenderer', 'code/didStartWorkbench')
+            },
+            platform: undefined,
+            release: undefined,
+            arch: undefined,
+            totalmem: undefined,
+            freemem: undefined,
+            meminfo: undefined,
+            cpus: undefined,
+            loadavg: undefined,
+            isVMLikelyhood: undefined,
+            initialStartup,
+            hasAccessibilitySupport: this._accessibilityService.isScreenReaderOptimized(),
+            emptyWorkbench: this._contextService.getWorkbenchState() === 1
+        };
+        await this._extendStartupInfo(info);
+        return info;
+    }
+};
+AbstractTimerService = ( __decorate([
+    ( __param(0, ILifecycleService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, IUpdateService)),
+    ( __param(4, IPaneCompositePartService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IAccessibilityService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IWorkbenchLayoutService))
+], AbstractTimerService));
+class TimerService extends AbstractTimerService {
+    _isInitialStartup() {
+        return false;
+    }
+    _didUseCachedData() {
+        return false;
+    }
+    async _getWindowCount() {
+        return 1;
+    }
+    async _extendStartupInfo(info) {
+        info.isVMLikelyhood = 0;
+        info.isARM64Emulated = false;
+        info.platform = navigator.userAgent;
+        info.release = navigator.appVersion;
+    }
+}
+
+export { AbstractTimerService, TimerService };