@art-ws/di 2.0.8 → 2.0.10

package/dist/es/injector.d.ts

@@ -1,4 +1,4 @@
-import type { Func, Provider, Token } from "./types.js";
+import type { DIModuleDef, Func, Provider, Token } from "./types.js";
 export type InjectorInstance = InstanceType<typeof Injector>;
 export declare class Injector {
     #private;
@@ -7,6 +7,9 @@ export declare class Injector {
     parent: Injector | null;
     addFactory<T>(token: Token<T>, factory?: Func<T>): void;
     addValue<T>(token: Token<T>, value: T): void;
+    private addModuleInner;
+    addModule(...modules: DIModuleDef[]): void;
+    addProvider(p: Provider): void;
     addProviders(...providers: Provider[]): this;
     get<T>(token: Token<T>): T;
     runScope<T>(fn: Func<T>, options?: Partial<{

package/dist/es/injector.js

@@ -14,7 +14,7 @@ export class Injector {
             }
         }
         else {
-            if (!factory && typeof token === "function") {
+            if (!factory && isClass(token)) {
                 factory = () => new token();
             }
         }
@@ -23,36 +23,60 @@ export class Injector {
     addValue(token, value) {
         this.addFactory(token, () => value);
     }
+    addModuleInner(set, ...modules) {
+        for (const module of modules) {
+            for (const imp of module.imports) {
+                if (set.has(imp))
+                    throw new Error(`Circular dependency detected: ${imp}`);
+                set.add(imp);
+                this.addModuleInner(set, imp);
+            }
+            this.addProviders(...module.providers);
+        }
+    }
+    addModule(...modules) {
+        const set = new Set();
+        this.addModuleInner(set, ...modules);
+    }
+    addProvider(p) {
+        const p1 = p;
+        const p2 = p;
+        const p3 = p;
+        if (isClass(p1)) {
+            this.addFactory(p1);
+        }
+        else if (p2.token && p2.factory) {
+            this.addFactory(p2.token, p2.factory);
+        }
+        else if (p3.provide || p3.useClass) {
+            const provide = p3.provide || p3.useClass;
+            if (!provide)
+                throw new Error(`provide|useClass is not defined`);
+            const factory = () => {
+                if (p3.useFactory || p3.useClass) {
+                    const deps = (p3.deps || []).map((dep) => inject(dep));
+                    if (p3.useClass)
+                        return new p3.useClass(...deps);
+                    else
+                        return p3.useFactory(...deps);
+                }
+                else if (p3.useValue) {
+                    return p3.useValue;
+                }
+                else if (p3.useExisting) {
+                    return inject(p3.useExisting);
+                }
+                else {
+                    throw new Error(`useClass|useFactory|useValue|useExisting is not defined`);
+                }
+            };
+            this.addFactory(provide, factory);
+        }
+    }
     addProviders(...providers) {
         if (Array.isArray(providers)) {
             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);
-                }
+                this.addProvider(p);
             }
         }
         return this;
@@ -95,3 +119,6 @@ export function inject(token) {
         throw new Error(`No injector found`);
     return injector.get(token);
 }
+function isClass(value) {
+    return typeof value === "function" && !!value.prototype;
+}

package/dist/es/types.d.ts

@@ -12,9 +12,11 @@ export interface Type<T> extends Function {
     new (...args: any[]): T;
 }
 export type Token<T = unknown> = string | Symbol | Type<T> | AbstractType<T> | InjectionToken<T>;
-export type Provider<T = unknown> = {
+export type ProviderCoreDef<T = unknown> = {
     token?: Token<T>;
     factory?: Func<T>;
+};
+export type ProviderAngularLikeDef<T = unknown> = {
     provide?: Token<T>;
     multi?: boolean;
     deps?: Token[];
@@ -23,3 +25,8 @@ export type Provider<T = unknown> = {
     useValue?: T;
     useFactory?: FuncArgs<T>;
 };
+export type Provider<T = unknown> = Type<T> | ProviderCoreDef<T> | ProviderAngularLikeDef<T>;
+export type DIModuleDef = {
+    imports: DIModuleDef[];
+    providers: Provider[];
+};

package/package.json

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