@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/api/browser/mainThreadEditor.js

@@ -0,0 +1,410 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { cursorStyleToString, TextEditorCursorStyle } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import { TextEditorRevealType } from '../common/extHost.protocol.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { EditorState } from 'monaco-editor/esm/vs/editor/contrib/editorState/browser/editorState.js';
+import { SnippetParser } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
+class MainThreadTextEditorProperties {
+    static readFromEditor(previousProperties, model, codeEditor) {
+        const selections = MainThreadTextEditorProperties._readSelectionsFromCodeEditor(previousProperties, codeEditor);
+        const options = MainThreadTextEditorProperties._readOptionsFromCodeEditor(previousProperties, model, codeEditor);
+        const visibleRanges = MainThreadTextEditorProperties._readVisibleRangesFromCodeEditor(previousProperties, codeEditor);
+        return ( new MainThreadTextEditorProperties(selections, options, visibleRanges));
+    }
+    static _readSelectionsFromCodeEditor(previousProperties, codeEditor) {
+        let result = null;
+        if (codeEditor) {
+            result = codeEditor.getSelections();
+        }
+        if (!result && previousProperties) {
+            result = previousProperties.selections;
+        }
+        if (!result) {
+            result = [( new Selection(1, 1, 1, 1))];
+        }
+        return result;
+    }
+    static _readOptionsFromCodeEditor(previousProperties, model, codeEditor) {
+        if (model.isDisposed()) {
+            if (previousProperties) {
+                return previousProperties.options;
+            }
+            else {
+                throw new Error('No valid properties');
+            }
+        }
+        let cursorStyle;
+        let lineNumbers;
+        if (codeEditor) {
+            const options = codeEditor.getOptions();
+            const lineNumbersOpts = options.get(65 );
+            cursorStyle = options.get(26 );
+            lineNumbers = lineNumbersOpts.renderType;
+        }
+        else if (previousProperties) {
+            cursorStyle = previousProperties.options.cursorStyle;
+            lineNumbers = previousProperties.options.lineNumbers;
+        }
+        else {
+            cursorStyle = TextEditorCursorStyle.Line;
+            lineNumbers = 1 ;
+        }
+        const modelOptions = model.getOptions();
+        return {
+            insertSpaces: modelOptions.insertSpaces,
+            tabSize: modelOptions.tabSize,
+            indentSize: modelOptions.indentSize,
+            cursorStyle: cursorStyle,
+            lineNumbers: lineNumbers
+        };
+    }
+    static _readVisibleRangesFromCodeEditor(previousProperties, codeEditor) {
+        if (codeEditor) {
+            return codeEditor.getVisibleRanges();
+        }
+        return [];
+    }
+    constructor(selections, options, visibleRanges) {
+        this.selections = selections;
+        this.options = options;
+        this.visibleRanges = visibleRanges;
+    }
+    generateDelta(oldProps, selectionChangeSource) {
+        const delta = {
+            options: null,
+            selections: null,
+            visibleRanges: null
+        };
+        if (!oldProps || !MainThreadTextEditorProperties._selectionsEqual(oldProps.selections, this.selections)) {
+            delta.selections = {
+                selections: this.selections,
+                source: withNullAsUndefined(selectionChangeSource)
+            };
+        }
+        if (!oldProps || !MainThreadTextEditorProperties._optionsEqual(oldProps.options, this.options)) {
+            delta.options = this.options;
+        }
+        if (!oldProps || !MainThreadTextEditorProperties._rangesEqual(oldProps.visibleRanges, this.visibleRanges)) {
+            delta.visibleRanges = this.visibleRanges;
+        }
+        if (delta.selections || delta.options || delta.visibleRanges) {
+            return delta;
+        }
+        return null;
+    }
+    static _selectionsEqual(a, b) {
+        return equals(a, b, (aValue, bValue) => aValue.equalsSelection(bValue));
+    }
+    static _rangesEqual(a, b) {
+        return equals(a, b, (aValue, bValue) => aValue.equalsRange(bValue));
+    }
+    static _optionsEqual(a, b) {
+        if (a && !b || !a && b) {
+            return false;
+        }
+        if (!a && !b) {
+            return true;
+        }
+        return (a.tabSize === b.tabSize
+            && a.indentSize === b.indentSize
+            && a.insertSpaces === b.insertSpaces
+            && a.cursorStyle === b.cursorStyle
+            && a.lineNumbers === b.lineNumbers);
+    }
+}
+class MainThreadTextEditor {
+    constructor(id, model, codeEditor, focusTracker, mainThreadDocuments, modelService, clipboardService) {
+        this._modelListeners = ( new DisposableStore());
+        this._codeEditorListeners = ( new DisposableStore());
+        this._id = id;
+        this._model = model;
+        this._codeEditor = null;
+        this._properties = null;
+        this._focusTracker = focusTracker;
+        this._mainThreadDocuments = mainThreadDocuments;
+        this._modelService = modelService;
+        this._clipboardService = clipboardService;
+        this._onPropertiesChanged = ( new Emitter());
+        this._modelListeners.add(this._model.onDidChangeOptions((e) => {
+            this._updatePropertiesNow(null);
+        }));
+        this.setCodeEditor(codeEditor);
+        this._updatePropertiesNow(null);
+    }
+    dispose() {
+        this._modelListeners.dispose();
+        this._codeEditor = null;
+        this._codeEditorListeners.dispose();
+    }
+    _updatePropertiesNow(selectionChangeSource) {
+        this._setProperties(MainThreadTextEditorProperties.readFromEditor(this._properties, this._model, this._codeEditor), selectionChangeSource);
+    }
+    _setProperties(newProperties, selectionChangeSource) {
+        const delta = newProperties.generateDelta(this._properties, selectionChangeSource);
+        this._properties = newProperties;
+        if (delta) {
+            this._onPropertiesChanged.fire(delta);
+        }
+    }
+    getId() {
+        return this._id;
+    }
+    getModel() {
+        return this._model;
+    }
+    getCodeEditor() {
+        return this._codeEditor;
+    }
+    hasCodeEditor(codeEditor) {
+        return (this._codeEditor === codeEditor);
+    }
+    setCodeEditor(codeEditor) {
+        if (this.hasCodeEditor(codeEditor)) {
+            return;
+        }
+        this._codeEditorListeners.clear();
+        this._codeEditor = codeEditor;
+        if (this._codeEditor) {
+            this._codeEditorListeners.add(this._codeEditor.onDidChangeModel(() => {
+                this.setCodeEditor(null);
+            }));
+            this._codeEditorListeners.add(this._codeEditor.onDidFocusEditorWidget(() => {
+                this._focusTracker.onGainedFocus();
+            }));
+            this._codeEditorListeners.add(this._codeEditor.onDidBlurEditorWidget(() => {
+                this._focusTracker.onLostFocus();
+            }));
+            let nextSelectionChangeSource = null;
+            this._codeEditorListeners.add(this._mainThreadDocuments.onIsCaughtUpWithContentChanges((uri) => {
+                if (( uri.toString()) === ( this._model.uri.toString())) {
+                    const selectionChangeSource = nextSelectionChangeSource;
+                    nextSelectionChangeSource = null;
+                    this._updatePropertiesNow(selectionChangeSource);
+                }
+            }));
+            const isValidCodeEditor = () => {
+                return (this._codeEditor && this._codeEditor.getModel() === this._model);
+            };
+            const updateProperties = (selectionChangeSource) => {
+                if (this._mainThreadDocuments.isCaughtUpWithContentChanges(this._model.uri)) {
+                    nextSelectionChangeSource = null;
+                    this._updatePropertiesNow(selectionChangeSource);
+                }
+                else {
+                    nextSelectionChangeSource = selectionChangeSource;
+                }
+            };
+            this._codeEditorListeners.add(this._codeEditor.onDidChangeCursorSelection((e) => {
+                if (!isValidCodeEditor()) {
+                    return;
+                }
+                updateProperties(e.source);
+            }));
+            this._codeEditorListeners.add(this._codeEditor.onDidChangeConfiguration((e) => {
+                if (!isValidCodeEditor()) {
+                    return;
+                }
+                updateProperties(null);
+            }));
+            this._codeEditorListeners.add(this._codeEditor.onDidLayoutChange(() => {
+                if (!isValidCodeEditor()) {
+                    return;
+                }
+                updateProperties(null);
+            }));
+            this._codeEditorListeners.add(this._codeEditor.onDidScrollChange(() => {
+                if (!isValidCodeEditor()) {
+                    return;
+                }
+                updateProperties(null);
+            }));
+            this._updatePropertiesNow(null);
+        }
+    }
+    isVisible() {
+        return !!this._codeEditor;
+    }
+    getProperties() {
+        return this._properties;
+    }
+    get onPropertiesChanged() {
+        return this._onPropertiesChanged.event;
+    }
+    setSelections(selections) {
+        if (this._codeEditor) {
+            this._codeEditor.setSelections(selections);
+            return;
+        }
+        const newSelections = ( selections.map(Selection.liftSelection));
+        this._setProperties(( new MainThreadTextEditorProperties(newSelections, this._properties.options, this._properties.visibleRanges)), null);
+    }
+    _setIndentConfiguration(newConfiguration) {
+        const creationOpts = this._modelService.getCreationOptions(this._model.getLanguageId(), this._model.uri, this._model.isForSimpleWidget);
+        if (newConfiguration.tabSize === 'auto' || newConfiguration.insertSpaces === 'auto') {
+            let insertSpaces = creationOpts.insertSpaces;
+            let tabSize = creationOpts.tabSize;
+            if (newConfiguration.insertSpaces !== 'auto' && typeof newConfiguration.insertSpaces !== 'undefined') {
+                insertSpaces = newConfiguration.insertSpaces;
+            }
+            if (newConfiguration.tabSize !== 'auto' && typeof newConfiguration.tabSize !== 'undefined') {
+                tabSize = newConfiguration.tabSize;
+            }
+            this._model.detectIndentation(insertSpaces, tabSize);
+            return;
+        }
+        const newOpts = {};
+        if (typeof newConfiguration.insertSpaces !== 'undefined') {
+            newOpts.insertSpaces = newConfiguration.insertSpaces;
+        }
+        if (typeof newConfiguration.tabSize !== 'undefined') {
+            newOpts.tabSize = newConfiguration.tabSize;
+        }
+        if (typeof newConfiguration.indentSize !== 'undefined') {
+            newOpts.indentSize = newConfiguration.indentSize;
+        }
+        this._model.updateOptions(newOpts);
+    }
+    setConfiguration(newConfiguration) {
+        this._setIndentConfiguration(newConfiguration);
+        if (!this._codeEditor) {
+            return;
+        }
+        if (newConfiguration.cursorStyle) {
+            const newCursorStyle = cursorStyleToString(newConfiguration.cursorStyle);
+            this._codeEditor.updateOptions({
+                cursorStyle: newCursorStyle
+            });
+        }
+        if (typeof newConfiguration.lineNumbers !== 'undefined') {
+            let lineNumbers;
+            switch (newConfiguration.lineNumbers) {
+                case 1 :
+                    lineNumbers = 'on';
+                    break;
+                case 2 :
+                    lineNumbers = 'relative';
+                    break;
+                default:
+                    lineNumbers = 'off';
+            }
+            this._codeEditor.updateOptions({
+                lineNumbers: lineNumbers
+            });
+        }
+    }
+    setDecorations(key, ranges) {
+        if (!this._codeEditor) {
+            return;
+        }
+        this._codeEditor.setDecorationsByType('exthost-api', key, ranges);
+    }
+    setDecorationsFast(key, _ranges) {
+        if (!this._codeEditor) {
+            return;
+        }
+        const ranges = [];
+        for (let i = 0, len = Math.floor(_ranges.length / 4); i < len; i++) {
+            ranges[i] = ( new Range(_ranges[4 * i], _ranges[4 * i + 1], _ranges[4 * i + 2], _ranges[4 * i + 3]));
+        }
+        this._codeEditor.setDecorationsByTypeFast(key, ranges);
+    }
+    revealRange(range, revealType) {
+        if (!this._codeEditor) {
+            return;
+        }
+        switch (revealType) {
+            case TextEditorRevealType.Default:
+                this._codeEditor.revealRange(range, 0 );
+                break;
+            case TextEditorRevealType.InCenter:
+                this._codeEditor.revealRangeInCenter(range, 0 );
+                break;
+            case TextEditorRevealType.InCenterIfOutsideViewport:
+                this._codeEditor.revealRangeInCenterIfOutsideViewport(range, 0 );
+                break;
+            case TextEditorRevealType.AtTop:
+                this._codeEditor.revealRangeAtTop(range, 0 );
+                break;
+            default:
+                console.warn(`Unknown revealType: ${revealType}`);
+                break;
+        }
+    }
+    isFocused() {
+        if (this._codeEditor) {
+            return this._codeEditor.hasTextFocus();
+        }
+        return false;
+    }
+    matches(editor) {
+        if (!editor) {
+            return false;
+        }
+        return editor.getControl() === this._codeEditor;
+    }
+    applyEdits(versionIdCheck, edits, opts) {
+        if (this._model.getVersionId() !== versionIdCheck) {
+            return false;
+        }
+        if (!this._codeEditor) {
+            return false;
+        }
+        if (typeof opts.setEndOfLine !== 'undefined') {
+            this._model.pushEOL(opts.setEndOfLine);
+        }
+        const transformedEdits = ( edits.map((edit) => {
+            return {
+                range: Range.lift(edit.range),
+                text: edit.text,
+                forceMoveMarkers: edit.forceMoveMarkers
+            };
+        }));
+        if (opts.undoStopBefore) {
+            this._codeEditor.pushUndoStop();
+        }
+        this._codeEditor.executeEdits('MainThreadTextEditor', transformedEdits);
+        if (opts.undoStopAfter) {
+            this._codeEditor.pushUndoStop();
+        }
+        return true;
+    }
+    async insertSnippet(modelVersionId, template, ranges, opts) {
+        if (!this._codeEditor || !this._codeEditor.hasModel()) {
+            return false;
+        }
+        let clipboardText;
+        const needsTemplate = SnippetParser.guessNeedsClipboard(template);
+        if (needsTemplate) {
+            const state = ( new EditorState(
+                this._codeEditor,
+                1  | 4
+            ));
+            clipboardText = await this._clipboardService.readText();
+            if (!state.validate(this._codeEditor)) {
+                return false;
+            }
+        }
+        if (this._codeEditor.getModel().getVersionId() !== modelVersionId) {
+            return false;
+        }
+        const snippetController = SnippetController2.get(this._codeEditor);
+        if (!snippetController) {
+            return false;
+        }
+        const selections = ( ranges.map(r => ( new Selection(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn))));
+        this._codeEditor.setSelections(selections);
+        this._codeEditor.focus();
+        snippetController.insert(template, {
+            overwriteBefore: 0, overwriteAfter: 0,
+            undoStopBefore: opts.undoStopBefore, undoStopAfter: opts.undoStopAfter,
+            clipboardText
+        });
+        return true;
+    }
+}
+export { MainThreadTextEditor, MainThreadTextEditorProperties };

