@codingame/monaco-vscode-api 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/output/browser/outputLinkProvider.js

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { OUTPUT_MODE_ID, LOG_MODE_ID } from '../../../services/output/common/output.js';
+import { createWebWorker } from '../../../../editor/browser/services/webWorker.js';
+import { dispose } from '../../../../base/common/lifecycle.js';
+import { ILanguageConfigurationService } from '../../../../editor/common/languages/languageConfigurationRegistry.js';
+import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.js';
+var OutputLinkProvider_1;
+let OutputLinkProvider = class OutputLinkProvider {
+    static { OutputLinkProvider_1 = this; }
+    static { this.DISPOSE_WORKER_TIME = 3 * 60 * 1000; }
+    constructor(contextService, modelService, languageConfigurationService, languageFeaturesService) {
+        this.contextService = contextService;
+        this.modelService = modelService;
+        this.languageConfigurationService = languageConfigurationService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.disposeWorkerScheduler = ( new RunOnceScheduler(() => this.disposeWorker(), OutputLinkProvider_1.DISPOSE_WORKER_TIME));
+        this.registerListeners();
+        this.updateLinkProviderWorker();
+    }
+    registerListeners() {
+        this.contextService.onDidChangeWorkspaceFolders(() => this.updateLinkProviderWorker());
+    }
+    updateLinkProviderWorker() {
+        const folders = this.contextService.getWorkspace().folders;
+        if (folders.length > 0) {
+            if (!this.linkProviderRegistration) {
+                this.linkProviderRegistration = this.languageFeaturesService.linkProvider.register([{ language: OUTPUT_MODE_ID, scheme: '*' }, { language: LOG_MODE_ID, scheme: '*' }], {
+                    provideLinks: async (model) => {
+                        const links = await this.provideLinks(model.uri);
+                        return links && { links };
+                    }
+                });
+            }
+        }
+        else {
+            dispose(this.linkProviderRegistration);
+            this.linkProviderRegistration = undefined;
+        }
+        this.disposeWorker();
+        this.disposeWorkerScheduler.cancel();
+    }
+    getOrCreateWorker() {
+        this.disposeWorkerScheduler.schedule();
+        if (!this.worker) {
+            const createData = {
+                workspaceFolders: ( this.contextService.getWorkspace().folders.map(folder => ( folder.uri.toString())))
+            };
+            this.worker = createWebWorker(this.modelService, this.languageConfigurationService, {
+                moduleId: 'vs/workbench/contrib/output/common/outputLinkComputer',
+                createData,
+                label: 'outputLinkComputer'
+            });
+        }
+        return this.worker;
+    }
+    async provideLinks(modelUri) {
+        const linkComputer = await this.getOrCreateWorker().withSyncedResources([modelUri]);
+        return linkComputer.computeLinks(( modelUri.toString()));
+    }
+    disposeWorker() {
+        if (this.worker) {
+            this.worker.dispose();
+            this.worker = undefined;
+        }
+    }
+};
+OutputLinkProvider = OutputLinkProvider_1 = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageConfigurationService)),
+    ( __param(3, ILanguageFeaturesService))
+], OutputLinkProvider));
+export { OutputLinkProvider };

package/vscode/src/vs/workbench/contrib/output/browser/outputServices.js

