Small diff editor refactoring

src/vs/base/common/observableInternal/base.ts

@@ -3,7 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
+import { recomputeInitiallyAndOnChange } from 'vs/base/common/observable';
 import type { derivedOpts } from 'vs/base/common/observableInternal/derived';
 import { getLogger } from 'vs/base/common/observableInternal/logging';
 
@@ -63,6 +64,11 @@ export interface IObservable<T, TChange = unknown> {
 	map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
 	map<TNew>(owner: object, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
 
+	/**
+	 * Makes sure this value is computed eagerly.
+	 */
+	recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
+
 	/**
 	 * A human-readable name for debugging purposes.
 	 */
@@ -145,6 +151,12 @@ export interface ITransaction {
 	updateObserver(observer: IObserver, observable: IObservable<any, any>): void;
 }
 
+let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
+
+export function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange) {
+	_recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
+}
+
 let _derived: typeof derivedOpts;
 /**
  * @internal
@@ -207,6 +219,11 @@ export abstract class ConvenientObservable<T, TChange> implements IObservable<T,
 		);
 	}
 
+	public recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T> {
+		store.add(_recomputeInitiallyAndOnChange!(this, handleValue));
+		return this;
+	}
+
 	public abstract get debugName(): string;
 }
 

src/vs/base/common/observableInternal/derived.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { BugIndicatingError } from 'vs/base/common/errors';
-import { DisposableStore } from 'vs/base/common/lifecycle';
+import { IDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { IReader, IObservable, BaseObservable, IObserver, _setDerivedOpts, IChangeContext, getFunctionName, DebugNameFn, getDebugName } from 'vs/base/common/observableInternal/base';
 import { getLogger } from 'vs/base/common/observableInternal/logging';
 
@@ -90,6 +90,37 @@ export function derivedWithStore<T>(computeFnOrOwner: ((reader: IReader, store:
 	);
 }
 
+export function derivedDisposable<T extends IDisposable | undefined>(computeFn: (reader: IReader) => T): IObservable<T>;
+export function derivedDisposable<T extends IDisposable | undefined>(owner: object, computeFn: (reader: IReader) => T): IObservable<T>;
+export function derivedDisposable<T extends IDisposable | undefined>(computeFnOrOwner: ((reader: IReader) => T) | object, computeFnOrUndefined?: ((reader: IReader) => T)): IObservable<T> {
+	let computeFn: (reader: IReader) => T;
+	let owner: object | undefined;
+	if (computeFnOrUndefined === undefined) {
+		computeFn = computeFnOrOwner as any;
+		owner = undefined;
+	} else {
+		owner = computeFnOrOwner;
+		computeFn = computeFnOrUndefined as any;
+	}
+
+	const store = new DisposableStore();
+	return new Derived(
+		owner,
+		(() => getFunctionName(computeFn) ?? '(anonymous)'),
+		r => {
+			store.clear();
+			const result = computeFn(r);
+			if (result) {
+				store.add(result);
+			}
+			return result;
+		}, undefined,
+		undefined,
+		() => store.dispose(),
+		defaultEqualityComparer
+	);
+}
+
 _setDerivedOpts(derivedOpts);
 
 const enum DerivedState {

src/vs/base/common/observableInternal/utils.ts

@@ -6,7 +6,7 @@
 import { Event } from 'vs/base/common/event';
 import { DisposableStore, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { autorun } from 'vs/base/common/observableInternal/autorun';
-import { BaseObservable, ConvenientObservable, IObservable, IObserver, IReader, ITransaction, getDebugName, getFunctionName, observableValue, subtransaction, transaction } from 'vs/base/common/observableInternal/base';
+import { BaseObservable, ConvenientObservable, IObservable, IObserver, IReader, ITransaction, _setRecomputeInitiallyAndOnChange, getDebugName, getFunctionName, observableValue, subtransaction, transaction } from 'vs/base/common/observableInternal/base';
 import { derived } from 'vs/base/common/observableInternal/derived';
 import { getLogger } from 'vs/base/common/observableInternal/logging';
 
@@ -324,7 +324,7 @@ export function wasEventTriggeredRecently(event: Event<any>, timeoutMs: number,
  * This makes sure the observable is being observed and keeps its cache alive.
  */
 export function keepObserved<T>(observable: IObservable<T>): IDisposable {
-	const o = new KeepAliveObserver(false);
+	const o = new KeepAliveObserver(false, undefined);
 	observable.addObserver(o);
 	return toDisposable(() => {
 		observable.removeObserver(o);
@@ -334,29 +334,42 @@ export function keepObserved<T>(observable: IObservable<T>): IDisposable {
 /**
  * This converts the given observable into an autorun.
  */
-export function recomputeInitiallyAndOnChange<T>(observable: IObservable<T>): IDisposable {
-	const o = new KeepAliveObserver(true);
+export function recomputeInitiallyAndOnChange<T>(observable: IObservable<T>, handleValue?: (value: T) => void): IDisposable {
+	const o = new KeepAliveObserver(true, handleValue);
 	observable.addObserver(o);
-	observable.reportChanges();
+	if (handleValue) {
+		handleValue(observable.get());
+	} else {
+		observable.reportChanges();
+	}
 
 	return toDisposable(() => {
 		observable.removeObserver(o);
 	});
 }
 
+_setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange);
+
 class KeepAliveObserver implements IObserver {
-	private counter = 0;
+	private _counter = 0;
 
-	constructor(private readonly forceRecompute: boolean) { }
+	constructor(
+		private readonly _forceRecompute: boolean,
+		private readonly _handleValue: ((value: any) => void) | undefined,
+	) { }
 
 	beginUpdate<T>(observable: IObservable<T, void>): void {
-		this.counter++;
+		this._counter++;
 	}
 
 	endUpdate<T>(observable: IObservable<T, void>): void {
-		this.counter--;
-		if (this.counter === 0 && this.forceRecompute) {
-			observable.reportChanges();
+		this._counter--;
+		if (this._counter === 0 && this._forceRecompute) {
+			if (this._handleValue) {
+				this._handleValue(observable.get());
+			} else {
+				observable.reportChanges();
+			}
 		}
 	}
 

src/vs/editor/browser/widget/diffEditor/diffEditorEditors.ts

@@ -25,6 +25,9 @@ export class DiffEditorEditors extends Disposable {
 	private readonly _onDidContentSizeChange = this._register(new Emitter<IContentSizeChangedEvent>());
 	public get onDidContentSizeChange() { return this._onDidContentSizeChange.event; }
 
+	public readonly modifiedScrollTop: IObservable<number>;
+	public readonly modifiedScrollHeight: IObservable<number>;
+
 	public readonly modifiedModel: IObservable<ITextModel | null>;
 
 	constructor(
@@ -43,6 +46,9 @@ export class DiffEditorEditors extends Disposable {
 
 		this.modifiedModel = observableFromEvent(this.modified.onDidChangeModel, () => /** @description modified.model */ this.modified.getModel());
 
+		this.modifiedScrollTop = observableFromEvent(this.modified.onDidScrollChange, () => /** @description modified.getScrollTop */ this.modified.getScrollTop());
+		this.modifiedScrollHeight = observableFromEvent(this.modified.onDidScrollChange, () => /** @description modified.getScrollHeight */ this.modified.getScrollHeight());
+
 		this._register(autorunHandleChanges({
 			createEmptyChangeSummary: () => ({} as IDiffEditorConstructionOptions),
 			handleChange: (ctx, changeSummary) => {

src/vs/editor/browser/widget/diffEditor/diffEditorSash.ts

@@ -28,6 +28,7 @@ export class DiffEditorSash extends Disposable {
 		private readonly _options: DiffEditorOptions,
 		private readonly _domNode: HTMLElement,
 		private readonly _dimensions: { height: IObservable<number>; width: IObservable<number> },
+		private readonly _sashes: IObservable<IBoundarySashes | undefined, void>,
 	) {
 		super();
 
@@ -42,6 +43,13 @@ export class DiffEditorSash extends Disposable {
 		this._register(this._sash.onDidEnd(() => this._sash.layout()));
 		this._register(this._sash.onDidReset(() => this._sashRatio.set(undefined, undefined)));
 
+		this._register(autorun(reader => {
+			const sashes = this._sashes.read(reader);
+			if (sashes) {
+				this._sash.orthogonalEndSash = sashes.bottom;
+			}
+		}));
+
 		this._register(autorun(reader => {
 			/** @description DiffEditorSash.layoutSash */
 			const enabled = this._options.enableSplitViewResizing.read(reader);
@@ -52,10 +60,6 @@ export class DiffEditorSash extends Disposable {
 		}));
 	}
 
-	setBoundarySashes(sashes: IBoundarySashes): void {
-		this._sash.orthogonalEndSash = sashes.bottom;
-	}
-
 	/** @pure */
 	private _computeSashLeft(desiredRatio: number, reader: IReader | undefined): number {
 		const contentWidth = this._dimensions.width.read(reader);