@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/utils.js

@@ -0,0 +1,169 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CompareResult, ArrayQueue } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { onUnexpectedError, BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableFromEvent, autorunOpts } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+class ReentrancyBarrier {
+    constructor() {
+        this._isActive = false;
+    }
+    get isActive() {
+        return this._isActive;
+    }
+    makeExclusive(fn) {
+        return ((...args) => {
+            if (this._isActive) {
+                return;
+            }
+            this._isActive = true;
+            try {
+                return fn(...args);
+            }
+            finally {
+                this._isActive = false;
+            }
+        });
+    }
+    runExclusively(fn) {
+        if (this._isActive) {
+            return;
+        }
+        this._isActive = true;
+        try {
+            fn();
+        }
+        finally {
+            this._isActive = false;
+        }
+    }
+    runExclusivelyOrThrow(fn) {
+        if (this._isActive) {
+            throw new BugIndicatingError();
+        }
+        this._isActive = true;
+        try {
+            fn();
+        }
+        finally {
+            this._isActive = false;
+        }
+    }
+}
+function setStyle(element, style) {
+    Object.entries(style).forEach(([key, value]) => {
+        element.style.setProperty(key, toSize(value));
+    });
+}
+function toSize(value) {
+    return typeof value === 'number' ? `${value}px` : value;
+}
+function applyObservableDecorations(editor, decorations) {
+    const d = ( new DisposableStore());
+    let decorationIds = [];
+    d.add(autorunOpts({ debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
+        const d = decorations.read(reader);
+        editor.changeDecorations(a => {
+            decorationIds = a.deltaDecorations(decorationIds, d);
+        });
+    }));
+    d.add({
+        dispose: () => {
+            editor.changeDecorations(a => {
+                decorationIds = a.deltaDecorations(decorationIds, []);
+            });
+        }
+    });
+    return d;
+}
+function* leftJoin(left, right, compare) {
+    const rightQueue = ( new ArrayQueue(right));
+    for (const leftElement of left) {
+        rightQueue.takeWhile(rightElement => CompareResult.isGreaterThan(compare(leftElement, rightElement)));
+        const equals = rightQueue.takeWhile(rightElement => CompareResult.isNeitherLessOrGreaterThan(compare(leftElement, rightElement)));
+        yield { left: leftElement, rights: equals || [] };
+    }
+}
+function* join(left, right, compare) {
+    const rightQueue = ( new ArrayQueue(right));
+    for (const leftElement of left) {
+        const skipped = rightQueue.takeWhile(rightElement => CompareResult.isGreaterThan(compare(leftElement, rightElement)));
+        if (skipped) {
+            yield { rights: skipped };
+        }
+        const equals = rightQueue.takeWhile(rightElement => CompareResult.isNeitherLessOrGreaterThan(compare(leftElement, rightElement)));
+        yield { left: leftElement, rights: equals || [] };
+    }
+}
+function concatArrays(...arrays) {
+    return [].concat(...arrays);
+}
+function thenIfNotDisposed(promise, then) {
+    let disposed = false;
+    promise.then(() => {
+        if (disposed) {
+            return;
+        }
+        then();
+    });
+    return toDisposable(() => {
+        disposed = true;
+    });
+}
+function setFields(obj, fields) {
+    return Object.assign(obj, fields);
+}
+function deepMerge(source1, source2) {
+    const result = {};
+    for (const key in source1) {
+        result[key] = source1[key];
+    }
+    for (const key in source2) {
+        const source2Value = source2[key];
+        if (typeof result[key] === 'object' && source2Value && typeof source2Value === 'object') {
+            result[key] = deepMerge(result[key], source2Value);
+        }
+        else {
+            result[key] = source2Value;
+        }
+    }
+    return result;
+}
+let PersistentStore = class PersistentStore {
+    constructor(key, storageService) {
+        this.key = key;
+        this.storageService = storageService;
+        this.hasValue = false;
+        this.value = undefined;
+    }
+    get() {
+        if (!this.hasValue) {
+            const value = this.storageService.get(this.key, 0 );
+            if (value !== undefined) {
+                try {
+                    this.value = JSON.parse(value);
+                }
+                catch (e) {
+                    onUnexpectedError(e);
+                }
+            }
+            this.hasValue = true;
+        }
+        return this.value;
+    }
+    set(newValue) {
+        this.value = newValue;
+        this.storageService.store(this.key, JSON.stringify(this.value), 0 , 0 );
+    }
+};
+PersistentStore = ( __decorate([
+    ( __param(1, IStorageService))
+], PersistentStore));
+function observableConfigValue(key, defaultValue, configurationService) {
+    return observableFromEvent((handleChange) => configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(key)) {
+            handleChange(e);
+        }
+    }), () => configurationService.getValue(key) ?? defaultValue);
+}
+export { PersistentStore, ReentrancyBarrier, applyObservableDecorations, concatArrays, deepMerge, join, leftJoin, observableConfigValue, setFields, setStyle, thenIfNotDisposed };

