@lppedd/di-wise-neo 0.25.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 -
@@ -731,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.
  *
@@ -761,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
@@ -1245,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.
@@ -1180,7 +1194,7 @@ function Inject(token) {
 }
 
 // @__NO_SIDE_EFFECTS__
-function Injectable(...args) {
+function Alias(...args) {
     return (target)=>{
         const metadata = getMetadata(target);
         const arg0 = args[0];
@@ -1198,6 +1212,9 @@ function Injectable(...args) {
         };
     };
 }
+/**
+ * @deprecated Use {@link Alias} instead.
+ */ const Injectable = Alias;
 
 // @__NO_SIDE_EFFECTS__
 function InjectAll(token) {
@@ -1421,6 +1438,7 @@ const Scope = {
    */ Container: "Container"
 };
 
+exports.Alias = Alias;
 exports.AutoRegister = AutoRegister;
 exports.ContainerScoped = ContainerScoped;
 exports.EagerInstantiate = EagerInstantiate;