@@ -0,0 +1,200 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_FILE_OUTPUT, CONTEXT_ACTIVE_OUTPUT_LEVEL_SETTABLE, CONTEXT_ACTIVE_OUTPUT_LEVEL, CONTEXT_ACTIVE_OUTPUT_LEVEL_IS_DEFAULT, OUTPUT_SCHEME, OUTPUT_VIEW_ID, Extensions, LOG_MIME, OUTPUT_MIME } from '../../../services/output/common/output.js';
+import { OutputLinkProvider } from './outputLinkProvider.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { LogLevelToString, ILogService, ILoggerService } from '../../../../platform/log/common/log.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { IOutputChannelModelService } from '../common/outputChannelModelService.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { SetLogLevelAction } from '../../logs/common/logsActions.js';
+import { IDefaultLogLevelsService } from '../../logs/common/defaultLogLevels.js';
+const OUTPUT_ACTIVE_CHANNEL_KEY = 'output.activechannel';
+let OutputChannel = class OutputChannel extends Disposable {
+    constructor(outputChannelDescriptor, outputChannelModelService, languageService) {
+        super();
+        this.outputChannelDescriptor = outputChannelDescriptor;
+        this.scrollLock = false;
+        this.id = outputChannelDescriptor.id;
+        this.label = outputChannelDescriptor.label;
+        this.uri = ( URI.from({ scheme: OUTPUT_SCHEME, path: this.id }));
+        this.model = this._register(outputChannelModelService.createOutputChannelModel(this.id, this.uri, outputChannelDescriptor.languageId ? languageService.createById(outputChannelDescriptor.languageId) : languageService.createByMimeType(outputChannelDescriptor.log ? LOG_MIME : OUTPUT_MIME), outputChannelDescriptor.file));
+    }
+    append(output) {
+        this.model.append(output);
+    }
+    update(mode, till) {
+        this.model.update(mode, till, true);
+    }
+    clear() {
+        this.model.clear();
+    }
+    replace(value) {
+        this.model.replace(value);
+    }
+};
+OutputChannel = ( __decorate([
+    ( __param(1, IOutputChannelModelService)),
+    ( __param(2, ILanguageService))
+], OutputChannel));
+let OutputService = class OutputService extends Disposable {
+    constructor(storageService, instantiationService, textModelResolverService, logService, loggerService, lifecycleService, viewsService, contextKeyService, defaultLogLevelsService) {
+        super();
+        this.storageService = storageService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.loggerService = loggerService;
+        this.lifecycleService = lifecycleService;
+        this.viewsService = viewsService;
+        this.defaultLogLevelsService = defaultLogLevelsService;
+        this.channels = ( new Map());
+        this._onActiveOutputChannel = this._register(( new Emitter()));
+        this.onActiveOutputChannel = this._onActiveOutputChannel.event;
+        this.activeChannelIdInStorage = this.storageService.get(OUTPUT_ACTIVE_CHANNEL_KEY, 1 , '');
+        this.activeOutputChannelContext = ACTIVE_OUTPUT_CHANNEL_CONTEXT.bindTo(contextKeyService);
+        this.activeOutputChannelContext.set(this.activeChannelIdInStorage);
+        this._register(this.onActiveOutputChannel(channel => this.activeOutputChannelContext.set(channel)));
+        this.activeFileOutputChannelContext = CONTEXT_ACTIVE_FILE_OUTPUT.bindTo(contextKeyService);
+        this.activeOutputChannelLevelSettableContext = CONTEXT_ACTIVE_OUTPUT_LEVEL_SETTABLE.bindTo(contextKeyService);
+        this.activeOutputChannelLevelContext = CONTEXT_ACTIVE_OUTPUT_LEVEL.bindTo(contextKeyService);
+        this.activeOutputChannelLevelIsDefaultContext = CONTEXT_ACTIVE_OUTPUT_LEVEL_IS_DEFAULT.bindTo(contextKeyService);
+        textModelResolverService.registerTextModelContentProvider(OUTPUT_SCHEME, this);
+        instantiationService.createInstance(OutputLinkProvider);
+        const registry = ( Registry.as(Extensions.OutputChannels));
+        for (const channelIdentifier of registry.getChannels()) {
+            this.onDidRegisterChannel(channelIdentifier.id);
+        }
+        this._register(registry.onDidRegisterChannel(this.onDidRegisterChannel, this));
+        if (!this.activeChannel) {
+            const channels = this.getChannelDescriptors();
+            this.setActiveChannel(channels && channels.length > 0 ? this.getChannel(channels[0].id) : undefined);
+        }
+        this._register(Event.filter(this.viewsService.onDidChangeViewVisibility, e => e.id === OUTPUT_VIEW_ID && e.visible)(() => {
+            if (this.activeChannel) {
+                this.viewsService.getActiveViewWithId(OUTPUT_VIEW_ID)?.showChannel(this.activeChannel, true);
+            }
+        }));
+        this._register(this.loggerService.onDidChangeLogLevel(_level => {
+            this.setLevelContext();
+            this.setLevelIsDefaultContext();
+        }));
+        this._register(this.defaultLogLevelsService.onDidChangeDefaultLogLevels(() => {
+            this.setLevelIsDefaultContext();
+        }));
+        this._register(this.lifecycleService.onDidShutdown(() => this.dispose()));
+    }
+    provideTextContent(resource) {
+        const channel = this.getChannel(resource.path);
+        if (channel) {
+            return channel.model.loadModel();
+        }
+        return null;
+    }
+    async showChannel(id, preserveFocus) {
+        const channel = this.getChannel(id);
+        if (this.activeChannel?.id !== channel?.id) {
+            this.setActiveChannel(channel);
+            this._onActiveOutputChannel.fire(id);
+        }
+        const outputView = await this.viewsService.openView(OUTPUT_VIEW_ID, !preserveFocus);
+        if (outputView && channel) {
+            outputView.showChannel(channel, !!preserveFocus);
+        }
+    }
+    getChannel(id) {
+        return this.channels.get(id);
+    }
+    getChannelDescriptor(id) {
+        return ( Registry.as(Extensions.OutputChannels)).getChannel(id);
+    }
+    getChannelDescriptors() {
+        return ( Registry.as(Extensions.OutputChannels)).getChannels();
+    }
+    getActiveChannel() {
+        return this.activeChannel;
+    }
+    async onDidRegisterChannel(channelId) {
+        const channel = this.createChannel(channelId);
+        this.channels.set(channelId, channel);
+        if (!this.activeChannel || this.activeChannelIdInStorage === channelId) {
+            this.setActiveChannel(channel);
+            this._onActiveOutputChannel.fire(channelId);
+            const outputView = this.viewsService.getActiveViewWithId(OUTPUT_VIEW_ID);
+            outputView?.showChannel(channel, true);
+        }
+    }
+    createChannel(id) {
+        const channel = this.instantiateChannel(id);
+        this._register(Event.once(channel.model.onDispose)(() => {
+            if (this.activeChannel === channel) {
+                const channels = this.getChannelDescriptors();
+                const channel = channels.length ? this.getChannel(channels[0].id) : undefined;
+                if (channel && this.viewsService.isViewVisible(OUTPUT_VIEW_ID)) {
+                    this.showChannel(channel.id);
+                }
+                else {
+                    this.setActiveChannel(undefined);
+                }
+            }
+            ( Registry.as(Extensions.OutputChannels)).removeChannel(id);
+        }));
+        return channel;
+    }
+    instantiateChannel(id) {
+        const channelData = ( Registry.as(Extensions.OutputChannels)).getChannel(id);
+        if (!channelData) {
+            this.logService.error(`Channel '${id}' is not registered yet`);
+            throw new Error(`Channel '${id}' is not registered yet`);
+        }
+        return this.instantiationService.createInstance(OutputChannel, channelData);
+    }
+    setLevelContext() {
+        const descriptor = this.activeChannel?.outputChannelDescriptor;
+        const channelLogLevel = descriptor?.log ? this.loggerService.getLogLevel(descriptor.file) : undefined;
+        this.activeOutputChannelLevelContext.set(channelLogLevel !== undefined ? LogLevelToString(channelLogLevel) : '');
+    }
+    async setLevelIsDefaultContext() {
+        const descriptor = this.activeChannel?.outputChannelDescriptor;
+        if (descriptor?.log) {
+            const channelLogLevel = this.loggerService.getLogLevel(descriptor.file);
+            const channelDefaultLogLevel = await this.defaultLogLevelsService.getDefaultLogLevel(descriptor.extensionId);
+            this.activeOutputChannelLevelIsDefaultContext.set(channelDefaultLogLevel === channelLogLevel);
+        }
+        else {
+            this.activeOutputChannelLevelIsDefaultContext.set(false);
+        }
+    }
+    setActiveChannel(channel) {
+        this.activeChannel = channel;
+        const descriptor = channel?.outputChannelDescriptor;
+        this.activeFileOutputChannelContext.set(!!descriptor?.file);
+        this.activeOutputChannelLevelSettableContext.set(descriptor !== undefined && SetLogLevelAction.isLevelSettable(descriptor));
+        this.setLevelIsDefaultContext();
+        this.setLevelContext();
+        if (this.activeChannel) {
+            this.storageService.store(OUTPUT_ACTIVE_CHANNEL_KEY, this.activeChannel.id, 1 , 1 );
+        }
+        else {
+            this.storageService.remove(OUTPUT_ACTIVE_CHANNEL_KEY, 1 );
+        }
+    }
+};
+OutputService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, ILogService)),
+    ( __param(4, ILoggerService)),
+    ( __param(5, ILifecycleService)),
+    ( __param(6, IViewsService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IDefaultLogLevelsService))
+], OutputService));
+export { OutputService };

