@lppedd/di-wise-neo 0.26.2 → 0.27.0

package/dist/cjs/index.d.ts

@@ -112,11 +112,23 @@ type Tokens<Value> = [Token<Value>, ...Token<Value>[]];
  */
 declare function createType<T>(debugName: string): Type<T>;
 /**
- * Creates a type token with a default {@link Provider} and optional default registration options.
+ * Creates a type token with a default {@link ClassProvider} and optional default registration options.
+ *
+ * Example:
+ * ```ts
+ * const ISpell = createType<Spell>("Spell", {
+ *   useClass: DefaultSpell,
+ * });
+ *
+ * container.register(ISpell);
+ * ```
+ */
+declare function createType<T extends object>(debugName: string, provider: ClassProvider<T>, options?: RegistrationOptions): ProviderType<T>;
+/**
+ * Creates a type token with a default {@link FactoryProvider} and optional default registration options.
  *
  * Example:
  * ```ts
- * // Notice how we pass in a Provider directly at type creation site
  * const ISpell = createType<Spell>("Spell", {
  *   useFactory: () => getDefaultSpell(),
  * });
@@ -124,7 +136,34 @@ declare function createType<T>(debugName: string): Type<T>;
  * container.register(ISpell);
  * ```
  */
-declare function createType<T>(debugName: string, provider: Provider<T>, options?: RegistrationOptions): ProviderType<T>;
+declare function createType<T>(debugName: string, provider: FactoryProvider<T>, options?: RegistrationOptions): ProviderType<T>;
+/**
+ * Creates a type token with a default {@link ValueProvider} and optional default registration options.
+ *
+ * Example:
+ * ```ts
+ * const defaultSpell = getDefaultSpell();
+ * const ISpell = createType<Spell>("Spell", {
+ *   useValue: defaultSpell,
+ * });
+ *
+ * container.register(ISpell);
+ * ```
+ */
+declare function createType<T>(debugName: string, provider: ValueProvider<T>, options?: RegistrationOptions): ProviderType<T>;
+/**
+ * Creates a type token with a default {@link ExistingProvider} and optional default registration options.
+ *
+ * Example:
+ * ```ts
+ * const ISpell = createType<Spell>("Spell", {
+ *   useExisting: IBaseSpell,
+ * });
+ *
+ * container.register(ISpell);
+ * ```
+ */
+declare function createType<T>(debugName: string, provider: ExistingProvider<T>, options?: RegistrationOptions): ProviderType<T>;
 
 interface ClassRef<Instance extends object> {
     readonly getRefClass: () => Constructor<Instance>;
@@ -647,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.
@@ -726,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.
@@ -1252,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/cjs/index.js

@@ -1130,6 +1130,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.
@@ -1194,29 +1214,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)=>{
@@ -1445,7 +1442,6 @@ exports.ContainerScoped = ContainerScoped;
 exports.EagerInstantiate = EagerInstantiate;
 exports.Inject = Inject;
 exports.InjectAll = InjectAll;
-exports.Injectable = Injectable;
 exports.Injector = Injector;
 exports.Named = Named;
 exports.Optional = Optional;