Add compatibility steps

utils/hostapi.v2.d.ts

@@ -3,10 +3,9 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 
-import type { ContextValueFilterableTreeNode, IActionContext, QuickPickWizardContext } from "./index";
+import type { IActionContext, AzExtResourceType, ContextValueFilterableTreeNode, QuickPickWizardContext } from "./index";
 import * as vscode from 'vscode';
 import type { Environment } from '@azure/ms-rest-azure-env';
-import { AzExtResourceType } from "./src/AzExtResourceType";
 
 export declare interface ApplicationAuthentication {
     getSession(scopes?: string[]): vscode.ProviderResult<vscode.AuthenticationSession>;

utils/index.d.ts

@@ -6,7 +6,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import type { Environment } from '@azure/ms-rest-azure-env';
-import { CancellationToken, CancellationTokenSource, Disposable, Event, ExtensionContext, FileChangeEvent, FileChangeType, FileStat, FileSystemProvider, FileType, InputBoxOptions, MarkdownString, MessageItem, MessageOptions, OpenDialogOptions, OutputChannel, Progress, QuickPickItem, QuickPickOptions, TextDocumentShowOptions, ThemeIcon, TreeDataProvider, TreeItem, TreeItemCollapsibleState, TreeView, Uri } from 'vscode';
+import { CancellationToken, CancellationTokenSource, Disposable, Event, ExtensionContext, FileChangeEvent, FileChangeType, FileStat, FileSystemProvider, FileType, InputBoxOptions, MarkdownString, MessageItem, MessageOptions, OpenDialogOptions, OutputChannel, Progress, QuickPickItem, QuickPickOptions as VSCodeQuickPickOptions, TextDocumentShowOptions, ThemeIcon, TreeDataProvider, TreeItem, TreeItemCollapsibleState, TreeView, Uri } from 'vscode';
 import { TargetPopulation } from 'vscode-tas-client';
 import { AzureExtensionApi, AzureExtensionApiProvider } from './api';
 import type { Activity, ActivityTreeItemOptions, AppResource, OnErrorActivityData, OnProgressActivityData, OnStartActivityData, OnSuccessActivityData } from './hostapi'; // This must remain `import type` or else a circular reference will result
@@ -360,6 +360,7 @@ export interface IAzExtParentTreeItem extends IAzExtTreeItem {
  * NOTE: *Impl methods are not meant to be called directly - just implemented.
  */
 export declare abstract class AzExtTreeItem implements IAzExtTreeItem {
+    public readonly _isAzExtTreeItem = true;
     //#region Properties implemented by base class
     /**
      * This is is used for the openInPortal action. It is also used per the following documentation copied from VS Code:
@@ -993,7 +994,7 @@ export interface IAzureQuickPickItem<T = undefined> extends QuickPickItem {
 /**
  * Provides additional options for QuickPicks used in Azure Extensions
  */
-export interface IAzureQuickPickOptions extends QuickPickOptions, AzExtUserInputOptions {
+export interface IAzureQuickPickOptions extends VSCodeQuickPickOptions, AzExtUserInputOptions {
     /**
      * An optional id to identify this QuickPick across sessions, used in persisting previous selections
      * If not specified, a hash of the placeHolder will be used
@@ -1703,10 +1704,17 @@ export declare interface Wrapper {
  */
 export declare function isWrapper(maybeWrapper: unknown): maybeWrapper is Wrapper;
 
-export declare function appResourceExperience<TPick extends ContextValueFilterableTreeNode>(context: IActionContext, tdp: TreeDataProvider<ResourceGroupsItem>, resourceType: AzExtResourceType, childItemFilter?: ContextValueFilter): Promise<TPick>;
+export declare function appResourceExperience<TPick extends ContextValueFilterableTreeNode>(context: IActionContext, tdp: TreeDataProvider<ResourceGroupsItem>, resourceTypes?: AzExtResourceType | AzExtResourceType[], childItemFilter?: ContextValueFilter): Promise<TPick>;
 export declare function contextValueExperience<TPick extends ContextValueFilterableTreeNode>(context: IActionContext, tdp: TreeDataProvider<ResourceGroupsItem>, contextValueFilter: ContextValueFilter): Promise<TPick>;
 export declare function findByIdExperience<TPick extends FindableByIdTreeNode>(context: IActionContext, tdp: TreeDataProvider<TPick>, id: string | Uri): Promise<TPick>;
 
+interface CompatibilityPickResourceExperienceOptions {
+    resourceTypes?: AzExtResourceType | AzExtResourceType[];
+    childItemFilter?: ContextValueFilter
+}
+
+export declare function compatibilityPickAppResourceExperience<TPick>(context: IActionContext, tdp: TreeDataProvider<ResourceGroupsItem>, options: CompatibilityPickResourceExperienceOptions): Promise<TPick>;
+
 export declare interface QuickPickWizardContext<TNode extends unknown> extends IActionContext {
     pickedNodes: TNode[];
 }
@@ -1729,14 +1737,31 @@ export declare interface ContextValueFilter {
     exclude?: string | RegExp | (string | RegExp)[];
 }
 
+interface QuickPickOptions {
+    readonly contextValues: Array<string>;
+    readonly isLeaf: boolean;
+}
+
+type CreateCallback<TNode = unknown> = (context: IActionContext) => TNode | Promise<TNode>;
+
+type CreateOptions<TNode = unknown> = {
+    label?: string;
+    callback: CreateCallback<TNode>;
+}
+
+interface CompatibleQuickPickOptions extends QuickPickOptions {
+    readonly createChild?: CreateOptions;
+}
+
 export declare interface ContextValueFilterableTreeNodeV2 {
-    readonly quickPickOptions: {
-        readonly contextValues: Array<string>;
-        readonly isLeaf: boolean;
-    }
+    readonly quickPickOptions: QuickPickOptions;
+}
+
+export declare interface CompatibleContextValueFilterableTreeNode {
+    readonly quickPickOptions: CompatibleQuickPickOptions;
 }
 
-export declare type ContextValueFilterableTreeNode = ContextValueFilterableTreeNodeV2 | AzExtTreeItem;
+export declare type ContextValueFilterableTreeNode = ContextValueFilterableTreeNodeV2;
 
 export declare interface FindableByIdTreeNodeV2 extends ContextValueFilterableTreeNodeV2 {
     id: string;
@@ -1752,4 +1777,4 @@ export declare type FindableByIdTreeNode = FindableByIdTreeNodeV2 | AzExtTreeIte
  * The telemetry event for this command will be named telemetryId if specified, otherwise it defaults to the commandId
  * NOTE: If the environment variable `DEBUGTELEMETRY` is set to a non-empty, non-zero value, then telemetry will not be sent. If the value is 'verbose' or 'v', telemetry will be displayed in the console window.
  */
-export declare function registerCommandWithTreeNodeUnboxing<T>(commandId: string, callback: TreeNodeCommandCallback<T>, debounce?: number, telemetryId?: string): void;
+export declare function registerCommandWithTreeNodeUnwrapping<T>(commandId: string, callback: TreeNodeCommandCallback<T>, debounce?: number, telemetryId?: string): void;

utils/src/index.ts

@@ -38,6 +38,7 @@ export * from './activityLog/activities/ExecuteActivity';
 export * from './getAzExtResourceType';
 export * from './AzExtResourceType';
 export * from './treev2/quickPickWizard/experiences/appResourceExperience';
+export * from './treev2/quickPickWizard/experiences/compatibilityPickResourceExperience';
 export * from './treev2/quickPickWizard/experiences/contextValueExperience';
 export * from './treev2/quickPickWizard/experiences/findByIdExperience';
 // NOTE: The auto-fix action "source.organizeImports" does weird things with this file, but there doesn't seem to be a way to disable it on a per-file basis so we'll just let it happen

utils/src/tree/AzExtTreeItem.ts

@@ -13,6 +13,9 @@ import { settingUtils } from '../utils/settingUtils';
 import { showContextValueSetting } from '../constants';
 
 export abstract class AzExtTreeItem implements types.AzExtTreeItem {
+
+    public readonly _isAzExtTreeItem = true;
+
     //#region Properties implemented by base class
     public abstract label: string;
     public abstract contextValue: string;
@@ -120,7 +123,7 @@ export abstract class AzExtTreeItem implements types.AzExtTreeItem {
     }
 
     public get tooltip(): string | undefined {
-        if(process.env.DEBUGTELEMETRY === 'v' && !!settingUtils.getWorkspaceSetting<unknown>(showContextValueSetting)) {
+        if (process.env.DEBUGTELEMETRY === 'v' && !!settingUtils.getWorkspaceSetting<unknown>(showContextValueSetting)) {
             return `Context: "${this.contextValue}"`;
         } else {
             return this._tooltip;

utils/src/treev2/quickPickWizard/ContextValueQuickPickStep.ts

@@ -5,7 +5,6 @@
 
 import * as types from '../../../index';
 import { GenericQuickPickOptions, GenericQuickPickStep } from './GenericQuickPickStep';
-import { isAzExtParentTreeItem } from '../../tree/InternalInterfaces';
 
 export interface ContextValueFilterQuickPickOptions extends GenericQuickPickOptions {
     contextValueFilter: types.ContextValueFilter;
@@ -21,22 +20,14 @@ export class ContextValueQuickPickStep<TNode extends types.ContextValueFilterabl
             (Array.isArray(excludeOption) ? excludeOption : [excludeOption]) :
             [];
 
-        const nodeContextValues: string[] = isContextValueFilterableTreeNodeV2(node) ?
-            node.quickPickOptions.contextValues :
-            [node.contextValue];
+        const nodeContextValues: string[] = node.quickPickOptions.contextValues;
 
         return includeArray.some(i => this.matchesSingleFilter(i, nodeContextValues)) &&
             !excludeArray.some(e => this.matchesSingleFilter(e, nodeContextValues));
     }
 
     protected override isIndirectPick(node: TNode): boolean {
-        if (isContextValueFilterableTreeNodeV2(node)) {
-            return node.quickPickOptions.isLeaf === false;
-        } else if (isAzExtParentTreeItem(node)) {
-            return true;
-        }
-
-        return false;
+        return node.quickPickOptions.isLeaf === false;
     }
 
     private matchesSingleFilter(matcher: string | RegExp, nodeContextValues: string[]): boolean {
@@ -50,13 +41,3 @@ export class ContextValueQuickPickStep<TNode extends types.ContextValueFilterabl
         })
     }
 }
-
-export function isContextValueFilterableTreeNodeV2(maybeNode: unknown): maybeNode is types.ContextValueFilterableTreeNodeV2 {
-    if (typeof maybeNode === 'object') {
-        return Array.isArray((maybeNode as types.ContextValueFilterableTreeNodeV2).quickPickOptions?.contextValues) &&
-            (maybeNode as types.ContextValueFilterableTreeNodeV2).quickPickOptions?.isLeaf !== undefined &&
-            (maybeNode as types.ContextValueFilterableTreeNodeV2).quickPickOptions?.isLeaf !== null;
-    }
-
-    return false;
-}

utils/src/treev2/quickPickWizard/FindByIdQuickPickStep.ts

@@ -7,7 +7,6 @@ import * as types from '../../../index';
 import * as vscode from 'vscode';
 import { getLastNode } from './QuickPickWizardContext';
 import { isAzExtParentTreeItem } from '../../tree/InternalInterfaces';
-import { isContextValueFilterableTreeNodeV2 } from './ContextValueQuickPickStep';
 import { GenericQuickPickStep, SkipIfOneQuickPickOptions } from './GenericQuickPickStep';
 
 interface FindByIdQuickPickOptions extends SkipIfOneQuickPickOptions {
@@ -76,6 +75,16 @@ export class FindByIdQuickPickStep<TNode extends types.FindableByIdTreeNode, TCo
     }
 }
 
+function isContextValueFilterableTreeNodeV2(maybeNode: unknown): maybeNode is types.ContextValueFilterableTreeNodeV2 {
+    if (typeof maybeNode === 'object') {
+        return Array.isArray((maybeNode as types.ContextValueFilterableTreeNodeV2).quickPickOptions?.contextValues) &&
+            (maybeNode as types.ContextValueFilterableTreeNodeV2).quickPickOptions?.isLeaf !== undefined &&
+            (maybeNode as types.ContextValueFilterableTreeNodeV2).quickPickOptions?.isLeaf !== null;
+    }
+
+    return false;
+}
+
 function isFindableByIdTreeNodeV2(maybeNode: unknown): maybeNode is types.FindableByIdTreeNodeV2 {
     if (!isContextValueFilterableTreeNodeV2(maybeNode)) {
         return false;

utils/src/treev2/quickPickWizard/GenericQuickPickStep.ts

@@ -55,7 +55,11 @@ export abstract class GenericQuickPickStep<TNode extends unknown, TContext exten
         if (picks.length === 1 && this.pickOptions.skipIfOne) {
             return picks[0].data;
         } else {
-            const selected = await wizardContext.ui.showQuickPick(picks, { /* TODO: options */ });
+            const selected = await wizardContext.ui.showQuickPick(picks, {
+                /* TODO: options */
+                /* TODO: set id here so recently picked items appear at the top */
+            });
+
             return selected.data;
         }
     }
@@ -100,7 +104,7 @@ export abstract class GenericQuickPickStep<TNode extends unknown, TContext exten
      */
     protected abstract isIndirectPick(node: TNode): boolean;
 
-    private async getQuickPickItem(resource: TNode): Promise<types.IAzureQuickPickItem<TNode>> {
+    protected async getQuickPickItem(resource: TNode): Promise<types.IAzureQuickPickItem<TNode>> {
         const treeItem = await Promise.resolve(this.treeDataProvider.getTreeItem(resource));
 
         return {

utils/src/treev2/quickPickWizard/compatibility/CompatibilityContextValueQuickPickStep.ts

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as types from "../../../../index";
+import { isAzExtParentTreeItem } from "../../../tree/InternalInterfaces";
+import { ContextValueFilterQuickPickOptions, ContextValueQuickPickStep } from "../ContextValueQuickPickStep";
+import { getLastNode } from "../QuickPickWizardContext";
+import { AzExtTreeItem } from "../../../tree/AzExtTreeItem";
+import { AzExtParentTreeItem } from "../../../tree/AzExtParentTreeItem";
+import { isWrapper } from "../../../registerCommandWithTreeNodeUnwrapping";
+
+/**
+ * Provides compatability with {@link AzExtParentTreeItem.pickTreeItemImpl}
+ */
+export class CompatibilityContextValueQuickPickStep<TNode extends types.CompatibleContextValueFilterableTreeNode, TContext extends types.QuickPickWizardContext<TNode>, TOptions extends ContextValueFilterQuickPickOptions> extends ContextValueQuickPickStep<TNode, TContext, TOptions> {
+
+    public override async prompt(wizardContext: TContext): Promise<void> {
+        await this.provideCompatabilityWithPickTreeItemImpl(wizardContext) || await super.prompt(wizardContext);
+    }
+
+    /**
+     * Mimics how the legacy {@link AzExtParentTreeItem.pickChildTreeItem}
+     * uses {@link AzExtParentTreeItem.pickTreeItemImpl} to customize the tree item picker.
+     *
+     * An example customization is skipping having to pick a UI-only node (ex: App Settings parent node)
+     */
+    private async provideCompatabilityWithPickTreeItemImpl(wizardContext: TContext): Promise<boolean> {
+        const lastPickedItem = getLastNode(wizardContext);
+        const lastPickedItemUnwrapped = isWrapper(lastPickedItem) ? lastPickedItem.unwrap() : lastPickedItem
+        if (isAzExtParentTreeItem(lastPickedItemUnwrapped)) {
+            const children = await this.treeDataProvider.getChildren(lastPickedItem);
+            if (children && children.length) {
+                const customChild = await this.getCustomChildren(wizardContext, lastPickedItemUnwrapped);
+
+                const customPick = children.find((child) => {
+                    const ti: AzExtTreeItem = isWrapper(child) ? child.unwrap() : child as unknown as AzExtTreeItem;
+                    return ti.fullId === customChild?.fullId;
+                });
+
+                if (customPick) {
+                    wizardContext.pickedNodes.push(customPick);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private async getCustomChildren(context: TContext, node: AzExtParentTreeItem): Promise<AzExtTreeItem | undefined> {
+        return await node.pickTreeItemImpl?.(Array.isArray(this.pickOptions.contextValueFilter.include) ? this.pickOptions.contextValueFilter.include : [this.pickOptions.contextValueFilter.include], context);
+    }
+}