package/vscode/src/vs/workbench/contrib/output/browser/outputView.js

@@ -0,0 +1,224 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './output.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { AbstractTextResourceEditor } from '../../../browser/parts/editor/textResourceEditor.js';
+import { CONTEXT_OUTPUT_SCROLL_LOCK, OUTPUT_VIEW_ID, CONTEXT_IN_OUTPUT } from '../../../services/output/common/output.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { TextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { Dimension } from '../../../../base/browser/dom.js';
+import { createCancelablePromise } from '../../../../base/common/async.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { ResourceContextKey } from '../../../common/contextkeys.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { computeEditorAriaLabel } from '../../../browser/editor.js';
+let OutputViewPane = class OutputViewPane extends ViewPane {
+    get scrollLock() { return !!this.scrollLockContextKey.get(); }
+    set scrollLock(scrollLock) { this.scrollLockContextKey.set(scrollLock); }
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.editorPromise = null;
+        this.scrollLockContextKey = CONTEXT_OUTPUT_SCROLL_LOCK.bindTo(this.contextKeyService);
+        const editorInstantiationService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
+        this.editor = editorInstantiationService.createInstance(OutputEditor);
+        this._register(this.editor.onTitleAreaUpdate(() => {
+            this.updateTitle(this.editor.getTitle());
+            this.updateActions();
+        }));
+        this._register(this.onDidChangeBodyVisibility(() => this.onDidChangeVisibility(this.isBodyVisible())));
+    }
+    showChannel(channel, preserveFocus) {
+        if (this.channelId !== channel.id) {
+            this.setInput(channel);
+        }
+        if (!preserveFocus) {
+            this.focus();
+        }
+    }
+    focus() {
+        super.focus();
+        this.editorPromise?.then(() => this.editor.focus());
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.editor.create(container);
+        container.classList.add('output-view');
+        const codeEditor = this.editor.getControl();
+        codeEditor.setAriaOptions({ role: 'document', activeDescendant: undefined });
+        this._register(codeEditor.onDidChangeModelContent(() => {
+            if (!this.scrollLock) {
+                this.editor.revealLastLine();
+            }
+        }));
+        this._register(codeEditor.onDidChangeCursorPosition((e) => {
+            if (e.reason !== 3 ) {
+                return;
+            }
+            if (!this.configurationService.getValue('output.smartScroll.enabled')) {
+                return;
+            }
+            const model = codeEditor.getModel();
+            if (model) {
+                const newPositionLine = e.position.lineNumber;
+                const lastLine = model.getLineCount();
+                this.scrollLock = lastLine !== newPositionLine;
+            }
+        }));
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.editor.layout(( new Dimension(width, height)));
+    }
+    onDidChangeVisibility(visible) {
+        this.editor.setVisible(visible);
+        if (!visible) {
+            this.clearInput();
+        }
+    }
+    setInput(channel) {
+        this.channelId = channel.id;
+        const input = this.createInput(channel);
+        if (!this.editor.input || !input.matches(this.editor.input)) {
+            this.editorPromise?.cancel();
+            this.editorPromise = createCancelablePromise(token => this.editor.setInput(this.createInput(channel), { preserveFocus: true }, Object.create(null), token)
+                .then(() => this.editor));
+        }
+    }
+    clearInput() {
+        this.channelId = undefined;
+        this.editor.clearInput();
+        this.editorPromise = null;
+    }
+    createInput(channel) {
+        return this.instantiationService.createInstance(TextResourceEditorInput, channel.uri, ( localizeWithPath(
+            'vs/workbench/contrib/output/browser/outputView',
+            'output model title',
+            "{0} - Output",
+            channel.label
+        )), ( localizeWithPath(
+            'vs/workbench/contrib/output/browser/outputView',
+            'channel',
+            "Output channel for '{0}'",
+            channel.label
+        )), undefined, undefined);
+    }
+};
+OutputViewPane = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService))
+], OutputViewPane));
+let OutputEditor = class OutputEditor extends AbstractTextResourceEditor {
+    constructor(telemetryService, instantiationService, storageService, configurationService, textResourceConfigurationService, themeService, editorGroupService, editorService, fileService) {
+        super(OUTPUT_VIEW_ID, editorGroupService.activeGroup , telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorGroupService, editorService, fileService);
+        this.configurationService = configurationService;
+        this.resourceContext = this._register(instantiationService.createInstance(ResourceContextKey));
+    }
+    getId() {
+        return OUTPUT_VIEW_ID;
+    }
+    getTitle() {
+        return ( localizeWithPath('vs/workbench/contrib/output/browser/outputView', 'output', "Output"));
+    }
+    getConfigurationOverrides(configuration) {
+        const options = super.getConfigurationOverrides(configuration);
+        options.wordWrap = 'on';
+        options.lineNumbers = 'off';
+        options.glyphMargin = false;
+        options.lineDecorationsWidth = 20;
+        options.rulers = [];
+        options.folding = false;
+        options.scrollBeyondLastLine = false;
+        options.renderLineHighlight = 'none';
+        options.minimap = { enabled: false };
+        options.renderValidationDecorations = 'editable';
+        options.padding = undefined;
+        options.readOnly = true;
+        options.domReadOnly = true;
+        options.unicodeHighlight = {
+            nonBasicASCII: false,
+            invisibleCharacters: false,
+            ambiguousCharacters: false,
+        };
+        const outputConfig = this.configurationService.getValue('[Log]');
+        if (outputConfig) {
+            if (outputConfig['editor.minimap.enabled']) {
+                options.minimap = { enabled: true };
+            }
+            if ('editor.wordWrap' in outputConfig) {
+                options.wordWrap = outputConfig['editor.wordWrap'];
+            }
+        }
+        return options;
+    }
+    getAriaLabel() {
+        return this.input ? this.input.getAriaLabel() : ( localizeWithPath(
+            'vs/workbench/contrib/output/browser/outputView',
+            'outputViewAriaLabel',
+            "Output panel"
+        ));
+    }
+    computeAriaLabel() {
+        return this.input ? computeEditorAriaLabel(this.input, undefined, undefined, this.editorGroupService.count) : this.getAriaLabel();
+    }
+    async setInput(input, options, context, token) {
+        const focus = !(options && options.preserveFocus);
+        if (this.input && input.matches(this.input)) {
+            return;
+        }
+        if (this.input) {
+            this.input.dispose();
+        }
+        await super.setInput(input, options, context, token);
+        this.resourceContext.set(input.resource);
+        if (focus) {
+            this.focus();
+        }
+        this.revealLastLine();
+    }
+    clearInput() {
+        if (this.input) {
+            this.input.dispose();
+        }
+        super.clearInput();
+        this.resourceContext.reset();
+    }
+    createEditor(parent) {
+        parent.setAttribute('role', 'document');
+        super.createEditor(parent);
+        const scopedContextKeyService = this.scopedContextKeyService;
+        if (scopedContextKeyService) {
+            CONTEXT_IN_OUTPUT.bindTo(scopedContextKeyService).set(true);
+        }
+    }
+};
+OutputEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ITextResourceConfigurationService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IEditorGroupsService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IFileService))
+], OutputEditor));
+export { OutputViewPane };