package/dist/vscode/vs/workbench/api/browser/mainThreadEditors.js

@@ -0,0 +1,223 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { disposed } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { EditorActivation, EditorResolution } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { ExtHostContext } from '../common/extHost.protocol.js';
+import { editorGroupToColumn, columnToEditorGroup } from '../../services/editor/common/editorGroupColumn.js';
+import { IEditorService } from '../../services/editor/common/editorService.js';
+import { IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IWorkingCopyService } from '../../services/workingCopy/common/workingCopyService.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+let MainThreadTextEditors = class MainThreadTextEditors {
+    constructor(_editorLocator, extHostContext, _codeEditorService, _editorService, _editorGroupService, _configurationService) {
+        this._editorLocator = _editorLocator;
+        this._codeEditorService = _codeEditorService;
+        this._editorService = _editorService;
+        this._editorGroupService = _editorGroupService;
+        this._configurationService = _configurationService;
+        this._toDispose = ( new DisposableStore());
+        this._instanceId = String(++MainThreadTextEditors.INSTANCE_COUNT);
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditors));
+        this._textEditorsListenersMap = Object.create(null);
+        this._editorPositionData = null;
+        this._toDispose.add(this._editorService.onDidVisibleEditorsChange(() => this._updateActiveAndVisibleTextEditors()));
+        this._toDispose.add(this._editorGroupService.onDidRemoveGroup(() => this._updateActiveAndVisibleTextEditors()));
+        this._toDispose.add(this._editorGroupService.onDidMoveGroup(() => this._updateActiveAndVisibleTextEditors()));
+        this._registeredDecorationTypes = Object.create(null);
+    }
+    dispose() {
+        ( Object.keys(this._textEditorsListenersMap)).forEach((editorId) => {
+            dispose(this._textEditorsListenersMap[editorId]);
+        });
+        this._textEditorsListenersMap = Object.create(null);
+        this._toDispose.dispose();
+        for (const decorationType in this._registeredDecorationTypes) {
+            this._codeEditorService.removeDecorationType(decorationType);
+        }
+        this._registeredDecorationTypes = Object.create(null);
+    }
+    handleTextEditorAdded(textEditor) {
+        const id = textEditor.getId();
+        const toDispose = [];
+        toDispose.push(textEditor.onPropertiesChanged((data) => {
+            this._proxy.$acceptEditorPropertiesChanged(id, data);
+        }));
+        this._textEditorsListenersMap[id] = toDispose;
+    }
+    handleTextEditorRemoved(id) {
+        dispose(this._textEditorsListenersMap[id]);
+        delete this._textEditorsListenersMap[id];
+    }
+    _updateActiveAndVisibleTextEditors() {
+        const editorPositionData = this._getTextEditorPositionData();
+        if (!equals(this._editorPositionData, editorPositionData)) {
+            this._editorPositionData = editorPositionData;
+            this._proxy.$acceptEditorPositionData(this._editorPositionData);
+        }
+    }
+    _getTextEditorPositionData() {
+        const result = Object.create(null);
+        for (const editorPane of this._editorService.visibleEditorPanes) {
+            const id = this._editorLocator.findTextEditorIdFor(editorPane);
+            if (id) {
+                result[id] = editorGroupToColumn(this._editorGroupService, editorPane.group);
+            }
+        }
+        return result;
+    }
+    async $tryShowTextDocument(resource, options) {
+        const uri = URI.revive(resource);
+        const editorOptions = {
+            preserveFocus: options.preserveFocus,
+            pinned: options.pinned,
+            selection: options.selection,
+            activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
+            override: EditorResolution.EXCLUSIVE_ONLY
+        };
+        const input = {
+            resource: uri,
+            options: editorOptions
+        };
+        const editor = await this._editorService.openEditor(input, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
+        if (!editor) {
+            return undefined;
+        }
+        const editorControl = editor.getControl();
+        const codeEditor = getCodeEditor(editorControl);
+        return codeEditor ? this._editorLocator.getIdOfCodeEditor(codeEditor) : undefined;
+    }
+    async $tryShowEditor(id, position) {
+        const mainThreadEditor = this._editorLocator.getEditor(id);
+        if (mainThreadEditor) {
+            const model = mainThreadEditor.getModel();
+            await this._editorService.openEditor({
+                resource: model.uri,
+                options: { preserveFocus: false }
+            }, columnToEditorGroup(this._editorGroupService, this._configurationService, position));
+            return;
+        }
+    }
+    async $tryHideEditor(id) {
+        const mainThreadEditor = this._editorLocator.getEditor(id);
+        if (mainThreadEditor) {
+            const editorPanes = this._editorService.visibleEditorPanes;
+            for (const editorPane of editorPanes) {
+                if (mainThreadEditor.matches(editorPane)) {
+                    await editorPane.group.closeEditor(editorPane.input);
+                    return;
+                }
+            }
+        }
+    }
+    $trySetSelections(id, selections) {
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(disposed(`TextEditor(${id})`));
+        }
+        editor.setSelections(selections);
+        return Promise.resolve(undefined);
+    }
+    $trySetDecorations(id, key, ranges) {
+        key = `${this._instanceId}-${key}`;
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(disposed(`TextEditor(${id})`));
+        }
+        editor.setDecorations(key, ranges);
+        return Promise.resolve(undefined);
+    }
+    $trySetDecorationsFast(id, key, ranges) {
+        key = `${this._instanceId}-${key}`;
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(disposed(`TextEditor(${id})`));
+        }
+        editor.setDecorationsFast(key, ranges);
+        return Promise.resolve(undefined);
+    }
+    $tryRevealRange(id, range, revealType) {
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(disposed(`TextEditor(${id})`));
+        }
+        editor.revealRange(range, revealType);
+        return Promise.resolve();
+    }
+    $trySetOptions(id, options) {
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(disposed(`TextEditor(${id})`));
+        }
+        editor.setConfiguration(options);
+        return Promise.resolve(undefined);
+    }
+    $tryApplyEdits(id, modelVersionId, edits, opts) {
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(disposed(`TextEditor(${id})`));
+        }
+        return Promise.resolve(editor.applyEdits(modelVersionId, edits, opts));
+    }
+    $tryInsertSnippet(id, modelVersionId, template, ranges, opts) {
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(disposed(`TextEditor(${id})`));
+        }
+        return Promise.resolve(editor.insertSnippet(modelVersionId, template, ranges, opts));
+    }
+    $registerTextEditorDecorationType(extensionId, key, options) {
+        key = `${this._instanceId}-${key}`;
+        this._registeredDecorationTypes[key] = true;
+        this._codeEditorService.registerDecorationType(`exthost-api-${extensionId}`, key, options);
+    }
+    $removeTextEditorDecorationType(key) {
+        key = `${this._instanceId}-${key}`;
+        delete this._registeredDecorationTypes[key];
+        this._codeEditorService.removeDecorationType(key);
+    }
+    $getDiffInformation(id) {
+        const editor = this._editorLocator.getEditor(id);
+        if (!editor) {
+            return Promise.reject(( new Error('No such TextEditor')));
+        }
+        const codeEditor = editor.getCodeEditor();
+        if (!codeEditor) {
+            return Promise.reject(( new Error('No such CodeEditor')));
+        }
+        const codeEditorId = codeEditor.getId();
+        const diffEditors = this._codeEditorService.listDiffEditors();
+        const [diffEditor] = diffEditors.filter(d => d.getOriginalEditor().getId() === codeEditorId || d.getModifiedEditor().getId() === codeEditorId);
+        if (diffEditor) {
+            return Promise.resolve(diffEditor.getLineChanges() || []);
+        }
+        const dirtyDiffContribution = codeEditor.getContribution('editor.contrib.dirtydiff');
+        if (dirtyDiffContribution) {
+            return Promise.resolve(dirtyDiffContribution.getChanges());
+        }
+        return Promise.resolve([]);
+    }
+};
+MainThreadTextEditors.INSTANCE_COUNT = 0;
+MainThreadTextEditors = ( __decorate([
+    ( __param(2, ICodeEditorService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IEditorGroupsService)),
+    ( __param(5, IConfigurationService))
+], MainThreadTextEditors));
+CommandsRegistry.registerCommand('_workbench.revertAllDirty', async function (accessor) {
+    const environmentService = accessor.get(IEnvironmentService);
+    if (!environmentService.extensionTestsLocationURI) {
+        throw new Error('Command is only available when running extension tests.');
+    }
+    const workingCopyService = accessor.get(IWorkingCopyService);
+    for (const workingCopy of workingCopyService.dirtyWorkingCopies) {
+        await workingCopy.revert({ soft: true });
+    }
+});
+export { MainThreadTextEditors };