Fixes view node parents in Launchpad view

Author: eamodio

src/views/draftsView.ts

@@ -11,7 +11,7 @@ import { ensurePlusFeaturesEnabled } from '../plus/gk/utils/-webview/plus.utils'
 import { executeCommand } from '../system/-webview/command';
 import { configuration } from '../system/-webview/configuration';
 import { gate } from '../system/decorators/-webview/gate';
-import { groupByFilterMap } from '../system/iterable';
+import { groupByFilterMap, map } from '../system/iterable';
 import { CacheableChildrenViewNode } from './nodes/abstract/cacheableChildrenViewNode';
 import type { ViewNode } from './nodes/abstract/viewNode';
 import { DraftNode } from './nodes/draftNode';
@@ -35,25 +35,29 @@ export class DraftsViewNode extends CacheableChildrenViewNode<'drafts', DraftsVi
 				const drafts = await this.view.container.drafts.getDrafts();
 				drafts?.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
 
-				const groups = groupByFilterMap(
-					drafts,
-					this.calcDraftGroupKey.bind(this),
-					d => new DraftNode(this.uri, this.view, this, d),
-				);
+				const groups = groupByFilterMap(drafts, getDraftGroupKey, d => d);
 
 				const mine = groups.get('mine');
 				const shared = groups.get('shared');
 				const isFlat = mine?.length && !shared?.length;
 
 				if (!isFlat) {
 					if (mine?.length) {
-						children.push(new GroupingNode(this.view, 'Created by Me', mine));
+						children.push(
+							new GroupingNode(this.view, this, 'Created by Me', p =>
+								mine.map(d => new DraftNode(this.uri, this.view, p, d)),
+							),
+						);
 					}
 					if (shared?.length) {
-						children.push(new GroupingNode(this.view, 'Shared with Me', shared));
+						children.push(
+							new GroupingNode(this.view, this, 'Shared with Me', p =>
+								shared.map(d => new DraftNode(this.uri, this.view, p, d)),
+							),
+						);
 					}
 				} else {
-					children.push(...mine);
+					children.push(...map(mine, d => new DraftNode(this.uri, this.view, this, d)));
 				}
 			} catch (ex) {
 				if (!(ex instanceof AuthenticationRequiredError)) throw ex;
@@ -70,13 +74,6 @@ export class DraftsViewNode extends CacheableChildrenViewNode<'drafts', DraftsVi
 		const item = new TreeItem('Drafts', TreeItemCollapsibleState.Expanded);
 		return item;
 	}
-
-	private calcDraftGroupKey(d: Draft): DraftGroupKey {
-		if (d.type === 'suggested_pr_change') {
-			return 'pr_suggestion';
-		}
-		return d.isMine ? 'mine' : 'shared';
-	}
 }
 
 type DraftGroupKey = 'pr_suggestion' | 'mine' | 'shared';
@@ -201,3 +198,9 @@ export class DraftsView extends ViewBase<'drafts', DraftsViewNode, DraftsViewCon
 		return configuration.updateEffective(`views.${this.configKey}.avatars` as const, enabled);
 	}
 }
+
+function getDraftGroupKey(d: Draft): DraftGroupKey {
+	if (d.type === 'suggested_pr_change') return 'pr_suggestion';
+
+	return d.isMine ? 'mine' : 'shared';
+}

src/views/launchpadView.ts

@@ -163,9 +163,7 @@ export class LaunchpadViewNode extends CacheableChildrenViewNode<
 			const children: (GroupingNode | LaunchpadItemNode)[] = [];
 
 			const hasIntegrations = await this.view.container.launchpad.hasConnectedIntegration();
-			if (!hasIntegrations) {
-				return [];
-			}
+			if (!hasIntegrations) return [];
 
 			try {
 				const result = await this.view.container.launchpad.getCategorizedItems();
@@ -190,15 +188,17 @@ export class LaunchpadViewNode extends CacheableChildrenViewNode<
 					children.push(
 						new LaunchpadViewGroupingNode(
 							this.view,
+							this,
 							launchpadGroupLabelMap.get(ui)!,
 							ui,
-							groupItems.map(i => new LaunchpadItemNode(this.view, this, ui, i)),
-							ui === 'current-branch' || expanded.get(ui)
-								? TreeItemCollapsibleState.Expanded
-								: TreeItemCollapsibleState.Collapsed,
-							undefined,
-							undefined,
-							new ThemeIcon(icon.substring(2, icon.length - 1)),
+							p => groupItems.map(i => new LaunchpadItemNode(this.view, p, ui, i)),
+							{
+								collapsibleState:
+									ui === 'current-branch' || expanded.get(ui)
+										? TreeItemCollapsibleState.Expanded
+										: TreeItemCollapsibleState.Collapsed,
+								iconPath: new ThemeIcon(icon.substring(2, icon.length - 1)),
+							},
 						),
 					);
 				}

