@codingame/monaco-vscode-scm-service-override 13.1.7 → 14.0.0

package/vscode/src/vs/workbench/contrib/scm/browser/quickDiffModel.js

@@ -0,0 +1,365 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { isTextFileEditorModel, EncodingMode } from '@codingame/monaco-vscode-a17f5129-e16c-5dac-857e-dcd91bfeffa2-common/vscode/vs/workbench/services/textfile/common/textfiles';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { ReferenceCollection, Disposable, DisposableStore, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService';
+import { shouldSynchronizeModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { compareChanges, getModifiedEndLineNumber } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff';
+import { IQuickDiffService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff.service';
+import { ThrottledDelayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { ISCMService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm.service';
+import { sortedDiff, equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { DiffState } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/diffEditorViewModel';
+import { toLineChanges } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/diffEditorWidget';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { WorkingSetEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { autorunWithStore, autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
+
+const decoratorQuickDiffModelOptions = {
+    algorithm: 'legacy',
+    maxComputationTimeMs: 1000
+};
+let QuickDiffModelReferenceCollection = class QuickDiffModelReferenceCollection extends ReferenceCollection {
+    constructor(_instantiationService) {
+        super();
+        this._instantiationService = _instantiationService;
+    }
+    createReferencedObject(_key, textFileModel, options) {
+        return this._instantiationService.createInstance(QuickDiffModel, textFileModel, options);
+    }
+    destroyReferencedObject(_key, object) {
+        object.dispose();
+    }
+};
+QuickDiffModelReferenceCollection = ( __decorate([
+    ( __param(0, IInstantiationService))
+], QuickDiffModelReferenceCollection));
+let QuickDiffModelService = class QuickDiffModelService {
+    constructor(instantiationService, textFileService, uriIdentityService) {
+        this.instantiationService = instantiationService;
+        this.textFileService = textFileService;
+        this.uriIdentityService = uriIdentityService;
+        this._references = this.instantiationService.createInstance(QuickDiffModelReferenceCollection);
+    }
+    createQuickDiffModelReference(resource, options = decoratorQuickDiffModelOptions) {
+        const textFileModel = this.textFileService.files.get(resource);
+        if (!textFileModel?.isResolved()) {
+            return undefined;
+        }
+        resource = this.uriIdentityService.asCanonicalUri(resource).with({ query: JSON.stringify(options) });
+        return this._references.acquire(( resource.toString()), textFileModel, options);
+    }
+};
+QuickDiffModelService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, IUriIdentityService))
+], QuickDiffModelService));
+let QuickDiffModel = class QuickDiffModel extends Disposable {
+    get originalTextModels() {
+        return ( Iterable.map(( this._originalEditorModels.values()), editorModel => editorModel.textEditorModel));
+    }
+    get changes() { return this._changes; }
+    get quickDiffChanges() { return this._quickDiffChanges; }
+    constructor(textFileModel, options, scmService, quickDiffService, editorWorkerService, configurationService, textModelResolverService, _chatEditingService, progressService) {
+        super();
+        this.options = options;
+        this.scmService = scmService;
+        this.quickDiffService = quickDiffService;
+        this.editorWorkerService = editorWorkerService;
+        this.configurationService = configurationService;
+        this.textModelResolverService = textModelResolverService;
+        this._chatEditingService = _chatEditingService;
+        this.progressService = progressService;
+        this._originalEditorModels = ( new ResourceMap());
+        this._originalEditorModelsDisposables = this._register(( new DisposableStore()));
+        this._disposed = false;
+        this._quickDiffs = [];
+        this._diffDelayer = ( new ThrottledDelayer(200));
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._changes = [];
+        this._quickDiffChanges = ( new Map());
+        this._repositoryDisposables = ( new DisposableMap());
+        this._model = textFileModel;
+        this._register(textFileModel.textEditorModel.onDidChangeContent(() => this.triggerDiff()));
+        this._register(Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.diffDecorationsIgnoreTrimWhitespace') || e.affectsConfiguration('diffEditor.ignoreTrimWhitespace'))(this.triggerDiff, this));
+        this._register(scmService.onDidAddRepository(this.onDidAddRepository, this));
+        for (const r of scmService.repositories) {
+            this.onDidAddRepository(r);
+        }
+        this._register(this._model.onDidChangeEncoding(() => {
+            this._diffDelayer.cancel();
+            this._quickDiffs = [];
+            this._originalEditorModels.clear();
+            this._quickDiffsPromise = undefined;
+            this.setChanges([], ( new Map()));
+            this.triggerDiff();
+        }));
+        this._register(this.quickDiffService.onDidChangeQuickDiffProviders(() => this.triggerDiff()));
+        this._register(autorunWithStore((r, store) => {
+            for (const session of this._chatEditingService.editingSessionsObs.read(r)) {
+                store.add(autorun(r => {
+                    for (const entry of session.entries.read(r)) {
+                        entry.state.read(r);
+                    }
+                    this.triggerDiff();
+                }));
+            }
+        }));
+        this.triggerDiff();
+    }
+    get quickDiffs() {
+        return this._quickDiffs;
+    }
+    getQuickDiffResults() {
+        return ( this._quickDiffs.map(quickDiff => {
+            const changes = this.changes
+                .filter(change => change.label === quickDiff.label);
+            return {
+                label: quickDiff.label,
+                original: quickDiff.originalResource,
+                modified: this._model.resource,
+                changes: ( changes.map(change => change.change)),
+                changes2: ( changes.map(change => change.change2))
+            };
+        }));
+    }
+    getDiffEditorModel(originalUri) {
+        const editorModel = this._originalEditorModels.get(originalUri);
+        return editorModel ?
+            {
+                modified: this._model.textEditorModel,
+                original: editorModel.textEditorModel
+            } : undefined;
+    }
+    onDidAddRepository(repository) {
+        const disposables = ( new DisposableStore());
+        disposables.add(repository.provider.onDidChangeResources(this.triggerDiff, this));
+        const onDidRemoveRepository = Event.filter(this.scmService.onDidRemoveRepository, r => r === repository);
+        disposables.add(onDidRemoveRepository(() => this._repositoryDisposables.deleteAndDispose(repository)));
+        this._repositoryDisposables.set(repository, disposables);
+        this.triggerDiff();
+    }
+    triggerDiff() {
+        if (!this._diffDelayer) {
+            return;
+        }
+        this._diffDelayer
+            .trigger(async () => {
+            const result = await this.diff();
+            const editorModels = Array.from(( this._originalEditorModels.values()));
+            if (!result || this._disposed || this._model.isDisposed() || ( editorModels.some(editorModel => editorModel.isDisposed()))) {
+                return;
+            }
+            this.setChanges(result.changes, result.mapChanges);
+        })
+            .catch(err => onUnexpectedError(err));
+    }
+    setChanges(changes, mapChanges) {
+        const diff = sortedDiff(this.changes, changes, (a, b) => compareChanges(a.change, b.change));
+        this._changes = changes;
+        this._quickDiffChanges = mapChanges;
+        this._onDidChange.fire({ changes, diff });
+    }
+    diff() {
+        return this.progressService.withProgress({ location: ProgressLocation.Scm, delay: 250 }, async () => {
+            const originalURIs = await this.getQuickDiffsPromise();
+            if (this._disposed || this._model.isDisposed() || (originalURIs.length === 0)) {
+                return Promise.resolve({ changes: [], mapChanges: ( new Map()) });
+            }
+            const filteredToDiffable = originalURIs.filter(quickDiff => this.editorWorkerService.canComputeDirtyDiff(quickDiff.originalResource, this._model.resource));
+            if (filteredToDiffable.length === 0) {
+                return Promise.resolve({ changes: [], mapChanges: ( new Map()) });
+            }
+            const ignoreTrimWhitespaceSetting = this.configurationService.getValue('scm.diffDecorationsIgnoreTrimWhitespace');
+            const ignoreTrimWhitespace = ignoreTrimWhitespaceSetting === 'inherit'
+                ? this.configurationService.getValue('diffEditor.ignoreTrimWhitespace')
+                : ignoreTrimWhitespaceSetting !== 'false';
+            const allDiffs = [];
+            for (const quickDiff of filteredToDiffable) {
+                const diff = await this._diff(quickDiff.originalResource, this._model.resource, ignoreTrimWhitespace);
+                if (diff.changes && diff.changes2 && diff.changes.length === diff.changes2.length) {
+                    for (let index = 0; index < diff.changes.length; index++) {
+                        allDiffs.push({
+                            label: quickDiff.label,
+                            original: quickDiff.originalResource,
+                            modified: this._model.resource,
+                            change: diff.changes[index],
+                            change2: diff.changes2[index]
+                        });
+                    }
+                }
+            }
+            const sorted = allDiffs.sort((a, b) => compareChanges(a.change, b.change));
+            const map = ( new Map());
+            for (let i = 0; i < sorted.length; i++) {
+                const label = sorted[i].label;
+                if (!( map.has(label))) {
+                    map.set(label, []);
+                }
+                map.get(label).push(i);
+            }
+            return { changes: sorted, mapChanges: map };
+        });
+    }
+    async _diff(original, modified, ignoreTrimWhitespace) {
+        const maxComputationTimeMs = this.options.maxComputationTimeMs ?? Number.MAX_SAFE_INTEGER;
+        const result = await this.editorWorkerService.computeDiff(original, modified, {
+            computeMoves: false, ignoreTrimWhitespace, maxComputationTimeMs
+        }, this.options.algorithm);
+        return { changes: result ? toLineChanges(DiffState.fromDiffResult(result)) : null, changes2: result?.changes ?? null };
+    }
+    getQuickDiffsPromise() {
+        if (this._quickDiffsPromise) {
+            return this._quickDiffsPromise;
+        }
+        this._quickDiffsPromise = this.getOriginalResource().then(async (quickDiffs) => {
+            if (this._disposed) {
+                return [];
+            }
+            if (quickDiffs.length === 0) {
+                this._quickDiffs = [];
+                this._originalEditorModels.clear();
+                return [];
+            }
+            if (equals(this._quickDiffs, quickDiffs, (a, b) => ( a.originalResource.toString()) === ( b.originalResource.toString()) && a.label === b.label)) {
+                return quickDiffs;
+            }
+            this._quickDiffs = quickDiffs;
+            this._originalEditorModels.clear();
+            this._originalEditorModelsDisposables.clear();
+            return (await Promise.all(( quickDiffs.map(async (quickDiff) => {
+                try {
+                    const ref = await this.textModelResolverService.createModelReference(quickDiff.originalResource);
+                    if (this._disposed) {
+                        ref.dispose();
+                        return [];
+                    }
+                    this._originalEditorModels.set(quickDiff.originalResource, ref.object);
+                    if (isTextFileEditorModel(ref.object)) {
+                        const encoding = this._model.getEncoding();
+                        if (encoding) {
+                            ref.object.setEncoding(encoding, EncodingMode.Decode);
+                        }
+                    }
+                    this._originalEditorModelsDisposables.add(ref);
+                    this._originalEditorModelsDisposables.add(ref.object.textEditorModel.onDidChangeContent(() => this.triggerDiff()));
+                    return quickDiff;
+                }
+                catch (error) {
+                    return [];
+                }
+            })))).flat();
+        });
+        return this._quickDiffsPromise.finally(() => {
+            this._quickDiffsPromise = undefined;
+        });
+    }
+    async getOriginalResource() {
+        if (this._disposed) {
+            return Promise.resolve([]);
+        }
+        const uri = this._model.resource;
+        const isBeingModifiedByChatEdits = ( this._chatEditingService.editingSessionsObs.get()
+            .some(
+            session => session.getEntry(uri)?.state.get() === WorkingSetEntryState.Modified
+        ));
+        if (isBeingModifiedByChatEdits) {
+            return Promise.resolve([]);
+        }
+        const isSynchronized = this._model.textEditorModel ? shouldSynchronizeModel(this._model.textEditorModel) : undefined;
+        return this.quickDiffService.getQuickDiffs(uri, this._model.getLanguageId(), isSynchronized);
+    }
+    findNextClosestChange(lineNumber, inclusive = true, provider) {
+        let preferredProvider;
+        if (!provider && inclusive) {
+            preferredProvider = this.quickDiffs.find(value => value.isSCM)?.label;
+        }
+        const possibleChanges = [];
+        for (let i = 0; i < this.changes.length; i++) {
+            if (provider && this.changes[i].label !== provider) {
+                continue;
+            }
+            if (!this.quickDiffs.find(quickDiff => quickDiff.label === this.changes[i].label)?.visible) {
+                continue;
+            }
+            const change = this.changes[i];
+            const possibleChangesLength = possibleChanges.length;
+            if (inclusive) {
+                if (getModifiedEndLineNumber(change.change) >= lineNumber) {
+                    if (preferredProvider && change.label !== preferredProvider) {
+                        possibleChanges.push(i);
+                    }
+                    else {
+                        return i;
+                    }
+                }
+            }
+            else {
+                if (change.change.modifiedStartLineNumber > lineNumber) {
+                    return i;
+                }
+            }
+            if ((possibleChanges.length > 0) && (possibleChanges.length === possibleChangesLength)) {
+                return possibleChanges[0];
+            }
+        }
+        return possibleChanges.length > 0 ? possibleChanges[0] : 0;
+    }
+    findPreviousClosestChange(lineNumber, inclusive = true, provider) {
+        for (let i = this.changes.length - 1; i >= 0; i--) {
+            if (provider && this.changes[i].label !== provider) {
+                continue;
+            }
+            if (!this.quickDiffs.find(quickDiff => quickDiff.label === this.changes[i].label)?.visible) {
+                continue;
+            }
+            const change = this.changes[i].change;
+            if (inclusive) {
+                if (change.modifiedStartLineNumber <= lineNumber) {
+                    return i;
+                }
+            }
+            else {
+                if (getModifiedEndLineNumber(change) < lineNumber) {
+                    return i;
+                }
+            }
+        }
+        return this.changes.length - 1;
+    }
+    dispose() {
+        this._disposed = true;
+        this._quickDiffs = [];
+        this._diffDelayer.cancel();
+        this._originalEditorModels.clear();
+        this._repositoryDisposables.dispose();
+        super.dispose();
+    }
+};
+QuickDiffModel = ( __decorate([
+    ( __param(2, ISCMService)),
+    ( __param(3, IQuickDiffService)),
+    ( __param(4, IEditorWorkerService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, IChatEditingService)),
+    ( __param(8, IProgressService))
+], QuickDiffModel));
+
+export { QuickDiffModel, QuickDiffModelService };

package/vscode/src/vs/workbench/contrib/scm/browser/quickDiffWidget.d.ts

@@ -0,0 +1,78 @@
+import { Action, IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IContextViewService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { ISelectOptionItem } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/selectBox/selectBox";
+import { SelectActionViewItem } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { EditorAction } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
+import { IInstantiationService, ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IEditorContribution } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon";
+import { IQuickDiffModelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/quickDiffModel.service";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export declare const isQuickDiffVisible: RawContextKey<boolean>;
+export interface IQuickDiffSelectItem extends ISelectOptionItem {
+    provider: string;
+}
+export declare class QuickDiffPickerViewItem extends SelectActionViewItem<IQuickDiffSelectItem> {
+    private readonly optionsItems;
+    constructor(action: IAction, providers: string[], selected: string, contextViewService: IContextViewService, themeService: IThemeService);
+    setSelection(provider: string): void;
+    protected getActionContext(_: string, index: number): IQuickDiffSelectItem;
+    render(container: HTMLElement): void;
+}
+export declare class QuickDiffPickerBaseAction extends Action {
+    private readonly callback;
+    static readonly ID = "quickDiff.base.switch";
+    static readonly LABEL: string;
+    constructor(callback: (event?: IQuickDiffSelectItem) => void);
+    run(event?: IQuickDiffSelectItem): Promise<void>;
+}
+export declare class QuickDiffEditorController extends Disposable implements IEditorContribution {
+    private editor;
+    private readonly configurationService;
+    private readonly quickDiffModelService;
+    private readonly instantiationService;
+    static readonly ID = "editor.contrib.quickdiff";
+    static get(editor: ICodeEditor): QuickDiffEditorController | null;
+    private model;
+    private widget;
+    private readonly isQuickDiffVisible;
+    private session;
+    private mouseDownInfo;
+    private enabled;
+    private readonly gutterActionDisposables;
+    private stylesheet;
+    constructor(editor: ICodeEditor, contextKeyService: IContextKeyService, configurationService: IConfigurationService, quickDiffModelService: IQuickDiffModelService, instantiationService: IInstantiationService);
+    private onDidChangeGutterAction;
+    canNavigate(): boolean;
+    refresh(): void;
+    next(lineNumber?: number): void;
+    previous(lineNumber?: number): void;
+    close(): void;
+    private assertWidget;
+    private onDidModelChange;
+    private onEditorMouseDown;
+    private onEditorMouseUp;
+    dispose(): void;
+}
+export declare class ShowPreviousChangeAction extends EditorAction {
+    private readonly outerEditor?;
+    constructor(outerEditor?: ICodeEditor | undefined);
+    run(accessor: ServicesAccessor): void;
+}
+export declare class ShowNextChangeAction extends EditorAction {
+    private readonly outerEditor?;
+    constructor(outerEditor?: ICodeEditor | undefined);
+    run(accessor: ServicesAccessor): void;
+}
+export declare class GotoPreviousChangeAction extends EditorAction {
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}
+export declare class GotoNextChangeAction extends EditorAction {
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}