@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

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

@@ -1,166 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-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 { 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';
-import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
-import { IViewsService } from '../../../common/views.js';
-import { IOutputChannelModelService } from '../common/outputChannelModelService.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.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, lifecycleService, viewsService, contextKeyService) {
-        super();
-        this.storageService = storageService;
-        this.instantiationService = instantiationService;
-        this.logService = logService;
-        this.lifecycleService = lifecycleService;
-        this.viewsService = viewsService;
-        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.activeLogOutputChannelContext = CONTEXT_ACTIVE_LOG_OUTPUT.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.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 channelDisposables = [];
-        const channel = this.instantiateChannel(id);
-        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);
-            dispose(channelDisposables);
-        }, channelDisposables);
-        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);
-    }
-    setActiveChannel(channel) {
-        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 , 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, ILifecycleService)),
-    ( __param(5, IViewsService)),
-    ( __param(6, IContextKeyService))
-], OutputService));
-export { OutputService };

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

@@ -1,234 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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.localizeWithPath(
-            'vs/workbench/contrib/output/browser/outputView',
-            'output model title',
-            "{0} - Output",
-            channel.label
-        )), ( nls.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, 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.localizeWithPath('vs/workbench/contrib/output/browser/outputView', '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.localizeWithPath(
-            'vs/workbench/contrib/output/browser/outputView',
-            '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 };