@lppedd/di-wise-neo 0.25.0 → 0.26.1

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 -
@@ -436,7 +440,10 @@ interface Container {
      */
     register<Value, ProviderValue extends Value>(token: Token<Value>, provider: ValueProvider<ProviderValue>): Container;
     /**
-     * Removes all registrations for the given token from the container's internal registry.
+     * Removes registrations for the given token from the container's internal registry.
+     *
+     * When a `name` is provided, only the registration with that `name` is removed.
+     * Otherwise, all registrations are removed.
      *
      * Returns an array of the distinct values that were cached by this container for the
      * removed registrations. Values from {@link ValueProvider} registrations are not included,
@@ -731,25 +738,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 +768,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 +1256,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.
-        // 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, {
+        // 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 aliasToken of metadata.tokenRef.getRefTokens()){
+            this.myTokenRegistry.put(aliasToken, {
                 name: name,
                 provider: {
                     useExisting: [
@@ -815,9 +816,10 @@ function isDisposable(value) {
         check(name === undefined || name.trim(), `name qualifier for token ${getTokenName(token)} must not be empty`);
         if (isClassProvider(provider)) {
             const metadata = getMetadata(provider.useClass);
+            // An explicit provider name overrides what is specified via @Named
+            const effectiveName = name ?? metadata.name;
             const registration = {
-                // An explicit provider name overrides what is specified via @Named
-                name: metadata.name ?? name,
+                name: effectiveName,
                 provider: metadata.provider,
                 options: {
                     // Explicit registration options override what is specified via class decorators (e.g., @Scoped)
@@ -826,7 +828,21 @@ function isDisposable(value) {
                 },
                 dependencies: metadata.dependencies
             };
+            // Register the class itself
             this.myTokenRegistry.put(token, registration);
+            // 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 aliasToken of metadata.tokenRef.getRefTokens()){
+                this.myTokenRegistry.put(aliasToken, {
+                    name: effectiveName,
+                    provider: {
+                        useExisting: [
+                            token,
+                            effectiveName
+                        ]
+                    }
+                });
+            }
             // 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 +1196,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 +1214,9 @@ function Injectable(...args) {
         };
     };
 }
+/**
+ * @deprecated Use {@link Alias} instead.
+ */ const Injectable = Alias;
 
 // @__NO_SIDE_EFFECTS__
 function InjectAll(token) {
@@ -1421,6 +1440,7 @@ const Scope = {
    */ Container: "Container"
 };
 
+exports.Alias = Alias;
 exports.AutoRegister = AutoRegister;
 exports.ContainerScoped = ContainerScoped;
 exports.EagerInstantiate = EagerInstantiate;