GlyriaBus
Vue d'ensemble
GlyriaBus est un bus d'événements pub/sub (publication/abonnement) typé avec support des middlewares. Il vous permet de faire communiquer les différentes parties de votre bot entre elles sans les coupler.
```text
File created successfully: GlyriaBus_FR.md
```ts
// src/utils/useBus.ts
type BotEvents = {
userBanned: [guildId: string, userId: string, reason: string]
levelUp: [userId: string, level: number]
}
export const useBus = new GlyriaBus<BotEvents>()
GlyriaBus est disponible globalement — aucun import n'est nécessaire. Définissez votre bus dans src/utils/ et il sera auto-importé partout.Constructeur
new GlyriaBus<Events>()
Paramètre de type
Events est un objet (record) associant les noms des événements aux types de leur contenu (sous forme de tuples) :
type Events = {
userBanned: [guildId: string, userId: string]
levelUp: [userId: string, level: number]
}
Méthodes
.on(event, listener)
Enregistre un écouteur (listener) pour un événement. Retourne une fonction de désinscription.
const stop = useBus.on("userBanned", (guildId, userId) => {
console.log(`${userId} a été banni de ${guildId}`)
})
// plus tard
stop()
| Paramètre | Type | Description |
|---|---|---|
event | keyof Events | Nom de l'événement |
listener | Listener<Events[K]> | Gestionnaire recevant les données de l'événement |
Retourne () => void — appelez cette fonction pour supprimer l'écouteur.
.use(event, middleware)
Enregistre un middleware pour un événement. Les middlewares s'exécutent avant les écouteurs et doivent appeler next() pour poursuivre la chaîne.
useBus.use("userBanned", async (guildId, userId, next) => {
console.log(`[middleware] bannissement reçu`)
await next()
})
| Paramètre | Type | Description |
|---|---|---|
event | keyof Events | Nom de l'événement |
middleware | Middleware<Events[K]> | Gestionnaire avec next comme dernier argument |
.emit(event, ...args)
Émet un événement avec des arguments typés. Exécute tous les middlewares et écouteurs dans l'ordre.
await useBus.emit("userBanned", guildId, userId, reason)
| Paramètre | Type | Description |
|---|---|---|
event | keyof Events | Nom de l'événement |
...args | Events[K] | Données typées de l'événement |
Retourne Promise<void>
.off(event, middleware)
Supprime un middleware spécifique pour un événement.
useBus.off("userBanned", myMiddleware)
.clear(event)
Supprime tous les écouteurs et middlewares pour un événement.
useBus.clear("userBanned")
Types
Middleware<T>
type Middleware<T extends any[]> = (
...args: [...ctx: T, next: NextFunction]
) => any | Promise<any>
Listener<T>
type Listener<T extends any[]> = (...ctx: T) => any | Promise<any>
NextFunction
type NextFunction = () => void | Promise<void>
Chaîne de middlewares
Les middlewares et les écouteurs s'exécutent dans leur ordre d'enregistrement. Le fait de ne pas appeler next() interrompt la chaîne — les middlewares et écouteurs suivants ne seront pas exécutés.
useBus.use("levelUp", async (userId, level, next) => {
if (level < 5) return // s'arrête ici, l'écouteur ne s'exécutera jamais
await next()
})
useBus.on("levelUp", (userId, level) => {
console.log(`${userId} a atteint le niveau ${level}`)
})