@lppedd/di-wise-neo 0.4.0 → 0.5.1

package/dist/es/index.mjs

@@ -494,15 +494,16 @@ function isDisposable(value) {
         if (args.length == 1) {
             const Class = args[0];
             const metadata = getMetadata(Class);
-            // Register the class itself
-            this.myTokenRegistry.set(Class, {
+            const registration = {
                 // The provider is of type ClassProvider, initialized by getMetadata
                 provider: metadata.provider,
                 options: {
-                    scope: metadata.scope
+                    scope: metadata.scope ?? this.myOptions.defaultScope
                 },
                 dependencies: metadata.dependencies
-            });
+            };
+            // Register the class itself
+            this.myTokenRegistry.set(Class, registration);
             // Register the additional tokens specified via class decorators.
             // These tokens will point to the original Class token and will have the same scope.
             for (const token of metadata.tokensRef.getRefTokens()){
@@ -512,21 +513,29 @@ function isDisposable(value) {
                     }
                 });
             }
+            // Eager-instantiate only if the class is container-scoped
+            if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
+                this.resolve(Class);
+            }
         } else {
             const [token, provider, options] = args;
             if (isClassProvider(provider)) {
-                const Class = provider.useClass;
-                const metadata = getMetadata(Class);
-                this.myTokenRegistry.set(token, {
+                const metadata = getMetadata(provider.useClass);
+                const registration = {
                     provider: metadata.provider,
                     options: {
                         // The explicit registration options override what is specified
                         // via class decorators (e.g., @Scoped)
-                        scope: metadata.scope,
+                        scope: metadata.scope ?? this.myOptions.defaultScope,
                         ...options
                     },
                     dependencies: metadata.dependencies
-                });
+                };
+                this.myTokenRegistry.set(token, registration);
+                // Eager-instantiate only if the provided class is container-scoped
+                if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
+                    this.resolve(token);
+                }
             } else {
                 if (isExistingProvider(provider)) {
                     assert(token !== provider.useExisting, `the useExisting token ${token.name} cannot be the same as the token being registered`);
@@ -630,8 +639,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) {
@@ -823,7 +840,7 @@ function isDisposable(value) {
  *
  * @example
  * ```ts
- * @AutoRegister()
+ * @AutoRegister
  * class Wizard {}
  *
  * const wizard = container.resolve(Wizard);
@@ -831,11 +848,32 @@ function isDisposable(value) {
  * ```
  *
  * @__NO_SIDE_EFFECTS__
- */ function AutoRegister(enable = true) {
-    return function(Class) {
-        const metadata = getMetadata(Class);
-        metadata.autoRegister = enable;
-    };
+ */ function AutoRegister(Class) {
+    const metadata = getMetadata(Class);
+    metadata.autoRegister = true;
+}
+
+/**
+ * Class decorator that enables eager instantiation of a class when it is registered
+ * in the container with `Scope.Container`.
+ *
+ * This causes the container to immediately create and cache the instance of the class,
+ * instead of deferring instantiation until the first resolution.
+ *
+ * @example
+ * ```ts
+ * @EagerInstantiate
+ * @Scoped(Scope.Container)
+ * class Wizard {}
+ *
+ * // A Wizard instance is immediately created and cached by the container
+ * const wizard = container.register(Wizard);
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function EagerInstantiate(Class) {
+    const metadata = getMetadata(Class);
+    metadata.eagerInstantiate = true;
 }
 
 function forwardRef(token) {
@@ -1062,5 +1100,5 @@ function OptionalAll(token) {
     return container;
 }
 
-export { AutoRegister, 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 };
 //# sourceMappingURL=index.mjs.map