API Reference

Basata direttamente sull'implementazione di TinyDI — ogni firma qui sotto è reale, non illustrativa.

createToken

function createToken<T>(description: string): Token<T>

Parametri: description: un'etichetta leggibile usata nei messaggi di errore. Non deve essere univoca.
Restituisce: un Token<T>, utilizzabile con registerInstance, registerFactory e resolve.

interface IMailService {
  send(to: string, body: string): Promise<void>;
}
 
const MailServiceToken = createToken<IMailService>('MailService');

Caso limite

Due token creati con la stessa description restano comunque registrazioni distinte — l'identità è il symbol sottostante, mai la stringa description.

ServiceLifetime

enum ServiceLifetime {
  Singleton,
  Transient,
}

Esistono solo questi due valori. Singleton è il default usato da registerFactory quando non viene fornito alcun lifetime. Vedi Lifetime per la spiegazione completa.

Container

Metodo	Descrizione
`registerInstance<T>(token, instance): void`	Registra un'istanza già creata. Sempre Singleton.
`registerFactory<T>(token, factory, lifetime?): void`	Registra una factory, costruita in modo lazy. `lifetime` di default è Singleton.
`resolve<T>(token): T`	Risolve il servizio, completamente tipizzato.
`has(token): boolean`	Controlla se un token è registrato.
`remove(token): void`	Rimuove la registrazione di un token, se presente.
`clear(): void`	Rimuove tutte le registrazioni.

registerInstance

registerInstance<T>(token: Token<T>, instance: T): void

Parametri: token: l'identificatore del servizio; instance: il valore restituito ad ogni risoluzione.
Restituisce: void.
Lancia: RegistrationError se token è già registrato.

registerFactory

registerFactory<T>(token: Token<T>, factory: (container: Container) => T, lifetime?: ServiceLifetime): void

Parametri: token: l'identificatore del servizio; factory: costruisce l'istanza, ricevendo il container così può risolvere le proprie dipendenze; lifetime: Singleton (default) o Transient.
Restituisce: void.
Lancia: RegistrationError se token è già registrato.

resolve

resolve<T>(token: Token<T>): T

Parametri: token: l'identificatore del servizio da risolvere.
Restituisce: l'istanza risolta, tipizzata come T.
Lancia: ResolutionError se non registrato; CircularDependencyError se risolverlo richiede di risolvere se stesso di nuovo, direttamente o transitivamente.

has / remove / clear

has(token: Token<unknown>): boolean
remove(token: Token<unknown>): void
clear(): void

remove su un token non registrato, e clear su un container vuoto, sono entrambi no-op sicuri — nessuno dei due lancia errori.

Errori

Ogni errore estende l'astratta ContainerError, che espone il token coinvolto (eccetto CircularDependencyError, che espone anche il ciclo completo).

Classe	Lanciato quando	Come risolvere
`ContainerError`	Classe base astratta. Mai lanciata direttamente.	Intercettala per gestire in modo generico qualsiasi errore del container, con `instanceof ContainerError`.
`RegistrationError`	Si registra un token già registrato.	Chiama `remove(token)` prima di ri-registrarlo, oppure registra la nuova implementazione sotto un token diverso.
`ResolutionError`	Si risolve un token senza registrazione.	Controlla se il riferimento al token contiene un errore di battitura, se manca una chiamata a `registerInstance`/`registerFactory`, o se `resolve()` viene eseguito prima che la registrazione avvenga.
`CircularDependencyError`	Si risolve un token che dipende (transitivamente) da se stesso.	Leggi `.path` per vedere il ciclo esatto, poi spezzalo — estrai la logica condivisa da entrambi i servizi in un terzo servizio, oppure risolvi la dipendenza in modo lazy dentro la factory invece che in modo eager alla costruzione.

CircularDependencyError espone il ciclo completo in .path (un array dei token coinvolti) e lo rende in .message come:

Circular dependency detected:
 
A
 -> B
 -> C
 -> A