package/vscode/src/vs/workbench/contrib/mergeEditor/common/mergeEditor.js

@@ -0,0 +1,64 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const ctxIsMergeEditor = ( new RawContextKey('isMergeEditor', false, { type: 'boolean', description: ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+ 'is',
+ 'The editor is a merge editor'
+)) }));
+const ctxIsMergeResultEditor = ( new RawContextKey(
+ 'isMergeResultEditor',
+ false,
+ { type: 'boolean', description: ( localizeWithPath(
+  'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+  'isr',
+  'The editor is a the result editor of a merge editor.'
+ )) }
+));
+const ctxMergeEditorLayout = ( new RawContextKey(
+ 'mergeEditorLayout',
+ 'mixed',
+ { type: 'string', description: ( localizeWithPath(
+  'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+  'editorLayout',
+  'The layout mode of a merge editor'
+ )) }
+));
+const ctxMergeEditorShowBase = ( new RawContextKey(
+ 'mergeEditorShowBase',
+ false,
+ { type: 'boolean', description: ( localizeWithPath(
+  'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+  'showBase',
+  'If the merge editor shows the base version'
+ )) }
+));
+const ctxMergeEditorShowBaseAtTop = ( new RawContextKey(
+ 'mergeEditorShowBaseAtTop',
+ false,
+ { type: 'boolean', description: ( localizeWithPath(
+  'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+  'showBaseAtTop',
+  'If base should be shown at the top'
+ )) }
+));
+const ctxMergeEditorShowNonConflictingChanges = ( new RawContextKey(
+ 'mergeEditorShowNonConflictingChanges',
+ false,
+ { type: 'boolean', description: ( localizeWithPath(
+  'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+  'showNonConflictingChanges',
+  'If the merge editor shows non-conflicting changes'
+ )) }
+));
+const ctxMergeBaseUri = ( new RawContextKey('mergeEditorBaseUri', '', { type: 'string', description: ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+ 'baseUri',
+ 'The uri of the baser of a merge editor'
+)) }));
+const ctxMergeResultUri = ( new RawContextKey('mergeEditorResultUri', '', { type: 'string', description: ( localizeWithPath(
+ 'vs/workbench/contrib/mergeEditor/common/mergeEditor',
+ 'resultUri',
+ 'The uri of the result of a merge editor'
+)) }));
+const StorageCloseWithConflicts = 'mergeEditorCloseWithConflicts';
+export { StorageCloseWithConflicts, ctxIsMergeEditor, ctxIsMergeResultEditor, ctxMergeBaseUri, ctxMergeEditorLayout, ctxMergeEditorShowBase, ctxMergeEditorShowBaseAtTop, ctxMergeEditorShowNonConflictingChanges, ctxMergeResultUri };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/clipboard/cellOutputClipboard.js

