@lppedd/di-wise-neo 0.24.0 → 0.26.0

package/dist/cjs/index.d.ts

@@ -75,6 +75,10 @@ interface Type<T> extends ParameterDecorator {
  * An injectable type `T` with a default {@link Provider} and optional default registration options.
  */
 interface ProviderType<T> extends Type<T> {
+    /**
+     * The underlying `Type<T>`.
+     */
+    readonly type: Type<T>;
     /**
      * The type's default provider.
      */
@@ -399,7 +403,7 @@ interface Container {
     /**
      * Registers a {@link ClassProvider}, using the class itself as its token.
      *
-     * Tokens provided via the {@link Injectable} decorator applied to the class
+     * Tokens provided via the {@link Alias} decorator applied to the class
      * are also registered as aliases.
      *
      * The scope is determined by the {@link Scoped} decorator - if present -
@@ -658,22 +662,6 @@ declare function createContainer(options?: ContainerOptions): Container;
  * ```
  */
 declare function AutoRegister<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that enables auto-registration of an unregistered class
- * when the class is first resolved from the container.
- *
- * Example:
- * ```ts
- * @AutoRegister()
- * class Wizard {}
- *
- * const wizard = container.resolve(Wizard);
- * container.isRegistered(Wizard); // => true
- * ```
- *
- * @deprecated Use `@AutoRegister` instead of `AutoRegister()`.
- */
-declare function AutoRegister<This extends object>(): ClassDecorator<This>;
 
 /**
  * Class decorator that sets the class scope to **Container** and enables
@@ -695,28 +683,6 @@ declare function AutoRegister<This extends object>(): ClassDecorator<This>;
  * ```
  */
 declare function EagerInstantiate<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that sets the class scope to **Container** and enables
- * eager instantiation when the class is registered in the container.
- *
- * This causes the container to create and cache the instance of the class
- * immediately, instead of deferring it until the first resolution.
- *
- * If the class cannot be resolved at registration time, registration fails.
- *
- * Example:
- * ```ts
- * @EagerInstantiate()
- * class Wizard {}
- *
- * // Wizard is registered with Container scope, and an instance
- * // is created and cached immediately by the container
- * container.register(Wizard);
- * ```
- *
- * @deprecated Use `@EagerInstantiate` instead of `@EagerInstantiate()`.
- */
-declare function EagerInstantiate<This extends object>(): ClassDecorator<This>;
 
 /**
  * Parameter decorator that injects the instance associated with the given class.
@@ -769,25 +735,25 @@ declare function Inject<Value>(tokens: TokenRef<Value>): ParameterDecorator;
  *
  * Example:
  * ```ts
- * @Injectable(Weapon)
+ * @Alias(Weapon)
  * class Rifle {}
  * ```
  *
- * Note that `@Injectable` decorators can be stacked to add multiple aliases.
+ * Note that `@Alias` decorators can be stacked to add multiple aliases.
  *
  * Example:
  * ```ts
- * @Injectable(Weapon)
- * @Injectable(Gun) // Or just @Injectable(Weapon, Gun)
+ * @Alias(Weapon)
+ * @Alias(Gun) // Or just @Alias(Weapon, Gun)
  * class Rifle {}
  * ```
  */
-declare function Injectable<Value, This extends Value & object>(token: Token<Value>): ClassDecorator<This>;
-declare function Injectable<VA, VB, This extends VA & VB & object>(tokenA: Token<VA>, tokenB: Token<VB>): ClassDecorator<This>;
-declare function Injectable<VA, VB, VC, This extends VA & VB & VC & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>): ClassDecorator<This>;
-declare function Injectable<VA, VB, VC, VD, This extends VA & VB & VC & VD & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>, tokenD: Token<VD>): ClassDecorator<This>;
-declare function Injectable<VA, VB, VC, VD, VE, This extends VA & VB & VC & VD & VE & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>, tokenD: Token<VD>, tokenE: Token<VE>): ClassDecorator<This>;
-declare function Injectable<VA, VB, VC, VD, VE, VF, This extends VA & VB & VC & VD & VE & VF & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>, tokenD: Token<VD>, tokenE: Token<VE>, tokenF: Token<VF>): ClassDecorator<This>;
+declare function Alias<Value, This extends Value & object>(token: Token<Value>): ClassDecorator<This>;
+declare function Alias<VA, VB, This extends VA & VB & object>(tokenA: Token<VA>, tokenB: Token<VB>): ClassDecorator<This>;
+declare function Alias<VA, VB, VC, This extends VA & VB & VC & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>): ClassDecorator<This>;
+declare function Alias<VA, VB, VC, VD, This extends VA & VB & VC & VD & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>, tokenD: Token<VD>): ClassDecorator<This>;
+declare function Alias<VA, VB, VC, VD, VE, This extends VA & VB & VC & VD & VE & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>, tokenD: Token<VD>, tokenE: Token<VE>): ClassDecorator<This>;
+declare function Alias<VA, VB, VC, VD, VE, VF, This extends VA & VB & VC & VD & VE & VF & object>(tokenA: Token<VA>, tokenB: Token<VB>, tokenC: Token<VC>, tokenD: Token<VD>, tokenE: Token<VE>, tokenF: Token<VF>): ClassDecorator<This>;
 /**
  * Class decorator that registers an additional aliasing token for the decorated type.
  *
@@ -799,22 +765,26 @@ declare function Injectable<VA, VB, VC, VD, VE, VF, This extends VA & VB & VC &
  *
  * Example:
  * ```ts
- * @Injectable(tokenRef(() => Weapon)) // Weapon is declared after Rifle
+ * @Alias(tokenRef(() => Weapon)) // Weapon is declared after Rifle
  * class Rifle {}
  * // Other code...
  * const Weapon = createType("Weapon");
  * ```
  *
- * Note that `@Injectable` decorators can be stacked to add multiple aliases.
+ * Note that `@Alias` decorators can be stacked to add multiple aliases.
  *
  * Example:
  * ```ts
- * @Injectable(tokenRef(() => Weapon))
- * @Injectable(Gun)
+ * @Alias(tokenRef(() => Weapon))
+ * @Alias(Gun)
  * class Rifle {}
  * ```
  */
