@art-ws/di 2.0.6 → 2.0.8

package/dist/es/injector.d.ts

@@ -7,7 +7,7 @@ export declare class Injector {
     parent: Injector | null;
     addFactory<T>(token: Token<T>, factory?: Func<T>): void;
     addValue<T>(token: Token<T>, value: T): void;
-    addProviders(providers?: Provider[]): this;
+    addProviders(...providers: Provider[]): this;
     get<T>(token: Token<T>): T;
     runScope<T>(fn: Func<T>, options?: Partial<{
         providers: Provider[];

package/dist/es/injector.js

@@ -23,10 +23,36 @@ export class Injector {
     addValue(token, value) {
         this.addFactory(token, () => value);
     }
-    addProviders(providers) {
+    addProviders(...providers) {
         if (Array.isArray(providers)) {
-            for (const { token, factory } of providers) {
-                this.addFactory(token, factory);
+            for (const p of providers) {
+                if (p.token && p.factory) {
+                    this.addFactory(p.token, p.factory);
+                }
+                else if (p.provide || p.useClass) {
+                    const provide = p.provide || p.useClass;
+                    if (!provide)
+                        throw new Error(`provide|useClass is not defined`);
+                    const factory = () => {
+                        if (p.useFactory || p.useClass) {
+                            const deps = (p.deps || []).map((dep) => inject(dep));
+                            if (p.useClass)
+                                return new p.useClass(...deps);
+                            else
+                                return p.useFactory(...deps);
+                        }
+                        else if (p.useValue) {
+                            return p.useValue;
+                        }
+                        else if (p.useExisting) {
+                            return inject(p.useExisting);
+                        }
+                        else {
+                            throw new Error(`useClass|useFactory|useValue|useExisting is not defined`);
+                        }
+                    };
+                    this.addFactory(provide, factory);
+                }
             }
         }
         return this;
@@ -34,13 +60,10 @@ export class Injector {
     get(token) {
         if (!token)
             throw new Error(`Token not defined`);
-        let instance = undefined;
-        if (this.parent) {
+        let instance = this.#instances.get(token);
+        if (typeof instance === "undefined" && this.parent) {
             instance = this.parent.get(token);
         }
-        if (typeof instance === "undefined") {
-            instance = this.#instances.get(token);
-        }
         if (typeof instance === "undefined") {
             const factory = this.#factories.get(token);
             if (typeof factory === "function") {
@@ -53,7 +76,7 @@ export class Injector {
     async runScope(fn, options) {
         const injector = new Injector();
         injector.parent = this;
-        injector.addProviders(options?.providers);
+        injector.addProviders(...(options?.providers || []));
         Injector.onScope?.(injector);
         return asyncLocalStorage.run({ injector }, async () => {
             try {

package/dist/es/types.d.ts

@@ -1,4 +1,5 @@
 export type Func<T = unknown> = () => T;
+export type FuncArgs<T = unknown> = (...args: any[]) => T;
 export declare class InjectionToken<T = unknown> {
     readonly name: string;
     factory?: (() => T) | undefined;
@@ -8,10 +9,17 @@ export interface AbstractType<T> extends Function {
     prototype: T;
 }
 export interface Type<T> extends Function {
-    new (...args: unknown[]): T;
+    new (...args: any[]): T;
 }
 export type Token<T = unknown> = string | Symbol | Type<T> | AbstractType<T> | InjectionToken<T>;
 export type Provider<T = unknown> = {
-    token: Token<T>;
-    factory: Func<T>;
+    token?: Token<T>;
+    factory?: Func<T>;
+    provide?: Token<T>;
+    multi?: boolean;
+    deps?: Token[];
+    useClass?: Type<T>;
+    useExisting?: Token<T>;
+    useValue?: T;
+    useFactory?: FuncArgs<T>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@art-ws/di",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Dependency injection for TypeScript",
   "license": "UNLICENSED",
   "author": "art-ws Team",