src/views/nodes/groupingNode.ts

@@ -6,28 +6,33 @@ import { ContextValues, ViewNode } from './abstract/viewNode';
 export class GroupingNode<TChild extends ViewNode = ViewNode> extends ViewNode<'grouping'> {
 	constructor(
 		view: View,
+		parent: ViewNode,
 		private readonly label: string,
-		private readonly childrenOrFn: TChild[] | Promise<TChild[]> | (() => TChild[] | Promise<TChild[]>),
-		private readonly collapsibleState: TreeItemCollapsibleState = TreeItemCollapsibleState.Expanded,
-		private readonly description?: string,
-		private readonly tooltip?: string,
-		private readonly iconPath?: TreeItem['iconPath'],
-		private readonly contextValue?: string,
+		private readonly children: (parent: ViewNode) => TChild[] | Promise<TChild[]>,
+		private readonly options?: {
+			readonly collapsibleState?: TreeItemCollapsibleState;
+			readonly contextValue?: ContextValues;
+			readonly description?: string;
+			readonly iconPath?: TreeItem['iconPath'];
+			readonly tooltip?: string;
+		},
 	) {
-		super('grouping', unknownGitUri, view);
+		super('grouping', unknownGitUri, view, parent);
 	}
 
 	getChildren(): ViewNode[] | Promise<ViewNode[]> {
-		return typeof this.childrenOrFn === 'function' ? this.childrenOrFn() : this.childrenOrFn;
+		return this.children(this);
 	}
 
 	getTreeItem(): TreeItem {
-		const item = new TreeItem(this.label, this.collapsibleState);
+		const { collapsibleState, description, tooltip, iconPath, contextValue } = this.options ?? {};
+
+		const item = new TreeItem(this.label, collapsibleState ?? TreeItemCollapsibleState.Expanded);
 		item.id = this.id;
-		item.contextValue = this.contextValue ?? ContextValues.Grouping;
-		item.description = this.description;
-		item.tooltip = this.tooltip;
-		item.iconPath = this.iconPath;
+		item.contextValue = contextValue ?? ContextValues.Grouping;
+		item.description = description;
+		item.tooltip = tooltip;
+		item.iconPath = iconPath;
 		return item;
 	}
 }

src/views/nodes/launchpadViewGroupingNode.ts

@@ -2,34 +2,45 @@ import type { TreeItem } from 'vscode';
 import { Disposable, TreeItemCollapsibleState } from 'vscode';
 import type { LaunchpadGroup } from '../../plus/launchpad/models/launchpad';
 import type { TreeViewNodeCollapsibleStateChangeEvent, View } from '../viewBase';
-import type { ViewNode } from './abstract/viewNode';
+import type { ContextValues, ViewNode } from './abstract/viewNode';
+import { getViewNodeId } from './abstract/viewNode';
 import { GroupingNode } from './groupingNode';
 
 export class LaunchpadViewGroupingNode<TChild extends ViewNode = ViewNode> extends GroupingNode {
 	private disposable: Disposable;
 
 	constructor(
 		view: View,
+		parent: ViewNode,
 		label: string,
 		private readonly group: LaunchpadGroup,
-		childrenOrFn: TChild[] | Promise<TChild[]> | (() => TChild[] | Promise<TChild[]>),
-		collapsibleState: TreeItemCollapsibleState = TreeItemCollapsibleState.Expanded,
-		description?: string,
-		tooltip?: string,
-		iconPath?: TreeItem['iconPath'],
-		contextValue?: string,
+		children: (parent: ViewNode) => TChild[] | Promise<TChild[]>,
+		options?: {
+			readonly collapsibleState?: TreeItemCollapsibleState;
+			readonly contextValue?: ContextValues;
+			readonly description?: string;
+			readonly iconPath?: TreeItem['iconPath'];
+			readonly tooltip?: string;
+		},
 	) {
-		super(view, label, childrenOrFn, collapsibleState, description, tooltip, iconPath, contextValue);
+		super(view, parent, label, children, options);
 		this.disposable = Disposable.from(
 			this.view.onDidChangeNodeCollapsibleState(this.onNodeCollapsibleStateChanged, this),
 		);
+
+		this.updateContext({ launchpadGroup: group });
+		this._uniqueId = getViewNodeId(this.type, this.context);
 	}
 
 	override dispose(): void {
 		super.dispose();
 		this.disposable?.dispose();
 	}
 
+	override get id(): string {
+		return this._uniqueId;
+	}
+
 	private onNodeCollapsibleStateChanged(e: TreeViewNodeCollapsibleStateChangeEvent<ViewNode>) {
 		if (e.element === this) {
 			const storedExpandedGroups = this.view.container.storage.get('launchpadView:groups:expanded') ?? [];