-declare function Injectable<Value, This extends Value & object>(tokens: TokenRef<Value>): ClassDecorator<This>;
+declare function Alias<Value, This extends Value & object>(tokens: TokenRef<Value>): ClassDecorator<This>;
+/**
+ * @deprecated Use {@link Alias} instead.
+ */
+declare const Injectable: typeof Alias;
 
 /**
  * Parameter decorator that injects all instances provided by the registrations
@@ -964,23 +934,6 @@ declare function OptionalAll<Value>(tokens: TokenRef<Value>): ParameterDecorator
  * ```
  */
 declare function ContainerScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that registers the decorated type with the **Container** scope.
- *
- * Use this scope when you want one cached instance per container,
- * with parent-container lookup fallback.
- *
- * Example:
- * ```ts
- * @ContainerScoped()
- * class Wizard {
- *   // ...
- * }
- * ```
- *
- * @deprecated Use `@ContainerScoped` instead of `@ContainerScoped()`.
- */
-declare function ContainerScoped<This extends object>(): ClassDecorator<This>;
 /**
  * Class decorator that registers the decorated type with the **Resolution** scope.
  *
@@ -996,23 +949,6 @@ declare function ContainerScoped<This extends object>(): ClassDecorator<This>;
  * ```
  */
 declare function ResolutionScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that registers the decorated type with the **Resolution** scope.
- *
- * Use this scope when you want one cached instance per resolution graph,
- * so repeated resolutions within the same request reuse the same value.
- *
- * Example:
- * ```ts
- * @ResolutionScoped()
- * class Wand {
- *   // ...
- * }
- * ```
- *
- * @deprecated Use `@ResolutionScoped` instead of `@ResolutionScoped()`.
- */
-declare function ResolutionScoped<This extends object>(): ClassDecorator<This>;
 /**
  * Class decorator that registers the decorated type with the **Transient** scope.
  *
@@ -1027,22 +963,6 @@ declare function ResolutionScoped<This extends object>(): ClassDecorator<This>;
  * ```
  */
 declare function TransientScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that registers the decorated type with the **Transient** scope.
- *
- * Use this scope when you want a fresh instance every time the class is resolved.
- *
- * Example:
- * ```ts
- * @TransientScoped()
- * class Wand {
- *   // ...
- * }
- * ```
- *
- * @deprecated Use `@TransientScoped` instead of `@TransientScoped()`.
- */
-declare function TransientScoped<This extends object>(): ClassDecorator<This>;
 /**
  * Class decorator for setting the scope of the decorated type when registering it.
  *
@@ -1333,5 +1253,5 @@ declare function optionalBy<Instance extends object>(thisArg: object, Class: Con
  */
 declare function optionalBy<Value>(thisArg: object, token: Token<Value>, name?: string): Value | undefined;
 
