@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/contrib/output/common/outputChannelModel.js

@@ -15,6 +15,7 @@ import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { ILogService, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { OutputChannelUpdateMode } from '../../../services/output/common/output.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
 class OutputFileListener extends Disposable {
     constructor(file, fileService, logService) {
         super();
@@ -36,7 +37,11 @@ class OutputFileListener extends Disposable {
     }
     poll() {
         const loop = () => this.doWatch().then(() => this.poll());
-        this.syncDelayer.trigger(loop);
+        this.syncDelayer.trigger(loop).catch(error => {
+            if (!isCancellationError(error)) {
+                throw error;
+            }
+        });
     }
     async doWatch() {
         const stat = await this.fileService.stat(this.file);
@@ -157,7 +162,7 @@ let FileOutputChannelModel = class FileOutputChannelModel extends Disposable {
     clearContent(model) {
         this.doUpdateModel(model, [EditOperation.delete(model.getFullModelRange())], VSBuffer.fromString(''));
     }
-    async appendContent(model, immediate, token) {
+    appendContent(model, immediate, token) {
         this.appendThrottler.trigger(async () => {
             if (token.isCancellationRequested) {
                 return;
@@ -179,7 +184,11 @@ let FileOutputChannelModel = class FileOutputChannelModel extends Disposable {
             const lastLineMaxColumn = model.getLineMaxColumn(lastLine);
             const edits = [EditOperation.insert(( new Position(lastLine, lastLineMaxColumn)), ( contentToAppend.toString()))];
             this.doUpdateModel(model, edits, contentToAppend);
-        }, immediate ? 0 : undefined);
+        }, immediate ? 0 : undefined).catch(error => {
+            if (!isCancellationError(error)) {
+                throw error;
+            }
+        });
     }
     async replaceContent(model, token) {
         const contentToReplace = await this.getContentToUpdate();

package/dist/vscode/vs/workbench/contrib/output/common/outputLinkComputer.js

@@ -0,0 +1,129 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import * as extpath from 'monaco-editor/esm/vs/base/common/extpath.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+class OutputLinkComputer {
+    constructor(ctx, createData) {
+        this.ctx = ctx;
+        this.patterns = ( new Map());
+        this.computePatterns(createData);
+    }
+    computePatterns(createData) {
+        const workspaceFolders = ( createData.workspaceFolders
+            .sort((resourceStrA, resourceStrB) => resourceStrB.length - resourceStrA.length)
+            .map(resourceStr => ( URI.parse(resourceStr))));
+        for (const workspaceFolder of workspaceFolders) {
+            const patterns = OutputLinkComputer.createPatterns(workspaceFolder);
+            this.patterns.set(workspaceFolder, patterns);
+        }
+    }
+    getModel(uri) {
+        const models = this.ctx.getMirrorModels();
+        return models.find(model => ( model.uri.toString()) === uri);
+    }
+    computeLinks(uri) {
+        const model = this.getModel(uri);
+        if (!model) {
+            return [];
+        }
+        const links = [];
+        const lines = strings.splitLines(model.getValue());
+        for (const [folderUri, folderPatterns] of this.patterns) {
+            const resourceCreator = {
+                toResource: (folderRelativePath) => {
+                    if (typeof folderRelativePath === 'string') {
+                        return resources.joinPath(folderUri, folderRelativePath);
+                    }
+                    return null;
+                }
+            };
+            for (let i = 0, len = lines.length; i < len; i++) {
+                links.push(...OutputLinkComputer.detectLinks(lines[i], i + 1, folderPatterns, resourceCreator));
+            }
+        }
+        return links;
+    }
+    static createPatterns(workspaceFolder) {
+        const patterns = [];
+        const workspaceFolderPath = workspaceFolder.scheme === Schemas.file ? workspaceFolder.fsPath : workspaceFolder.path;
+        const workspaceFolderVariants = [workspaceFolderPath];
+        if (isWindows && workspaceFolder.scheme === Schemas.file) {
+            workspaceFolderVariants.push(extpath.toSlashes(workspaceFolderPath));
+        }
+        for (const workspaceFolderVariant of workspaceFolderVariants) {
+            const validPathCharacterPattern = '[^\\s\\(\\):<>"]';
+            const validPathCharacterOrSpacePattern = `(?:${validPathCharacterPattern}| ${validPathCharacterPattern})`;
+            const pathPattern = `${validPathCharacterOrSpacePattern}+\\.${validPathCharacterPattern}+`;
+            const strictPathPattern = `${validPathCharacterPattern}+`;
+            patterns.push(( new RegExp(
+                strings.escapeRegExpCharacters(workspaceFolderVariant) + `(${pathPattern}) on line ((\\d+)(, column (\\d+))?)`,
+                'gi'
+            )));
+            patterns.push(( new RegExp(
+                strings.escapeRegExpCharacters(workspaceFolderVariant) + `(${pathPattern}):line ((\\d+)(, column (\\d+))?)`,
+                'gi'
+            )));
+            patterns.push(( new RegExp(
+                strings.escapeRegExpCharacters(workspaceFolderVariant) + `(${pathPattern})(\\s?\\((\\d+)(,(\\d+))?)\\)`,
+                'gi'
+            )));
+            patterns.push(( new RegExp(
+                strings.escapeRegExpCharacters(workspaceFolderVariant) + `(${strictPathPattern})(:(\\d+))?(:(\\d+))?`,
+                'gi'
+            )));
+        }
+        return patterns;
+    }
+    static detectLinks(line, lineIndex, patterns, resourceCreator) {
+        const links = [];
+        patterns.forEach(pattern => {
+            pattern.lastIndex = 0;
+            let match;
+            let offset = 0;
+            while ((match = pattern.exec(line)) !== null) {
+                const folderRelativePath = strings.rtrim(match[1], '.').replace(/\\/g, '/');
+                let resourceString;
+                try {
+                    const resource = resourceCreator.toResource(folderRelativePath);
+                    if (resource) {
+                        resourceString = ( resource.toString());
+                    }
+                }
+                catch (error) {
+                    continue;
+                }
+                if (match[3]) {
+                    const lineNumber = match[3];
+                    if (match[5]) {
+                        const columnNumber = match[5];
+                        resourceString = strings.format('{0}#{1},{2}', resourceString, lineNumber, columnNumber);
+                    }
+                    else {
+                        resourceString = strings.format('{0}#{1}', resourceString, lineNumber);
+                    }
+                }
+                const fullMatch = strings.rtrim(match[0], '.');
+                const index = line.indexOf(fullMatch, offset);
+                offset = index + fullMatch.length;
+                const linkRange = {
+                    startColumn: index + 1,
+                    startLineNumber: lineIndex,
+                    endColumn: index + 1 + fullMatch.length,
+                    endLineNumber: lineIndex
+                };
+                if (( links.some(link => Range.areIntersectingOrTouching(link.range, linkRange)))) {
+                    return;
+                }
+                links.push({
+                    range: linkRange,
+                    url: resourceString
+                });
+            }
+        });
+        return links;
+    }
+}
+export { OutputLinkComputer };

package/dist/vscode/vs/workbench/contrib/preferences/browser/keybindingWidgets.js

@@ -0,0 +1,270 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/keybindings.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { KeybindingLabel } from 'monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as aria from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { createFastDomNode } from 'monaco-editor/esm/vs/base/browser/fastDomNode.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { asCssVariable, editorWidgetBackground, editorWidgetForeground, widgetShadow } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { SearchWidget } from './preferencesWidgets.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Promises, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { defaultInputBoxStyles, defaultKeybindingLabelStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+let KeybindingsSearchWidget = class KeybindingsSearchWidget extends SearchWidget {
+    constructor(parent, options, contextViewService, instantiationService, contextKeyService, keybindingService) {
+        super(parent, options, contextViewService, instantiationService, contextKeyService, keybindingService);
+        this.recordDisposables = this._register(( new DisposableStore()));
+        this._onKeybinding = this._register(( new Emitter()));
+        this.onKeybinding = this._onKeybinding.event;
+        this._onEnter = this._register(( new Emitter()));
+        this.onEnter = this._onEnter.event;
+        this._onEscape = this._register(( new Emitter()));
+        this.onEscape = this._onEscape.event;
+        this._onBlur = this._register(( new Emitter()));
+        this.onBlur = this._onBlur.event;
+        this._register(toDisposable(() => this.stopRecordingKeys()));
+        this._chords = null;
+        this._inputValue = '';
+    }
+    clear() {
+        this._chords = null;
+        super.clear();
+    }
+    startRecordingKeys() {
+        this.recordDisposables.add(dom.addDisposableListener(this.inputBox.inputElement, dom.EventType.KEY_DOWN, (e) => this._onKeyDown(( new StandardKeyboardEvent(e)))));
+        this.recordDisposables.add(dom.addDisposableListener(this.inputBox.inputElement, dom.EventType.BLUR, () => this._onBlur.fire()));
+        this.recordDisposables.add(dom.addDisposableListener(this.inputBox.inputElement, dom.EventType.INPUT, () => {
+            this.setInputValue(this._inputValue);
+        }));
+    }
+    stopRecordingKeys() {
+        this._chords = null;
+        this.recordDisposables.clear();
+    }
+    setInputValue(value) {
+        this._inputValue = value;
+        this.inputBox.value = this._inputValue;
+    }
+    _onKeyDown(keyboardEvent) {
+        keyboardEvent.preventDefault();
+        keyboardEvent.stopPropagation();
+        const options = this.options;
+        if (!options.recordEnter && keyboardEvent.equals(3 )) {
+            this._onEnter.fire();
+            return;
+        }
+        if (keyboardEvent.equals(9 )) {
+            this._onEscape.fire();
+            return;
+        }
+        this.printKeybinding(keyboardEvent);
+    }
+    printKeybinding(keyboardEvent) {
+        const keybinding = this.keybindingService.resolveKeyboardEvent(keyboardEvent);
+        const info = `code: ${keyboardEvent.browserEvent.code}, keyCode: ${keyboardEvent.browserEvent.keyCode}, key: ${keyboardEvent.browserEvent.key} => UI: ${keybinding.getAriaLabel()}, user settings: ${keybinding.getUserSettingsLabel()}, dispatch: ${keybinding.getDispatchChords()[0]}`;
+        const options = this.options;
+        if (!this._chords) {
+            this._chords = [];
+        }
+        const hasIncompleteChord = this._chords.length > 0 && this._chords[this._chords.length - 1].getDispatchChords()[0] === null;
+        if (hasIncompleteChord) {
+            this._chords[this._chords.length - 1] = keybinding;
+        }
+        else {
+            if (this._chords.length === 2) {
+                this._chords = [];
+            }
+            this._chords.push(keybinding);
+        }
+        const value = ( this._chords.map((keybinding) => keybinding.getUserSettingsLabel() || '')).join(' ');
+        this.setInputValue(options.quoteRecordedKeys ? `"${value}"` : value);
+        this.inputBox.inputElement.title = info;
+        this._onKeybinding.fire(this._chords);
+    }
+};
+KeybindingsSearchWidget = ( __decorate([
+    ( __param(2, IContextViewService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IKeybindingService))
+], KeybindingsSearchWidget));
+let DefineKeybindingWidget = class DefineKeybindingWidget extends Widget {
+    constructor(parent, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this._chords = null;
+        this._isVisible = false;
+        this._onHide = this._register(( new Emitter()));
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onShowExistingKeybindings = this._register(( new Emitter()));
+        this.onShowExistingKeybidings = this._onShowExistingKeybindings.event;
+        this._domNode = createFastDomNode(document.createElement('div'));
+        this._domNode.setDisplay('none');
+        this._domNode.setClassName('defineKeybindingWidget');
+        this._domNode.setWidth(DefineKeybindingWidget.WIDTH);
+        this._domNode.setHeight(DefineKeybindingWidget.HEIGHT);
+        const message = ( nls.localize(
+            'defineKeybinding.initial',
+            "Press desired key combination and then press ENTER."
+        ));
+        dom.append(this._domNode.domNode, dom.$('.message', undefined, message));
+        this._domNode.domNode.style.backgroundColor = asCssVariable(editorWidgetBackground);
+        this._domNode.domNode.style.color = asCssVariable(editorWidgetForeground);
+        this._domNode.domNode.style.boxShadow = `0 2px 8px ${asCssVariable(widgetShadow)}`;
+        this._keybindingInputWidget = this._register(this.instantiationService.createInstance(KeybindingsSearchWidget, this._domNode.domNode, { ariaLabel: message, history: [], inputBoxStyles: defaultInputBoxStyles }));
+        this._keybindingInputWidget.startRecordingKeys();
+        this._register(this._keybindingInputWidget.onKeybinding(keybinding => this.onKeybinding(keybinding)));
+        this._register(this._keybindingInputWidget.onEnter(() => this.hide()));
+        this._register(this._keybindingInputWidget.onEscape(() => this.clearOrHide()));
+        this._register(this._keybindingInputWidget.onBlur(() => this.onCancel()));
+        this._outputNode = dom.append(this._domNode.domNode, dom.$('.output'));
+        this._showExistingKeybindingsNode = dom.append(this._domNode.domNode, dom.$('.existing'));
+        if (parent) {
+            dom.append(parent, this._domNode.domNode);
+        }
+    }
+    get domNode() {
+        return this._domNode.domNode;
+    }
+    define() {
+        this._keybindingInputWidget.clear();
+        return Promises.withAsyncBody(async (c) => {
+            if (!this._isVisible) {
+                this._isVisible = true;
+                this._domNode.setDisplay('block');
+                this._chords = null;
+                this._keybindingInputWidget.setInputValue('');
+                dom.clearNode(this._outputNode);
+                dom.clearNode(this._showExistingKeybindingsNode);
+                await timeout(0);
+                this._keybindingInputWidget.focus();
+            }
+            const disposable = this._onHide.event(() => {
+                c(this.getUserSettingsLabel());
+                disposable.dispose();
+            });
+        });
+    }
+    layout(layout) {
+        const top = Math.round((layout.height - DefineKeybindingWidget.HEIGHT) / 2);
+        this._domNode.setTop(top);
+        const left = Math.round((layout.width - DefineKeybindingWidget.WIDTH) / 2);
+        this._domNode.setLeft(left);
+    }
+    printExisting(numberOfExisting) {
+        if (numberOfExisting > 0) {
+            const existingElement = dom.$('span.existingText');
+            const text = numberOfExisting === 1 ? ( nls.localize(
+                'defineKeybinding.oneExists',
+                "1 existing command has this keybinding",
+                numberOfExisting
+            )) : ( nls.localize(
+                'defineKeybinding.existing',
+                "{0} existing commands have this keybinding",
+                numberOfExisting
+            ));
+            dom.append(existingElement, document.createTextNode(text));
+            aria.alert(text);
+            this._showExistingKeybindingsNode.appendChild(existingElement);
+            existingElement.onmousedown = (e) => { e.preventDefault(); };
+            existingElement.onmouseup = (e) => { e.preventDefault(); };
+            existingElement.onclick = () => { this._onShowExistingKeybindings.fire(this.getUserSettingsLabel()); };
+        }
+    }
+    onKeybinding(keybinding) {
+        this._chords = keybinding;
+        dom.clearNode(this._outputNode);
+        dom.clearNode(this._showExistingKeybindingsNode);
+        const firstLabel = ( new KeybindingLabel(this._outputNode, OS, defaultKeybindingLabelStyles));
+        firstLabel.set(withNullAsUndefined(this._chords?.[0]));
+        if (this._chords) {
+            for (let i = 1; i < this._chords.length; i++) {
+                this._outputNode.appendChild(document.createTextNode(( nls.localize('defineKeybinding.chordsTo', "chord to"))));
+                const chordLabel = ( new KeybindingLabel(this._outputNode, OS, defaultKeybindingLabelStyles));
+                chordLabel.set(this._chords[i]);
+            }
+        }
+        const label = this.getUserSettingsLabel();
+        if (label) {
+            this._onDidChange.fire(label);
+        }
+    }
+    getUserSettingsLabel() {
+        let label = null;
+        if (this._chords) {
+            label = ( this._chords.map(keybinding => keybinding.getUserSettingsLabel())).join(' ');
+        }
+        return label;
+    }
+    onCancel() {
+        this._chords = null;
+        this.hide();
+    }
+    clearOrHide() {
+        if (this._chords === null) {
+            this.hide();
+        }
+        else {
+            this._chords = null;
+            this._keybindingInputWidget.clear();
+            dom.clearNode(this._outputNode);
+            dom.clearNode(this._showExistingKeybindingsNode);
+        }
+    }
+    hide() {
+        this._domNode.setDisplay('none');
+        this._isVisible = false;
+        this._onHide.fire();
+    }
+};
+DefineKeybindingWidget.WIDTH = 400;
+DefineKeybindingWidget.HEIGHT = 110;
+DefineKeybindingWidget = ( __decorate([
+    ( __param(1, IInstantiationService))
+], DefineKeybindingWidget));
+let DefineKeybindingOverlayWidget = class DefineKeybindingOverlayWidget extends Disposable {
+    constructor(_editor, instantiationService) {
+        super();
+        this._editor = _editor;
+        this._widget = instantiationService.createInstance(DefineKeybindingWidget, null);
+        this._editor.addOverlayWidget(this);
+    }
+    getId() {
+        return DefineKeybindingOverlayWidget.ID;
+    }
+    getDomNode() {
+        return this._widget.domNode;
+    }
+    getPosition() {
+        return {
+            preference: null
+        };
+    }
+    dispose() {
+        this._editor.removeOverlayWidget(this);
+        super.dispose();
+    }
+    start() {
+        if (this._editor.hasModel()) {
+            this._editor.revealPositionInCenterIfOutsideViewport(this._editor.getPosition(), 0 );
+        }
+        const layoutInfo = this._editor.getLayoutInfo();
+        this._widget.layout(new dom.Dimension(layoutInfo.width, layoutInfo.height));
+        return this._widget.define();
+    }
+};
+DefineKeybindingOverlayWidget.ID = 'editor.contrib.defineKeybindingWidget';
+DefineKeybindingOverlayWidget = ( __decorate([
+    ( __param(1, IInstantiationService))
+], DefineKeybindingOverlayWidget));
+export { DefineKeybindingOverlayWidget, DefineKeybindingWidget, KeybindingsSearchWidget };