@lppedd/di-wise-neo 0.26.3 → 0.27.0

package/dist/es/index.d.mts

@@ -686,6 +686,61 @@ interface Container {
  */
 declare function createContainer(options?: ContainerOptions): Container;
 
+/**
+ * Class decorator that registers additional aliasing tokens for the decorated type.
+ *
+ * The aliases are added using {@link ExistingProvider}(s) when the class is first
+ * registered in the container.
+ *
+ * Example:
+ * ```ts
+ * @Alias(Weapon)
+ * class Rifle {}
+ * ```
+ *
+ * Note that `@Alias` decorators can be stacked to add multiple aliases.
+ *
+ * Example:
+ * ```ts
+ * @Alias(Weapon)
+ * @Alias(Gun) // Or just @Alias(Weapon, Gun)
+ * class Rifle {}
+ * ```
+ */
+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.
+ *
+ * The alias is added using an {@link ExistingProvider} when the class is first
+ * registered in the container.
+ *
+ * This overload allows referencing tokens that are declared later in the file
+ * by using the {@link tokenRef} helper function.
+ *
+ * Example:
+ * ```ts
+ * @Alias(tokenRef(() => Weapon)) // Weapon is declared after Rifle
+ * class Rifle {}
+ * // Other code...
+ * const Weapon = createType("Weapon");
+ * ```
+ *
+ * Note that `@Alias` decorators can be stacked to add multiple aliases.
+ *
+ * Example:
+ * ```ts
+ * @Alias(tokenRef(() => Weapon))
+ * @Alias(Gun)
+ * class Rifle {}
+ * ```
+ */
+declare function Alias<Value, This extends Value & object>(tokens: TokenRef<Value>): ClassDecorator<This>;
+
 /**
  * Class decorator that enables auto-registration of an unregistered class
  * when the class is first resolved from the container.
@@ -765,65 +820,6 @@ declare function Inject<Value>(token: Token<Value>): ParameterDecorator;
  */
 declare function Inject<Value>(tokens: TokenRef<Value>): ParameterDecorator;
 
-/**
- * Class decorator that registers additional aliasing tokens for the decorated type.
- *
- * The aliases are added using {@link ExistingProvider}(s) when the class is first
- * registered in the container.
- *
- * Example:
- * ```ts
- * @Alias(Weapon)
- * class Rifle {}
- * ```
- *
- * Note that `@Alias` decorators can be stacked to add multiple aliases.
- *
- * Example:
- * ```ts
- * @Alias(Weapon)
- * @Alias(Gun) // Or just @Alias(Weapon, Gun)
- * class Rifle {}
- * ```
- */
-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.
- *
- * The alias is added using an {@link ExistingProvider} when the class is first
- * registered in the container.
- *
- * This overload allows referencing tokens that are declared later in the file
- * by using the {@link tokenRef} helper function.
- *
- * Example:
- * ```ts
- * @Alias(tokenRef(() => Weapon)) // Weapon is declared after Rifle
- * class Rifle {}
- * // Other code...
- * const Weapon = createType("Weapon");
- * ```
- *
- * Note that `@Alias` decorators can be stacked to add multiple aliases.
- *
- * Example:
- * ```ts
- * @Alias(tokenRef(() => Weapon))
- * @Alias(Gun)
- * class Rifle {}
- * ```
- */
-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
  * associated with the given class.
@@ -1291,5 +1287,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 { 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 { Alias, AutoRegister, ContainerScoped, EagerInstantiate, Inject, InjectAll, 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/es/index.mjs

@@ -1128,6 +1128,26 @@ function isDisposable(value) {
     return new ContainerImpl(undefined, options);
 }
 
+// @__NO_SIDE_EFFECTS__
+function Alias(...args) {
+    return (target)=>{
+        const metadata = getMetadata(target);
+        const arg0 = args[0];
+        const ref = isTokenRef(arg0) ? arg0 : tokenRef(()=>args);
+        const currentRef = metadata.tokenRef;
+        metadata.tokenRef = {
+            getRefToken: ()=>currentRef.getRefToken(),
+            getRefTokens: ()=>{
+                const existingTokens = currentRef.getRefTokens();
+                for (const token of ref.getRefTokens()){
+                    existingTokens.add(token);
+                }
+                return existingTokens;
+            }
+        };
+    };
+}
+
 /**
  * Class decorator that enables auto-registration of an unregistered class
  * when the class is first resolved from the container.
@@ -1192,29 +1212,6 @@ function Inject(token) {
     };
 }
 
-// @__NO_SIDE_EFFECTS__
-function Alias(...args) {
-    return (target)=>{
-        const metadata = getMetadata(target);
-        const arg0 = args[0];
-        const ref = isTokenRef(arg0) ? arg0 : tokenRef(()=>args);
-        const currentRef = metadata.tokenRef;
-        metadata.tokenRef = {
-            getRefToken: ()=>currentRef.getRefToken(),
-            getRefTokens: ()=>{
-                const existingTokens = currentRef.getRefTokens();
-                for (const token of ref.getRefTokens()){
-                    existingTokens.add(token);
-                }
-                return existingTokens;
-            }
-        };
-    };
-}
-/**
- * @deprecated Use {@link Alias} instead.
- */ const Injectable = Alias;
-
 // @__NO_SIDE_EFFECTS__
 function InjectAll(token) {
     return (target, propertyKey, parameterIndex)=>{
@@ -1437,5 +1434,5 @@ const Scope = {
    */ Container: "Container"
 };
 
-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 { Alias, AutoRegister, ContainerScoped, EagerInstantiate, Inject, InjectAll, Injector, Named, Optional, OptionalAll, ResolutionScoped, Scope, Scoped, TransientScoped, assertInjectionContext, build, classRef, createContainer, createType, inject, injectAll, injectBy, optional, optionalAll, optionalBy, setClassIdentityMapping, tokenRef };
 //# sourceMappingURL=index.mjs.map