-export { AutoRegister, ContainerScoped, EagerInstantiate, Inject, InjectAll, Injectable, Injector, Named, Optional, OptionalAll, ResolutionScoped, Scope, Scoped, TransientScoped, assertInjectionContext, build, classRef, createContainer, createType, inject, injectAll, injectBy, optional, optionalAll, optionalBy, setClassIdentityMapping, tokenRef };
+export { Alias, AutoRegister, ContainerScoped, EagerInstantiate, Inject, InjectAll, Injectable, Injector, Named, Optional, OptionalAll, ResolutionScoped, Scope, Scoped, TransientScoped, assertInjectionContext, build, classRef, createContainer, createType, inject, injectAll, injectBy, optional, optionalAll, optionalBy, setClassIdentityMapping, tokenRef };
 export type { ChildContainerOptions, ClassProvider, ClassRef, Constructor, Container, ContainerHook, ContainerOptions, ExistingProvider, FactoryProvider, Provider, ProviderType, RegistrationOptions, Token, TokenRef, Tokens, Type, ValueProvider };

package/dist/cjs/index.js

@@ -453,6 +453,7 @@ function createType(debugName, provider, options) {
     type.__type = undefined;
     type.toString = ()=>name;
     if (provider) {
+        type.type = type;
         type.provider = provider;
         type.options = options;
     }
@@ -790,10 +791,10 @@ function isDisposable(value) {
         };
         // Register the class itself
         this.myTokenRegistry.put(Class, registration);
-        // Register the additional tokens specified via class decorators.
+        // Register additional aliasing 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.tokenRef.getRefTokens()){
-            this.myTokenRegistry.put(token, {
+        for (const aliasToken of metadata.tokenRef.getRefTokens()){
+            this.myTokenRegistry.put(aliasToken, {
                 name: name,
                 provider: {
                     useExisting: [
@@ -827,6 +828,19 @@ function isDisposable(value) {
                 dependencies: metadata.dependencies
             };
             this.myTokenRegistry.put(token, registration);
+            // Register additional aliasing tokens specified via class decorators.
+            // These tokens will point to the original token and will have the same scope.
+            for (const aliasToken of metadata.tokenRef.getRefTokens()){
+                this.myTokenRegistry.put(aliasToken, {
+                    name: name,
+                    provider: {
+                        useExisting: [
+                            token,
+                            name
+                        ]
+                    }
+                });
+            }
             // Eager-instantiate only if the provided class is container-scoped.
             // Note that we are comparing the scope using the registration configured just above,
             // which takes into account both the metadata and the container option as a fallback.
@@ -1115,33 +1129,57 @@ function isDisposable(value) {
     return new ContainerImpl(undefined, options);
 }
 
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that enables auto-registration of an unregistered class
+ * when the class is first resolved from the container.
+ *
+ * Example:
+ * ```ts
+ * @AutoRegister
+ * class Wizard {}
+ *
+ * const wizard = container.resolve(Wizard);
+ * container.isRegistered(Wizard); // => true
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function AutoRegister(target) {
-    const decorator = (Class)=>{
-        const metadata = getMetadata(Class);
-        metadata.autoRegister = true;
-    };
-    return target === undefined ? decorator : decorator(target);
+    const metadata = getMetadata(target);
+    metadata.autoRegister = true;
 }
 
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that sets the class scope to **Container** and enables
+ * eager instantiation when the class is registered in the container.
+ *
+ * This causes the container to create and cache the instance of the class
+ * immediately, instead of deferring it until the first resolution.
+ *
+ * If the class cannot be resolved at registration time, registration fails.
+ *
+ * Example:
+ * ```ts
+ * @EagerInstantiate
+ * class Wizard {}
+ *
+ * // Wizard is registered with Container scope, and an instance
+ * // is created and cached immediately by the container
+ * container.register(Wizard);
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function EagerInstantiate(target) {
-    const decorator = (Class)=>{
-        const metadata = getMetadata(Class);
-        const currentScope = metadata.scope;
-        check(!currentScope || currentScope.value === "Container", ()=>{
-            const { value, appliedBy } = currentScope;
-            const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
-            const className = getTokenName(Class);
-            return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @EagerInstantiate is trying to set a conflicting scope Container.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
-        });
-        metadata.eagerInstantiate = true;
-        metadata.scope = {
-            value: "Container",
-            appliedBy: "EagerInstantiate"
-        };
+    const metadata = getMetadata(target);
+    const currentScope = metadata.scope;
+    check(!currentScope || currentScope.value === "Container", ()=>{
+        const { value, appliedBy } = currentScope;
+        const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
+        const className = getTokenName(target);
+        return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @EagerInstantiate is trying to set a conflicting scope Container.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
+    });
+    metadata.eagerInstantiate = true;
+    metadata.scope = {
+        value: "Container",
+        appliedBy: "EagerInstantiate"
     };
-    return target === undefined ? decorator : decorator(target);
 }
 
 // @__NO_SIDE_EFFECTS__
@@ -1156,9 +1194,9 @@ function Inject(token) {
 }
 
 // @__NO_SIDE_EFFECTS__
-function Injectable(...args) {
-    return (Class)=>{
-        const metadata = getMetadata(Class);
+function Alias(...args) {
+    return (target)=>{
+        const metadata = getMetadata(target);
         const arg0 = args[0];
         const ref = isTokenRef(arg0) ? arg0 : tokenRef(()=>args);
         const currentRef = metadata.tokenRef;
@@ -1174,6 +1212,9 @@ function Injectable(...args) {
         };
     };
 }
+/**
+ * @deprecated Use {@link Alias} instead.
+ */ const Injectable = Alias;
 
 // @__NO_SIDE_EFFECTS__
 function InjectAll(token) {
@@ -1251,20 +1292,55 @@ function OptionalAll(token) {
     };
 }
 
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that registers the decorated type with the **Container** scope.
+ *
+ * Use this scope when you want one cached instance per container,
+ * with parent-container lookup fallback.
+ *
+ * Example:
+ * ```ts
+ * @ContainerScoped
+ * class Wizard {
+ *   // ...
+ * }
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function ContainerScoped(target) {
-    const decorator = scoped("Container", "ContainerScoped");
-    return target === undefined ? decorator : decorator(target);
+    scoped(target, "Container", "ContainerScoped");
 }
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that registers the decorated type with the **Resolution** scope.
+ *
+ * Use this scope when you want one cached instance per resolution graph,
+ * so repeated resolutions within the same request reuse the same value.
+ *
+ * Example:
+ * ```ts
+ * @ResolutionScoped
+ * class Wand {
+ *   // ...
+ * }
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function ResolutionScoped(target) {
-    const decorator = scoped("Resolution", "ResolutionScoped");
-    return target === undefined ? decorator : decorator(target);
+    scoped(target, "Resolution", "ResolutionScoped");
 }
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that registers the decorated type with the **Transient** scope.
+ *
+ * Use this scope when you want a fresh instance every time the class is resolved.
+ *
+ * Example:
+ * ```ts
+ * @TransientScoped
+ * class Wand {
+ *   // ...
+ * }
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function TransientScoped(target) {
-    const decorator = scoped("Transient", "TransientScoped");
-    return target === undefined ? decorator : decorator(target);
+    scoped(target, "Transient", "TransientScoped");
 }
 /**
  * Class decorator for setting the scope of the decorated type when registering it.
@@ -1287,22 +1363,20 @@ function TransientScoped(target) {
  * ```
  */ // @__NO_SIDE_EFFECTS__
 function Scoped(scope) {
-    return scoped(scope, "Scoped");
-}
-function scoped(scope, decorator) {
-    return (Class)=>{
-        const metadata = getMetadata(Class);
-        const currentScope = metadata.scope;
-        check(!currentScope || currentScope.value === scope, ()=>{
-            const { value, appliedBy } = currentScope;
-            const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
-            const className = getTokenName(Class);
-            return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @${decorator} is trying to set a conflicting scope ${scope}.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
-        });
-        metadata.scope = {
-            value: scope,
-            appliedBy: decorator
-        };
+    return (target)=>scoped(target, scope, "Scoped");
+}
+function scoped(target, scope, decorator) {
+    const metadata = getMetadata(target);
+    const currentScope = metadata.scope;
+    check(!currentScope || currentScope.value === scope, ()=>{
+        const { value, appliedBy } = currentScope;
+        const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
+        const className = getTokenName(target);
+        return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @${decorator} is trying to set a conflicting scope ${scope}.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
+    });
+    metadata.scope = {
+        value: scope,
+        appliedBy: decorator
     };
 }
 
@@ -1364,6 +1438,7 @@ const Scope = {
    */ Container: "Container"
 };
 
+exports.Alias = Alias;
 exports.AutoRegister = AutoRegister;
 exports.ContainerScoped = ContainerScoped;
 exports.EagerInstantiate = EagerInstantiate;