When it comes to design patterns and the Strategy pattern, think of your FormBuilder as the Context, holding a reference to the current strategy being used (IFormStrategy). This strategy is provided from external sources (using a setter), allowing for extension and following the Open/Closed Principle.

1. Is it appropriate to select the strategy inside the FormBuilder rather than passing it from outside?

Selecting the strategy within the FormBuilder is not an ideal strategy implementation. Instead, create instances of the strategy and pass them to the context. This allows for runtime swapping of strategies.

2. Doesn't this violate the Open/Closed Principle? If I need to add or remove a form strategy, do I have to modify the FormBuilder class?

Indeed, this approach does violate the Open/Closed Principle. To introduce a new strategy to the FormBuilder, you would need to make changes directly to the class.

For an example, refer here.

FormBuilder context = new FormBuilder();
IFormStrategy simple = new SimpleFormStrategy();
IFormStrategy extended = new ExtendedFormStrategy();
IFormStrategy custom = new CustomFormStrategy();

context.setStrategy(simple);
context.build(/* parameters */)

context.setStrategy(custom);
context.build(/* parameters */) 

Strategy is a design pattern that transforms behaviors into objects, allowing them to be interchangeable within the original context object.

The main object, known as the context, holds a reference to a strategy object and delegates the execution of the behavior to it. By swapping the currently linked strategy object with another one, the way in which the context performs its work can be altered.

Examples of Usage: The Strategy pattern is frequently utilized in TypeScript code, especially in frameworks where users need to adjust the behavior of a class without extending it.

Identification: The Strategy pattern can be recognized by a method that enables nested objects to carry out the actual work, along with a setter that allows for the substitution of that object with a different one.

Conceptual Example This example showcases the structure of the Strategy design pattern and addresses questions such as: • What are the classes involved? • What roles do these classes fulfill? • How are the elements of the pattern connected?

index.ts: Conceptual Example

/**
     * The Context defines the interface that is relevant to clients.
     */
    class Context {
        /**
         * @type {Strategy} The Context maintains a reference to one of the Strategy
         * objects. It does not know the concrete class of a strategy, working with all strategies via the Strategy interface.
         */
        private strategy: Strategy;

        /**
         * Typically, the Context receives a strategy through the constructor but also provides a setter to switch it during runtime.
         */
        constructor(strategy: Strategy) {
            this.strategy = strategy;
        }

        /**
         * Usually, the Context permits changing a Strategy object at runtime.
         */
        public setStrategy(strategy: Strategy) {
            this.strategy = strategy;
        }

        /**
         * The Context delegates some tasks to the Strategy object instead of implementing multiple versions of the algorithm itself.
         */
        public doSomeBusinessLogic(): void {
            // ...

            console.log('Context: Sorting data using the strategy (uncertain about the process)');
            const result = this.strategy.doAlgorithm(['a', 'b', 'c', 'd', 'e']);
            console.log(result.join(','));

            // ...
        }
    }

    /**
     * The Strategy interface declares operations common to all supported versions
     * of a particular algorithm.
     *
     * The Context uses this interface to invoke the algorithm specified by Concrete
     * Strategies.
     */
    interface Strategy {
        doAlgorithm(data: string[]): string[];
    }

    /**
     * Concrete Strategies implement the algorithm following the base Strategy
     * interface, making them interchangeable in the Context.
     */
    class ConcreteStrategyA implements Strategy {
        public doAlgorithm(data: string[]): string[] {
            return data.sort();
        }
    }

    class ConcreteStrategyB implements Strategy {
        public doAlgorithm(data: string[]): string[] {
            return data.reverse();
        }
    }

    /**
     * The client code selects a specific strategy and passes it to the context. Being aware of the distinctions between strategies is crucial for making an informed choice.
     */
    const context = new Context(new ConcreteStrategyA());
    console.log('Client: Strategy set for normal sorting.');
    context.doSomeBusinessLogic();

    console.log('');

    console.log('Client: Strategy set for reverse sorting.');
    context.setStrategy(new ConcreteStrategyB());
    context.doSomeBusinessLogic();

Output.txt: Execution outcome

Client: Strategy set for normal sorting.
Context: Sorting data using the strategy (uncertain about the process)
a,b,c,d,e

Client: Strategy set for reverse sorting.
Context: Sorting data using the strategy (uncertain about the process)
e,d,c,b,a