package/vscode/src/vs/workbench/contrib/performance/browser/inputLatencyContrib.js

@@ -0,0 +1,43 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { inputLatency } from '../../../../base/browser/performance.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+let InputLatencyContrib = class InputLatencyContrib extends Disposable {
+    constructor(_editorService, _telemetryService) {
+        super();
+        this._editorService = _editorService;
+        this._telemetryService = _telemetryService;
+        this._listener = this._register(( new MutableDisposable()));
+        this._scheduler = this._register(( new RunOnceScheduler(() => {
+            this._logSamples();
+            this._setupListener();
+        }, 60000)));
+        if (Math.random() <= 0.01) {
+            this._setupListener();
+        }
+    }
+    _setupListener() {
+        this._listener.value = Event.once(this._editorService.onDidActiveEditorChange)(() => this._scheduler.schedule());
+    }
+    _logSamples() {
+        const measurements = inputLatency.getAndClearMeasurements();
+        if (!measurements) {
+            return;
+        }
+        this._telemetryService.publicLog2('performance.inputLatency', {
+            keydown: measurements.keydown,
+            input: measurements.input,
+            render: measurements.render,
+            total: measurements.total,
+            sampleCount: measurements.sampleCount
+        });
+    }
+};
+InputLatencyContrib = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, ITelemetryService))
+], InputLatencyContrib));
+export { InputLatencyContrib };

