@lppedd/di-wise-neo 0.5.1 → 0.5.3

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: [],
@@ -171,8 +190,25 @@ function getMetadata(Class) {
             }
         });
     }
+    if (metadata.provider.useClass !== Class) {
+        // This is part of the class identity mapping API (see setClassIdentityMapping).
+        //
+        // Scenario:
+        // 1. Metadata is created for class A (the original class) because of a parameter decorator.
+        // 2. Later, because of a class decorator that extends the decorated class, a third-party
+        //    registers a class identity mapping from class B to class A, where B is the class
+        //    generated from the class decorator by extending A.
+        //
+        // We must update useClass to be the extender class B so that instances created by the
+        // DI container match the consumer's registered class. Without this update, the DI
+        // system would instantiate the original class A, causing behavior inconsistencies.
+        //
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        metadata.provider.useClass = Class;
+    }
     return metadata;
 }
+const classIdentityMap = new WeakMap();
 const metadataMap = new WeakMap();
 
 function optional(token) {
@@ -1100,5 +1136,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