--- title: "Référence d'API — nodefony — racine" source: docs/api/core/racine.md url: https://nodefony.github.io/nodefony-core/docs/api/core/racine/ --- [Documentation](../../../) › [Référence d'API](../../) › [`nodefony`](../) › 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` `import { … } from "nodefony"` — 36 symboles. ### Classes (8) #### `Cli` ```ts class Cli extends Service ``` - `options: CliDefaultOptions` - `debug: DebugType` - `environment: EnvironmentType` - `commander: typeof program | null` - `protected commands: Record` - `pid: number | null` - `interactive: boolean` - `unhandledRejections: Map, string>` - `response: Record` - `timers: Record` - `version: string` - `clc: Clc` - `blankLine: () => void` - `columns: number` - `rows: number` - `protected shuttingDown: boolean` — Vrai dès le 1ᵉʳ signal d'arrêt reçu. - `protected static readonly SIGNUM: Record` — Numéros POSIX → code de sortie forcé `128 + signum` au 2ᵉ signal. - `constructor(name?: string)` - `constructor(name: string, options: CliDefaultOptions)` - `constructor(name: string, container: Container | null, options: CliDefaultOptions)` - `constructor(name: string, container: Container | null, notificationsCenter: Event | false, options: CliDefaultOptions)` - `protected handleSignals(): void` - `protected trackProcessListener(off: () => void, signal?: boolean): void` — Mémorise DE QUOI retirer un listener de `process`. - `releaseProcessListeners(): number` — Retire tous les listeners que cette instance a posés sur `process`. - `releaseSignalListeners(): number` — Retire les gestionnaires de SIGNAUX de cette instance — et rien d'autre. - `start(): Promise` - `idle(): { resolve: null; promise: Promise; reject: null; }` - `checkVersion(version?: string | semver.SemVer | null): string` - `showAsciify(name?: string | null): Promise` - `showBanner(): string | null` - `listenRejection(): void` - `setPid(): number` - `setProcessTitle(name?: string): string` - `logEnv(): string` - `initCommander(): typeof program | null` - `initUi(): void` - `getFonts(): Promise` - `asciify(txt: string, options?: object, callback?: (error: Error, data: string) => void): Promise` - `parse(argv?: string[], options?: ParseOptions): CommanderCommand` - `parseAsync(argv?: string[], options?: ParseOptions): Promise` - `clearCommand(): void` - `runCommand(cmd: string, args?: any[]): CommanderCommand` - `runCommandAsync(cmd: string, args?: any[]): Promise` - `setCommandOption(flags: string, description?: string, defaultValue?: string | boolean | string[]): CommanderCommand` - `setCommandVersion(version: string): CommanderCommand` - `setCommand(nameAndArgs: string, description: string, options?: ExecutableCommandOptions): CommanderCommand` - `addCommand(cliCommand: new (cli: this) => Command): Command` - `hasCommand(name: string): boolean` - `getCommand(name: string): Command | null` - `showHelp(quit: boolean, context: HelpContext): void | never` - `displayTable(datas: (HorizontalTableRow | VerticalTableRow | CrossTableRow)[] | null, options: TableConstructorOptions, syslog?: Syslog | null): Table.Table` - `static niceBytes(x: string | number): string` - `static niceUptime(date: Date | number | string, suffix?: boolean): string` — Temps relatif lisible ("a few seconds ago", "24 years ago") — natif via `Intl.RelativeTimeFormat` (remplace `moment().fromNow()`, dep supprimée). - `static niceDate(date: Date | number | string, format?: string): string` — Formate une date selon des tokens `moment`-like (`YYYY MM DD HH mm ss SSS`) en heure **locale** — natif (remplace `moment().format()`, dep supprimée). - `clear(): void` - `reset(): void` - `resize(): void` - `createDirectory(myPath: fs.PathLike, mode?: fs.MakeDirectoryOptions | fs.Mode | null, force?: boolean): Promise` - `existsSync(myPath: fs.PathLike): boolean` - `exists(myPath: fs.PathLike, mode?: number, callback?: fs.NoParamCallback): boolean` - `terminate(code?: number, quiet?: boolean): Promise` - `static quit(code: number): void` - `startTimer(name: string): void` - `stopTimer(name?: string | null): void` — Arrête un timer et affiche le temps écoulé ; sans nom, arrête tous les timers. - `getCommandManager(manager: string): "bun" | "npm" | "npm.cmd" | "pnpm" | "pnpm.cmd" | "yarn" | "yarn.cmd"` — Nom de l'exécutable d'un gestionnaire de paquets sur cette plateforme. - `runPackageManager(argv: string[], cwd: string, env: EnvironmentType, manager: string): Promise` - `npm(argv?: string[], cwd?: string, env?: EnvironmentType): Promise` - `yarn(argv?: string[], cwd?: string, env?: EnvironmentType): Promise` - `pnpm(argv?: string[], cwd?: string, env?: EnvironmentType): Promise` - `bun(argv?: string[], cwd?: string, env?: EnvironmentType): Promise` - `spawn(command: string, args: readonly string[], options: SpawnOptions, close?: (code: number) => void | null): Promise` - `spawnSync(command: string, args: readonly string[], options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns` #### `Container` ```ts 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 | void` — Emit a log entry through the registered `syslog` service. - `set(name: string, object: unknown): void` — Register a service under `name`. - `get(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` — 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. #### `Event` ```ts class Event extends EventEmitter ``` Signatures d'abonnement d'`Event` : un listener peut RENDRE une valeur ou une promesse — `emitAsync`/`emitAsyncGuarded` les attendent et collectent leurs résultats. Les signatures héritées d'`EventEmitter` déclarent un retour `void`, ce qui fait passer tout listener `async` pour une promesse perdue ; ce contrat-ci dit la vérité. Pur type (fusion de déclarations) : aucun coût à l'exécution, les méthodes restent celles de `EventEmitter`. - `constructor(settings?: EventDefaultInterface, context?: ContextType, options?: EventOptionInterface)` - `settingsToListen(localSettings: EventDefaultInterface, context?: ContextType): void` — Parcourt `localSettings` et enregistre chaque clé matchant `/^on(.*)$/` comme listener — convention héritée des composants WebComponent / config Nodefony historique. - `listen(context: ContextType, eventName: string | symbol, listener: Listener): (...args: unknown[]) => boolean` — Bind `listener` sur `context` puis l'enregistre. - `fire(eventName: string | symbol, ...args: unknown[]): boolean` — Alias `emit` — émission synchrone (API EventEmitter standard). - `emitAsync(eventName: string | symbol, ...args: unknown[]): Promise` — Émet et attend chaque listener en séquence (`await Reflect.apply` un par un). - `fireAsync(eventName: string | symbol, ...args: unknown[]): Promise` — Alias `emitAsync`. - `emitAsyncGuarded(eventName: string | symbol, options?: IGuardedEmitOptions, ...args: unknown[]): Promise` — Variante **gardée** de `emitAsync` : émet les listeners en SÉRIE (ordre préservé) mais isole chacun par un `try/catch` + un `timeout` optionnel, et COLLECTE les échecs au lieu de laisser le premier re … #### `FileClass` ```ts class FileClass ``` Wrapper fs Node.js avec métadonnées pré-parsées (path, name, ext, mime, stats). - `stats: fs.Stats` - `type: string` - `path: fs.PathOrFileDescriptor` - `parse: path.ParsedPath` - `name: string` - `shortName: string` - `ext: string` - `mimeType: string | false` - `encoding: string` - `extention: string | false` - `dirName: string` - `match: RegExpExecArray | null` - `constructor(Path: string | fs.PathOrFileDescriptor, options?: { defer?: boolean; })` - `static from(Path: string | fs.PathOrFileDescriptor): Promise` — Construit un FileClass SANS I/O synchrone — `fsp.lstat`/`fsp.realpath` async. - `stat(): Promise` — Résout les stats en async (`fsp.lstat` + `fsp.realpath`) puis hydrate l'instance. - `toString(): string` - `toJson(): FileClassInterface` — Sérialise les métadonnées du fichier en objet plain (compatible JSON.stringify). - `checkType(): string` — Détermine le type — `"File"`, `"Directory"`, `"SymbolicLink"`, etc. - `checkSum(type?: string, hasOption?: crypto.HashOptions): string` — Calcule le hash du contenu du fichier (synchronous). - `getMimeType(name?: string): string | false` - `getExtension(mimeType: string | false): string | false` - `getRealpath(Path: string, options?: fs.EncodingOption): string` — Canonicalise un chemin par la voie SYSTÈME (`uv_fs_realpath`), la même que `fsp.realpath` employé par la voie async. - `matchName(ele: RegExp | string): boolean | RegExpExecArray | null` - `matchType(type: string): boolean` - `isFile(): boolean` - `isDirectory(): boolean` - `isSymbolicLink(): boolean` - `dirname(): string` - `isHidden(): boolean` - `content(encoding?: string): string | Buffer` - `read(encoding?: string): string | Buffer` — Lit le contenu du fichier (synchronous). - `readAsync(encoding?: string): Promise` - `readByLine(callback: (line: string, n: number) => void, encoding?: string): string | Buffer` - `write(data: string | NodeJS.ArrayBufferView, options: fs.WriteFileOptions): void` — Écrit du contenu dans le fichier (synchronous). - `move(target: fs.PathLike): FileClass` — Déplace/renomme le fichier (synchronous). - `moveAsync(target: fs.PathLike): Promise` — Déplace/renomme le fichier en **async** (`fsp.rename`) — variante non bloquante de `move()`. - `unlink(): void` — Supprime le fichier du filesystem (synchronous, irréversible). - `unlinkAsync(): Promise` — Supprime le fichier du filesystem en **async** (`fsp.unlink`). #### `Nodefony` ```ts class Nodefony ``` Façade statique du framework — point d'entrée global remplaçant le singleton JS legacy. - `static readonly version: string` — Version du package `nodefony` (lue depuis `package.json` au build). - `static getKernel(): Kernel | null` — Retourne le `Kernel` courant ou `null` s'il n'a pas encore été instancié. - `static setKernel(k: Kernel): void` — Enregistre le `Kernel` courant — appelé une seule fois au boot. - `static generateId(): string` — Génère un UUID v4 (aléatoire) — utilisé pour `requestId`, ids divers, etc. - `static generateSortableId(): string` — Génère un UUID **v7** (RFC 9562) — identifiant **ordonné dans le temps**, à préférer pour une clé primaire de base de données. #### `Scope` ```ts class Scope extends Container implements IScope ``` Short-lived child container tied to a parent `Container`. Used by the HTTP/WS kernel to isolate per-request services (e.g. request-bound sessions, scoped resolvers) without polluting the global container. - `name: string` - `constructor(name: string, parent: Container, parentProtoService: ProtoService)` - `reset(): void` — Refused on a scope: rebuilding fresh prototypes would silently detach it from its parent (every inherited service would read as `null`). - `set(name: string, object: unknown): void` — Register a per-request service — own property ONLY (shadowing). - `remove(name: string): boolean` — Unregister a service registered ON THIS SCOPE (own property only). - `hasOwn(name: string): boolean` — `true` si `name` est posé SUR ce scope (propriété propre) — jamais pour un service hérité du parent. - `own(instance: object): void` — Lie la durée de vie de `instance` à celle du scope : son `clean()`, s'il en a un, sera appelé à la fermeture (`Container.leaveScope`), dans l'ordre INVERSE des rattachements — un service créé après ce … - `clean(): void` — Nettoie les objets rattachés (`own`), du dernier au premier, puis libère le scope. #### `Service` ```ts 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 | 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` — É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` — Émet et attend les listeners async — équivalent de `fireAsync`. - `emitAsyncGuarded(eventName: string | symbol, options?: IGuardedEmitOptions, ...args: unknown[]): Promise` — 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(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. #### `nodefonyError` ```ts class nodefonyError extends Error ``` Erreur Nodefony — wrapper riche autour de `Error` natif qui ajoute : - Un `code` numérique (HTTP status ou code custom — pas un string). - Un `errorType` détecté automatiquement (TypeError, SystemError, AssertionError, OrmError, ClientError, etc.). - Une sérialisation `toJSON()` filtrée qui exclut `context`, `resolver`, `container`, `secure` (références circulaires). - Un `toString()` coloré (cli-color) qui adapte le format selon l'environnement (production = message court ; dev = champs détaillés). - `code: number | null` - `error?: Error` - `errorType: string` - `[key: string]: any` - `toJSON: () => Record` — Sérialisation JSON filtrée — POSÉE sur le prototype plus bas (`Object.defineProperty(nodefonyError.prototype, "toJSON", …)`), donc déclarée ici sans initialiseur (`declare` : aucun code émis). - `constructor(message?: string | Error, code?: number)` - `static isError(error: unknown): error is Error` — Type guard — vérifie qu'une valeur est une instance d'`Error`. - `static detectType(error: Error): string | false` — Détecte la catégorie d'une erreur (TypeError, SystemError, OrmError, etc.). - `getType(error: Error): string` — Détecte le type d'erreur et copie ses champs spécifiques sur `this`. - `toString(): string` — Sérialise l'erreur en string coloré (cli-color) selon `errorType` et l'environnement. - `parseMessage(message: unknown): void` — Parse l'argument du constructeur et hydrate les champs (`message`, `code`, `stack`). - `getDefaultMessage(): void` — Renseigne `this.message` à partir du `code` HTTP via `STATUS_CODES`. - `logger(): void` — Affiche l'erreur formatée sur `console.log` (raccourci de `toString()`). ### Fonctions (1) #### `registerErrorAdapter` ```ts function registerErrorAdapter(name: string, adapter: IErrorAdapter | null): void ``` Enregistre un adapter d'erreurs tiers sous une clé (ex. le nom du driver ORM `"mongoose"`). Inversion de dépendance : le module s'enregistre lui-même à son boot, le core ne connaît aucune bibliothèque. `null` retire l'adapter (teardown, tests). ### Constantes (15) #### `clc` ```ts const clc: Clc ``` #### `escapeRegExp` ```ts const escapeRegExp: (value: string) => string ``` Neutralise les métacaractères d'une chaîne destinée à être insérée dans une expression régulière, pour qu'elle n'y vaille que pour elle-même. #### `extend` ```ts const extend: (...args: unknown[]) => any ``` Fusionne plusieurs objets dans une cible — API compatible `jQuery.extend`. #### `finallyMaybe` ```ts const finallyMaybe: (step: () => MaybePromise, onSettled: () => void) => MaybePromise ``` Exécute `step`, puis `onSettled` quoi qu'il arrive — le `try/finally` d'une étape qui n'est asynchrone que lorsqu'elle attend. #### `isArray` ```ts const isArray: (arg: any) => arg is any[] ``` Alias direct de `Array.isArray` — exporté pour usage cohérent dans les modules. #### `isContainer` ```ts const isContainer: (container: unknown) => container is Container ``` Type guard — `true` si la valeur est une instance de `Container` (DI). #### `isEmptyObject` ```ts const isEmptyObject: (obj: object | null) => boolean ``` Vérifie qu'un objet existe et ne contient aucune clé propre énumérable. #### `isFunction` ```ts const isFunction: (value: unknown) => value is (...args: unknown[]) => unknown ``` Type guard — `true` si `value` est une fonction (incluant arrow et classes). #### `isLoopbackHostname` ```ts const isLoopbackHostname: (hostname: string) => boolean ``` Ce nom d'hôte désigne-t-il la boucle locale ? Règle UNIQUE du framework — l'inspecteur de développement, le proxy inverse et le frontend décident tous par elle. #### `isPromise` ```ts const isPromise: (obj: unknown) => obj is PromiseLike ``` Vérifie qu'une valeur est une `Promise` ou un thenable (duck-typing `.then`). #### `isRegExp` ```ts const isRegExp: (value: unknown) => value is RegExp ``` Type guard — `true` si `value` est une instance `RegExp`. #### `isUndefined` ```ts const isUndefined: (value: unknown) => value is undefined ``` Type guard — `true` si `value === undefined` (strict, jamais `null`). #### `stripTrailingSlashes` ```ts const stripTrailingSlashes: (value: string) => string ``` Retire les barres obliques finales d'une chaîne, sans expression régulière. #### `thenMaybe` ```ts const thenMaybe: (value: T | PromiseLike, onResolved: (resolved: T) => MaybePromise) => MaybePromise ``` Enchaîne `onResolved` sur une valeur qui peut être déjà connue ou encore attendue — un `.then` qui reste SYNCHRONE quand il n'y a rien à attendre. #### `typeOf` ```ts const typeOf: (value: unknown) => string | null ``` ### Interfaces (6) #### `DynamicService` ```ts interface DynamicService ``` - `[key: string]: unknown` #### `IErrorAdapter` ```ts interface IErrorAdapter ``` Adapter d'erreurs d'une bibliothèque tierce (driver ORM, client externe…). - `isError(e: Error): boolean` — Vrai si l'erreur relève de la famille gérée par cet adapter. - `errorToString(e: unknown): string` — Formate l'erreur en message lisible. #### `IGuardedEmitError` ```ts interface IGuardedEmitError ``` Erreur collectée pour un listener pendant `Event.emitAsyncGuarded`. - `index: number` — Index du listener fautif. - `error: unknown` — Erreur levée par le listener (ou erreur de timeout). - `timedOut: boolean` — `true` si l'échec est un dépassement de `timeoutMs`. #### `IGuardedEmitOptions` ```ts interface IGuardedEmitOptions ``` Options de `Event.emitAsyncGuarded` — purement MÉCANIQUES : aucune notion de module / criticité / log (ça, c'est la POLITIQUE, décidée par l'appelant via les callbacks). Sépare le « comment on isole un listener » du « quoi faire d'un échec ». - `timeoutMs?: number | (listener: object, index: number) => number` — Timeout par listener (ms). - `warnMs?: number` — Seuil d'alerte de lenteur par listener (ms). - `onListenerError?: (error: unknown, info: IGuardedListenerInfo) => boolean | void` — Appelé quand un listener rejette OU dépasse `timeoutMs`. - `onListenerSlow?: (info: IGuardedListenerInfo) => void` — Appelé quand un listener réussit mais dépasse `warnMs` (observabilité). #### `IGuardedEmitResult` ```ts interface IGuardedEmitResult ``` Résultat de `Event.emitAsyncGuarded`. - `results: unknown[]` — Valeurs résolues par les listeners ayant réussi (ordre d'exécution). - `errors: IGuardedEmitError[]` — Erreurs / timeouts collectés (vide si tout a réussi). - `stopped: boolean` — `true` si la chaîne a été arrêtée par `onListenerError`. #### `IGuardedListenerInfo` ```ts interface IGuardedListenerInfo ``` Information sur un listener pendant une émission gardée (`Event.emitAsyncGuarded`). - `index: number` — Index du listener dans l'ordre d'enregistrement. - `listener: object` — Référence du listener (pour lire d'éventuels tags posés par l'appelant). - `timedOut: boolean` — `true` si le listener a été interrompu par le timeout. - `durationMs: number` — Durée d'exécution mesurée (ms) — `0` si la mesure est off (`warnMs ≤ 0`). ### Types (5) #### `Clc` ```ts type Clc = ColorFn & { readonly reset: string; } ``` Racine `clc` : une `ColorFn` + la constante brute `reset`. #### `ColorFn` ```ts type ColorFn = (s: string | number) => string & { [K in StyleName]: ColorFn; } ``` Fonction de coloration chainable : appelable (`fn(text)`) et indexable (`fn.bold`, `fn.bgBlue`…), chaque accès renvoyant une nouvelle `ColorFn` aux styles accumulés. #### `MaybePromise` ```ts type MaybePromise = T | Promise ``` Une valeur déjà connue, ou la promesse de cette valeur — le type de retour d'une étape qui n'est asynchrone que lorsqu'elle attend réellement (un corps à lire, une base, un hook qui rend une promesse). #### `ProtoService` ```ts type ProtoService = { (): void; prototype: DynamicService; } ``` Porteur du prototype partagé des services (cf `createProto`). #### `Scopes` ```ts type Scopes = Map> ``` Registre des scopes ouverts : nom de scope → ensemble des instances vivantes. Il ne sert qu'à les COMPTER (`Container.scopeCount`) et à les refermer toutes au `Container.clean` : un `Set` tenu par l'objet lui-même rend ce service sans fabriquer de clé. Un index par identifiant chaîne — fabriqué et haché à chaque ouverture — coûte ~70 % du cycle `enterScope` + `leaveScope`, payé à chaque requête. ### Bibliothèques réexportées (1) #### `freezeConfigTree` Réexport sans déclaration lisible. --- [← Toutes les références d'API](../../)