Référence d'API — nodefony/client — racine

stable

Documentation › Référence d’API › nodefony › client-racine

Générée depuis les déclarations de types publiées de nodefony 10.0.0-beta.5 : exactement ce que reçoit une application qui l’installe. Cette page n’existe dans aucun dépôt — pour la corriger, on corrige le TSDoc du code.

nodefony/client#

import { … } from "nodefony/client" — 12 symboles.

Classes (2)#

Container#

class Container implements IContainer

Dependency Injection container — registers services by name and exposes them to the rest of the framework.

• protoService: ProtoService
• protected services: DynamicService | null
• get id(): string — Identifiant unique du conteneur dans le process (base 36).
• get closed(): boolean — true après clean — pour un scope, après leaveScope.
• log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): ReturnType<Syslog["log"]> | void — Emit a log entry through the registered syslog service.
• set(name: string, object: unknown): void — Register a service under name.
• get<T = unknown>(name: string): T | null — Resolve a service by name.
• remove(name: string): boolean — Unregister a service.
• has(name: string): boolean — Whether a service is registered under name.
• keys(): string[] — All service names currently registered on this container.
• entries(): [ string, unknown ][] — All [name, service] pairs currently registered on this container.
• addScope(name: string): ReadonlySet<IScope> — Declare a scope.
• enterScope(name: string): Scope — Open a new instance of the named scope.
• leaveScope(scope: IScope): void — Close a scope instance and release its services.
• scopeCount(name: string): number — Nombre d’instances VIVANTES du scope nommé — introspection bon marché (sondes de fuite, Studio, diagnostics) sans exposer la structure interne.
• removeScope(name: string): void — Close every open instance of the named scope and forget it.
• clean(): void — Tear the container down: close every scope and drop services.
• reset(): void — Clean the container and rebuild fresh prototype chains, leaving it ready to register services again.

Service#

class Service implements IService

• name: string
• options: DefaultOptionsService
• container: Container | null
• kernel: IKernel | null
• syslog: Syslog | null
• get notificationsCenter(): Event — Bus d’événements du service.
• constructor(name: string, container?: Container, notificationsCenter?: Event | false | null, options?: DefaultOptionsService)
• initSyslog(environment?: EnvironmentType, debug?: DebugType, options?: conditionsInterface): ReturnType<Syslog["init"]> | null — Démarre la sortie console du Syslog avec l’environnement et la verbosité voulus.
• getName(): string — Renvoie le nom logique du service (utilisé comme msgid syslog par défaut).
• clean(syslog?: boolean): void — Libère les ressources — retire les listeners trackés du bus partagé pour éviter les fuites mémoire, puis détache container/kernel/syslog/nc.
• log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message, moduleName?: string): Pdu — Émet une entrée de log structurée — point d’entrée central pour TOUT log Nodefony.
• logger(pci: Pci, ...args: unknown[]): void — Raccourci debug — log severity DEBUG + console.debug formaté.
• trace(pci: Pci, ...args: unknown[]): void — Comme logger mais console.trace (avec stack trace).
• eventNames(): (string | symbol)[] — Liste les noms d’événements ayant au moins un listener.
• fire(eventName: string | symbol, ...args: unknown[]): boolean — Alias emit — émet l’événement de manière synchrone.
• fireAsync(eventName: string | symbol, ...args: unknown[]): Promise<unknown> — Émet l’événement et attend que tous les listeners async résolvent.
• emit(eventName: string | symbol, ...args: unknown[]): boolean — Émet l’événement (API EventEmitter standard).
• emitAsync(eventName: string | symbol, ...args: unknown[]): Promise<unknown> — Émet et attend les listeners async — équivalent de fireAsync.
• emitAsyncGuarded(eventName: string | symbol, options?: IGuardedEmitOptions, ...args: unknown[]): Promise<IGuardedEmitResult> — Variante gardée de emitAsync (cf Event.emitAsyncGuarded) : isole chaque listener par try/catch + timeout et collecte les échecs.
• addListener(eventName: string | symbol, listener: EventListener): this — Enregistre un listener (tracké pour cleanup).
• listen(eventName: string | symbol, listener: EventListener): (...args: unknown[]) => boolean — Bind le listener sur this puis l’enregistre — utile quand le listener référence this.foo et ne peut pas être tracké à l’identique.
• on(eventName: string | symbol, listener: EventListener): this — Enregistre un listener (tracké pour cleanup).
• once(eventName: string | symbol, listener: EventListener): this — Enregistre un listener one-shot — auto-retiré après le premier emit.
• off(eventName: string | symbol, listener: EventListener): this — Retire un listener (alias EventEmitter de removeListener).
• settingsToListen(localSettings: EventDefaultInterface, context: object): void — Enregistre les événements déclarés dans localSettings.events.listeners — utilisé en config pour mapper des hooks sans code impératif.
• setMaxListeners(n: number): this — Augmente la limite Node.js (défaut 10) pour éviter le warning MaxListeners.
• removeListener(eventName: string | symbol, listener: EventListener): this — Retire un listener spécifique et nettoie le tracking interne.
• removeAllListeners(eventName?: string | symbol): this — Retire tous les listeners (ou ceux d’un événement précis si fourni).
• prependOnceListener(eventName: string | symbol, listener: EventListener): this — Comme once mais inséré en tête de la liste des listeners.
• prependListener(eventName: string | symbol, listener: EventListener): this — Comme on mais inséré en tête de la liste des listeners.
• getMaxListeners(): number — Limite courante de listeners avant warning Node.js.
• listenerCount(eventName: string | symbol, listener?: EventListener): number — Nombre de listeners attachés à un événement (filtré sur listener si fourni).
• listeners(eventName: string | symbol): EventListener[] — Copie de la liste des listeners (résolus, sans le wrapper once).
• rawListeners(eventName: string | symbol): EventListener[] — Comme listeners mais retourne les wrappers Node.js bruts (avec once).
• get<T>(name: string): T | null — Récupère un service du DI container par nom.
• set(name: string, obj: unknown): void — Enregistre un objet dans le DI container.
• remove(name: string): boolean — Retire un service du container — si c’est un Service, appelle d’abord son clean() pour libérer ses listeners.
• has(name: string): boolean — Vérifie l’existence d’un service dans le container.

Constantes (10)#

extend#

const extend: (...args: unknown[]) => any

Fusionne plusieurs objets dans une cible — API compatible jQuery.extend.

isArray#

const isArray: (arg: any) => arg is any[]

Alias direct de Array.isArray — exporté pour usage cohérent dans les modules.

isContainer#

const isContainer: (container: unknown) => container is Container

Type guard — true si la valeur est une instance de Container (DI).

isEmptyObject#

const isEmptyObject: (obj: object | null) => boolean

Vérifie qu’un objet existe et ne contient aucune clé propre énumérable.

isFunction#

const isFunction: (value: unknown) => value is (...args: unknown[]) => unknown

Type guard — true si value est une fonction (incluant arrow et classes).

isPromise#

const isPromise: (obj: unknown) => obj is PromiseLike<unknown>

Vérifie qu’une valeur est une Promise ou un thenable (duck-typing .then).

isRegExp#

const isRegExp: (value: unknown) => value is RegExp

Type guard — true si value est une instance RegExp.

isSubclassOf#

const isSubclassOf: (subclass: unknown, superclass: any) => boolean

Vérifie qu’une classe hérite (directement ou non) d’une autre.

isUndefined#

const isUndefined: (value: unknown) => value is undefined

Type guard — true si value === undefined (strict, jamais null).

typeOf#

const typeOf: (value: unknown) => string | null

← Toutes les références d’API