@art-ws/di 2.0.25 → 2.0.27

package/dist/es/injector.d.ts

@@ -32,3 +32,15 @@ export declare function setRootInjector(injector: Injector | undefined): void;
 export declare function getOnScopeHandler(): OnScopeHandler | undefined;
 export declare function setOnScopeHandler(handler: OnScopeHandler | undefined): void;
 export declare function getModuleName(module: DIModuleDef): string;
+export declare function runScopedTask<T = void>(options: {
+    task: (...args: any[]) => Promise<T | undefined>;
+    deps?: Token[];
+    providers?: Provider[];
+}): Promise<T | undefined>;
+export type IDisposable = {
+    dispose: () => void;
+};
+export declare function disposeInstances(instances: unknown[]): {
+    instance: unknown;
+    error: Error;
+}[];

package/dist/es/injector.js

@@ -54,21 +54,24 @@ export class Injector {
         const p1 = p;
         const p2 = p;
         const p3 = p;
+        const p4 = 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;
+        else if (p3.provide || p4.useClass) {
+            const provide = p3.provide || p4.useClass;
             if (!provide)
                 throw new Error(`provide|useClass is not defined`);
             const factory = () => {
-                if (p3.useFactory || p3.useClass) {
+                if (p3.useFactory || p4.useClass) {
                     const deps = (p3.deps || []).map((dep) => inject(dep));
-                    if (p3.useClass)
-                        return new p3.useClass(...deps);
+                    if (p4.useClass) {
+                        const C = p4.useClass;
+                        return new C(...deps);
+                    }
                     else
                         return p3.useFactory(...deps);
                 }
@@ -172,3 +175,44 @@ export function getModuleName(module) {
     name = name || "Unknown Module";
     return name;
 }
+export function runScopedTask(options) {
+    let resolveFunc;
+    let rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+        resolveFunc = resolve;
+        rejectFunc = reject;
+    });
+    let result = undefined;
+    getRootInjector().runScope(async () => {
+        const deps = options.deps?.map((d) => inject(d)) || [];
+        try {
+            result = await options.task(...deps);
+        }
+        catch (e) {
+            rejectFunc(e);
+        }
+    }, {
+        providers: options.providers,
+        onEnd: ({ injector }) => {
+            resolveFunc(result);
+            disposeInstances(injector.getInstances());
+            injector.dispose();
+        },
+    });
+    return promise;
+}
+export function disposeInstances(instances) {
+    const errors = [];
+    for (const instance of instances) {
+        const d = instance;
+        if (d && typeof d.dispose === "function") {
+            try {
+                d.dispose();
+            }
+            catch (error) {
+                errors.push({ instance, error: error });
+            }
+        }
+    }
+    return errors;
+}

package/dist/es/types.d.ts

@@ -20,14 +20,27 @@ export type ProviderAngularLikeDef<T = unknown> = {
     provide?: Token<T>;
     multi?: boolean;
     deps?: Token[];
-    useClass?: Type<T>;
     useExisting?: Token<T>;
     useValue?: T;
     useFactory?: FuncArgs<T>;
 };
-export type Provider<T = unknown> = Type<T> | ProviderCoreDef<T> | ProviderAngularLikeDef<T>;
+export type Provider<T = unknown> = Type<T> | ProviderCoreDef<T> | ProviderAngularLikeDef<T> | ProviderClassDef<T>;
 export type DIModuleDef = {
     name?: string;
     imports?: DIModuleDef[];
     providers?: Provider[];
 };
+type Ctor<R = any, A extends any[] = any[]> = abstract new (...args: A) => R;
+type TokenFor<P> = Ctor<P, any[]>;
+type DepsFor<C extends Ctor> = {
+    [K in keyof ConstructorParameters<C>]: TokenFor<ConstructorParameters<C>[K]>;
+} & {
+    length: ConstructorParameters<C>["length"];
+};
+export type ProviderClassDef<T = unknown, C extends Ctor<T> = Ctor<T>> = {
+    useClass: C;
+    deps?: ConstructorParameters<C> extends [] ? never : DepsFor<C>;
+};
+export declare class NoDeps {
+}
+export {};

package/dist/es/types.js

@@ -7,3 +7,5 @@ export class InjectionToken {
         this.factory = factory;
     }
 }
+export class NoDeps {
+}

package/package.json

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