Creational Design Patterns

class Logger {
  /**
   * L'attribut statique `instance` qui va contenir la référence
   * à la seule instance de la classe
   */
  private static instance: Logger;
 
  /**
   * Le constructeur privé, inacessible hors de la classe
   */
  private constructor() {}
 
  /**
   * La méthode statique `getInstance` responsable de :
 
   * - Créer une instance de la classe si elle n'existe pas
   * - La retourner dans tous les cas
   */
  static getInstance(): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger();
    }
 
    return Logger.instance;
  }
 
  log(message: string) {
    // logique d'écriture dans un fichier
  }
}

/*
 * Toutes les instances de la classe `Logger` retournent le meme objet
 */
const logger = Logger.getInstance();
const loggerUsedSomeWhereElse = Logger.getInstance();
 
console.log(logger === loggerUsedSomeWhereElse); // true
 
/*
 * L'instanciation via new retourne une erreur
 */
new Logger(); // Constructor of class 'Logger' is private and only accessible within the class declaration

class Monster {
  public appear() {
    console.log('A wild monster appears !');
  }
 
  public makeSomeSillyFace() {
    console.log('👿');
  }
 
  public shout() {
    console.log('Arrrrg !');
  }
}
 
class Room {
  readonly monster: Monster = new Monster();
 
  public frightenHero() {
    this.monster.appear();
    this.monster.makeSomeSillyFace();
    this.monster.shout();
  }
}
 
function clientCode() {
  const room = new Room();
  room.frightenHero();
}
 
clientCode();
// A wild monster appears !
// 👿
// Arrrrg !

/**
 * La classe `RoomCreator` déclare la méthode de fabrique qui est censée retourner un
 * objet de type `Enemy` : `makeEnemy()`
 * Cette méthode est abstraite : Ce sont les sous-classes de `RoomCreator` qui fournissent une implémentation concrète de cette méthode.
 */
abstract class RoomCreator {
  /**
   * Notre factory method, dont le type de retour est `Enemy`
   */
  public abstract makeEnemy(): Enemy;
 
  /**
   * La responsabilité première de `RoomCreator` n'est pas la création d'ennemis.
   * Elle contient une logique métier qui s'appuie sur les objets `Enemy` retournés par la factory method.
   * Les sous-classes peuvent indirectement changer cette logique en surchargeant ladite méthode
   * et en renvoyant un type de produit différent.
   */
  public frightenHero() {
    const enemy = this.makeEnemy();
    enemy.appear();
    enemy.makeSomeSillyFace();
    enemy.shout();
  }
}
 
/**
 * Les créateurs concrets surchargent la factory method afin de changer le type d'ennemi retourné
 */
class MonsterRoomCreator extends RoomCreator {
  /**
   * La méthode retourne toujours le type `Enemy`, même si le type d'ennemi concret renvoyé par la méthode diffère.
   * De cette façon, le créateur peut rester indépendant des classes de produits concrets.
   */
  public makeEnemy(): Enemy {
    return new Monster();
  }
}
 
class GhostRoomCreator extends RoomCreator {
  public makeEnemy(): Enemy {
    return new Ghost();
  }
}
 
/**
 * Toutes les instances concrètes d'`Enemy` doivent implémenter ces méthodes.
 */
interface Enemy {
  appear(): void;
  makeSomeSillyFace(): void;
  shout(): void;
}
 
/**
 * Des exemples d'implémentations concrètes d'`Enemy`.
 */
class Monster implements Enemy {
  public appear() {
    console.log('A wild monster appears !');
  }
  public makeSomeSillyFace() {
    console.log('👿');
  }
  public shout() {
    console.log('Arrrrg !');
  }
}
 
class Ghost implements Enemy {
  public appear() {
    console.log('A ghost appears !');
  }
  public makeSomeSillyFace() {
    console.log('👻');
  }
  public shout() {
    console.log('woooooooo !');
  }
}
 
/**
 * Le code client reçoit une instance concrète de `RoomCreator`, mais typée en tant que l'interface implémentée.
 * On peut donc lui passer tout type d'implementation concrete.
 */
function clientCode(room: RoomCreator) {
  room.frightenHero();
}
 
/**
 * Il est maintenant possible d'éxécuter notre code client en lui passant
 * une de nos deux classes de création sans que ce dernier n'ait conaissance de ce qu'on lui passe
 */
 
// Application lancée avec le MonsterRoomCreator
clientCode(new MonsterRoomCreator());
// A wild monster appears !
// 👿
// Arrrrg !
 
// Application lancée avec le GhostRoomCreator
clientCode(new GhostRoomCreator());
// A ghost appears !
// 👻
// woooooooo !

/**
 * L'Abstract Factory déclare un ensemble de méthodes renvoyant différents produits abstraits.
 * Ces produits forment une `famille` dont les composantes sont liées par un thème ou un concept de haut niveau.
 * Les produits d'une même famille sont généralement capables de collaborer entre eux.
 * Une famille de produits peut avoir plusieurs variantes, mais les produits d'une variante sont incompatibles avec les produits d'une autre.
 */
