Merge from vscode 099a7622e6e90dbcc226e428d4e35a72cb19ecbc (#9646)

* Merge from vscode 099a7622e6e90dbcc226e428d4e35a72cb19ecbc

* fix strict

src/vs/platform/quickinput/browser/pickerQuickAccess.ts

@@ -0,0 +1,167 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IQuickPick, IQuickPickItem } from 'vs/platform/quickinput/common/quickInput';
+import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
+import { IQuickPickSeparator, IKeyMods, IQuickPickAcceptEvent } from 'vs/base/parts/quickinput/common/quickInput';
+import { IQuickAccessProvider } from 'vs/platform/quickinput/common/quickAccess';
+import { IDisposable, DisposableStore, Disposable } from 'vs/base/common/lifecycle';
+
+export enum TriggerAction {
+
+	/**
+	 * Do nothing after the button was clicked.
+	 */
+	NO_ACTION,
+
+	/**
+	 * Close the picker.
+	 */
+	CLOSE_PICKER,
+
+	/**
+	 * Update the results of the picker.
+	 */
+	REFRESH_PICKER
+}
+
+export interface IPickerQuickAccessItem extends IQuickPickItem {
+
+	/**
+	* A method that will be executed when the pick item is accepted from
+	* the picker. The picker will close automatically before running this.
+	*
+	* @param keyMods the state of modifier keys when the item was accepted.
+	* @param event the underlying event that caused the accept to trigger.
+	*/
+	accept?(keyMods: IKeyMods, event: IQuickPickAcceptEvent): void;
+
+	/**
+	 * A method that will be executed when a button of the pick item was
+	 * clicked on.
+	 *
+	 * @param buttonIndex index of the button of the item that
+	 * was clicked.
+	 *
+	 * @param the state of modifier keys when the button was triggered.
+	 *
+	 * @returns a value that indicates what should happen after the trigger
+	 * which can be a `Promise` for long running operations.
+	 */
+	trigger?(buttonIndex: number, keyMods: IKeyMods): TriggerAction | Promise<TriggerAction>;
+}
+
+export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem> extends Disposable implements IQuickAccessProvider {
+
+	constructor(private prefix: string) {
+		super();
+	}
+
+	provide(picker: IQuickPick<T>, token: CancellationToken): IDisposable {
+		const disposables = new DisposableStore();
+
+		// Allow subclasses to configure picker
+		this.configure(picker);
+
+		// Disable filtering & sorting, we control the results
+		picker.matchOnLabel = picker.matchOnDescription = picker.matchOnDetail = picker.sortByLabel = false;
+
+		// Set initial picks and update on type
+		let picksCts: CancellationTokenSource | undefined = undefined;
+		const updatePickerItems = async () => {
+
+			// Cancel any previous ask for picks and busy
+			picksCts?.dispose(true);
+			picker.busy = false;
+
+			// Create new cancellation source for this run
+			picksCts = new CancellationTokenSource(token);
+
+			// Collect picks and support both long running and short
+			const res = this.getPicks(picker.value.substr(this.prefix.length).trim(), disposables.add(new DisposableStore()), picksCts.token);
+			if (Array.isArray(res)) {
+				picker.items = res;
+			} else {
+				picker.busy = true;
+				try {
+					const items = await res;
+					if (token.isCancellationRequested) {
+						return;
+					}
+
+					picker.items = items;
+				} finally {
+					if (!token.isCancellationRequested) {
+						picker.busy = false;
+					}
+				}
+			}
+		};
+		disposables.add(picker.onDidChangeValue(() => updatePickerItems()));
+		updatePickerItems();
+
+		// Accept the pick on accept and hide picker
+		disposables.add(picker.onDidAccept(event => {
+			const [item] = picker.selectedItems;
+			if (typeof item?.accept === 'function') {
+				if (!event.inBackground) {
+					picker.hide(); // hide picker unless we accept in background
+				}
+				item.accept(picker.keyMods, event);
+			}
+		}));
+
+		// Trigger the pick with button index if button triggered
+		disposables.add(picker.onDidTriggerItemButton(async ({ button, item }) => {
+			if (typeof item.trigger === 'function') {
+				const buttonIndex = item.buttons?.indexOf(button) ?? -1;
+				if (buttonIndex >= 0) {
+					const result = item.trigger(buttonIndex, picker.keyMods);
+					const action = (typeof result === 'number') ? result : await result;
+
+					if (token.isCancellationRequested) {
+						return;
+					}
+
+					switch (action) {
+						case TriggerAction.NO_ACTION:
+							break;
+						case TriggerAction.CLOSE_PICKER:
+							picker.hide();
+							break;
+						case TriggerAction.REFRESH_PICKER:
+							updatePickerItems();
+							break;
+					}
+				}
+			}
+		}));
+
+		return disposables;
+	}
+
+	/**
+	 * Subclasses can override this method to configure the picker before showing it.
+	 *
+	 * @param picker the picker instance used for the quick access before it opens.
+	 */
+	protected configure(picker: IQuickPick<T>): void { }
+
+	/**
+	 * Returns an array of picks and separators as needed. If the picks are resolved
+	 * long running, the provided cancellation token should be used to cancel the
+	 * operation when the token signals this.
+	 *
+	 * The implementor is responsible for filtering and sorting the picks given the
+	 * provided `filter`.
+	 *
+	 * @param filter a filter to apply to the picks.
+	 * @param disposables can be used to register disposables that should be cleaned
+	 * up when the picker closes.
+	 * @param token for long running tasks, implementors need to check on cancellation
+	 * through this token.
+	 */
+	protected abstract getPicks(filter: string, disposables: DisposableStore, token: CancellationToken): Array<T | IQuickPickSeparator> | Promise<Array<T | IQuickPickSeparator>>;
+}