Merge branch 'microsoft:main' into main

Author: ashwin31

extensions/git/src/git.ts

@@ -1995,6 +1995,26 @@ export class Repository {
 		});
 	}
 
+	async getHEADBranch(): Promise<Branch | undefined> {
+		let HEAD: Branch | undefined;
+
+		try {
+			HEAD = await this.getHEAD();
+
+			if (HEAD.name) {
+				try {
+					HEAD = await this.getBranch(HEAD.name);
+				} catch (err) {
+					// noop
+				}
+			}
+		} catch (err) {
+			// noop
+		}
+
+		return HEAD;
+	}
+
 	async getHEAD(): Promise<Ref> {
 		try {
 			// Attempt to parse the HEAD file

extensions/git/src/repository.ts

@@ -2017,27 +2017,19 @@ export class Repository implements Disposable {
 			this.telemetryReporter.sendTelemetryEvent('statusSlow', { ignoreSubmodules: String(ignoreSubmodules), didHitLimit: String(didHitLimit), didWarnAboutLimit: String(this.didWarnAboutLimit) }, { statusLength, totalTime });
 		}
 
-		let HEAD: Branch | undefined;
-
-		try {
-			HEAD = await this.repository.getHEAD();
-
-			if (HEAD.name) {
-				try {
-					HEAD = await this.repository.getBranch(HEAD.name);
-				} catch (err) {
-					// noop
-				}
-			}
-		} catch (err) {
-			// noop
-		}
-
 		let sort = config.get<'alphabetically' | 'committerdate'>('branchSortOrder') || 'alphabetically';
 		if (sort !== 'alphabetically' && sort !== 'committerdate') {
 			sort = 'alphabetically';
 		}
-		const [refs, remotes, submodules, rebaseCommit, mergeInProgress, commitTemplate] = await Promise.all([this.repository.getRefs({ sort }), this.repository.getRemotes(), this.repository.getSubmodules(), this.getRebaseCommit(), this.isMergeInProgress(), this.getInputTemplate()]);
+		const [HEAD, refs, remotes, submodules, rebaseCommit, mergeInProgress, commitTemplate] =
+			await Promise.all([
+				this.repository.getHEADBranch(),
+				this.repository.getRefs({ sort }),
+				this.repository.getRemotes(),
+				this.repository.getSubmodules(),
+				this.getRebaseCommit(),
+				this.isMergeInProgress(),
+				this.getInputTemplate()]);
 
 		this._HEAD = HEAD;
 		this._refs = refs!;

src/vs/editor/browser/editorExtensions.ts

@@ -248,7 +248,12 @@ export abstract class EditorCommand extends Command {
 		};
 	}
 
-	public runCommand(accessor: ServicesAccessor, args: any): void | Promise<void> {
+	public static runEditorCommand(
+		accessor: ServicesAccessor,
+		args: any,
+		precondition: ContextKeyExpression | undefined,
+		runner: (accessor: ServicesAccessor | null, editor: ICodeEditor, args: any) => void | Promise<void>
+	): void | Promise<void> {
 		const codeEditorService = accessor.get(ICodeEditorService);
 
 		// Find the editor with text focus or active
@@ -260,15 +265,19 @@ export abstract class EditorCommand extends Command {
 
 		return editor.invokeWithinContext((editorAccessor) => {
 			const kbService = editorAccessor.get(IContextKeyService);
-			if (!kbService.contextMatchesRules(withNullAsUndefined(this.precondition))) {
+			if (!kbService.contextMatchesRules(withNullAsUndefined(precondition))) {
 				// precondition does not hold
 				return;
 			}
 
-			return this.runEditorCommand(editorAccessor, editor!, args);
+			return runner(editorAccessor, editor, args);
 		});
 	}
 
+	public runCommand(accessor: ServicesAccessor, args: any): void | Promise<void> {
+		return EditorCommand.runEditorCommand(accessor, args, this.precondition, (accessor, editor, args) => this.runEditorCommand(accessor, editor, args));
+	}
+
 	public abstract runEditorCommand(accessor: ServicesAccessor | null, editor: ICodeEditor, args: any): void | Promise<void>;
 }
 

src/vs/editor/standalone/browser/standaloneEditor.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import 'vs/css!./standalone-tokens';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { splitLines } from 'vs/base/common/strings';
 import { URI } from 'vs/base/common/uri';
 import { FontMeasurements } from 'vs/editor/browser/config/fontMeasurements';
@@ -23,12 +23,16 @@ import { IModelService } from 'vs/editor/common/services/model';
 import { createWebWorker as actualCreateWebWorker, IWebWorkerOptions, MonacoWebWorker } from 'vs/editor/browser/services/webWorker';
 import * as standaloneEnums from 'vs/editor/common/standalone/standaloneEnums';
 import { Colorizer, IColorizerElementOptions, IColorizerOptions } from 'vs/editor/standalone/browser/colorizer';
-import { createTextModel, IStandaloneCodeEditor, IStandaloneDiffEditor, IStandaloneDiffEditorConstructionOptions, IStandaloneEditorConstructionOptions, StandaloneDiffEditor, StandaloneEditor } from 'vs/editor/standalone/browser/standaloneCodeEditor';
-import { IEditorOverrideServices, StandaloneServices } from 'vs/editor/standalone/browser/standaloneServices';
+import { createTextModel, IActionDescriptor, IStandaloneCodeEditor, IStandaloneDiffEditor, IStandaloneDiffEditorConstructionOptions, IStandaloneEditorConstructionOptions, StandaloneDiffEditor, StandaloneEditor } from 'vs/editor/standalone/browser/standaloneCodeEditor';
+import { IEditorOverrideServices, StandaloneKeybindingService, StandaloneServices } from 'vs/editor/standalone/browser/standaloneServices';
 import { StandaloneThemeService } from 'vs/editor/standalone/browser/standaloneThemeService';
 import { IStandaloneThemeData, IStandaloneThemeService } from 'vs/editor/standalone/common/standaloneTheme';
-import { CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { CommandsRegistry, ICommandHandler } from 'vs/platform/commands/common/commands';
 import { IMarker, IMarkerData, IMarkerService } from 'vs/platform/markers/common/markers';
+import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { EditorCommand, ServicesAccessor } from 'vs/editor/browser/editorExtensions';
+import { IMenuItem, MenuRegistry, MenuId } from 'vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
 
 /**
  * Create a new editor under `domElement`.
@@ -99,6 +103,119 @@ export function createDiffNavigator(diffEditor: IStandaloneDiffEditor, opts?: ID
 	return new DiffNavigator(diffEditor, opts);
 }
 
+/**
+ * Description of a command contribution
+ */
+export interface ICommandDescriptor {
+	/**
+	 * An unique identifier of the contributed command.
+	 */
+	id: string;
+	/**
+	 * Callback that will be executed when the command is triggered.
+	 */
+	run: ICommandHandler;
+}
+
+/**
+ * Add a command.
+ */
+export function addCommand(descriptor: ICommandDescriptor): IDisposable {
+	if ((typeof descriptor.id !== 'string') || (typeof descriptor.run !== 'function')) {
+		throw new Error('Invalid command descriptor, `id` and `run` are required properties!');
+	}
+	return CommandsRegistry.registerCommand(descriptor.id, descriptor.run);
+}
+
+/**
+ * Add an action to all editors.
+ */
+export function addEditorAction(descriptor: IActionDescriptor): IDisposable {
+	if ((typeof descriptor.id !== 'string') || (typeof descriptor.label !== 'string') || (typeof descriptor.run !== 'function')) {
+		throw new Error('Invalid action descriptor, `id`, `label` and `run` are required properties!');
+	}
+
+	const precondition = ContextKeyExpr.deserialize(descriptor.precondition);
+	const run = (accessor: ServicesAccessor, ...args: any[]): void | Promise<void> => {
+		return EditorCommand.runEditorCommand(accessor, args, precondition, (accessor, editor, args) => Promise.resolve(descriptor.run(editor, ...args)));
+	};
+
+	const toDispose = new DisposableStore();
+
+	// Register the command
+	toDispose.add(CommandsRegistry.registerCommand(descriptor.id, run));
+
+	// Register the context menu item
+	if (descriptor.contextMenuGroupId) {
+		const menuItem: IMenuItem = {
+			command: {
+				id: descriptor.id,
+				title: descriptor.label
+			},
+			when: precondition,
+			group: descriptor.contextMenuGroupId,
+			order: descriptor.contextMenuOrder || 0
+		};
+		toDispose.add(MenuRegistry.appendMenuItem(MenuId.EditorContext, menuItem));
+	}
+
+	// Register the keybindings
+	if (Array.isArray(descriptor.keybindings)) {
+		const keybindingService = StandaloneServices.get(IKeybindingService);
+		if (!(keybindingService instanceof StandaloneKeybindingService)) {
+			console.warn('Cannot add keybinding because the editor is configured with an unrecognized KeybindingService');
+		} else {
+			const keybindingsWhen = ContextKeyExpr.and(precondition, ContextKeyExpr.deserialize(descriptor.keybindingContext));
+			toDispose.add(keybindingService.addDynamicKeybindings(descriptor.keybindings.map((keybinding) => {
+				return {
+					keybinding,
+					command: descriptor.id,
+					when: keybindingsWhen
+				};
+			})));
+		}
+	}
+
+	return toDispose;
+}
+
+/**
+ * A keybinding rule.
+ */
+export interface IKeybindingRule {
+	keybinding: number;
+	command?: string | null;
+	commandArgs?: any;
+	when?: string | null;
+}
+
+/**
+ * Add a keybinding rule.
+ */
+export function addKeybindingRule(rule: IKeybindingRule): IDisposable {
+	return addKeybindingRules([rule]);
+}
+
+/**
+ * Add keybinding rules.
+ */
+export function addKeybindingRules(rules: IKeybindingRule[]): IDisposable {
+	const keybindingService = StandaloneServices.get(IKeybindingService);
+	if (!(keybindingService instanceof StandaloneKeybindingService)) {
+		console.warn('Cannot add keybinding because the editor is configured with an unrecognized KeybindingService');
+		return Disposable.None;
+	}
+
+	return keybindingService.addDynamicKeybindings(rules.map((rule) => {
+		return {
+			keybinding: rule.keybinding,
+			command: rule.command,
+			commandArgs: rule.commandArgs,
+			when: ContextKeyExpr.deserialize(rule.when),
+		};
+	}));
+}
+
 /**
  * Create a new editor model.
  * You can specify the language that should be set for this model or let the language be inferred from the `uri`.
@@ -325,6 +442,11 @@ export function createMonacoEditorAPI(): typeof monaco.editor {
 		createDiffEditor: <any>createDiffEditor,
 		createDiffNavigator: <any>createDiffNavigator,
 
+		addCommand: <any>addCommand,
+		addEditorAction: <any>addEditorAction,
+		addKeybindingRule: <any>addKeybindingRule,
+		addKeybindingRules: <any>addKeybindingRules,
+
 		createModel: <any>createModel,
 		setModelLanguage: <any>setModelLanguage,
 		setModelMarkers: <any>setModelMarkers,

src/vs/editor/standalone/browser/standaloneServices.ts

@@ -14,7 +14,7 @@ import * as dom from 'vs/base/browser/dom';
 import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Keybinding, ResolvedKeybinding, SimpleKeybinding, createKeybinding } from 'vs/base/common/keybindings';
-import { IDisposable, IReference, ImmortalReference, toDisposable, DisposableStore, Disposable } from 'vs/base/common/lifecycle';
+import { IDisposable, IReference, ImmortalReference, toDisposable, DisposableStore, Disposable, combinedDisposable } from 'vs/base/common/lifecycle';
 import { OS, isLinux, isMacintosh } from 'vs/base/common/platform';
 import Severity from 'vs/base/common/severity';
 import { URI } from 'vs/base/common/uri';
@@ -323,9 +323,16 @@ export class StandaloneCommandService implements ICommandService {
 	}
 }
 
+export interface IKeybindingRule {
+	keybinding: number;
+	command?: string | null;
+	commandArgs?: any;
+	when?: ContextKeyExpression | null;
+}
+
 export class StandaloneKeybindingService extends AbstractKeybindingService {
 	private _cachedResolver: KeybindingResolver | null;
-	private readonly _dynamicKeybindings: IKeybindingItem[];
+	private _dynamicKeybindings: IKeybindingItem[];
 	private readonly _domNodeListeners: DomNodeListeners[];
 
 	constructor(
@@ -403,39 +410,45 @@ export class StandaloneKeybindingService extends AbstractKeybindingService {
 		codeEditorService.listDiffEditors().forEach(addDiffEditor);
 	}
 
-	public addDynamicKeybinding(commandId: string, _keybinding: number, handler: ICommandHandler, when: ContextKeyExpression | undefined): IDisposable {
-		const keybinding = createKeybinding(_keybinding, OS);
-
-		const toDispose = new DisposableStore();
+	public addDynamicKeybinding(command: string, keybinding: number, handler: ICommandHandler, when: ContextKeyExpression | undefined): IDisposable {
+		return combinedDisposable(
+			CommandsRegistry.registerCommand(command, handler),
+			this.addDynamicKeybindings([{
+				keybinding,
+				command,
+				when
+			}])
+		);
+	}
 
-		if (keybinding) {
-			this._dynamicKeybindings.push({
-				keybinding: keybinding.parts,
-				command: commandId,
-				when: when,
+	public addDynamicKeybindings(rules: IKeybindingRule[]): IDisposable {
+		const entries: IKeybindingItem[] = rules.map((rule) => {
+			const keybinding = createKeybinding(rule.keybinding, OS);
+			return {
+				keybinding: keybinding?.parts ?? null,
+				command: rule.command ?? null,
+				commandArgs: rule.commandArgs,
+				when: rule.when,
 				weight1: 1000,
 				weight2: 0,
 				extensionId: null,
 				isBuiltinExtension: false
-			});
-
-			toDispose.add(toDisposable(() => {
-				for (let i = 0; i < this._dynamicKeybindings.length; i++) {
-					const kb = this._dynamicKeybindings[i];
-					if (kb.command === commandId) {
-						this._dynamicKeybindings.splice(i, 1);
-						this.updateResolver();
-						return;
-					}
-				}
-			}));
-		}
-
-		toDispose.add(CommandsRegistry.registerCommand(commandId, handler));
+			};
+		});
+		this._dynamicKeybindings = this._dynamicKeybindings.concat(entries);
 
 		this.updateResolver();
 
-		return toDispose;
+		return toDisposable(() => {
+			// Search the first entry and remove them all since they will be contiguous
+			for (let i = 0; i < this._dynamicKeybindings.length; i++) {
+				if (this._dynamicKeybindings[i] === entries[0]) {
+					this._dynamicKeybindings.splice(i, entries.length);
+					this.updateResolver();
+					return;
+				}
+			}
+		});
 	}
 
 	private updateResolver(): void {