@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/output/browser/output.contribution.js

@@ -0,0 +1,378 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as aria from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { ModesRegistry } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { registerAction2, Action2, MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { LogContentProvider } from './outputServices.js';
+import { OUTPUT_MODE_ID, OUTPUT_MIME, LOG_MODE_ID, LOG_MIME, OUTPUT_VIEW_ID, LOG_SCHEME, IOutputService, CONTEXT_IN_OUTPUT, CONTEXT_OUTPUT_SCROLL_LOCK, CONTEXT_ACTIVE_LOG_OUTPUT, ACTIVE_OUTPUT_CHANNEL_CONTEXT, Extensions as Extensions$3 } from '../../../services/output/common/output.js';
+import { OutputViewPane } from './outputView.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { LogViewer, LogViewerInput } from './logViewer.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Extensions as Extensions$1 } from '../../../common/contributions.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { Extensions, IViewsService } from '../../../common/views.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { Disposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+ModesRegistry.registerLanguage({
+    id: OUTPUT_MODE_ID,
+    extensions: [],
+    mimetypes: [OUTPUT_MIME]
+});
+ModesRegistry.registerLanguage({
+    id: LOG_MODE_ID,
+    extensions: [],
+    mimetypes: [LOG_MIME]
+});
+const outputViewIcon = registerIcon('output-view-icon', Codicon.output, ( nls.localize('outputViewIcon', 'View icon of the output view.')));
+const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+    id: OUTPUT_VIEW_ID,
+    title: ( nls.localize('output', "Output")),
+    icon: outputViewIcon,
+    order: 1,
+    ctorDescriptor: ( new SyncDescriptor(
+        ViewPaneContainer,
+        [OUTPUT_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
+    )),
+    storageId: OUTPUT_VIEW_ID,
+    hideIfEmpty: true,
+}, 1 , { doNotRegisterOpenCommand: true });
+( Registry.as(Extensions.ViewsRegistry)).registerViews([{
+        id: OUTPUT_VIEW_ID,
+        name: ( nls.localize('output', "Output")),
+        containerIcon: outputViewIcon,
+        canMoveView: true,
+        canToggleVisibility: false,
+        ctorDescriptor: ( new SyncDescriptor(OutputViewPane)),
+        openCommandActionDescriptor: {
+            id: 'workbench.action.output.toggleOutput',
+            mnemonicTitle: ( nls.localize({ key: 'miToggleOutput', comment: ['&& denotes a mnemonic'] }, "&&Output")),
+            keybindings: {
+                primary: 2048  | 1024  | 51 ,
+                linux: {
+                    primary: KeyChord(2048  | 41 , 2048  | 38 )
+                }
+            },
+            order: 1,
+        }
+    }], VIEW_CONTAINER);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(LogViewer, LogViewer.LOG_VIEWER_EDITOR_ID, ( nls.localize('logViewer', "Log Viewer"))), [
+    ( new SyncDescriptor(LogViewerInput))
+]);
+let OutputContribution = class OutputContribution extends Disposable {
+    constructor(instantiationService, textModelService, outputService) {
+        super();
+        this.outputService = outputService;
+        textModelService.registerTextModelContentProvider(LOG_SCHEME, instantiationService.createInstance(LogContentProvider));
+        this.registerActions();
+    }
+    registerActions() {
+        this.registerSwitchOutputAction();
+        this.registerShowOutputChannelsAction();
+        this.registerClearOutputAction();
+        this.registerToggleAutoScrollAction();
+        this.registerOpenActiveLogOutputFileAction();
+        this.registerShowLogsAction();
+        this.registerOpenLogFileAction();
+    }
+    registerSwitchOutputAction() {
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.output.action.switchBetweenOutputs`,
+                    title: ( nls.localize('switchBetweenOutputs.label', "Switch Output")),
+                });
+            }
+            async run(accessor, channelId) {
+                if (channelId) {
+                    accessor.get(IOutputService).showChannel(channelId, true);
+                }
+            }
+        }));
+        const switchOutputMenu = ( new MenuId('workbench.output.menu.switchOutput'));
+        this._register(MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+            submenu: switchOutputMenu,
+            title: ( nls.localize('switchToOutput.label', "Switch Output")),
+            group: 'navigation',
+            when: ( ContextKeyExpr.equals('view', OUTPUT_VIEW_ID)),
+            order: 1,
+            isSelection: true
+        }));
+        const registeredChannels = ( new Map());
+        this._register(toDisposable(() => dispose(( registeredChannels.values()))));
+        const registerOutputChannels = (channels) => {
+            for (const channel of channels) {
+                const title = channel.label;
+                const group = channel.extensionId ? '0_ext_outputchannels' : '1_core_outputchannels';
+                registeredChannels.set(channel.id, registerAction2(class extends Action2 {
+                    constructor() {
+                        super({
+                            id: `workbench.action.output.show.${channel.id}`,
+                            title,
+                            toggled: ( ACTIVE_OUTPUT_CHANNEL_CONTEXT.isEqualTo(channel.id)),
+                            menu: {
+                                id: switchOutputMenu,
+                                group,
+                            }
+                        });
+                    }
+                    async run(accessor) {
+                        return accessor.get(IOutputService).showChannel(channel.id, true);
+                    }
+                }));
+            }
+        };
+        registerOutputChannels(this.outputService.getChannelDescriptors());
+        const outputChannelRegistry = ( Registry.as(Extensions$3.OutputChannels));
+        this._register(outputChannelRegistry.onDidRegisterChannel(e => {
+            const channel = this.outputService.getChannelDescriptor(e);
+            if (channel) {
+                registerOutputChannels([channel]);
+            }
+        }));
+        this._register(outputChannelRegistry.onDidRemoveChannel(e => {
+            registeredChannels.get(e)?.dispose();
+            registeredChannels.delete(e);
+        }));
+    }
+    registerShowOutputChannelsAction() {
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.showOutputChannels',
+                    title: { value: ( nls.localize('showOutputChannels', "Show Output Channels...")), original: 'Show Output Channels...' },
+                    category: { value: ( nls.localize('output', "Output")), original: 'Output' },
+                    f1: true
+                });
+            }
+            async run(accessor) {
+                const outputService = accessor.get(IOutputService);
+                const quickInputService = accessor.get(IQuickInputService);
+                const extensionChannels = [], coreChannels = [];
+                for (const channel of outputService.getChannelDescriptors()) {
+                    if (channel.extensionId) {
+                        extensionChannels.push(channel);
+                    }
+                    else {
+                        coreChannels.push(channel);
+                    }
+                }
+                const entries = [];
+                for (const { id, label } of extensionChannels) {
+                    entries.push({ id, label });
+                }
+                if (extensionChannels.length && coreChannels.length) {
+                    entries.push({ type: 'separator' });
+                }
+                for (const { id, label } of coreChannels) {
+                    entries.push({ id, label });
+                }
+                const entry = await quickInputService.pick(entries, { placeHolder: ( nls.localize('selectOutput', "Select Output Channel")) });
+                if (entry) {
+                    return outputService.showChannel(entry.id);
+                }
+            }
+        }));
+    }
+    registerClearOutputAction() {
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.output.action.clearOutput`,
+                    title: { value: ( nls.localize('clearOutput.label', "Clear Output")), original: 'Clear Output' },
+                    category: Categories.View,
+                    menu: [{
+                            id: MenuId.ViewTitle,
+                            when: ( ContextKeyExpr.equals('view', OUTPUT_VIEW_ID)),
+                            group: 'navigation',
+                            order: 2
+                        }, {
+                            id: MenuId.CommandPalette
+                        }, {
+                            id: MenuId.EditorContext,
+                            when: CONTEXT_IN_OUTPUT
+                        }],
+                    icon: Codicon.clearAll
+                });
+            }
+            async run(accessor) {
+                const outputService = accessor.get(IOutputService);
+                const activeChannel = outputService.getActiveChannel();
+                if (activeChannel) {
+                    activeChannel.clear();
+                    aria.status(( nls.localize('outputCleared', "Output was cleared")));
+                }
+            }
+        }));
+    }
+    registerToggleAutoScrollAction() {
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.output.action.toggleAutoScroll`,
+                    title: { value: ( nls.localize('toggleAutoScroll', "Toggle Auto Scrolling")), original: 'Toggle Auto Scrolling' },
+                    tooltip: ( nls.localize('outputScrollOff', "Turn Auto Scrolling Off")),
+                    menu: {
+                        id: MenuId.ViewTitle,
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', OUTPUT_VIEW_ID)))),
+                        group: 'navigation',
+                        order: 3,
+                    },
+                    icon: Codicon.lock,
+                    toggled: {
+                        condition: CONTEXT_OUTPUT_SCROLL_LOCK,
+                        icon: Codicon.unlock,
+                        tooltip: ( nls.localize('outputScrollOn', "Turn Auto Scrolling On"))
+                    }
+                });
+            }
+            async run(accessor) {
+                const outputView = accessor.get(IViewsService).getActiveViewWithId(OUTPUT_VIEW_ID);
+                outputView.scrollLock = !outputView.scrollLock;
+            }
+        }));
+    }
+    registerOpenActiveLogOutputFileAction() {
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.action.openActiveLogOutputFile`,
+                    title: { value: ( nls.localize('openActiveLogOutputFile', "Open Log Output File")), original: 'Open Log Output File' },
+                    menu: [{
+                            id: MenuId.ViewTitle,
+                            when: ( ContextKeyExpr.equals('view', OUTPUT_VIEW_ID)),
+                            group: 'navigation',
+                            order: 4
+                        }],
+                    icon: Codicon.goToFile,
+                    precondition: CONTEXT_ACTIVE_LOG_OUTPUT
+                });
+            }
+            async run(accessor) {
+                const outputService = accessor.get(IOutputService);
+                const editorService = accessor.get(IEditorService);
+                const instantiationService = accessor.get(IInstantiationService);
+                const logFileOutputChannelDescriptor = this.getLogFileOutputChannelDescriptor(outputService);
+                if (logFileOutputChannelDescriptor) {
+                    await editorService.openEditor(instantiationService.createInstance(LogViewerInput, logFileOutputChannelDescriptor), { pinned: true });
+                }
+            }
+            getLogFileOutputChannelDescriptor(outputService) {
+                const channel = outputService.getActiveChannel();
+                if (channel) {
+                    const descriptor = outputService.getChannelDescriptors().filter(c => c.id === channel.id)[0];
+                    if (descriptor && descriptor.file && descriptor.log) {
+                        return descriptor;
+                    }
+                }
+                return null;
+            }
+        }));
+    }
+    registerShowLogsAction() {
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.showLogs',
+                    title: { value: ( nls.localize('showLogs', "Show Logs...")), original: 'Show Logs...' },
+                    category: Categories.Developer,
+                    menu: {
+                        id: MenuId.CommandPalette,
+                    },
+                });
+            }
+            async run(accessor) {
+                const outputService = accessor.get(IOutputService);
+                const quickInputService = accessor.get(IQuickInputService);
+                const extensionLogs = [], logs = [];
+                for (const channel of outputService.getChannelDescriptors()) {
+                    if (channel.log) {
+                        if (channel.extensionId) {
+                            extensionLogs.push(channel);
+                        }
+                        else {
+                            logs.push(channel);
+                        }
+                    }
+                }
+                const entries = [];
+                for (const { id, label } of logs) {
+                    entries.push({ id, label });
+                }
+                if (extensionLogs.length && logs.length) {
+                    entries.push({ type: 'separator', label: ( nls.localize('extensionLogs', "Extension Logs")) });
+                }
+                for (const { id, label } of extensionLogs) {
+                    entries.push({ id, label });
+                }
+                const entry = await quickInputService.pick(entries, { placeHolder: ( nls.localize('selectlog', "Select Log")) });
+                if (entry) {
+                    return outputService.showChannel(entry.id);
+                }
+            }
+        }));
+    }
+    registerOpenLogFileAction() {
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openLogFile',
+                    title: { value: ( nls.localize('openLogFile', "Open Log File...")), original: 'Open Log File...' },
+                    category: Categories.Developer,
+                    menu: {
+                        id: MenuId.CommandPalette,
+                    },
+                });
+            }
+            async run(accessor) {
+                const outputService = accessor.get(IOutputService);
+                const quickInputService = accessor.get(IQuickInputService);
+                const instantiationService = accessor.get(IInstantiationService);
+                const editorService = accessor.get(IEditorService);
+                const entries = ( outputService.getChannelDescriptors().filter(c => c.file && c.log)
+                    .map(channel => ({ id: channel.id, label: channel.label, channel })));
+                const entry = await quickInputService.pick(entries, { placeHolder: ( nls.localize('selectlogFile', "Select Log file")) });
+                if (entry) {
+                    assertIsDefined(entry.channel.file);
+                    await editorService.openEditor(instantiationService.createInstance(LogViewerInput, entry.channel), { pinned: true });
+                }
+            }
+        }));
+    }
+};
+OutputContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, IOutputService))
+], OutputContribution));
+( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(OutputContribution, 3 );
+( Registry.as(Extensions$2.Configuration)).registerConfiguration({
+    id: 'output',
+    order: 30,
+    title: ( nls.localize('output', "Output")),
+    type: 'object',
+    properties: {
+        'output.smartScroll.enabled': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'output.smartScroll.enabled',
+                "Enable/disable the ability of smart scrolling in the output view. Smart scrolling allows you to lock scrolling automatically when you click in the output view and unlocks when you click in the last line."
+            )),
+            default: true,
+            scope: 3 ,
+            tags: ['output']
+        }
+    }
+});

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