package/vscode/src/vs/workbench/contrib/performance/browser/performance.contribution.js

@@ -0,0 +1,116 @@
+import { localize2WithPath } from '../../../../nls.js';
+import { registerAction2, Action2 } from '../../../../platform/actions/common/actions.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { registerWorkbenchContribution2, Extensions } from '../../../common/contributions.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { PerfviewContrib, PerfviewInput } from './perfviewEditor.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { InstantiationService, Trace } from '../../../../platform/instantiation/common/instantiationService.js';
+import { EventProfiling } from '../../../../base/common/event.js';
+import { InputLatencyContrib } from './inputLatencyContrib.js';
+registerWorkbenchContribution2(PerfviewContrib.ID, PerfviewContrib, { lazy: true });
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(PerfviewInput.Id, class {
+    canSerialize() {
+        return true;
+    }
+    serialize() {
+        return '';
+    }
+    deserialize(instantiationService) {
+        return instantiationService.createInstance(PerfviewInput);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'perfview.show',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/performance/browser/performance.contribution',
+                'show.label',
+                'Startup Performance'
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const contrib = PerfviewContrib.get();
+        return editorService.openEditor(contrib.getEditorInput(), { pinned: true });
+    }
+});
+registerAction2(class PrintServiceCycles extends Action2 {
+    constructor() {
+        super({
+            id: 'perf.insta.printAsyncCycles',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/performance/browser/performance.contribution',
+                'cycles',
+                'Print Service Cycles'
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        const instaService = accessor.get(IInstantiationService);
+        if (instaService instanceof InstantiationService) {
+            const cycle = instaService._globalGraph?.findCycleSlow();
+            if (cycle) {
+                console.warn(`CYCLE`, cycle);
+            }
+            else {
+                console.warn(`YEAH, no more cycles`);
+            }
+        }
+    }
+});
+registerAction2(class PrintServiceTraces extends Action2 {
+    constructor() {
+        super({
+            id: 'perf.insta.printTraces',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/performance/browser/performance.contribution',
+                'insta.trace',
+                'Print Service Traces'
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run() {
+        if (Trace.all.size === 0) {
+            console.log('Enable via `instantiationService.ts#_enableAllTracing`');
+            return;
+        }
+        for (const item of Trace.all) {
+            console.log(item);
+        }
+    }
+});
+registerAction2(class PrintEventProfiling extends Action2 {
+    constructor() {
+        super({
+            id: 'perf.event.profiling',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/performance/browser/performance.contribution',
+                'emitter',
+                'Print Emitter Profiles'
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run() {
+        if (EventProfiling.all.size === 0) {
+            console.log('USE `EmitterOptions._profName` to enable profiling');
+            return;
+        }
+        for (const item of EventProfiling.all) {
+            console.log(`${item.name}: ${item.invocationCount} invocations COST ${item.elapsedOverall}ms, ${item.listenerCount} listeners, avg cost is ${item.durations.reduce((a, b) => a + b, 0) / item.durations.length}ms`);
+        }
+    }
+});
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(InputLatencyContrib, 4 );

package/vscode/src/vs/workbench/contrib/performance/browser/performance.web.contribution.js

@@ -0,0 +1,5 @@
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { BrowserResourcePerformanceMarks, BrowserStartupTimings } from './startupTimings.js';
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BrowserResourcePerformanceMarks, 4 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BrowserStartupTimings, 4 );