@rotomeca/event - v5.0.0
    Preparing search index...

    Class CircularEventDelegate<TRecord>

    Raccourci ergonomique vers CircularEventHandler conservant la même signature qu'à l'origine.

    Permet d'instancier un gestionnaire d'événement circulaire en ne spécifiant que le type du record propagé entre les callbacks :

    // Avec CircularEventDelegate
    const pipeline = new CircularEventDelegate<{ count: number }>();

    // Équivalent avec CircularEventHandler
    const pipeline = new CircularEventHandler<{ count: number }, (param: { count: number }) => Partial<{ count: number }>>();
    const pipeline = new CircularEventDelegate<{ count: number; label: string }>();

    pipeline.add('increment', (record) => ({ count: record.count + 1 }));
    pipeline.add('label', (record) => ({ label: `count=${record.count}` }));

    const result = pipeline.invoke({ count: 0, label: '' });
    // result → { type: 'record', value: { count: 1, label: 'count=1' } }

    Type Parameters

    • TRecord extends Record<string, unknown> = Record<string, unknown>

      Type du record propagé entre les callbacks. Doit étendre Record<string, unknown>. Par défaut Record<string, unknown>.

    Hierarchy (View Summary)

    Index

    Constructors

    Accessors

    • get keys(): string[]

      Retourne la liste des clés des callbacks actuellement enregistrés.

      Returns string[]

      const keys = event.keys; // ['handler1', 'handler2']
      

    Methods

    • Ajoute un callback avec une clé spécifique.

      Parameters

      • key: string

        Clé identifiant le callback.

      • event: Func

        Le callback à ajouter.

      • ...args: [TRecord?]

        Arguments par défaut transmis au callback à chaque appel.

      Returns this

      L'instance courante pour permettre le chaînage.

    • Supprime tous les callbacks enregistrés en une seule opération O(1).

      Capture la liste des callbacks avant l'effacement, puis déclenche onHandlerCleared après — garantissant que la Map est vide avant la notification, sans risque de double déclenchement si un observateur appelle add dans son callback.

      Returns this

      L'instance courante pour permettre le chaînage.

    • Déclenche la chaîne de callbacks en propageant un record muté de l'un à l'autre.

      Pour chaque callback enregistré, dans l'ordre d'enregistrement :

      1. Les arguments par défaut du callback (s'ils sont un plain object) sont mergés dans le record courant.
      2. Le callback est appelé avec le record courant.
      3. Si le résultat est un plain object, il est mergé dans le record courant avant le prochain callback.

      Si args_0 n'est pas un plain object, un avertissement est émis via logger, la valeur est wrappée dans { default: args_0 } et la chaîne est exécutée normalement. Le résultat est alors de type 'other'.

      Parameters

      • args_0: TRecord

        Le record initial transmis au premier callback.

      Returns CircularEventCallResult<TRecord>

      Un CircularEventCallResult décrivant le résultat :

      • { type: 'empty' } si aucun callback n'est enregistré.
      • { type: 'record', value } si la chaîne s'est exécutée normalement.
      • { type: 'other', value, originalValue } si args_0 n'était pas un plain object.
      const result = pipeline.invoke({ count: 0 });

      if (result.type === 'record') {
      console.log(result.value.count);
      }