@codingame/monaco-vscode-api 3.2.2 → 4.0.0

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/lineAlignment.js

@@ -3,7 +3,7 @@ import { assertFn, checkAdjacentItems } from '../../../../../base/common/assert.
 import { isDefined } from '../../../../../base/common/types.js';
 import { Position } from '../../../../../editor/common/core/position.js';
 import { Range } from '../../../../../editor/common/core/range.js';
-import { LengthObj } from '../../../../../editor/common/model/bracketPairsTextModelPart/bracketPairsTree/length.js';
+import { TextLength } from '../../../../../editor/common/core/textLength.js';
 import { RangeMapping } from '../model/mapping.js';
 import { lengthOfRange, addLength, lengthBetweenPositions } from '../model/rangeUtils.js';
 function getAlignments(m) {
@@ -34,7 +34,7 @@ function getAlignments(m) {
             result.push(lineAlignment);
         }
         else {
-            if (m.length.isGreaterThan(( new LengthObj(1, 0)))) {
+            if (m.length.isGreaterThan(( new TextLength(1, 0)))) {
                 result.push([
                     m.output1Pos ? m.output1Pos.lineNumber + 1 : undefined,
                     m.inputPos.lineNumber + 1,

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

@@ -5,6 +5,11 @@ import { Color } from '../../../../../base/common/color.js';
 import { BugIndicatingError, onUnexpectedError } from '../../../../../base/common/errors.js';
 import { Emitter } from '../../../../../base/common/event.js';
 import { DisposableStore, MutableDisposable, toDisposable, Disposable } from '../../../../../base/common/lifecycle.js';
+import { observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
+import '../../../../../base/common/observableInternal/derived.js';
+import { autorunWithStore, autorun } from '../../../../../base/common/observableInternal/autorun.js';
+import '../../../../../base/common/observableInternal/utils.js';
+import '../../../../../base/common/cancellation.js';
 import { isEqual, basename } from '../../../../../base/common/resources.js';
 import { isDefined } from '../../../../../base/common/types.js';
 import './media/mergeEditor.css.js';
@@ -33,10 +38,9 @@ import { settingsSashBorder } from '../../../preferences/common/settingsEditorCo
 import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
 import { RegisteredEditorPriority, IEditorResolverService } from '../../../../services/editor/common/editorResolverService.js';
 import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import './colors.js';
 import { InputCodeEditorView } from './editors/inputCodeEditorView.js';
 import { ResultCodeEditorView } from './editors/resultCodeEditorView.js';
-import { observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
-import { autorunWithStore, autorun } from '../../../../../base/common/observableInternal/autorun.js';
 import { AbstractTextEditor } from '../../../../browser/parts/editor/textEditor.js';
 var MergeEditor_1, MergeEditorLayoutStore_1;
 let MergeEditor = class MergeEditor extends AbstractTextEditor {
@@ -54,8 +58,8 @@ let MergeEditor = class MergeEditor extends AbstractTextEditor {
     get inputsWritable() {
         return !!this._configurationService.getValue('mergeEditor.writableInputs');
     }
-    constructor(instantiation, contextKeyService, telemetryService, storageService, themeService, textResourceConfigurationService, _configurationService, editorService, editorGroupService, fileService, _codeEditorService, configurationService) {
-        super(MergeEditor_1.ID, telemetryService, instantiation, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService);
+    constructor(group, instantiation, contextKeyService, telemetryService, storageService, themeService, textResourceConfigurationService, _configurationService, editorService, editorGroupService, fileService, _codeEditorService, configurationService) {
+        super(MergeEditor_1.ID, group, telemetryService, instantiation, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService);
         this.contextKeyService = contextKeyService;
         this._configurationService = _configurationService;
         this._codeEditorService = _codeEditorService;
@@ -251,7 +255,7 @@ let MergeEditor = class MergeEditor extends AbstractTextEditor {
                         return;
                     }
                 }
-                that.editorService.replaceEditors([{ editor: input, replacement: { resource: input.result, options: { preserveFocus: true } }, forceReplaceDirty: true }], that.group ?? that.editorGroupService.activeGroup);
+                that.editorService.replaceEditors([{ editor: input, replacement: { resource: input.result, options: { preserveFocus: true } }, forceReplaceDirty: true }], that.group);
             }
         }));
     }
@@ -332,8 +336,8 @@ let MergeEditor = class MergeEditor extends AbstractTextEditor {
         }
         return super.hasFocus();
     }
-    setEditorVisible(visible, group) {
-        super.setEditorVisible(visible, group);
+    setEditorVisible(visible) {
+        super.setEditorVisible(visible);
         for (const { editor } of [this.input1View, this.input2View, this.inputResultView]) {
             if (visible) {
                 editor.onVisible();
@@ -506,18 +510,18 @@ let MergeEditor = class MergeEditor extends AbstractTextEditor {
     }
 };
 MergeEditor = MergeEditor_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, ITextResourceConfigurationService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IEditorGroupsService)),
-    ( __param(9, IFileService)),
-    ( __param(10, ICodeEditorService)),
-    ( __param(11, IConfigurationService))
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, ITextResourceConfigurationService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, IEditorGroupsService)),
+    ( __param(10, IFileService)),
+    ( __param(11, ICodeEditorService)),
+    ( __param(12, IConfigurationService))
 ], MergeEditor));
 let MergeEditorLayoutStore = class MergeEditorLayoutStore {
     static { MergeEditorLayoutStore_1 = this; }

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/scrollSynchronizer.js

@@ -1,7 +1,10 @@
 import { Disposable } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/observableInternal/derived.js';
+import { autorunWithStore } from '../../../../../base/common/observableInternal/autorun.js';
+import '../../../../../base/common/observableInternal/utils.js';
+import '../../../../../base/common/cancellation.js';
 import { DocumentLineRangeMap } from '../model/mapping.js';
 import { ReentrancyBarrier } from '../utils.js';
-import { autorunWithStore } from '../../../../../base/common/observableInternal/autorun.js';
 class ScrollSynchronizer extends Disposable {
     get model() { return this.viewModel.get()?.model; }
     get shouldAlignResult() { return this.layout.get().kind === 'columns'; }

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/viewModel.js

@@ -1,15 +1,17 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { findLast } from '../../../../../base/common/arraysFind.js';
 import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
+import { derived } from '../../../../../base/common/observableInternal/derived.js';
+import '../../../../../base/common/observableInternal/autorun.js';
+import { derivedObservableWithWritableCache } from '../../../../../base/common/observableInternal/utils.js';
+import '../../../../../base/common/cancellation.js';
 import { Range } from '../../../../../editor/common/core/range.js';
 import { localizeWithPath } from '../../../../../nls.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
 import { INotificationService } from '../../../../../platform/notification/common/notification.js';
 import { LineRange } from '../model/lineRange.js';
 import { observableConfigValue } from '../utils.js';
-import { observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
-import { derivedObservableWithWritableCache } from '../../../../../base/common/observableInternal/utils.js';
-import { derived } from '../../../../../base/common/observableInternal/derived.js';
 let MergeEditorViewModel = class MergeEditorViewModel extends Disposable {
     constructor(model, inputCodeEditorView1, inputCodeEditorView2, resultCodeEditorView, baseCodeEditorView, showNonConflictingChanges, configurationService, notificationService) {
         super();

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/icons.contribution.js

@@ -0,0 +1,9 @@
+import { Codicon } from '../../../../base/common/codicons.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+const MultiDiffEditorIcon = registerIcon('multi-diff-editor-label-icon', Codicon.diffMultiple, ( localizeWithPath(
+ 'vs/workbench/contrib/multiDiffEditor/browser/icons.contribution',
+ 'multiDiffEditorLabelIcon',
+ 'Icon of the multi diff editor label.'
+)));
+export { MultiDiffEditorIcon };

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput.js

@@ -0,0 +1,303 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { LazyStatefulPromise, raceTimeout } from '../../../../base/common/async.js';
+import { BugIndicatingError, onUnexpectedError } from '../../../../base/common/errors.js';
+import { Event, Emitter } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { parse } from '../../../../base/common/marshalling.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { deepClone } from '../../../../base/common/objects.js';
+import { derived } from '../../../../base/common/observableInternal/derived.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent, constObservable, mapObservableArrayCached } from '../../../../base/common/observableInternal/utils.js';
+import { ObservableLazyPromise } from '../../../../base/common/observableInternal/promise.js';
+import { isDefined, isObject } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ConstLazyPromise } from '../../../../editor/browser/widget/multiDiffEditor/model.js';
+import { MultiDiffEditorViewModel } from '../../../../editor/browser/widget/multiDiffEditor/multiDiffEditorViewModel.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { MultiDiffEditorIcon } from './icons.contribution.js';
+import { MultiDiffEditorItem, ConstResolvedMultiDiffSource, IMultiDiffSourceResolverService } from './multiDiffSourceResolverService.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+var MultiDiffEditorInput_1;
+let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
+    static { MultiDiffEditorInput_1 = this; }
+    static fromResourceMultiDiffEditorInput(input, instantiationService) {
+        if (!input.multiDiffSource && !input.resources) {
+            throw new BugIndicatingError('MultiDiffEditorInput requires either multiDiffSource or resources');
+        }
+        const multiDiffSource = input.multiDiffSource ?? ( URI.parse(`multi-diff-editor:${( ( new Date()).getMilliseconds().toString()) + ( Math.random().toString())}`));
+        return instantiationService.createInstance(MultiDiffEditorInput_1, multiDiffSource, input.label, input.resources?.map(resource => {
+            return ( new MultiDiffEditorItem(resource.original.resource, resource.modified.resource));
+        }), input.isTransient ?? false);
+    }
+    static fromSerialized(data, instantiationService) {
+        return instantiationService.createInstance(MultiDiffEditorInput_1, ( URI.parse(data.multiDiffSourceUri)), data.label, data.resources?.map(resource => ( new MultiDiffEditorItem(resource.originalUri ? ( URI.parse(resource.originalUri)) : undefined, resource.modifiedUri ? ( URI.parse(resource.modifiedUri)) : undefined))), false);
+    }
+    static { this.ID = 'workbench.input.multiDiffEditor'; }
+    get resource() { return this.multiDiffSource; }
+    get capabilities() { return 2 ; }
+    get typeId() { return MultiDiffEditorInput_1.ID; }
+    getName() { return this._name; }
+    get editorId() { return DEFAULT_EDITOR_ASSOCIATION.id; }
+    getIcon() { return MultiDiffEditorIcon; }
+    constructor(multiDiffSource, label, initialResources, isTransient = false, _textModelService, _textResourceConfigurationService, _instantiationService, _multiDiffSourceResolverService, _textFileService) {
+        super();
+        this.multiDiffSource = multiDiffSource;
+        this.label = label;
+        this.initialResources = initialResources;
+        this.isTransient = isTransient;
+        this._textModelService = _textModelService;
+        this._textResourceConfigurationService = _textResourceConfigurationService;
+        this._instantiationService = _instantiationService;
+        this._multiDiffSourceResolverService = _multiDiffSourceResolverService;
+        this._textFileService = _textFileService;
+        this._name = '';
+        this._viewModel = ( new LazyStatefulPromise(async () => {
+            const model = await this._createModel();
+            this._register(model);
+            const vm = ( new MultiDiffEditorViewModel(model, this._instantiationService));
+            this._register(vm);
+            await raceTimeout(vm.waitForDiffs(), 1000);
+            return vm;
+        }));
+        this._resolvedSource = ( new ObservableLazyPromise(async () => {
+            const source = this.initialResources
+                ? ( new ConstResolvedMultiDiffSource(this.initialResources))
+                : await this._multiDiffSourceResolverService.resolve(this.multiDiffSource);
+            return {
+                source,
+                resources: source ? observableFromEvent(source.onDidChange, () => source.resources) : constObservable([]),
+            };
+        }));
+        this._resources = derived(this, reader => this._resolvedSource.cachedPromiseResult.read(reader)?.data?.resources.read(reader));
+        this._isDirtyObservables = mapObservableArrayCached(this, ( this._resources.map(r => r || [])), res => {
+            const isModifiedDirty = res.modified ? isUriDirty(this._textFileService, res.modified) : constObservable(false);
+            const isOriginalDirty = res.original ? isUriDirty(this._textFileService, res.original) : constObservable(false);
+            return derived(reader =>  isModifiedDirty.read(reader) || isOriginalDirty.read(reader));
+        }, i => JSON.stringify([i.modified?.toString(), i.original?.toString()]));
+        this._isDirtyObservable = derived(this, reader => ( this._isDirtyObservables.read(reader).some(isDirty => isDirty.read(reader))))
+            .keepObserved(this._store);
+        this.onDidChangeDirty = Event.fromObservableLight(this._isDirtyObservable);
+        this.closeHandler = {
+            async confirm() {
+                return 1 ;
+            },
+            showConfirm() {
+                return false;
+            }
+        };
+        this._register(autorun((reader) => {
+            const resources = this._resources.read(reader) ?? [];
+            const label = this.label ?? ( localizeWithPath(
+                'vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput',
+                'name',
+                "Multi Diff Editor"
+            ));
+            this._name = label + ( localizeWithPath('vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput', {
+                key: 'files',
+                comment: ['the number of files being shown']
+            }, " ({0} files)", resources?.length ?? 0));
+            this._onDidChangeLabel.fire();
+        }));
+    }
+    serialize() {
+        return {
+            label: this.label,
+            multiDiffSourceUri: ( this.multiDiffSource.toString()),
+            resources: this.initialResources?.map(resource => ({
+                originalUri: resource.original?.toString(),
+                modifiedUri: resource.modified?.toString(),
+            })),
+        };
+    }
+    setLanguageId(languageId, source) {
+        const activeDiffItem = this._viewModel.requireValue().activeDiffItem.get();
+        const value = activeDiffItem?.entry?.value;
+        if (!value) {
+            return;
+        }
+        const target = value.modified ?? value.original;
+        if (!target) {
+            return;
+        }
+        target.setLanguage(languageId, source);
+    }
+    async getViewModel() {
+        return this._viewModel.getPromise();
+    }
+    async _createModel() {
+        const source = await this._resolvedSource.getPromise();
+        const textResourceConfigurationService = this._textResourceConfigurationService;
+        const garbage = ( new DisposableStore());
+        const documentsWithPromises = mapObservableArrayCached(undefined, source.resources, async (r, store) => {
+            let original;
+            let modified;
+            const store2 = ( new DisposableStore());
+            store.add(toDisposable(() => {
+                garbage.add(store2);
+            }));
+            try {
+                [original, modified] = await Promise.all([
+                    r.original ? this._textModelService.createModelReference(r.original) : undefined,
+                    r.modified ? this._textModelService.createModelReference(r.modified) : undefined,
+                ]);
+                if (original) {
+                    store.add(original);
+                }
+                if (modified) {
+                    store.add(modified);
+                }
+            }
+            catch (e) {
+                console.error(e);
+                onUnexpectedError(e);
+                return undefined;
+            }
+            const uri = (r.modified ?? r.original);
+            return ( new ConstLazyPromise({
+                original: original?.object.textEditorModel,
+                modified: modified?.object.textEditorModel,
+                get options() {
+                    return {
+                        ...getReadonlyConfiguration(modified?.object.isReadonly() ?? true),
+                        ...computeOptions(textResourceConfigurationService.getValue(uri)),
+                    };
+                },
+                onOptionsDidChange: h => this._textResourceConfigurationService.onDidChangeConfiguration(e => {
+                    if (e.affectsConfiguration(uri, 'editor') || e.affectsConfiguration(uri, 'diffEditor')) {
+                        h();
+                    }
+                }),
+            }));
+        }, i => JSON.stringify([i.modified?.toString(), i.original?.toString()]));
+        let documents = [];
+        const documentChangeEmitter = ( new Emitter());
+        const p = Event.toPromise(documentChangeEmitter.event);
+        const a = autorun(async (reader) => {
+            const docsPromises = documentsWithPromises.read(reader);
+            const docs = await Promise.all(docsPromises);
+            documents = docs.filter(isDefined);
+            documentChangeEmitter.fire();
+            garbage.clear();
+        });
+        await p;
+        return {
+            dispose: () => {
+                a.dispose();
+                garbage.dispose();
+            },
+            onDidChange: documentChangeEmitter.event,
+            get documents() { return documents; },
+            contextKeys: source.source?.contextKeys,
+        };
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof MultiDiffEditorInput_1) {
+            return ( this.multiDiffSource.toString()) === ( otherInput.multiDiffSource.toString());
+        }
+        return false;
+    }
+    isDirty() { return this._isDirtyObservable.get(); }
+    async save(group, options) {
+        await this.doSaveOrRevert('save', group, options);
+        return this;
+    }
+    revert(group, options) {
+        return this.doSaveOrRevert('revert', group, options);
+    }
+    async doSaveOrRevert(mode, group, options) {
+        const items = this._viewModel.currentValue?.items.get();
+        if (items) {
+            await Promise.all(( items.map(async (item) => {
+                const model = item.diffEditorViewModel.model;
+                const handleOriginal = model.original.uri.scheme !== Schemas.untitled && this._textFileService.isDirty(model.original.uri);
+                await Promise.all([
+                    handleOriginal ? mode === 'save' ? this._textFileService.save(model.original.uri, options) : this._textFileService.revert(model.original.uri, options) : Promise.resolve(),
+                    mode === 'save' ? this._textFileService.save(model.modified.uri, options) : this._textFileService.revert(model.modified.uri, options),
+                ]);
+            })));
+        }
+        return undefined;
+    }
+};
+MultiDiffEditorInput = MultiDiffEditorInput_1 = ( __decorate([
+    ( __param(4, ITextModelService)),
+    ( __param(5, ITextResourceConfigurationService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IMultiDiffSourceResolverService)),
+    ( __param(8, ITextFileService))
+], MultiDiffEditorInput));
+function isUriDirty(textFileService, uri) {
+    return observableFromEvent(Event.filter(textFileService.files.onDidChangeDirty, e => ( e.resource.toString()) === ( uri.toString())), () => textFileService.isDirty(uri));
+}
+function getReadonlyConfiguration(isReadonly) {
+    return {
+        readOnly: !!isReadonly,
+        readOnlyMessage: typeof isReadonly !== 'boolean' ? isReadonly : undefined
+    };
+}
+function computeOptions(configuration) {
+    const editorConfiguration = deepClone(configuration.editor);
+    if (isObject(configuration.diffEditor)) {
+        const diffEditorConfiguration = deepClone(configuration.diffEditor);
+        diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
+        delete diffEditorConfiguration.codeLens;
+        diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
+        delete diffEditorConfiguration.wordWrap;
+        Object.assign(editorConfiguration, diffEditorConfiguration);
+    }
+    return editorConfiguration;
+}
+let MultiDiffEditorResolverContribution = class MultiDiffEditorResolverContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.multiDiffEditorResolver'; }
+    constructor(editorResolverService, instantiationService) {
+        super();
+        this._register(editorResolverService.registerEditor(`*`, {
+            id: DEFAULT_EDITOR_ASSOCIATION.id,
+            label: DEFAULT_EDITOR_ASSOCIATION.displayName,
+            detail: DEFAULT_EDITOR_ASSOCIATION.providerDisplayName,
+            priority: RegisteredEditorPriority.builtin
+        }, {}, {
+            createMultiDiffEditorInput: (multiDiffEditor) => {
+                return {
+                    editor: MultiDiffEditorInput.fromResourceMultiDiffEditorInput(multiDiffEditor, instantiationService),
+                };
+            },
+        }));
+    }
+};
+MultiDiffEditorResolverContribution = ( __decorate([
+    ( __param(0, IEditorResolverService)),
+    ( __param(1, IInstantiationService))
+], MultiDiffEditorResolverContribution));
+class MultiDiffEditorSerializer {
+    canSerialize(editor) {
+        return editor instanceof MultiDiffEditorInput && !editor.isTransient;
+    }
+    serialize(editor) {
+        if (!this.canSerialize(editor)) {
+            return undefined;
+        }
+        return JSON.stringify(editor.serialize());
+    }
+    deserialize(instantiationService, serializedEditor) {
+        try {
+            const data = parse(serializedEditor);
+            return MultiDiffEditorInput.fromSerialized(data, instantiationService);
+        }
+        catch (err) {
+            onUnexpectedError(err);
+            return undefined;
+        }
+    }
+}
+export { MultiDiffEditorInput, MultiDiffEditorResolverContribution, MultiDiffEditorSerializer };