Add all structural patterns in TypeScript

Author: Badacadabra

src/TypeScript/GoF/Structural/Adapter/Adapter.ts

@@ -0,0 +1,40 @@
+// ==============================
+// ABSTRACT CONNECTIONS
+// ==============================
+
+interface AnalogInterface {
+    handleAnalogSignal(): string;
+}
+
+interface DigitalInterface {
+    handleDigitalSignal(): string;
+}
+
+// ==============================
+// CONCRETE CONNECTIONS
+// ==============================
+
+// VGA has its own interface which handles images only through an analog signal
+class VGA implements AnalogInterface {
+    public handleAnalogSignal(): string {
+        return "Interface: VGA\nData: images\nSignal: analog\n";
+    }
+}
+
+// But your computer uses HDMI as output and your projector uses VGA as input...
+// Here you need an adapter if you want to display images. The two interfaces are incompatible.
+class HDMIToVGAAdapter implements DigitalInterface {
+    private vga: VGA = new VGA();
+    
+    public handleDigitalSignal(): string {
+        return this.vga.handleAnalogSignal();
+    }
+}
+
+// ==============================
+// CLIENT CODE
+// ==============================
+
+let adapter: HDMIToVGAAdapter = new HDMIToVGAAdapter();
+
+console.log(adapter.handleDigitalSignal()); // Your computer uses HDMI and your projector uses VGA

src/TypeScript/GoF/Structural/Bridge/Bridge.ts

@@ -0,0 +1,64 @@
+// ==============================
+// ABSTRACTIONS
+// ==============================
+
+abstract class Recipe {
+    protected sauce: Sauce;
+
+    constructor(sauce: Sauce) {
+        this.sauce = sauce;   
+    }
+
+    public abstract cook(): string;
+}
+
+interface Sauce {
+    ingredients(): string;
+}
+
+// ==============================
+// CONCRETE RECIPES
+// ==============================
+
+class Pasta extends Recipe {
+    public cook(): string {
+        return "Pasta with " + this.sauce.ingredients();
+    }
+}
+
+class Risotto extends Recipe {
+    public cook(): string {
+        return "Risotto with " + this.sauce.ingredients();
+    }
+}
+
+// ==============================
+// CONCRETE SAUCES
+// ==============================
+
+class Pesto implements Sauce {
+    public ingredients(): string {
+        return "Pesto (basil, garlic, oil, grated cheese, pine nuts)";
+    }
+}
+
+class Carbonara implements Sauce {
+    public ingredients(): string {
+        return "Carbonara (eggs, bacon, black pepper, grated cheese)";
+    }
+}
+
+// ==============================
+// CLIENT CODE
+// ==============================
+
+// Sauces
+let pesto: Sauce = new Pesto(),
+    carbonara: Sauce = new Carbonara();
+
+// Recipes
+let pasta: Recipe = new Pasta(pesto),
+    risotto: Recipe = new Risotto(carbonara);
+
+console.log(pasta.cook());
+console.log(risotto.cook());

src/TypeScript/GoF/Structural/Composite/Composite.ts

@@ -0,0 +1,65 @@
+// ==============================
+// ABSTRACT COMPONENT
+// ==============================
+
+interface Toy {
+    description(): string;
+}
+
+// ==============================
+// SIMPLE (CONCRETE) COMPONENT
+// ==============================
+
+// A ball does not contain anything
+class Ball implements Toy {
+    public description(): string {
+        return "There's a ball!\n";
+    }
+}
+
+// ==============================
+// COMPOSITE (CONCRETE) COMPONENT
+// ==============================
+
+// A toy box is a toy entity which contains toys, including smaller toy boxes.
+class ToyBox implements Toy {
+    private toys: Toy[] = [];
+
+    public description(): string {
+        return "There's a toy box!\n";
+    }
+
+    public add(toy: Toy): void {
+        this.toys.push(toy);   
+    }
+
+    public inventory(): string {
+        let inventory: string = "Let's open the toy box...\n";
+        for (let toy of this.toys) {
+            inventory += toy.description();
+            if (toy instanceof ToyBox) {
+                inventory += toy.inventory();
+            }
+        }
+        return inventory;
+    }
+}
+
+// ==============================
+// CLIENT CODE
+// ==============================
+
+// Here we organize our toys in an optimal way
+let ball1: Ball = new Ball(),
+    ball2: Ball = new Ball(),
+    ball3: Ball = new Ball(),
+    bigToyBox: ToyBox = new ToyBox(),
+    smallToyBox: ToyBox = new ToyBox();
+
+smallToyBox.add(ball1);
+smallToyBox.add(ball2);
+bigToyBox.add(ball3);
+bigToyBox.add(smallToyBox);
+
+// Now we open our big toy box...
+console.log(bigToyBox.inventory());

src/TypeScript/GoF/Structural/Decorator/Decorator.ts