@@ -0,0 +1,49 @@
+import { isTextStreamMime } from '../../../common/notebookCommon.js';
+async function copyCellOutput(mimeType, outputViewModel, clipboardService, logService) {
+    const cellOutput = outputViewModel.model;
+    const output = mimeType && TEXT_BASED_MIMETYPES.includes(mimeType) ?
+        cellOutput.outputs.find(output => output.mime === mimeType) :
+        cellOutput.outputs.find(output => TEXT_BASED_MIMETYPES.includes(output.mime));
+    mimeType = output?.mime;
+    if (!mimeType || !output) {
+        return;
+    }
+    const decoder = ( new TextDecoder());
+    let text = decoder.decode(output.data.buffer);
+    if (isTextStreamMime(mimeType)) {
+        const cellViewModel = outputViewModel.cellViewModel;
+        let index = cellViewModel.outputsViewModels.indexOf(outputViewModel) + 1;
+        while (index < cellViewModel.model.outputs.length) {
+            const nextCellOutput = cellViewModel.model.outputs[index];
+            const nextOutput = nextCellOutput.outputs.find(output => isTextStreamMime(output.mime));
+            if (!nextOutput) {
+                break;
+            }
+            text = text + decoder.decode(nextOutput.data.buffer);
+            index = index + 1;
+        }
+    }
+    if (mimeType.endsWith('error')) {
+        text = text.replace(/\\u001b\[[0-9;]*m/gi, '').replaceAll('\\n', '\n');
+    }
+    try {
+        await clipboardService.writeText(text);
+    }
+    catch (e) {
+        logService.error(`Failed to copy content: ${e}`);
+    }
+}
+const TEXT_BASED_MIMETYPES = [
+    'text/latex',
+    'text/html',
+    'application/vnd.code.notebook.error',
+    'application/vnd.code.notebook.stdout',
+    'application/x.notebook.stdout',
+    'application/x.notebook.stream',
+    'application/vnd.code.notebook.stderr',
+    'application/x.notebook.stderr',
+    'text/plain',
+    'text/markdown',
+    'application/json'
+];
+export { TEXT_BASED_MIMETYPES, copyCellOutput };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/findFilters.js

@@ -0,0 +1,70 @@
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+class NotebookFindFilters extends Disposable {
+    get markupInput() {
+        return this._markupInput;
+    }
+    set markupInput(value) {
+        if (this._markupInput !== value) {
+            this._markupInput = value;
+            this._onDidChange.fire({ markupInput: value });
+        }
+    }
+    get markupPreview() {
+        return this._markupPreview;
+    }
+    set markupPreview(value) {
+        if (this._markupPreview !== value) {
+            this._markupPreview = value;
+            this._onDidChange.fire({ markupPreview: value });
+        }
+    }
+    get codeInput() {
+        return this._codeInput;
+    }
+    set codeInput(value) {
+        if (this._codeInput !== value) {
+            this._codeInput = value;
+            this._onDidChange.fire({ codeInput: value });
+        }
+    }
+    get codeOutput() {
+        return this._codeOutput;
+    }
+    set codeOutput(value) {
+        if (this._codeOutput !== value) {
+            this._codeOutput = value;
+            this._onDidChange.fire({ codeOutput: value });
+        }
+    }
+    constructor(markupInput, markupPreview, codeInput, codeOutput) {
+        super();
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._markupInput = true;
+        this._markupPreview = true;
+        this._codeInput = true;
+        this._codeOutput = true;
+        this._markupInput = markupInput;
+        this._markupPreview = markupPreview;
+        this._codeInput = codeInput;
+        this._codeOutput = codeOutput;
+        this._initialMarkupInput = markupInput;
+        this._initialMarkupPreview = markupPreview;
+        this._initialCodeInput = codeInput;
+        this._initialCodeOutput = codeOutput;
+    }
+    isModified() {
+        return (this._markupInput !== this._initialMarkupInput
+            || this._markupPreview !== this._initialMarkupPreview
+            || this._codeInput !== this._initialCodeInput
+            || this._codeOutput !== this._initialCodeOutput);
+    }
+    update(v) {
+        this._markupInput = v.markupInput;
+        this._markupPreview = v.markupPreview;
+        this._codeInput = v.codeInput;
+        this._codeOutput = v.codeOutput;
+    }
+}
+export { NotebookFindFilters };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/findMatchDecorationModel.js

@@ -0,0 +1,120 @@
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { FindDecorations } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findDecorations.js';
+import { overviewRulerSelectionHighlightForeground, overviewRulerFindMatchForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { NotebookOverviewRulerLane } from '../../notebookBrowser.js';
+class FindMatchDecorationModel extends Disposable {
+    constructor(_notebookEditor, ownerID) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this.ownerID = ownerID;
+        this._allMatchesDecorations = [];
+        this._currentMatchCellDecorations = [];
+        this._allMatchesCellDecorations = [];
+        this._currentMatchDecorations = null;
+    }
+    get currentMatchDecorations() {
+        return this._currentMatchDecorations;
+    }
+    clearDecorations() {
+        this.clearCurrentFindMatchDecoration();
+        this.setAllFindMatchesDecorations([]);
+    }
+    async highlightCurrentFindMatchDecorationInCell(cell, cellRange) {
+        this.clearCurrentFindMatchDecoration();
+        this._notebookEditor.changeModelDecorations(accessor => {
+            const findMatchesOptions = FindDecorations._CURRENT_FIND_MATCH_DECORATION;
+            const decorations = [
+                { range: cellRange, options: findMatchesOptions }
+            ];
+            const deltaDecoration = {
+                ownerId: cell.handle,
+                decorations: decorations
+            };
+            this._currentMatchDecorations = {
+                kind: 'input',
+                decorations: accessor.deltaDecorations(this._currentMatchDecorations?.kind === 'input' ? this._currentMatchDecorations.decorations : [], [deltaDecoration])
+            };
+        });
+        this._currentMatchCellDecorations = this._notebookEditor.deltaCellDecorations(this._currentMatchCellDecorations, [{
+                ownerId: cell.handle,
+                handle: cell.handle,
+                options: {
+                    overviewRuler: {
+                        color: overviewRulerSelectionHighlightForeground,
+                        modelRanges: [cellRange],
+                        includeOutput: false,
+                        position: NotebookOverviewRulerLane.Center
+                    }
+                }
+            }]);
+        return null;
+    }
+    async highlightCurrentFindMatchDecorationInWebview(cell, index) {
+        this.clearCurrentFindMatchDecoration();
+        const offset = await this._notebookEditor.findHighlightCurrent(index, this.ownerID);
+        this._currentMatchDecorations = { kind: 'output', index: index };
+        this._currentMatchCellDecorations = this._notebookEditor.deltaCellDecorations(this._currentMatchCellDecorations, [{
+                ownerId: cell.handle,
+                handle: cell.handle,
+                options: {
+                    overviewRuler: {
+                        color: overviewRulerSelectionHighlightForeground,
+                        modelRanges: [],
+                        includeOutput: true,
+                        position: NotebookOverviewRulerLane.Center
+                    }
+                }
+            }]);
+        return offset;
+    }
+    clearCurrentFindMatchDecoration() {
+        if (this._currentMatchDecorations?.kind === 'input') {
+            this._notebookEditor.changeModelDecorations(accessor => {
+                accessor.deltaDecorations(this._currentMatchDecorations?.kind === 'input' ? this._currentMatchDecorations.decorations : [], []);
+                this._currentMatchDecorations = null;
+            });
+        }
+        else if (this._currentMatchDecorations?.kind === 'output') {
+            this._notebookEditor.findUnHighlightCurrent(this._currentMatchDecorations.index, this.ownerID);
+        }
+        this._currentMatchCellDecorations = this._notebookEditor.deltaCellDecorations(this._currentMatchCellDecorations, []);
+    }
+    setAllFindMatchesDecorations(cellFindMatches) {
+        this._notebookEditor.changeModelDecorations((accessor) => {
+            const findMatchesOptions = FindDecorations._FIND_MATCH_DECORATION;
+            const deltaDecorations = ( cellFindMatches.map(cellFindMatch => {
+                const newFindMatchesDecorations = ( new Array(cellFindMatch.contentMatches.length));
+                for (let i = 0; i < cellFindMatch.contentMatches.length; i++) {
+                    newFindMatchesDecorations[i] = {
+                        range: cellFindMatch.contentMatches[i].range,
+                        options: findMatchesOptions
+                    };
+                }
+                return { ownerId: cellFindMatch.cell.handle, decorations: newFindMatchesDecorations };
+            }));
+            this._allMatchesDecorations = accessor.deltaDecorations(this._allMatchesDecorations, deltaDecorations);
+        });
+        this._allMatchesCellDecorations = this._notebookEditor.deltaCellDecorations(this._allMatchesCellDecorations, ( cellFindMatches.map(cellFindMatch => {
+            return {
+                ownerId: cellFindMatch.cell.handle,
+                handle: cellFindMatch.cell.handle,
+                options: {
+                    overviewRuler: {
+                        color: overviewRulerFindMatchForeground,
+                        modelRanges: ( cellFindMatch.contentMatches.map(match => match.range)),
+                        includeOutput: cellFindMatch.webviewMatches.length > 0,
+                        position: NotebookOverviewRulerLane.Center
+                    }
+                }
+            };
+        })));
+    }
+    stopWebviewFind() {
+        this._notebookEditor.findStop(this.ownerID);
+    }
+    dispose() {
+        this.clearDecorations();
+        super.dispose();
+    }
+}
+export { FindMatchDecorationModel };