Abstract Factory pattern

Author: blue32a

README.md

@@ -1 +1,7 @@
 # Design Patterns is TypeScript
+
+## Catalog
+
+### Creational
+
+- [Abstract Factory](./src/AbstractFactory/README.md)

src/AbstractFactory/README.md

@@ -0,0 +1,68 @@
+## Abstract Factory
+
+https://refactoring.guru/ja/design-patterns/abstract-factory
+
+```mermaid
+classDiagram
+  class Client
+
+  namespace factory {
+    class AbstractProductA {
+      executeA()
+      executeB()
+    }
+    class AbstractProductB {
+      doAlpha()
+      doBeta()
+    }
+    class AbstractFactory {
+      createProductA()
+      createProductB()
+    }
+  }
+  namespace concretefactory {
+    class ConcreteFactory1 {
+      createProductA()
+      createProductB()
+    }
+    class ConcreteProductA1 {
+      executeA()
+      executeB()
+    }
+    class ConcreteProductB1 {
+      doAlpha()
+      doBeta()
+    }
+    class ConcreteFactory2 {
+      createProductA()
+      createProductB()
+    }
+    class ConcreteProductA2 {
+      executeA()
+      executeB()
+    }
+    class ConcreteProductB2 {
+      doAlpha()
+      doBeta()
+    }
+  }
+
+  Client ..> AbstractFactory: use
+  Client ..> AbstractProductA: use
+  Client ..> AbstractProductB: use
+
+  AbstractFactory --> AbstractProductA: create
+  AbstractFactory --> AbstractProductB: create
+
+  ConcreteFactory1 ..> ConcreteProductA1: create
+  ConcreteFactory1 ..> ConcreteProductB1: create
+  ConcreteFactory2 ..> ConcreteProductA2: create
+  ConcreteFactory2 ..> ConcreteProductB2: create
+
+  ConcreteFactory1 --|> AbstractFactory
+  ConcreteFactory2 --|> AbstractFactory
+  ConcreteProductA1 --|> AbstractProductA
+  ConcreteProductA2 --|> AbstractProductA
+  ConcreteProductB1 --|> AbstractProductB
+  ConcreteProductB2 --|> AbstractProductB
+```

src/AbstractFactory/index.ts

@@ -0,0 +1,82 @@
+interface AbstractFactory {
+  createProductA(): AbstractProductA;
+  createProductB(): AbstractProductB;
+}
+
+class ConcreteFactory1 implements AbstractFactory {
+  public createProductA(): AbstractProductA {
+    return new ConcreteProductA1();
+  }
+  public createProductB(): AbstractProductB {
+    return new ConcreteProductB1();
+  }
+}
+
+class ConcreteFactory2 implements AbstractFactory {
+  public createProductA(): AbstractProductA {
+    return new ConcreteProductA2();
+  }
+  public createProductB(): AbstractProductB {
+    return new ConcreteProductB2();
+  }
+}
+
+interface AbstractProductA {
+  usefulFunctionA(): string;
+}
+
+class ConcreteProductA1 implements AbstractProductA {
+  public usefulFunctionA(): string {
+    return 'The result of the product A1.';
+  }
+}
+
+class ConcreteProductA2 implements AbstractProductA {
+  public usefulFunctionA(): string {
+    return 'The result of the product A2.';
+  }
+}
+
+interface AbstractProductB {
+  usefulFunctionB(): string;
+
+  anotherUsefulFunctionB(callaborator: AbstractProductA): string;
+}
+
+class ConcreteProductB1 implements AbstractProductB {
+  public usefulFunctionB(): string {
+    return 'The result of the product B1.';
+  }
+
+  public anotherUsefulFunctionB(collaborator: AbstractProductA): string {
+    const result = collaborator.usefulFunctionA();
+    return `The result of the B1 collaborating with the (${result})`;
+  }
+}
+
+class ConcreteProductB2 implements AbstractProductB {
+  public usefulFunctionB(): string {
+    return 'The result of the product B2.';
+  }
+
+  public anotherUsefulFunctionB(collaborator: AbstractProductA): string {
+    const result = collaborator.usefulFunctionA();
+    return `The result of the B2 collaborating with the (${result})`;
+  }
+}
+
+function clientCode(factory: AbstractFactory) {
+  const productA = factory.createProductA();
+  const productB = factory.createProductB();
+
+  console.log(productB.usefulFunctionB());
+  console.log(productB.anotherUsefulFunctionB(productA));
+}
+
+console.log('Client: Testing client code with the first factory type...');
+clientCode(new ConcreteFactory1());
+
+console.log('');
+
+console.log('Client: Testing the same client code with the second factory type...');
+clientCode(new ConcreteFactory2());