Renames isCommandContext* commands

src/commands/common.ts

@@ -216,82 +216,82 @@ export interface CommandBaseContext {
 }
 
 export interface CommandScmGroupsContext extends CommandBaseContext {
-	type: 'scm-groups';
-	scmResourceGroups: SourceControlResourceGroup[];
+	readonly type: 'scm-groups';
+	readonly scmResourceGroups: SourceControlResourceGroup[];
 }
 
 export interface CommandScmStatesContext extends CommandBaseContext {
-	type: 'scm-states';
-	scmResourceStates: SourceControlResourceState[];
+	readonly type: 'scm-states';
+	readonly scmResourceStates: SourceControlResourceState[];
 }
 
 export interface CommandUnknownContext extends CommandBaseContext {
-	type: 'unknown';
+	readonly type: 'unknown';
 }
 
 export interface CommandUriContext extends CommandBaseContext {
-	type: 'uri';
+	readonly type: 'uri';
 }
 
 export interface CommandUrisContext extends CommandBaseContext {
-	type: 'uris';
-	uris: Uri[];
+	readonly type: 'uris';
+	readonly uris: Uri[];
 }
 
 // export interface CommandViewContext extends CommandBaseContext {
-//     type: 'view';
+//     readonly type: 'view';
 // }
 
