@lppedd/di-wise-neo 0.3.2 → 0.5.0

package/dist/cjs/index.js

@@ -209,10 +209,6 @@ function isClassProvider(provider) {
     return "useClass" in provider;
 }
 // @internal
-function isExistingProvider(provider) {
-    return "useExisting" in provider;
-}
-// @internal
 function isFactoryProvider(provider) {
     return "useFactory" in provider;
 }
@@ -220,6 +216,10 @@ function isFactoryProvider(provider) {
 function isValueProvider(provider) {
     return "useValue" in provider;
 }
+// @internal
+function isExistingProvider(provider) {
+    return "useExisting" in provider;
+}
 
 const Scope = {
     Inherited: "Inherited",
@@ -231,11 +231,11 @@ const Scope = {
 /**
  * Type API.
  */ /**
- * Create a type token.
+ * Creates a type token.
  *
  * @example
  * ```ts
- * const Spell = createType<Spell>("Spell");
+ * const ISpell = createType<Spell>("Spell");
  * ```
  *
  * @__NO_SIDE_EFFECTS__
@@ -281,8 +281,8 @@ function getTypeName(value) {
 // @internal
 class TokenRegistry {
     constructor(parent){
-        this.parent = parent;
         this.myMap = new Map();
+        this.myParent = parent;
     }
     get(token) {
         // To clarify, at(-1) means we take the last added registration for this token
@@ -335,7 +335,7 @@ class TokenRegistry {
     }
     getAllFromParent(token) {
         const registrations = this.myMap.get(token);
-        return registrations || this.parent?.getAllFromParent(token);
+        return registrations || this.myParent?.getAllFromParent(token);
     }
 }
 // @internal
@@ -386,12 +386,11 @@ function isDisposable(value) {
 
 /**
  * The default implementation of a di-wise-neo {@link Container}.
- */ class DefaultContainer {
-    constructor(myParent, options){
-        this.myParent = myParent;
-        // eslint-disable-next-line no-use-before-define
+ */ class ContainerImpl {
+    constructor(parent, options){
         this.myChildren = new Set();
         this.myDisposed = false;
+        this.myParent = parent;
         this.myOptions = {
             autoRegister: false,
             defaultScope: Scope.Inherited,
@@ -415,7 +414,7 @@ function isDisposable(value) {
     }
     createChild(options) {
         this.checkDisposed();
-        const container = new DefaultContainer(this, {
+        const container = new ContainerImpl(this, {
             ...this.myOptions,
             ...options
         });
@@ -462,20 +461,51 @@ function isDisposable(value) {
         this.checkDisposed();
         return this.myTokenRegistry.get(token) !== undefined;
     }
+    registerClass(token, Class, options) {
+        // This mess will go away once/if we remove the register method
+        // in favor of the multiple specialized ones
+        if (Class) {
+            const ctor = Class ?? token;
+            this.register(token, {
+                useClass: ctor
+            }, options);
+        } else {
+            this.register(token);
+        }
+    }
+    registerFactory(token, factory, options) {
+        this.register(token, {
+            useFactory: factory
+        }, options);
+    }
+    registerValue(token, value) {
+        this.register(token, {
+            useValue: value
+        });
+    }
+    registerAlias(targetToken, aliasTokens) {
+        // De-duplicate tokens
+        for (const alias of new Set(aliasTokens)){
+            this.register(alias, {
+                useExisting: targetToken
+            });
+        }
+    }
     register(...args) {
         this.checkDisposed();
         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()){
@@ -485,21 +515,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`);
@@ -787,16 +825,16 @@ function isDisposable(value) {
     autoRegister: false,
     defaultScope: Scope.Inherited
 }) {
-    return new DefaultContainer(undefined, options);
+    return new ContainerImpl(undefined, options);
 }
 
 /**
- * Class decorator for enabling auto-registration of an unregistered class
- * when first resolving it from the container.
+ * Class decorator that enables auto-registration of an unregistered class,
+ * when the class is first resolved from the container.
  *
  * @example
  * ```ts
- * @AutoRegister()
+ * @AutoRegister
  * class Wizard {}
  *
  * const wizard = container.resolve(Wizard);
@@ -804,11 +842,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) {
@@ -992,7 +1051,7 @@ function OptionalAll(token) {
 });
 
 /**
- * Apply middleware functions to a container.
+ * Applies middleware functions to a container.
  *
  * Middlewares are applied in array order, but execute in reverse order.
  *
@@ -1036,6 +1095,7 @@ function OptionalAll(token) {
 }
 
 exports.AutoRegister = AutoRegister;
+exports.EagerInstantiate = EagerInstantiate;
 exports.Inject = Inject;
 exports.InjectAll = InjectAll;
 exports.Injectable = Injectable;