poc: builder more modular

[mathcovax]

Actuellement les fonction useRouteBuilder et useProcessBuilder sont dépendantes de la fonction useBuilder. Ces 2 fonction font appelle a la méthode push de useBuilder pour l'ajouter a la pile des duplose.

Cette architecture cause un problème de sémantique. Cela rend la fonction useBuilder indispensable au fonctionnement de useRouteBuilder et useProcessBuilder alors que ça ne devrait pas être le cas. Cette dépendance rend la modularization des builder plus complexe et aussi moins propre.

Les builder ont déjà bq de répétition de code qu'il faudrait factorisai. Donc pour rendre les builder plus modulaire il faudrait d'abord les rework.

solution actuelle envisagé:
Créer un builder de builder ! (builderception)

Exemple d'utilisation:

interface MySuperbuilder {
  method1(arg1: string): MySuperbuilder;
  build(arg1: string): SomeThing;
}

const mySuperBuilder: ((...args: any[]) => MySuperbuilder) = createBuilder<
  ((...args: any[]) => object),
  MySuperbuilder
>(
  (args) => ({myArg: args})
)
  .setMethod(
    "method1", 
    ({args, definition, nextBuilder, stopBuilder}) => {
      // do some thing 

      return nextBuilder({...definition});
    }
  )
  .setMethod(
    "build", 
    ({args, definition, stopBuilder}) => {
      // do some thing 

      return stopBuilder(new SomeThing(definition));
    }
  );

const thing = mySuperBuilder("myArg")
  .method1(arg)
  .build(arg);

Cela rendra la modularité plus simple avec ce genre de chose :

declare module "..." {
  interface MySuperbuilder {
    newMethod(arg1: string): MySuperbuilder;
  }
}

mySuperBuilder.setMethod(
  "newMethod",
  /* ... */
);

La fonction nextBuilder permet de renvoyer le builder au complet avec une nouvelle définition.
La fonction stopBuilder permet de stopper le builder et renvoyer l'objet qu'on souhaite construire. stopBuilder doit également ajouter l'objet a la pile de objet construit avec ce builder.