@@ -0,0 +1,55 @@
+// ==============================
+// ABSTRACT PIZZA
+// ==============================
+
+interface Pizza {
+    ingredients(): string;
+}
+
+// ==============================
+// CONCRETE PIZZA
+// ==============================
+
+class Margherita implements Pizza {
+    public ingredients(): string {
+        return "- Tomatoes\n- Mozzarella\n";
+    }
+}
+
+// ==============================
+// PIZZA DECORATOR
+// ==============================
+
+abstract class CustomPizza implements Pizza {
+    protected pizza: Pizza;
+
+    constructor(pizza: Pizza) {
+        this.pizza = pizza;
+    }
+
+    public ingredients(): string {
+        return this.pizza.ingredients();
+    }
+}
+
+// ==============================
+// PIZZA INGREDIENTS
+// ==============================
+
+class Bacon extends CustomPizza {
+    public ingredients(): string {
+        return this.pizza.ingredients() + "- Bacon\n";
+    }
+}
+
+class Peppers extends CustomPizza {
+    public ingredients(): string {
+        return this.pizza.ingredients() + "- Peppers\n";
+    }
+}
+
+// ==============================
+// CLIENT CODE
+// ==============================
+
+console.log(new Peppers(new Bacon(new Margherita())).ingredients());

src/TypeScript/GoF/Structural/Facade/Facade.ts

@@ -0,0 +1,44 @@
+// ==============================
+// ABSTRACT ANIMAL
+// ==============================
+
+interface Animal {
+    eat(): string;
+}
+
+// ==============================
+// CONCRETE ANIMALS
+// ==============================
+
+class Dog implements Animal {
+    public eat(): string {
+        return "Dog: 'Meat, please!'\n";
+    }
+}
+
+class Rabbit implements Animal {
+    public eat(): string {
+        return "Rabbit: 'A carrot would be great!'\n";
+    }
+}
+
+// ==============================
+// THE FACADE 
+// ==============================
+
+class HowToFeedAnimals {
+    private dog: Dog = new Dog();
+    private rabbit: Rabbit = new Rabbit();
+
+    public feedAnimals(): string {
+        return `${this.dog.eat()}${this.rabbit.eat()}`;
+    }
+}
+
+// ==============================
+// CLIENT CODE
+// ==============================
+
+let facade: HowToFeedAnimals = new HowToFeedAnimals();
+
+console.log(facade.feedAnimals());

src/TypeScript/GoF/Structural/Flyweight/Flyweight.ts

@@ -0,0 +1,84 @@
+// ==============================
+// ABSTRACT GNU/LINUX DISTRO
+// ==============================
+
+abstract class LinuxDistro {
+    private name: string;
+
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    public boot(): string {
+        return `${this.name} is booting...`;
+    }
+}
+
+// ==============================
+// CONCRETE GNU/LINUX DISTROS
+// ==============================
+
+// Let's say that each instance of a Linux distro will have the name of its constructor...
+
+class Debian extends LinuxDistro {
+    constructor() {
+        super("Debian");
+    }
+}
+
+class RedHat extends LinuxDistro {
+    constructor() {
+        super("RedHat");
+    }
+}
+
+class Slackware extends LinuxDistro {
+    constructor() {
+        super("Slackware");
+    }
+}
+
+// ==============================
+// FACTORY OF GNU/LINUX DISTROS
+// ==============================
+
+class LinuxDistrosFactory {
+    public static readonly DEBIAN: number = 0;
+    public static readonly REDHAT: number = 1;
+    public static readonly SLACKWARE: number = 2;
+
+    public static activeDistros: Map<number, LinuxDistro> = new Map(); // Flyweights!
+
+    public static getLinuxDistro(id: number): LinuxDistro {
+        // If the distro has never been instantiated, we will have to create a new object
+        if (!this.activeDistros.has(id)) {
+            switch (id) {
+                case this.DEBIAN:
+                    this.activeDistros.set(id, new Debian());
+                    break;
+                case this.REDHAT:
+                    this.activeDistros.set(id, new RedHat());
+                    break;
+                case this.SLACKWARE:
+                    this.activeDistros.set(id, new Slackware());
+                    break;
+                default:
+                    throw new Error("The Linux distribution you are looking for has not been found");
+            }
+        }
+        // If the distro has already been instantiated, we return the initial instance
+        return this.activeDistros.get(id);
+    }
+}
+
+// ==============================
+// CLIENT CODE 
+// ==============================
+
+// Creation of our objects through the factory
+let debian: Debian = LinuxDistrosFactory.getLinuxDistro(LinuxDistrosFactory.DEBIAN),
+    debianAgain: Debian = LinuxDistrosFactory.getLinuxDistro(LinuxDistrosFactory.DEBIAN);
+
+console.log(debian.boot()); // Debian is booting...
+console.log(debianAgain.boot()); // Debian is booting...
+console.log(debian === debianAgain); // true (the same instance has been reused)