interface DungeonFactory {
  createBuilding(): AbstractBuilding;
  createBoss(): AbstractBoss;
}
 
/**
 * Les factory concrètes produisent des produits appartenant à la même famille.
 * La factory garantit que les produits résultants sont compatibles.
 * Notez que les signatures des méthodes de la Fabrique Concrète retournent un produit abstrait
 * alors que la méthode instancie bel et bien un produit concret (cf cas de la Factory Method)
 */
class EvilWarlockDungeonFactory implements DungeonFactory {
  public createBuilding(): AbstractBuilding {
    return new EvilWarlockLibrary();
  }
 
  public createBoss(): AbstractBoss {
    return new EvilWarlock();
  }
}
 
/**
 * À chaque factory concrète correspond une variante de produit.
 */
class DarkKnightDungeonFactory implements DungeonFactory {
  public createBuilding(): AbstractBuilding {
    return new DarkKnightCastle();
  }
 
  public createBoss(): AbstractBoss {
    return new DarkKnight();
  }
}
 
/**
 * Chaque produit d'une famille de produits doit avoir une interface de base que toutes les
 * variantes concrètes doivent implémenter.
 */
interface AbstractBuilding {
  playMusic(): void;
  getTreasureKey(): string;
}
 
/**
 * Les classes concrètes seront créées par les factory concrètes associées.
 */
class EvilWarlockLibrary implements AbstractBuilding {
  public playMusic() {
    console.log('Some eerie music starts playing...');
  }
  public getTreasureKey(): string {
    return 'an ancient key made with bones';
  }
}
 
class DarkKnightCastle implements AbstractBuilding {
  public playMusic() {
    console.log('Some dark music starts playing...');
  }
  public getTreasureKey(): string {
    return 'a dark and heavy metal key';
  }
}
 
/**
 * Les produits concrets peuvent interargir entre eux, mais seulement si ce sont les produits de la même Factory concrète.
 */
interface AbstractBoss {
  stateTheirName(): void;
  protectBuildingTreasure(collaborator: AbstractBuilding): void;
}
 
class EvilWarlock implements AbstractBoss {
  public stateTheirName() {
    console.log('I am the almighty Evil Warlock 🧙‍‍️ !!!');
  }
 
  /**
   * Un `Boss` ne peut interagir qu'avec un `Building` issu de la même `DungeonFactory` concrete.
   */
  public protectBuildingTreasure(building: AbstractBuilding) {
    const key = building.getTreasureKey();
    console.log(`Evil warlock is protecting ${key} !`);
  }
}
 
class DarkKnight implements AbstractBoss {
  public stateTheirName() {
    console.log('I am the invincible Dark Knight 🔪 !!!');
  }
 
  public protectBuildingTreasure(building: AbstractBuilding) {
    const key = building.getTreasureKey();
    console.log(`Dark night is protecting ${key} !`);
  }
}
 
/**
 * Le code client n'a connaissance des produits et des Factory que via leur interface (DungeonFactory / AbstractBuilding | AbstractBoss)
 */
function clientCode(dungeon: DungeonFactory) {
  const building = dungeon.createBuilding();
  const boss = dungeon.createBoss();
 
  building.playMusic();
  boss.stateTheirName();
  boss.protectBuildingTreasure(building);
}
 
/**
 * Le code client peut désormais fonctionner avec n'importe quelle factory concrète !
 */
clientCode(new EvilWarlockDungeonFactory());
// Some eerie music starts playing...
// I am the almighty Evil Warlock 🧙‍‍️ !!!
// Evil warlock is protecting an ancient key made with bones !
 
clientCode(new DarkKnightDungeonFactory());
// Some dark music starts playing...
// I am the invincible Dark Knight 🔪 !!!
// Dark night is protecting a dark and heavy metal key !

class Mount {
  constructor(private name: string, private color: string, private speed: number) {}
}
 
const basicHorse = new Mount('Thunder', 'greyish', 22.5);

class Mount {
  constructor(
    private name?: string,
    private color?: string,
    private speed?: number,
    private legs: number = 4,
    private rarity: number = 1,
    private canFly: boolean = false,
    private canBreatheFire: boolean = false,
    private age?: number,
  ) {
    // ...
  }
}
 
const basicHorse = new Mount('Thunder', 'greyish', 22.5, null, null, null, null, 5);
 
const mythicalHellishHorse = new Mount('Armaggedon', 'red', 145, null, 5, null, null, 8);
 
const mutantFlyingCreature = new Mount(
  'x3zU!zz762uxKivargzTToLdjskdaqiwdjdqdqu',
  'lavender',
  800,
  8,
  9,
  true,
  true,
  99,
);

class MountBuilder {
  private mount: Mount;
 
