@lppedd/di-wise-neo 0.5.0 → 0.5.2

package/README.md

@@ -442,7 +442,7 @@ export class ExtensionContext {
 
 ## Behavioral decorators
 
-The library includes two behavioral decorators that influence how classes are registered in the container.
+The library includes three behavioral decorators that influence how classes are registered in the container.
 These decorators attach metadata to the class type, which is then interpreted by the container during registration.
 
 ### `@Scoped`
@@ -503,6 +503,10 @@ export class ExtensionContext {
 container.register(ExtensionContext);
 ```
 
+> [!WARNING]
+> Eager instantiation requires that all dependencies of the class are already registered in the container.  
+> If they are not, registration will fail.
+
 ## Testing support
 
 Testing is an important part of software development, and dependency injection is meant to make it easier.  

package/dist/cjs/index.d.ts

@@ -792,6 +792,24 @@ interface Injector {
  */
 declare const Injector: Type<Injector>;
 
+/**
+ * Registers a mapping between a generated (e.g., decorated or proxied) constructor
+ * and its original, underlying constructor.
+ *
+ * This allows libraries or consumers that manipulate constructors, such as through
+ * class decorators, to inform the DI system about the real "identity" of a class.
+ *
+ * @param transformedClass The constructor function returned by a class decorator or factory.
+ * @param originalClass The original constructor function.
+ *
+ * @remarks
+ * This API affects the core class identity resolution mechanism of the DI system.
+ * Incorrect usage may cause metadata to be misassociated, leading to subtle errors.
+ * Use only when manipulating constructors (e.g., via decorators or proxies),
+ * and ensure the mapping is correct.
+ */
+declare function setClassIdentityMapping<T extends object>(transformedClass: Constructor<T>, originalClass: Constructor<T>): void;
+
 /**
  * Composer API for middleware functions.
  */
@@ -847,5 +865,5 @@ interface Middleware {
  */
 declare function applyMiddleware(container: Container, middlewares: Middleware[]): Container;
 
-export { AutoRegister, EagerInstantiate, Inject, InjectAll, Injectable, Injector, Optional, OptionalAll, Scope, Scoped, applyMiddleware, build, createContainer, createType, forwardRef, inject, injectAll, injectBy };
+export { AutoRegister, EagerInstantiate, Inject, InjectAll, Injectable, Injector, Optional, OptionalAll, Scope, Scoped, applyMiddleware, build, createContainer, createType, forwardRef, inject, injectAll, injectBy, setClassIdentityMapping };
 export type { ClassProvider, Constructor, Container, ContainerOptions, ExistingProvider, FactoryProvider, Middleware, MiddlewareComposer, Provider, RegistrationOptions, Token, TokenRef, Tokens, TokensRef, Type, ValueProvider };

package/dist/cjs/index.js

@@ -156,16 +156,35 @@ function injectAll(token) {
     return context.container.resolveAll(token);
 }
 
+/**
+ * Registers a mapping between a generated (e.g., decorated or proxied) constructor
+ * and its original, underlying constructor.
+ *
+ * This allows libraries or consumers that manipulate constructors, such as through
+ * class decorators, to inform the DI system about the real "identity" of a class.
+ *
+ * @param transformedClass The constructor function returned by a class decorator or factory.
+ * @param originalClass The original constructor function.
+ *
+ * @remarks
+ * This API affects the core class identity resolution mechanism of the DI system.
+ * Incorrect usage may cause metadata to be misassociated, leading to subtle errors.
+ * Use only when manipulating constructors (e.g., via decorators or proxies),
+ * and ensure the mapping is correct.
+ */ function setClassIdentityMapping(transformedClass, originalClass) {
+    classIdentityMap.set(transformedClass, originalClass);
+}
 // @internal
 function getMetadata(Class) {
-    let metadata = metadataMap.get(Class);
+    const originalClass = classIdentityMap.get(Class) ?? Class;
+    let metadata = metadataMap.get(originalClass);
     if (!metadata) {
-        metadataMap.set(Class, metadata = {
+        metadataMap.set(originalClass, metadata = {
             tokensRef: {
                 getRefTokens: ()=>new Set()
             },
             provider: {
-                useClass: Class
+                useClass: originalClass
             },
             dependencies: {
                 constructor: [],
@@ -175,6 +194,7 @@ function getMetadata(Class) {
     }
     return metadata;
 }
+const classIdentityMap = new WeakMap();
 const metadataMap = new WeakMap();
 
 function optional(token) {
@@ -641,8 +661,16 @@ function isDisposable(value) {
     instantiateClass(Class, optional) {
         const metadata = getMetadata(Class);
         if (metadata.autoRegister ?? this.myOptions.autoRegister) {
-            this.register(Class);
-            return this.resolve(Class);
+            // Temporarily set eagerInstantiate to false to avoid resolving the class two times:
+            // one inside register(), and the other just below
+            const eagerInstantiate = metadata.eagerInstantiate;
+            metadata.eagerInstantiate = false;
+            try {
+                this.register(Class);
+                return this.resolve(Class);
+            } finally{
+                metadata.eagerInstantiate = eagerInstantiate;
+            }
         }
         const scope = this.resolveScope(metadata.scope);
         if (optional && scope === Scope.Container) {
@@ -1112,4 +1140,5 @@ exports.forwardRef = forwardRef;
 exports.inject = inject;
 exports.injectAll = injectAll;
 exports.injectBy = injectBy;
+exports.setClassIdentityMapping = setClassIdentityMapping;
 //# sourceMappingURL=index.js.map