address comment

Author: vicheey

packages/core/src/shared/ui/nestedWizardPrompter.ts

@@ -7,21 +7,51 @@ import { Wizard, WizardOptions } from '../wizards/wizard'
 import { WizardPrompter } from './wizardPrompter'
 import { createHash } from 'crypto'
 
+/**
+ * An abstract class that extends the base Wizard class plus the ability to
+ * use other wizard classes as prompters
+ */
 export abstract class NestedWizard<T> extends Wizard<T> {
-    // Map to store wizard instances
+    /**
+     * Map to store memoized wizard instances using SHA-256 hashed keys
+     */
     private wizardInstances: Map<string, any> = new Map()
 
     protected constructor(options: WizardOptions<T>) {
         super(options)
     }
 
-    protected createWizardPrompter<T>(constructor: new (...args: any[]) => T, ...args: any[]): WizardPrompter<T> {
+    /**
+     * Creates or retrieves a memoized wizard prompter instance
+     *
+     * @param {new (...args: any[]) => T} constructor - The constructor function for creating the wizard instance
+     * @param {...any[]} args - Arguments to pass to the constructor
+     * @returns {WizardPrompter<T>} A wrapped wizard to be used as prompter in parent wizard class
+     *
+     * @remarks
+     * This method uses memoization to cache wizard instances based on their constructor
+     * name and arguments, allowing for restoring wizard state for back button.
+     *
+     * @example
+     * this.createWizardPrompter(
+     *       TemplateParametersWizard,
+     *       template!.uri,
+     *       samSyncUrl,
+     *       syncMementoRootKey
+     *   ),
+     */
+    protected createWizardPrompter<T extends Wizard<any>>(
+        constructor: new (...args: any[]) => T,
+        ...args: ConstructorParameters<new (...args: any[]) => T>
+    ): WizardPrompter<T> {
         const memoizeKey = createHash('sha256')
             .update(constructor.name + JSON.stringify(args))
             .digest('hex')
-        if (!this.wizardInstances.get(memoizeKey) as T) {
+
+        if (!this.wizardInstances.get(memoizeKey)) {
             this.wizardInstances.set(memoizeKey, new constructor(...args))
         }
+
         return new WizardPrompter(this.wizardInstances.get(memoizeKey))
     }
 }

packages/core/src/shared/ui/wizardPrompter.ts

@@ -10,10 +10,15 @@ import { Prompter, PromptResult } from './prompter'
 /**
  * Wraps {@link Wizard} object into its own {@link Prompter}, allowing wizards to use other
  * wizards in their flows.
+ *
+ * @remarks
+ *  - This class should not use direclty inside a parent class.
+ *  - Consider extending {@link NestedWizard} instead. Example: {@link SyncWizard}
  */
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export const WIZARD_PROMPTER = 'WIZARD_PROMPTER'
+
 export class WizardPrompter<T> extends Prompter<T> {
     public get recentItem(): any {
         return undefined

packages/core/src/shared/wizards/stateController.ts

@@ -16,7 +16,7 @@ export enum ControlSignal {
  * Value for indicating current direction of the wizard
  * Created mainly to support skipping prompters
  */
-export enum DIRECTON {
+export enum DIRECTION {
     Forward,
     Backward,
 }
@@ -48,11 +48,11 @@ export class StateMachineController<TState> {
     private extraSteps = new Map<number, Branch<TState>>()
     private steps: Branch<TState> = []
     private internalStep: number = 0
-    private direction: DIRECTON
+    private direction: DIRECTION
 
     public constructor(private state: TState = {} as TState) {
         this.previousStates = [_.cloneDeep(state)]
-        this.direction = DIRECTON.Forward
+        this.direction = DIRECTION.Forward
     }
 
     public addStep(step: StepFunction<TState>): void {
@@ -82,14 +82,14 @@ export class StateMachineController<TState> {
 
         this.state = this.previousStates.pop()!
         this.internalStep -= 1
-        this.direction = DIRECTON.Backward
+        this.direction = DIRECTION.Backward
     }
 
     protected advanceState(nextState: TState): void {
         this.previousStates.push(this.state)
         this.state = nextState
         this.internalStep += 1
-        this.direction = DIRECTON.Forward
+        this.direction = DIRECTION.Forward
     }
 
     protected detectCycle(step: StepFunction<TState>): TState | undefined {
@@ -122,7 +122,7 @@ export class StateMachineController<TState> {
                 /**
                  * Depending on current wizard direction, skip signal get converted to forward or backward control signal
                  */
-                result.controlSignal = this.direction === DIRECTON.Forward ? undefined : ControlSignal.Back
+                result.controlSignal = this.direction === DIRECTION.Forward ? undefined : ControlSignal.Back
             }
             return result
         } else {