-export interface CommandViewItemContext extends CommandBaseContext {
-	type: 'viewItem';
-	node: ViewNode;
+export interface CommandViewNodeContext extends CommandBaseContext {
+	readonly type: 'viewItem';
+	readonly node: ViewNode;
 }
 
-export function isCommandViewContextWithBranch(
+export function isCommandContextViewNodeHasBranch(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { branch: GitBranch } } {
+): context is CommandViewNodeContext & { node: ViewNode & { branch: GitBranch } } {
 	if (context.type !== 'viewItem') return false;
 
 	return GitBranch.is((context.node as ViewNode & { branch: GitBranch }).branch);
 }
 
-export function isCommandViewContextWithCommit<T extends GitCommit>(
+export function isCommandContextViewNodeHasCommit<T extends GitCommit>(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { commit: T } } {
+): context is CommandViewNodeContext & { node: ViewNode & { commit: T } } {
 	if (context.type !== 'viewItem') return false;
 
 	return GitCommit.is((context.node as ViewNode & { commit: GitCommit }).commit);
 }
 
-export function isCommandViewContextWithContributor(
+export function isCommandContextViewNodeHasContributor(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { contributor: GitContributor } } {
+): context is CommandViewNodeContext & { node: ViewNode & { contributor: GitContributor } } {
 	if (context.type !== 'viewItem') return false;
 
 	return GitContributor.is((context.node as ViewNode & { contributor: GitContributor }).contributor);
 }
 
-export function isCommandViewContextWithFile(
+export function isCommandContextViewNodeHasFile(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { file: GitFile; repoPath: string } } {
+): context is CommandViewNodeContext & { node: ViewNode & { file: GitFile; repoPath: string } } {
 	if (context.type !== 'viewItem') return false;
 
 	const node = context.node as ViewNode & { file: GitFile; repoPath: string };
 	return node.file != null && (node.file.repoPath != null || node.repoPath != null);
 }
 
-export function isCommandViewContextWithFileCommit(
+export function isCommandContextViewNodeHasFileCommit(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { commit: GitCommit; file: GitFile; repoPath: string } } {
+): context is CommandViewNodeContext & { node: ViewNode & { commit: GitCommit; file: GitFile; repoPath: string } } {
 	if (context.type !== 'viewItem') return false;
 
 	const node = context.node as ViewNode & { commit: GitCommit; file: GitFile; repoPath: string };
 	return node.file != null && GitCommit.is(node.commit) && (node.file.repoPath != null || node.repoPath != null);
 }
 
-export function isCommandViewContextWithFileRefs(
+export function isCommandContextViewNodeHasFileRefs(
 	context: CommandContext,
-): context is CommandViewItemContext & {
+): context is CommandViewNodeContext & {
 	node: ViewNode & { file: GitFile; ref1: string; ref2: string; repoPath: string };
 } {
 	if (context.type !== 'viewItem') return false;
@@ -305,39 +305,39 @@ export function isCommandViewContextWithFileRefs(
 	);
 }
 
-export function isCommandViewContextWithRef(
+export function isCommandContextViewNodeHasRef(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { ref: string } } {
+): context is CommandViewNodeContext & { node: ViewNode & { ref: string } } {
 	return context.type === 'viewItem' && context.node instanceof ViewRefNode;
 }
 
-export function isCommandViewContextWithRemote(
+export function isCommandContextViewNodeHasRemote(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { remote: GitRemote } } {
+): context is CommandViewNodeContext & { node: ViewNode & { remote: GitRemote } } {
 	if (context.type !== 'viewItem') return false;
 
 	return GitRemote.is((context.node as ViewNode & { remote: GitRemote }).remote);
 }
 
-export function isCommandViewContextWithRepo(
+export function isCommandContextViewNodeHasRepository(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { repo: Repository } } {
+): context is CommandViewNodeContext & { node: ViewNode & { repo: Repository } } {
 	if (context.type !== 'viewItem') return false;
 
 	return (context.node as ViewNode & { repo?: Repository }).repo instanceof Repository;
 }
 
-export function isCommandViewContextWithRepoPath(
+export function isCommandContextViewNodeHasRepoPath(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { repoPath: string } } {
+): context is CommandViewNodeContext & { node: ViewNode & { repoPath: string } } {
 	if (context.type !== 'viewItem') return false;
 
 	return typeof (context.node as ViewNode & { repoPath?: string }).repoPath === 'string';
 }
 
-export function isCommandViewContextWithTag(
+export function isCommandContextViewNodeHasTag(
 	context: CommandContext,
-): context is CommandViewItemContext & { node: ViewNode & { tag: GitTag } } {
+): context is CommandViewNodeContext & { node: ViewNode & { tag: GitTag } } {
 	if (context.type !== 'viewItem') return false;
 
 	return GitTag.is((context.node as ViewNode & { tag: GitTag }).tag);
@@ -350,24 +350,23 @@ export type CommandContext =
 	| CommandUriContext
 	| CommandUrisContext
 	// | CommandViewContext
-	| CommandViewItemContext;
+	| CommandViewNodeContext;
 
 function isScmResourceGroup(group: any): group is SourceControlResourceGroup {
 	if (group == null) return false;
 
 	return (
-		(group as SourceControl).inputBox == null &&
 		(group as SourceControlResourceGroup).id != null &&
-		(group.handle != null ||
-			(group as SourceControlResourceGroup).label != null ||
-			(group as SourceControlResourceGroup).resourceStates != null)
+		(group as SourceControlResourceGroup).label != null &&
+		(group as SourceControlResourceGroup).resourceStates != null &&
+		Array.isArray((group as SourceControlResourceGroup).resourceStates)
 	);
 }
 
-function isScmResourceState(state: any): state is SourceControlResourceState {
-	if (state == null) return false;
+function isScmResourceState(resource: any): resource is SourceControlResourceState {
+	if (resource == null) return false;
 
-	return (state as SourceControlResourceState).resourceUri != null;
+	return (resource as SourceControlResourceState).resourceUri != null;
 }
 
 export abstract class Command implements Disposable {

src/commands/copyMessageToClipboard.ts

@@ -11,7 +11,7 @@ import {
 	CommandContext,
 	Commands,
 	getCommandUri,
-	isCommandViewContextWithCommit,
+	isCommandContextViewNodeHasCommit,
 } from './common';
 
 export interface CopyMessageToClipboardCommandArgs {
@@ -26,7 +26,7 @@ export class CopyMessageToClipboardCommand extends ActiveEditorCommand {
 	}
 
 	protected preExecute(context: CommandContext, args?: CopyMessageToClipboardCommandArgs) {
-		if (isCommandViewContextWithCommit(context)) {
+		if (isCommandContextViewNodeHasCommit(context)) {
 			args = { ...args };
 			args.sha = context.node.commit.sha;
 			return this.execute(context.editor, context.node.commit.uri, args);

src/commands/copyShaToClipboard.ts

@@ -11,9 +11,9 @@ import {
 	CommandContext,
 	Commands,
 	getCommandUri,
-	isCommandViewContextWithBranch,
-	isCommandViewContextWithCommit,
-	isCommandViewContextWithTag,
+	isCommandContextViewNodeHasBranch,
+	isCommandContextViewNodeHasCommit,
+	isCommandContextViewNodeHasTag,
 } from './common';
 
 export interface CopyShaToClipboardCommandArgs {
@@ -27,15 +27,15 @@ export class CopyShaToClipboardCommand extends ActiveEditorCommand {
 	}
 
 	protected preExecute(context: CommandContext, args?: CopyShaToClipboardCommandArgs) {
-		if (isCommandViewContextWithCommit(context)) {
+		if (isCommandContextViewNodeHasCommit(context)) {
 			args = { ...args };
 			args.sha = context.node.commit.sha;
 			return this.execute(context.editor, context.node.commit.uri, args);
-		} else if (isCommandViewContextWithBranch(context)) {
+		} else if (isCommandContextViewNodeHasBranch(context)) {
 			args = { ...args };
 			args.sha = context.node.branch.sha;
 			return this.execute(context.editor, context.node.uri, args);
-		} else if (isCommandViewContextWithTag(context)) {
+		} else if (isCommandContextViewNodeHasTag(context)) {
 			args = { ...args };
 			args.sha = context.node.tag.sha;
 			return this.execute(context.editor, context.node.uri, args);

src/commands/externalDiff.ts

@@ -6,8 +6,8 @@ import {
 	CommandContext,
 	Commands,
 	getRepoPathOrPrompt,
-	isCommandViewContextWithFileCommit,
-	isCommandViewContextWithFileRefs,
+	isCommandContextViewNodeHasFileCommit,
+	isCommandContextViewNodeHasFileRefs,
 } from './common';
 import { Container } from '../container';
 import { GitRevision } from '../git/git';
@@ -68,7 +68,7 @@ export class ExternalDiffCommand extends Command {
 	protected async preExecute(context: CommandContext, args?: ExternalDiffCommandArgs) {
 		args = { ...args };
 
-		if (isCommandViewContextWithFileCommit(context)) {
+		if (isCommandContextViewNodeHasFileCommit(context)) {
 			const ref1 = GitRevision.isUncommitted(context.node.commit.previousFileSha)
 				? ''
 				: context.node.commit.previousFileSha;
@@ -86,7 +86,7 @@ export class ExternalDiffCommand extends Command {
 			return this.execute(args);
 		}
 
-		if (isCommandViewContextWithFileRefs(context)) {
+		if (isCommandContextViewNodeHasFileRefs(context)) {
 			args.files = [
 				{
 					uri: GitUri.fromFile(context.node.file, context.node.file.repoPath ?? context.node.repoPath),

src/commands/inviteToLiveShare.ts

@@ -1,5 +1,5 @@
 'use strict';
-import { command, Command, CommandContext, Commands, isCommandViewContextWithContributor } from './common';
+import { command, Command, CommandContext, Commands, isCommandContextViewNodeHasContributor } from './common';
 import { Container } from '../container';
 
 export interface InviteToLiveShareCommandArgs {
@@ -21,7 +21,7 @@ export class InviteToLiveShareCommand extends Command {
 	}
 
 	protected preExecute(context: CommandContext, args?: InviteToLiveShareCommandArgs) {
-		if (isCommandViewContextWithContributor(context)) {
+		if (isCommandContextViewNodeHasContributor(context)) {
 			args = { ...args };
 			args.email = context.node.contributor.email;
 			return this.execute(args);

src/commands/openBranchOnRemote.ts

@@ -8,7 +8,7 @@ import {
 	executeCommand,
 	getCommandUri,
 	getRepoPathOrActiveOrPrompt,
-	isCommandViewContextWithBranch,
+	isCommandContextViewNodeHasBranch,
 } from './common';
 import { BranchSorting } from '../configuration';
 import { RemoteResourceType } from '../git/git';
@@ -30,7 +30,7 @@ export class OpenBranchOnRemoteCommand extends ActiveEditorCommand {
 	}
 
 	protected preExecute(context: CommandContext, args?: OpenBranchOnRemoteCommandArgs) {
-		if (isCommandViewContextWithBranch(context)) {
+		if (isCommandContextViewNodeHasBranch(context)) {
 			args = {
 				...args,
 				branch: context.node.branch.name,

src/commands/openBranchesOnRemote.ts

@@ -11,7 +11,7 @@ import {
 	executeCommand,
 	getCommandUri,
 	getRepoPathOrActiveOrPrompt,
-	isCommandViewContextWithRemote,
+	isCommandContextViewNodeHasRemote,
 } from './common';
 import { OpenOnRemoteCommandArgs } from './openOnRemote';
 
@@ -27,7 +27,7 @@ export class OpenBranchesOnRemoteCommand extends ActiveEditorCommand {
 	}
 
 	protected preExecute(context: CommandContext, args?: OpenBranchesOnRemoteCommandArgs) {
-		if (isCommandViewContextWithRemote(context)) {
+		if (isCommandContextViewNodeHasRemote(context)) {
 			args = { ...args, remote: context.node.remote.name };
 		}
 

src/commands/openCommitOnRemote.ts

@@ -7,7 +7,7 @@ import {
 	Commands,
 	executeCommand,
 	getCommandUri,
-	isCommandViewContextWithCommit,
+	isCommandContextViewNodeHasCommit,
 } from './common';
 import { Container } from '../container';
 import { RemoteResourceType } from '../git/git';
@@ -37,7 +37,7 @@ export class OpenCommitOnRemoteCommand extends ActiveEditorCommand {
 	protected preExecute(context: CommandContext, args?: OpenCommitOnRemoteCommandArgs) {
 		let uri = context.uri;
 
-		if (isCommandViewContextWithCommit(context)) {
+		if (isCommandContextViewNodeHasCommit(context)) {
 			if (context.node.commit.isUncommitted) return Promise.resolve(undefined);
 
 			args = { ...args, sha: context.node.commit.sha };

src/commands/openDirectoryCompare.ts

@@ -7,7 +7,7 @@ import {
 	Commands,
 	getCommandUri,
 	getRepoPathOrActiveOrPrompt,
-	isCommandViewContextWithRef,
+	isCommandContextViewNodeHasRef,
 } from './common';
 import { Container } from '../container';
 import { Logger } from '../logger';
@@ -47,7 +47,7 @@ export class OpenDirectoryCompareCommand extends ActiveEditorCommand {
 				break;
 
 			case Commands.ViewsOpenDirectoryDiffWithWorking:
-				if (isCommandViewContextWithRef(context)) {
+				if (isCommandContextViewNodeHasRef(context)) {
 					args = { ...args };
 					args.ref1 = context.node.ref;
 					args.ref2 = undefined;

src/commands/openFileOnRemote.ts

@@ -7,8 +7,8 @@ import {
 	Commands,
 	executeCommand,
 	getCommandUri,
-	isCommandViewContextWithBranch,
-	isCommandViewContextWithCommit,
+	isCommandContextViewNodeHasBranch,
+	isCommandContextViewNodeHasCommit,
 } from './common';
 import { UriComparer } from '../comparers';
 import { BranchSorting } from '../configuration';
@@ -40,13 +40,13 @@ export class OpenFileOnRemoteCommand extends ActiveEditorCommand {
 
 		if (context.type === 'uris' || context.type === 'scm-states') {
 			args = { ...args, range: false };
-		} else if (isCommandViewContextWithCommit(context)) {
+		} else if (isCommandContextViewNodeHasCommit(context)) {
 			args = { ...args, range: false };
 
 			if (context.command === Commands.CopyRemoteFileUrl) {
 				// If it is a StatusFileNode then don't include the sha, since it hasn't been pushed yet
 				args.sha = context.node instanceof StatusFileNode ? undefined : context.node.commit.sha;
-			} else if (isCommandViewContextWithBranch(context)) {
+			} else if (isCommandContextViewNodeHasBranch(context)) {
 				args.branch = context.node.branch?.name;
 			}