@codingame/monaco-vscode-scm-service-override 36.2.7 → 37.1.0

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

@@ -0,0 +1,430 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import * as dirtydiffDecorator from './media/dirtydiffDecorator.css';
+import { Disposable, DisposableStore, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ModelDecorationOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { isCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { OverviewRulerLane, MinimapPosition } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { createStyleSheet } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/domStylesheets';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { minimapGutterAddedBackground, overviewRulerAddedForeground, minimapGutterModifiedBackground, overviewRulerModifiedForeground, minimapGutterDeletedBackground, overviewRulerDeletedForeground, getChangeType, ChangeType } 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 { IQuickDiffModelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/quickDiffModel.service';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { RawContextKey, ContextKeyTrueExpr, ContextKeyFalseExpr } 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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var QuickDiffDecorator_1;
+registerCss(dirtydiffDecorator);
+const quickDiffDecorationCount = ( new RawContextKey("quickDiffDecorationCount", 0));
+let QuickDiffDecorator = QuickDiffDecorator_1 = class QuickDiffDecorator extends Disposable {
+    static createDecoration(className, tooltip, options) {
+        const decorationOptions = {
+            description: "dirty-diff-decoration",
+            isWholeLine: options.isWholeLine
+        };
+        if (options.gutter) {
+            decorationOptions.linesDecorationsClassName = `dirty-diff-glyph ${className}`;
+            decorationOptions.linesDecorationsTooltip = tooltip;
+        }
+        if (options.overview.active) {
+            decorationOptions.overviewRuler = {
+                color: themeColorFromId(options.overview.color),
+                position: OverviewRulerLane.Left
+            };
+        }
+        if (options.minimap.active) {
+            decorationOptions.minimap = {
+                color: themeColorFromId(options.minimap.color),
+                position: MinimapPosition.Gutter
+            };
+        }
+        return ModelDecorationOptions.createDynamic(decorationOptions);
+    }
+    constructor(codeEditor, quickDiffModelRef, configurationService, quickDiffService) {
+        super();
+        this.codeEditor = codeEditor;
+        this.quickDiffModelRef = quickDiffModelRef;
+        this.configurationService = configurationService;
+        this.quickDiffService = quickDiffService;
+        const decorations = configurationService.getValue("scm.diffDecorations");
+        const gutter = decorations === "all" || decorations === "gutter";
+        const overview = decorations === "all" || decorations === "overview";
+        const minimap = decorations === "all" || decorations === "minimap";
+        const diffAdded = ( localize(15650, "Added lines"));
+        const diffAddedOptions = {
+            gutter,
+            overview: {
+                active: overview,
+                color: overviewRulerAddedForeground
+            },
+            minimap: {
+                active: minimap,
+                color: minimapGutterAddedBackground
+            },
+            isWholeLine: true
+        };
+        this.addedOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-added primary", diffAdded, diffAddedOptions);
+        this.addedPatternOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-added primary pattern", diffAdded, diffAddedOptions);
+        this.addedSecondaryOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-added secondary", diffAdded, diffAddedOptions);
+        this.addedSecondaryPatternOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-added secondary pattern", diffAdded, diffAddedOptions);
+        const diffModified = ( localize(15651, "Changed lines"));
+        const diffModifiedOptions = {
+            gutter,
+            overview: {
+                active: overview,
+                color: overviewRulerModifiedForeground
+            },
+            minimap: {
+                active: minimap,
+                color: minimapGutterModifiedBackground
+            },
+            isWholeLine: true
+        };
+        this.modifiedOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-modified primary", diffModified, diffModifiedOptions);
+        this.modifiedPatternOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-modified primary pattern", diffModified, diffModifiedOptions);
+        this.modifiedSecondaryOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-modified secondary", diffModified, diffModifiedOptions);
+        this.modifiedSecondaryPatternOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-modified secondary pattern", diffModified, diffModifiedOptions);
+        const diffDeleted = ( localize(15652, "Removed lines"));
+        const diffDeletedOptions = {
+            gutter,
+            overview: {
+                active: overview,
+                color: overviewRulerDeletedForeground
+            },
+            minimap: {
+                active: minimap,
+                color: minimapGutterDeletedBackground
+            },
+            isWholeLine: false
+        };
+        this.deletedOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-deleted primary", diffDeleted, diffDeletedOptions);
+        this.deletedSecondaryOptions = QuickDiffDecorator_1.createDecoration("dirty-diff-deleted secondary", diffDeleted, diffDeletedOptions);
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("scm.diffDecorationsGutterPattern")) {
+                this.onDidChange();
+            }
+        }));
+        this._register(
+            Event.runAndSubscribe(this.quickDiffModelRef.object.onDidChange, () => this.onDidChange())
+        );
+    }
+    onDidChange() {
+        if (!this.codeEditor.hasModel()) {
+            return;
+        }
+        const pattern = this.configurationService.getValue("scm.diffDecorationsGutterPattern");
+        const primaryQuickDiff = this.quickDiffModelRef.object.quickDiffs.find(quickDiff => quickDiff.kind === "primary");
+        const primaryQuickDiffChanges = this.quickDiffModelRef.object.changes.filter(change => change.providerId === primaryQuickDiff?.id);
+        const decorations = [];
+        for (const change of this.quickDiffModelRef.object.changes) {
+            const quickDiff = this.quickDiffModelRef.object.quickDiffs.find(quickDiff => quickDiff.id === change.providerId);
+            if (!quickDiff || !this.quickDiffService.isQuickDiffProviderVisible(quickDiff.id)) {
+                continue;
+            }
+            if (quickDiff.kind !== "primary" && ( primaryQuickDiffChanges.some(c => c.change2.modified.intersectsOrTouches(change.change2.modified)))) {
+                continue;
+            }
+            const changeType = getChangeType(change.change);
+            const startLineNumber = change.change.modifiedStartLineNumber;
+            const endLineNumber = change.change.modifiedEndLineNumber || startLineNumber;
+            switch (changeType) {
+            case ChangeType.Add:
+                decorations.push({
+                    range: {
+                        startLineNumber: startLineNumber,
+                        startColumn: 1,
+                        endLineNumber: endLineNumber,
+                        endColumn: 1
+                    },
+                    options: quickDiff.kind === "primary" || quickDiff.kind === "contributed" ? pattern.added ? this.addedPatternOptions : this.addedOptions : pattern.added ? this.addedSecondaryPatternOptions : this.addedSecondaryOptions
+                });
+                break;
+            case ChangeType.Delete:
+                decorations.push({
+                    range: {
+                        startLineNumber: startLineNumber,
+                        startColumn: Number.MAX_VALUE,
+                        endLineNumber: startLineNumber,
+                        endColumn: Number.MAX_VALUE
+                    },
+                    options: quickDiff.kind === "primary" || quickDiff.kind === "contributed" ? this.deletedOptions : this.deletedSecondaryOptions
+                });
+                break;
+            case ChangeType.Modify:
+                decorations.push({
+                    range: {
+                        startLineNumber: startLineNumber,
+                        startColumn: 1,
+                        endLineNumber: endLineNumber,
+                        endColumn: 1
+                    },
+                    options: quickDiff.kind === "primary" || quickDiff.kind === "contributed" ? pattern.modified ? this.modifiedPatternOptions : this.modifiedOptions : pattern.modified ? this.modifiedSecondaryPatternOptions : this.modifiedSecondaryOptions
+                });
+                break;
+            }
+        }
+        if (!this.decorationsCollection) {
+            this.decorationsCollection = this.codeEditor.createDecorationsCollection(decorations);
+        } else {
+            this.decorationsCollection.set(decorations);
+        }
+    }
+    dispose() {
+        if (this.decorationsCollection) {
+            this.decorationsCollection.clear();
+        }
+        this.decorationsCollection = undefined;
+        this.quickDiffModelRef.dispose();
+        super.dispose();
+    }
+};
+QuickDiffDecorator = QuickDiffDecorator_1 = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, IQuickDiffService))], QuickDiffDecorator));
+let QuickDiffWorkbenchController = class QuickDiffWorkbenchController extends Disposable {
+    constructor(
+        editorService,
+        configurationService,
+        quickDiffModelService,
+        quickDiffService,
+        uriIdentityService,
+        contextKeyService
+    ) {
+        super();
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+        this.quickDiffModelService = quickDiffModelService;
+        this.quickDiffService = quickDiffService;
+        this.uriIdentityService = uriIdentityService;
+        this.enabled = false;
+        this.decorators = ( new ResourceMap());
+        this.viewState = {
+            width: 3,
+            visibility: "always"
+        };
+        this.transientDisposables = this._register(( new DisposableStore()));
+        this.stylesheet = createStyleSheet(undefined, undefined, this._store);
+        this.quickDiffDecorationCount = quickDiffDecorationCount.bindTo(contextKeyService);
+        this.activeEditor = observableFromEvent(
+            this,
+            this.editorService.onDidActiveEditorChange,
+            () => this.editorService.activeEditor
+        );
+        this.quickDiffProviders = observableFromEvent(
+            this,
+            this.quickDiffService.onDidChangeQuickDiffProviders,
+            () => this.quickDiffService.providers
+        );
+        const onDidChangeConfiguration = Event.filter(
+            configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration("scm.diffDecorations")
+        );
+        this._register(onDidChangeConfiguration(this.onDidChangeConfiguration, this));
+        this.onDidChangeConfiguration();
+        const onDidChangeDiffWidthConfiguration = Event.filter(
+            configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration("scm.diffDecorationsGutterWidth")
+        );
+        this._register(
+            onDidChangeDiffWidthConfiguration(this.onDidChangeDiffWidthConfiguration, this)
+        );
+        this.onDidChangeDiffWidthConfiguration();
+        const onDidChangeDiffVisibilityConfiguration = Event.filter(
+            configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration("scm.diffDecorationsGutterVisibility")
+        );
+        this._register(
+            onDidChangeDiffVisibilityConfiguration(this.onDidChangeDiffVisibilityConfiguration, this)
+        );
+        this.onDidChangeDiffVisibilityConfiguration();
+    }
+    onDidChangeConfiguration() {
+        const enabled = this.configurationService.getValue("scm.diffDecorations") !== "none";
+        if (enabled) {
+            this.enable();
+        } else {
+            this.disable();
+        }
+    }
+    onDidChangeDiffWidthConfiguration() {
+        let width = this.configurationService.getValue("scm.diffDecorationsGutterWidth");
+        if (isNaN(width) || width <= 0 || width > 5) {
+            width = 3;
+        }
+        this.setViewState({
+            ...this.viewState,
+            width
+        });
+    }
+    onDidChangeDiffVisibilityConfiguration() {
+        const visibility = this.configurationService.getValue("scm.diffDecorationsGutterVisibility");
+        this.setViewState({
+            ...this.viewState,
+            visibility
+        });
+    }
+    setViewState(state) {
+        this.viewState = state;
+        this.stylesheet.textContent = `
+            .monaco-editor .dirty-diff-added,
+            .monaco-editor .dirty-diff-modified {
+                border-left-width:${state.width}px;
+            }
+            .monaco-editor .dirty-diff-added.pattern,
+            .monaco-editor .dirty-diff-added.pattern:before,
+            .monaco-editor .dirty-diff-modified.pattern,
+            .monaco-editor .dirty-diff-modified.pattern:before {
+                background-size: ${state.width}px ${state.width}px;
+            }
+            .monaco-editor .dirty-diff-added,
+            .monaco-editor .dirty-diff-modified,
+            .monaco-editor .dirty-diff-deleted {
+                opacity: ${state.visibility === "always" ? 1 : 0};
+            }
+        `;
+    }
+    enable() {
+        if (this.enabled) {
+            this.disable();
+        }
+        this.transientDisposables.add(Event.any(
+            this.editorService.onDidCloseEditor,
+            this.editorService.onDidVisibleEditorsChange
+        )(() => this.onEditorsChanged()));
+        this.onEditorsChanged();
+        this.onDidActiveEditorChange();
+        this.onDidChangeQuickDiffProviders();
+        this.enabled = true;
+    }
+    disable() {
+        if (!this.enabled) {
+            return;
+        }
+        this.transientDisposables.clear();
+        this.quickDiffDecorationCount.set(0);
+        for (const [uri, decoratorMap] of this.decorators.entries()) {
+            decoratorMap.dispose();
+            this.decorators.delete(uri);
+        }
+        this.enabled = false;
+    }
+    onDidActiveEditorChange() {
+        this.transientDisposables.add(autorun(reader => {
+            const activeEditor = this.activeEditor.read(reader);
+            const activeTextEditorControl = this.editorService.activeTextEditorControl;
+            if (!isCodeEditor(activeTextEditorControl) || !activeEditor?.resource) {
+                this.quickDiffDecorationCount.set(0);
+                return;
+            }
+            const quickDiffModelRef = this.quickDiffModelService.createQuickDiffModelReference(activeEditor.resource);
+            if (!quickDiffModelRef) {
+                this.quickDiffDecorationCount.set(0);
+                return;
+            }
+            reader.store.add(quickDiffModelRef);
+            const visibleDecorationCount = observableFromEvent(this, quickDiffModelRef.object.onDidChange, () => {
+                const visibleQuickDiffs = quickDiffModelRef.object.quickDiffs.filter(
+                    quickDiff => this.quickDiffService.isQuickDiffProviderVisible(quickDiff.id)
+                );
+                return quickDiffModelRef.object.changes.filter(change => ( visibleQuickDiffs.some(quickDiff => quickDiff.id === change.providerId))).length;
+            });
+            reader.store.add(autorun(reader => {
+                const count = visibleDecorationCount.read(reader);
+                this.quickDiffDecorationCount.set(count);
+            }));
+        }));
+    }
+    onDidChangeQuickDiffProviders() {
+        this.transientDisposables.add(autorun(reader => {
+            const providers = this.quickDiffProviders.read(reader);
+            const labels = [];
+            for (let index = 0; index < providers.length; index++) {
+                const provider = providers[index];
+                if (labels.includes(provider.label)) {
+                    continue;
+                }
+                const visible = this.quickDiffService.isQuickDiffProviderVisible(provider.id);
+                const group = provider.kind !== "contributed" ? "0_scm" : "1_contributed";
+                const order = index + 1;
+                reader.store.add(registerAction2(class extends Action2 {
+                    constructor() {
+                        super({
+                            id: `workbench.scm.action.toggleQuickDiffVisibility.${provider.id}`,
+                            title: provider.label,
+                            toggled: visible ? ContextKeyTrueExpr.INSTANCE : ContextKeyFalseExpr.INSTANCE,
+                            menu: {
+                                id: MenuId.SCMQuickDiffDecorations,
+                                group,
+                                order
+                            },
+                            f1: false
+                        });
+                    }
+                    run(accessor) {
+                        const quickDiffService = accessor.get(IQuickDiffService);
+                        quickDiffService.toggleQuickDiffProviderVisibility(provider.id);
+                    }
+                }));
+                labels.push(provider.label);
+            }
+        }));
+    }
+    onEditorsChanged() {
+        for (const editor of this.editorService.visibleTextEditorControls) {
+            if (!isCodeEditor(editor)) {
+                continue;
+            }
+            const textModel = editor.getModel();
+            if (!textModel) {
+                continue;
+            }
+            const editorId = editor.getId();
+            if (this.decorators.get(textModel.uri)?.has(editorId)) {
+                continue;
+            }
+            const quickDiffModelRef = this.quickDiffModelService.createQuickDiffModelReference(textModel.uri);
+            if (!quickDiffModelRef) {
+                continue;
+            }
+            if (!( this.decorators.has(textModel.uri))) {
+                this.decorators.set(textModel.uri, ( new DisposableMap()));
+            }
+            this.decorators.get(textModel.uri).set(editorId, ( new QuickDiffDecorator(
+                editor,
+                quickDiffModelRef,
+                this.configurationService,
+                this.quickDiffService
+            )));
+        }
+        for (const [uri, decoratorMap] of this.decorators.entries()) {
+            for (const editorId of ( decoratorMap.keys())) {
+                const codeEditor = this.editorService.visibleTextEditorControls.find(
+                    editor => isCodeEditor(editor) && editor.getId() === editorId && this.uriIdentityService.extUri.isEqual(editor.getModel()?.uri, uri)
+                );
+                if (!codeEditor) {
+                    decoratorMap.deleteAndDispose(editorId);
+                }
+            }
+            if (decoratorMap.size === 0) {
+                decoratorMap.dispose();
+                this.decorators.delete(uri);
+            }
+        }
+    }
+    dispose() {
+        this.disable();
+        super.dispose();
+    }
+};
+QuickDiffWorkbenchController = ( __decorate([( __param(0, IEditorService)), ( __param(1, IConfigurationService)), ( __param(2, IQuickDiffModelService)), ( __param(3, IQuickDiffService)), ( __param(4, IUriIdentityService)), ( __param(5, IContextKeyService))], QuickDiffWorkbenchController));
+
+export { QuickDiffWorkbenchController, quickDiffDecorationCount };

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

@@ -211,6 +211,9 @@ let QuickDiffModel = class QuickDiffModel extends Disposable {
             location,
             delay: 250
         }, async () => {
+            if (this._disposed || this._model.isDisposed()) {
+                return null;
+            }
             const versionId = this._model.textEditorModel.getVersionId();
             const originalURIs = await this.getQuickDiffsPromise();
             if (this._disposed || this._model.isDisposed() || (originalURIs.length === 0)) {

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

@@ -0,0 +1,80 @@
+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";
+import { QuickDiff } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff";
+export declare const isQuickDiffVisible: RawContextKey<boolean>;
+export interface IQuickDiffSelectItem extends ISelectOptionItem {
+    providerId: string;
+}
+export declare class QuickDiffPickerViewItem extends SelectActionViewItem<IQuickDiffSelectItem> {
+    private optionsItems;
+    constructor(action: IAction, contextViewService: IContextViewService, themeService: IThemeService, configurationService: IConfigurationService);
+    setSelection(quickDiffs: QuickDiff[], providerId: 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;
+    toggleFocus(): 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>;
+}