  /**
   * Une nouvelle instance de `MontBuilder` doit contenir un objet `Mount` vierge, qui sera ensuite
   * utilisé dans les différentes étapes de production
   */
  constructor() {
    this.reset();
  }
 
  public reset(): void {
    this.mount = new Mount();
  }
 
  /**
   * Toutes les étapes de production s'appliquent à l'instance de `Mount`, qui est
   * retournée à chaque fois pour permettre de chaîner les appels auxdites étapes.
   */
  public setName(name: string): this {
    this.mount.setName(name);
    return this;
  }
 
  public setColor(color: string): this {
    this.mount.setColor(color);
    return this;
  }
 
  public setLegs(amount: number): this {
    this.mount.setLegs(amount);
    return this;
  }
 
  public setRarity(amount: number): this {
    this.mount.setRarity(amount);
    return this;
  }
 
  public canFly(): this {
    this.mount.addFlyingAbility();
    return this;
  }
 
  public canBreatheFire(): this {
    this.mount.addBreathingFireAbility();
    return this;
  }
 
  public setAge(age: number): this {
    this.mount.setAge(age);
    return this;
  }
 
  /**
   * Il est d'usage de reset le builder lorsqu'un produit "assemblé" est retourné au client.
   * Ainsi le builder peut directement produire un nouvel objet from scratch
   * débarassé de toute trace du produit précédemment créé.
   */
  public getMount(): Mount {
    const mount = this.mount;
    this.reset();
    return mount;
  }
}
 
const mountBuilder = new MountBuilder();
 
const basicHorse = mountBuilder
.setName('Thunder')
.setColor('greyish')
.setSpeed(22.5)
.setAge(5);
 
const mythicalHellishHorse = mountBuilder
  .setName('Armaggedon')
  .setColor('red')
  .setSpeed(145)
  .setRarity(5)
  .setAge(8);
 
const mutantHorse = mountBuilder
  .setName('x3zU!zz762uxKivargzTToLdjskdaqiwdjdqdqu')
  .setColor('lavender')
  .setSpeed(800)
  .setLegs(8)
  .setRarity(9)
  .canFly();
  .canBreatherFire();
  .setAge(99);

class Weapon {
  constructor(public type: string, public powerLevel: number) {}
}
 
class Monster {
  public type?: string;
  public weapon?: Weapon;
  public hp?: number;
  public color?: string;
  private _isEnraged: boolean;
 
  constructor() {
    // Une chance sur dix
    this._isEnraged = Math.random() < 0.1;
  }
 
  get isEnraged(): boolean {
    return this._isEnraged;
  }
}
 
const cloneEnemy = (monster: Monster): Monster => {
  const clone = new Monster();
  clone.type = monster.type;
  clone.weapon = monster.weapon;
  clone.hp = monster.hp;
  return clone;
};
 
const monster = new Monster();
monster.type = 'BASIC';
monster.hp = 500;
monster.color = 'red';
monster.weapon = new Weapon('AXE', 9001);
 
const monster2 = cloneEnemy(monster);
 
console.log(monster.type === monster2.type); // true
console.log(monster.hp === monster2.hp); // true
console.log(monster.weapon === monster2.weapon); // ❌ true, les deux `Monsters` partagent la même instance de `Weapon` !
console.log(monster.isEnraged === monster2.isEnraged); // ❌ true 1% du temps, false le reste

class Weapon {
  constructor(public type: string, public powerLevel: number) {}
}

abstract class EnemyPrototype {
  constructor(
    public type?: string,
    public hp?: number,
    public color?: string,
    public weapon?: Weapon
  ) {}

  clone(): this {
    const clone = Object.create(this);
    /**
     * Une nouvelle `Weapon` est créée déclarativement, mais on pourrait aussi rendre la classe Weapon clonable 😏
     */
    if (this.weapon) {
      clone.weapon = new Weapon(this.weapon.type, this.weapon.powerLevel);
    }

    return clone;
  }
}

class Monster extends EnemyPrototype {
  private _isEnraged: boolean;

  constructor() {
    // Une chance sur dix
    super();
    this._isEnraged = Math.random() < 0.1;
  }

  get isEnraged(): boolean {
    return this._isEnraged;
  }
}

/**
 * Il est désormais possible de cloner tout type d'ennemi, tant que ce sont des instances
 * d'une classe etendant `EnemyPrototype`.
 * Toute la logique de clonage est encapsulée dans `EnemyPrototype`.
 */
const cloneEnemy = <T extends EnemyPrototype>(enemy: T): T => {
  return enemy.clone();
};

const monster = new Monster();
monster.type = "BASIC";
monster.hp = 500;
monster.color = "red";
monster.weapon = new Weapon("AXE", 9001);

const monster2 = cloneEnemy(monster);

console.log(monster.type === monster2.type); // true
console.log(monster.hp === monster2.hp); // true
console.log(monster.weapon === monster2.weapon); // ✅ false, ce n'est pas la meme instance de Weapon
console.log(monster.isEnraged === monster2.isEnraged); // ✅ true