Improves grouped view selection

 - Moves selection tracking from Views class into ScmGroupedView
 - Adds default selection to ensure views always have a selected node

Author: eamodio

src/views/scmGroupedView.ts

@@ -34,6 +34,10 @@ export class ScmGroupedView implements Disposable {
 	private _cleared: Deferred<void> | undefined;
 	private _clearLoadingTimer: ReturnType<typeof setTimeout> | undefined;
 	private readonly _disposable: Disposable;
+	private _lastSelectedByView = new Map<
+		GroupableTreeViewTypes,
+		{ node: ViewNode; parents: ViewNode[] | undefined; expanded: boolean }
+	>();
 	private _loaded: Deferred<void> | undefined;
 	private _onDidChangeTreeData: EventEmitter<ViewNode | undefined> | undefined;
 	private _tree: TreeView<ViewNode> | undefined;
@@ -63,6 +67,26 @@ export class ScmGroupedView implements Disposable {
 	async clearView<T extends GroupableTreeViewTypes>(type: T): Promise<void> {
 		if (this._view == null || this._view.type === type) return;
 
+		// Save current selection before switching views
+		const node: ViewNode | undefined = this._view.selection?.[0];
+		if (node != null) {
+			const parents: ViewNode[] = [];
+
+			let parent: ViewNode | undefined = node;
+			while (true) {
+				parent = parent.getParent();
+				if (parent == null) break;
+
+				parents.unshift(parent);
+			}
+
+			this._lastSelectedByView.set(this._view.type, {
+				node: node,
+				parents: parents,
+				expanded: this._view.isNodeExpanded(node),
+			});
+		}
+
 		void setContext('gitlens:views:scm:grouped:loading', true);
 		clearTimeout(this._clearLoadingTimer);
 
@@ -114,11 +138,39 @@ export class ScmGroupedView implements Disposable {
 		this._loaded?.cancel();
 		this._loaded = defer<void>();
 		void this._loaded.promise.then(
-			() => {
+			async () => {
 				this._loaded = undefined;
 
-				if (focus) {
-					setTimeout(() => void this._view?.show({ preserveFocus: false }), 50);
+				const view = this._view;
+				if (view != null) {
+					if (!view.visible) {
+						await view.show({ preserveFocus: !focus });
+					}
+
+					let selection = this._lastSelectedByView.get(type);
+
+					setTimeout(async () => {
+						if (selection == null && view.selection?.length) {
+							selection = { node: view.selection[0], parents: undefined, expanded: false };
+						}
+						if (selection == null) {
+							if (focus) {
+								await view.show({ preserveFocus: false });
+							}
+							return;
+						}
+
+						const { node, parents, expanded } = selection;
+						if (parents == null) {
+							await view.revealDeep(node, { expand: expanded, focus: focus ?? false, select: true });
+						} else {
+							await view.revealDeep(node, parents, {
+								expand: expanded,
+								focus: focus ?? false,
+								select: true,
+							});
+						}
+					}, 50);
 				}
 
 				this._clearLoadingTimer = setTimeout(

src/views/viewBase.ts

@@ -448,6 +448,7 @@ export abstract class ViewBase<
 			this.tree = window.createTreeView<ViewNode>(this.id, { ...options, treeDataProvider: this });
 			this.disposables.push(this.tree);
 		}
+		this._defaultSelection = [];
 
 		this.disposables.push(
 			configuration.onDidChange(e => {
@@ -513,12 +514,20 @@ export abstract class ViewBase<
 			if (!children.length) return children;
 
 			const index = children.findIndex(n => n instanceof GroupedHeaderNode);
-			if (index === 0) return children.length === 1 ? [] : children;
+			if (index === 0) {
+				this._defaultSelection = [children[0]];
+				return children.length === 1 ? [] : children;
+			}
 
+			let header: ViewNode | undefined;
 			if (index === -1) {
-				children.unshift(new GroupedHeaderNode(this as unknown as View, node));
+				header = new GroupedHeaderNode(this as unknown as View, node);
 			} else if (index > 0) {
-				children.unshift(children.splice(index, 1)[0]);
+				header = children.splice(index, 1)[0];
+			}
+			if (header != null) {
+				this._defaultSelection = [header];
+				children.unshift(header);
 			}
 
 			return children;
@@ -666,10 +675,11 @@ export abstract class ViewBase<
 		return this.tree.selection[0];
 	}
 
+	private _defaultSelection: readonly ViewNode[] = [];
 	get selection(): readonly ViewNode[] {
 		if (this.tree == null || this.root == null) return [];
 
-		return this.tree.selection;
+		return this.tree.selection.length === 0 ? this._defaultSelection : this.tree.selection;
 	}
 
 	get visible(): boolean {

src/views/views.ts

@@ -100,10 +100,6 @@ export class Views implements Disposable {
 		return this._scmGroupedViews;
 	}
 
-	private _lastSelectedByView = new Map<
-		GroupableTreeViewTypes,
-		{ node: ViewNode; parents: ViewNode[]; expanded: boolean }
-	>();
 	private _welcomeDismissed = false;
 
 	constructor(
@@ -504,48 +500,8 @@ export class Views implements Disposable {
 
 	private async setScmGroupedView<T extends GroupableTreeViewTypes>(type: T, focus?: boolean) {
 		if (this._scmGroupedView != null) {
-			// Save current selection before switching views
-			let { view } = this._scmGroupedView;
-			if (view) {
-				const node: ViewNode | undefined = view.selection?.[0];
-				if (node != null) {
-					const parents: ViewNode[] = [];
-
-					let parent: ViewNode | undefined = node;
-					while (true) {
-						parent = parent.getParent();
-						if (parent == null) break;
-
-						parents.unshift(parent);
-					}
-
-					this._lastSelectedByView.set(view.type, {
-						node: node,
-						parents: parents,
-						expanded: view.isNodeExpanded(node),
-					});
-				}
-			}
-
 			await this._scmGroupedView.clearView(type);
-			view = this._scmGroupedView.setView(type, focus);
-
-			// Restore the last selection for this view type (if any)
-			if (view) {
-				if (!view.visible) {
-					await view.show({ preserveFocus: !focus });
-				}
-
-				const selection = this._lastSelectedByView.get(type);
-				if (selection != null) {
-					setTimeout(async () => {
-						const { node, parents, expanded } = selection;
-						await view.revealDeep(node, parents, { expand: expanded, focus: focus ?? false, select: true });
-					}, 1);
-				}
-			}
-
-			return view;
+			return this._scmGroupedView.setView(type, focus);
 		}
 
 		if (!this.scmGroupedViews?.has(type)) {