@@ -5,7 +5,7 @@ import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, OUTPUT_SCHEME, OUTPUT_VIEW_ID, Extensions, LOG_MIME, OUTPUT_MIME } from '../../../services/output/common/output.js';
+import { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, OUTPUT_SCHEME, OUTPUT_VIEW_ID, Extensions, LOG_MIME, OUTPUT_MIME, LOG_SCHEME, IOutputService } from '../../../services/output/common/output.js';
 import { OutputLinkProvider } from './outputLinkProvider.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
@@ -147,7 +147,7 @@ let OutputService = class OutputService extends Disposable {
         this.activeChannel = channel;
         this.activeLogOutputChannelContext.set(!!channel?.outputChannelDescriptor?.file && channel?.outputChannelDescriptor?.log);
         if (this.activeChannel) {
-            this.storageService.store(OUTPUT_ACTIVE_CHANNEL_KEY, this.activeChannel.id, 1 , 0 );
+            this.storageService.store(OUTPUT_ACTIVE_CHANNEL_KEY, this.activeChannel.id, 1 , 1 );
         }
         else {
             this.storageService.remove(OUTPUT_ACTIVE_CHANNEL_KEY, 1 );
@@ -163,4 +163,40 @@ OutputService = ( __decorate([
     ( __param(5, IViewsService)),
     ( __param(6, IContextKeyService))
 ], OutputService));
-export { OutputService };
+let LogContentProvider = class LogContentProvider {
+    constructor(outputService, outputChannelModelService, languageService) {
+        this.outputService = outputService;
+        this.outputChannelModelService = outputChannelModelService;
+        this.languageService = languageService;
+        this.channelModels = ( new Map());
+    }
+    provideTextContent(resource) {
+        if (resource.scheme === LOG_SCHEME) {
+            const channelModel = this.getChannelModel(resource);
+            if (channelModel) {
+                return channelModel.loadModel();
+            }
+        }
+        return null;
+    }
+    getChannelModel(resource) {
+        const channelId = resource.path;
+        let channelModel = this.channelModels.get(channelId);
+        if (!channelModel) {
+            const channelDisposables = [];
+            const outputChannelDescriptor = this.outputService.getChannelDescriptors().filter(({ id }) => id === channelId)[0];
+            if (outputChannelDescriptor && outputChannelDescriptor.file) {
+                channelModel = this.outputChannelModelService.createOutputChannelModel(channelId, resource, outputChannelDescriptor.languageId ? this.languageService.createById(outputChannelDescriptor.languageId) : this.languageService.createByMimeType(outputChannelDescriptor.log ? LOG_MIME : OUTPUT_MIME), outputChannelDescriptor.file);
+                channelModel.onDispose(() => dispose(channelDisposables), channelDisposables);
+                this.channelModels.set(channelId, channelModel);
+            }
+        }
+        return channelModel;
+    }
+};
+LogContentProvider = ( __decorate([
+    ( __param(0, IOutputService)),
+    ( __param(1, IOutputChannelModelService)),
+    ( __param(2, ILanguageService))
+], LogContentProvider));
+export { LogContentProvider, OutputService };

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

@@ -0,0 +1,220 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/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 { registerThemingParticipant, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/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 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { TextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
+import { editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { createCancelablePromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ResourceContextKey } from '../../../common/contextkeys.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.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, ( nls.localize('output model title', "{0} - Output", channel.label)), ( nls.localize('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, contextKeyService) {
+        super(OUTPUT_VIEW_ID, 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 ( nls.localize('output', "Output"));
+    }
+    getConfigurationOverrides() {
+        const options = super.getConfigurationOverrides();
+        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() : ( nls.localize('outputViewAriaLabel', "Output panel"));
+    }
+    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)),
+    ( __param(9, IContextKeyService))
+], OutputEditor));
+registerThemingParticipant((theme, collector) => {
+    const sidebarBackground = theme.getColor(SIDE_BAR_BACKGROUND);
+    if (sidebarBackground && sidebarBackground !== theme.getColor(editorBackground)) {
+        collector.addRule(`
+			.monaco-workbench .part.sidebar .output-view .monaco-editor,
+			.monaco-workbench .part.sidebar .output-view .monaco-editor .margin,
+			.monaco-workbench .part.sidebar .output-view .monaco-editor .monaco-editor-background {
+				background-color: ${sidebarBackground};
+			}
+		`);
+    }
+});
+export { OutputViewPane };