typestack/typedi

Features

• TypeScript Dependency Injection Libraries - A specialized dependency injection library utilizing TypeScript decorators and type inference to decouple class dependencies.
• Dependency Injection - Provides a comprehensive TypeScript container for decoupling software components through automated dependency injection.
• Metadata-Driven Dependency Injection - Implements a system that uses TypeScript decorators and metadata for automatic service registration and resolution.
• Hierarchical Containers - Provides hierarchical containers that allow for scoped dependency resolution and isolated service sets across different contexts.
• Execution Context Isolation - Provides scoped dependency management to isolate service instances within specific contexts and prevent data leakage between execution flows.
• Dependency Injection Containers - Implements a container that manages service lifecycles and resolves class dependencies using TypeScript-specific metadata.
• Inversion-of-Control Containers - Functions as a centralized registry that manages object lifecycles and dependency wiring to decouple components.
• Instance Lifecycles - Manages service lifetimes, allowing users to define whether dependencies should be shared singletons or fresh transient instances.
• Dependency Lifetimes - Implements comprehensive service lifecycle management, supporting both singleton and transient lifetimes for optimized memory and state handling.
• Service Dependency Registration - Provides a centralized registry to map classes and unique tokens to their respective service implementations.
• Service Locators - Provides a centralized registry for resolving and retrieving shared or transient service instances via unique tokens.
• Token-Based Service Mapping - Allows decoupling of service retrieval by mapping unique identifiers or class types to specific service implementations.
• Service Lifetime Scopes - Provides configuration for service lifetimes, specifically supporting singleton and transient scopes within the container.
• Type-Safe Tokens - Implements type-safe tokens to prevent errors caused by using string identifiers for service retrieval.
• Isolated Resolution Scopes - Implements isolated resolution scopes to prevent data leakage between separate execution flows or users.
• Circular Dependency Resolvers - Provides mechanisms to break circular dependency loops during object instantiation using proxies or delayed resolution.
• Dependency Injection Integrations - Provides a bridge to integrate third-party libraries and external frameworks into the centralized dependency container.
• Custom Injection Logic - Allows the creation of specialized decorators and factory functions to define custom instantiation logic for dependencies.
• Factory-Based Instantiation - Supports the creation of complex services through custom factory functions that handle dynamic setup logic.
• Circular Dependency Resolution - Handles circular dependencies between components by deferring registration and using function-based resolution.
• Function - Enables the resolution of dependencies for standalone functions and factory objects in addition to standard classes.
• Named Service Injection - Allows controlling which specific service instance is injected by associating them with unique names or identifiers.
• Modular Application Architectures - Supports organizing services into scoped containers and groups to manage complex dependencies between application modules.
• Dependency Mocking - Provides mechanisms to replace registered services with mock implementations for isolated unit testing.
• Unit Testing - Enables component isolation during automated tests by substituting real service implementations with mock objects.

Star history