@lppedd/di-wise-neo 0.5.0 → 0.5.2

package/dist/es/index.mjs

@@ -154,16 +154,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: [],
@@ -173,6 +192,7 @@ function getMetadata(Class) {
     }
     return metadata;
 }
+const classIdentityMap = new WeakMap();
 const metadataMap = new WeakMap();
 
 function optional(token) {
@@ -639,8 +659,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) {
@@ -1092,5 +1120,5 @@ function OptionalAll(token) {
     return 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 };
 //# sourceMappingURL=index.mjs.map