awilixify 3.0.0 → 3.1.0

package/dist/lib/di/processors/initializer-processor.js

@@ -1,25 +1,48 @@
 import { resolveDecoratorState } from "../../decorators/decorator-state.js";
+import { getControllerMethodNames } from "../../devtools/helpers.js";
 import * as ERRORS from "../errors.js";
 import { runInRequestScopeContext } from "../request-scope-context.js";
 import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
 export class InitializerProcessor {
+    devtoolsProcessorRef;
     keyedFeatureRegistrar = new KeyedFeatureRegistrar({});
     resolversByModule = new WeakMap();
+    constructor(devtoolsProcessorRef) {
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
+    }
     collectInitializers(m, scope, importedModulesWithScope, controllers) {
-        this.processInitializerResolvers(m, scope, importedModulesWithScope);
+        this.resolversByModule.set(m, this.keyedFeatureRegistrar.register({
+            featureKind: "initializers",
+            module: m,
+            scope,
+            importedModulesWithScope,
+        }));
         const initializers = [
             ...(this.resolversByModule.get(m) ??
                 new Map()).entries(),
         ];
         if (initializers.length === 0 || controllers.length === 0)
             return null;
+        this.devtoolsProcessorRef.current?.graphCollector.collectModuleRoutes({
+            module: m,
+            controllers,
+            initializers,
+        });
         return async (options) => {
             const activeInitializers = this.filterActiveInitializers(initializers, options);
             if (activeInitializers.length === 0)
                 return;
             for (const controller of controllers) {
-                for (const methodName of this.getControllerMethodNames(controller.controllerClass)) {
-                    const invoke = (...args) => runInRequestScopeContext(() => controller.resolve()[methodName](...args));
+                for (const methodName of getControllerMethodNames(controller.controllerClass)) {
+                    const invoke = (...args) => this.devtoolsProcessorRef.current?.tracer.traceInitializer({
+                        args,
+                        callback: () => runInRequestScopeContext(() => controller.resolve()[methodName](...args)),
+                        controllerName: controller.controllerClass.name,
+                        getStatusCode: () => getStatusCode(args),
+                        methodName: String(methodName),
+                        moduleName: m.name,
+                    }) ??
+                        runInRequestScopeContext(() => controller.resolve()[methodName](...args));
                     this.ensureNoMultiInvokableInitializersPerMethod(m.name, methodName, controller, activeInitializers);
                     for (const [, resolveInitializer] of activeInitializers) {
                         const initializer = resolveInitializer();
@@ -62,30 +85,11 @@ export class InitializerProcessor {
         const excludedKeys = new Set(options.excludeInitializers);
         return initializers.filter(([key]) => !excludedKeys.has(key));
     }
-    processInitializerResolvers(m, scope, importedModulesWithScope) {
-        this.resolversByModule.set(m, this.keyedFeatureRegistrar.register({
-            featureKind: "initializers",
-            module: m,
-            scope,
-            importedModulesWithScope,
-        }));
-    }
-    getControllerMethodNames(controllerClass) {
-        const collected = new Set();
-        let proto = controllerClass.prototype;
-        while (proto && proto !== Object.prototype) {
-            Object.getOwnPropertyNames(proto)
-                .filter((name) => name !== "constructor" && typeof proto[name] === "function")
-                .forEach((name) => {
-                collected.add(name);
-            });
-            Object.getOwnPropertySymbols(proto)
-                .filter((symbol) => typeof proto[symbol] === "function")
-                .forEach((symbol) => {
-                collected.add(symbol);
-            });
-            proto = Object.getPrototypeOf(proto);
-        }
-        return [...collected];
-    }
+}
+function getStatusCode(args) {
+    const reply = args[1];
+    if (!reply || typeof reply !== "object")
+        return undefined;
+    const statusCode = reply.statusCode;
+    return typeof statusCode === "number" ? statusCode : undefined;
 }

package/dist/lib/di/processors/interceptor-processor.d.ts

@@ -1,11 +1,13 @@
 import * as Awilix from "awilix";
+import type { DevtoolsProcessorRef } from "../../devtools/devtools.types.js";
 import type { RegisteredModuleScope } from "../contexts/container-context-base.js";
 import type { DiContextOptions } from "../contexts/di-context-base.js";
 import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
 export declare class InterceptorProcessor {
+    private readonly devtoolsProcessorRef;
     private readonly keyedFeatureRegistrar;
     private readonly resolversByModule;
-    constructor(providerOptions: DiContextOptions["providerOptions"]);
+    constructor(providerOptions: DiContextOptions["providerOptions"], devtoolsProcessorRef: DevtoolsProcessorRef);
     processInterceptors(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
     createInterceptedProviderResolver({ module, useClass, options, resolver, }: {
         module: M;
@@ -15,4 +17,5 @@ export declare class InterceptorProcessor {
     }): Awilix.Resolver<any>;
     private createInterceptedProviderInstance;
     private callWithInterceptorChain;
+    private get devtoolsTracer();
 }

package/dist/lib/di/processors/interceptor-processor.js

@@ -2,9 +2,11 @@ import * as Awilix from "awilix";
 import { hasDecoratorMethodMetadata, resolveDecoratorState, } from "../../decorators/decorator-state.js";
 import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
 export class InterceptorProcessor {
+    devtoolsProcessorRef;
     keyedFeatureRegistrar;
     resolversByModule = new WeakMap();
-    constructor(providerOptions) {
+    constructor(providerOptions, devtoolsProcessorRef) {
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
         this.keyedFeatureRegistrar = new KeyedFeatureRegistrar(providerOptions ?? {});
     }
     processInterceptors(m, scope, importedModulesWithScope) {
@@ -86,7 +88,8 @@ export class InterceptorProcessor {
             if (metadata === undefined) {
                 return invoke(index + 1, next);
             }
-            return current.intercept({
+            const interceptorName = current.constructor.name;
+            const callInterceptor = () => current.intercept({
                 target,
                 methodName,
                 args,
@@ -95,7 +98,20 @@ export class InterceptorProcessor {
                 decoratorState: metadata.state,
                 proceed: () => invoke(index + 1, next),
             });
+            if (!this.devtoolsTracer)
+                return callInterceptor();
+            return this.devtoolsTracer.recordSpan({
+                kind: "interceptor",
+                moduleName,
+                providerKey: interceptorName,
+                methodName: String(methodName),
+                args,
+                callback: callInterceptor,
+            });
         };
         return invoke(0, proceed);
     }
+    get devtoolsTracer() {
+        return this.devtoolsProcessorRef.current?.tracer;
+    }
 }

package/dist/lib/di/processors/keyed-feature-registrar.js

@@ -30,7 +30,7 @@ export class KeyedFeatureRegistrar {
         const resolverMap = new Map();
         const ownerByInitializerToken = new Map();
         const config = this.featureConfig[featureKind];
-        const providerResolver = new ProviderResolver(undefined, this.getProviderOptions(featureKind), getOrCreateRequestScope);
+        const providerResolver = new ProviderResolver(undefined, this.getProviderOptions(featureKind), {}, getOrCreateRequestScope);
         for (const { module: importedModule, moduleScope: importedModuleScope, } of importedModulesWithScope) {
             for (const key of importedModule[config.exportKey] ?? []) {
                 const feature = importedModule[featureKind]?.[key];

package/dist/lib/di/processors/lifecycle-processor.d.ts

@@ -34,5 +34,4 @@ export declare class LifecycleProcessor {
     private getProviderInitAfter;
     private sortEagerProviderIds;
     private static buildEagerProviderNodeKeyMap;
-    private static createEagerProviderId;
 }

package/dist/lib/di/processors/lifecycle-processor.js

@@ -113,7 +113,7 @@ export class LifecycleProcessor {
     sortEagerProviderRefs() {
         const nodes = this.eagerProviderRefs.map((ref) => ({
             ...ref,
-            id: LifecycleProcessor.createEagerProviderId(ref.module.name, ref.key),
+            id: `${ref.module.name}:${ref.key}`,
             initAfter: this.getProviderInitAfter(ref.module, ref.key),
         }));
         const nodeById = new Map(nodes.map((node) => [node.id, node]));
@@ -172,7 +172,4 @@ export class LifecycleProcessor {
         }
         return nodeByKey;
     }
-    static createEagerProviderId(moduleName, key) {
-        return `${moduleName}:${key}`;
-    }
 }

package/dist/lib/di/providers/provider-resolver.d.ts

@@ -1,10 +1,12 @@
 import * as Awilix from "awilix";
+import type { DevtoolsProcessorRef } from "../../devtools/devtools.types.js";
 import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
 import type { InterceptorProcessor } from "../processors/interceptor-processor.js";
 import type { AnyProvider } from "./provider.types.js";
 export type RequestScopeResolver = (scope: Awilix.AwilixContainer) => Awilix.AwilixContainer;
 type ResolveProviderParams = {
     key: string;
+    moduleId?: string;
     provider: AnyProvider;
     resolutionScope: Awilix.AwilixContainer;
     module: M;
@@ -19,13 +21,15 @@ type ResolveClassProviderParams = {
 export declare class ProviderResolver {
     private readonly interceptorProcessor;
     private readonly providerOptions;
+    private readonly devtoolsProcessorRef;
     private readonly requestScopeResolver?;
-    constructor(interceptorProcessor: InterceptorProcessor | undefined, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, requestScopeResolver?: RequestScopeResolver | undefined);
+    constructor(interceptorProcessor: InterceptorProcessor | undefined, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, devtoolsProcessorRef: DevtoolsProcessorRef, requestScopeResolver?: RequestScopeResolver | undefined);
     static mergeResolverOptions(module: M, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, options?: Partial<Awilix.BuildResolverOptions<any>>): Awilix.BuildResolverOptions<any>;
     resolveClassProvider({ provider, resolutionScope, module, wrapForExport, }: ResolveClassProviderParams): Awilix.Resolver<any>;
-    resolveProvider({ key, provider, resolutionScope, module, }: ResolveProviderParams): Awilix.Resolver<any>;
-    resolveProviderAsync({ key, provider, resolutionScope, module, }: ResolveProviderParams): Promise<Awilix.Resolver<any>>;
+    resolveProvider({ key, moduleId, provider, resolutionScope, module, }: ResolveProviderParams): Awilix.Resolver<any>;
+    resolveProviderAsync({ key, moduleId, provider, resolutionScope, module, }: ResolveProviderParams): Promise<Awilix.Resolver<any>>;
     private extractResolverOptions;
     private createProxyResolver;
+    private get devtoolsTracer();
 }
 export {};

package/dist/lib/di/providers/provider-resolver.js

@@ -4,10 +4,12 @@ import * as GUARGS from "../type-guards.js";
 export class ProviderResolver {
     interceptorProcessor;
     providerOptions;
+    devtoolsProcessorRef;
     requestScopeResolver;
-    constructor(interceptorProcessor, providerOptions, requestScopeResolver) {
+    constructor(interceptorProcessor, providerOptions, devtoolsProcessorRef, requestScopeResolver) {
         this.interceptorProcessor = interceptorProcessor;
         this.providerOptions = providerOptions;
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
         this.requestScopeResolver = requestScopeResolver;
     }
     static mergeResolverOptions(module, providerOptions, options) {
@@ -35,7 +37,7 @@ export class ProviderResolver {
                 ? this.requestScopeResolver(resolutionScope)
                 : resolutionScope), resolverOptions);
     }
-    resolveProvider({ key, provider, resolutionScope, module, }) {
+    resolveProvider({ key, moduleId, provider, resolutionScope, module, }) {
         if (GUARGS.isPrimitive(provider)) {
             return Awilix.asValue(provider);
         }
@@ -51,13 +53,22 @@ export class ProviderResolver {
         }
         const resolverOptions = this.extractResolverOptions(module, provider);
         if (GUARGS.isCostructorProvider(provider)) {
-            if (!this.interceptorProcessor) {
-                return Awilix.asClass(provider, resolverOptions);
-            }
-            return this.interceptorProcessor.createInterceptedProviderResolver({
+            const resolver = !this.interceptorProcessor
+                ? Awilix.asClass(provider, resolverOptions)
+                : this.interceptorProcessor.createInterceptedProviderResolver({
+                    module,
+                    useClass: provider,
+                    options: resolverOptions,
+                });
+            if (!this.devtoolsTracer)
+                return resolver;
+            return this.devtoolsTracer.wrapResolver({
+                kind: "provider",
                 module,
-                useClass: provider,
+                moduleId,
                 options: resolverOptions,
+                providerKey: key,
+                resolver,
             });
         }
         if (GUARGS.isFactoryProvider(provider)) {
@@ -70,26 +81,52 @@ export class ProviderResolver {
                 throw new ERRORS.AsyncFactoryRequiresAsyncCreateError(module.name, key ?? "unknown");
             }
             const factoryDeps = (provider.inject || []).map((k) => resolutionScope.registrations[k].resolve(resolutionScope));
-            return Awilix.asFunction(() => provider.useFactory(...factoryDeps), resolverOptions);
+            const resolver = Awilix.asFunction(() => provider.useFactory(...factoryDeps), resolverOptions);
+            if (!this.devtoolsTracer)
+                return resolver;
+            return this.devtoolsTracer.wrapResolver({
+                kind: "provider",
+                module,
+                moduleId,
+                options: resolverOptions,
+                providerKey: key,
+                isFactory: true,
+                resolver,
+            });
         }
         const baseResolver = Awilix.asClass(provider.useClass, resolverOptions);
         const classResolver = provider.allowCircular
             ? this.createProxyResolver(baseResolver, resolverOptions)
             : baseResolver;
-        if (!this.interceptorProcessor) {
-            return classResolver;
-        }
-        return this.interceptorProcessor.createInterceptedProviderResolver({
+        const resolver = !this.interceptorProcessor
+            ? classResolver
+            : this.interceptorProcessor.createInterceptedProviderResolver({
+                module,
+                useClass: provider.useClass,
+                options: resolverOptions,
+                resolver: classResolver,
+            });
+        if (!this.devtoolsTracer)
+            return resolver;
+        return this.devtoolsTracer.wrapResolver({
+            kind: "provider",
             module,
-            useClass: provider.useClass,
+            moduleId,
             options: resolverOptions,
-            resolver: classResolver,
+            providerKey: key,
+            resolver,
         });
     }
-    async resolveProviderAsync({ key, provider, resolutionScope, module, }) {
+    async resolveProviderAsync({ key, moduleId, provider, resolutionScope, module, }) {
         if (!GUARGS.isFactoryProvider(provider) ||
             !GUARGS.isAsyncFactoryProvider(provider)) {
-            return this.resolveProvider({ provider, resolutionScope, module, key });
+            return this.resolveProvider({
+                provider,
+                resolutionScope,
+                module,
+                key,
+                moduleId,
+            });
         }
         const resolverOptions = this.extractResolverOptions(module, provider);
         if (resolverOptions.lifetime !== Awilix.Lifetime.SINGLETON) {
@@ -125,4 +162,7 @@ export class ProviderResolver {
             },
         });
     }
+    get devtoolsTracer() {
+        return this.devtoolsProcessorRef.current?.tracer;
+    }
 }

package/dist/lib/di/providers/types/provider.types.d.ts

@@ -3,22 +3,22 @@ export type DefProviderMap = Record<string, object | string | boolean | number>;
 export type ConstructorProvider<T extends object = object> = Constructor<T>;
 export type PrimitiveProvider = string | number | boolean | symbol | bigint;
 export type FunctionProvider = (...args: any[]) => any;
-export type FactoryProvider<T extends object, DepsMap extends Record<string, unknown>, Keys extends readonly Extract<keyof DepsMap, string>[], Strict extends boolean = true> = {
+export type FactoryProvider<T extends object, DepsMap extends Record<string, unknown>, Keys extends readonly Extract<keyof DepsMap, string>[], Strict extends boolean = true, ResolverOptions extends object = BuildResolverOptions<T>> = {
     inject?: Keys;
     initAfter?: readonly Extract<keyof DepsMap, string>[];
     eager?: boolean;
     useFactory: Strict extends true ? (...args: MapKeysToValues<DepsMap, Keys>) => T | Promise<T> : (...args: any[]) => T | Promise<T>;
-} & BuildResolverOptions<T>;
-export type ClassProvider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>> = {
+} & ResolverOptions;
+export type ClassProvider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>, ResolverOptions extends object = BuildResolverOptions<T>> = {
     useClass: Constructor<T>;
     allowCircular?: boolean;
     eager?: boolean;
     initAfter?: readonly Extract<keyof DepsMap, string>[];
-} & BuildResolverOptions<T>;
+} & ResolverOptions;
 export interface ProviderInit {
     init(): void | Promise<void>;
 }
-export type Provider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>> = FactoryProvider<T, DepsMap, readonly Extract<keyof DepsMap, string>[], false> | ClassProvider<T, DepsMap> | ConstructorProvider<T>;
+export type Provider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>, ResolverOptions extends object = BuildResolverOptions<T>> = FactoryProvider<T, DepsMap, readonly Extract<keyof DepsMap, string>[], false> | ClassProvider<T, DepsMap, ResolverOptions> | ConstructorProvider<T>;
 export type AnyProvider = FactoryProvider<any, any, readonly string[], false> | ClassProvider<any> | ConstructorProvider<any> | PrimitiveProvider | FunctionProvider | object;
 type MapKeysToValues<DepsMap extends Record<string, unknown>, Keys extends readonly Extract<keyof DepsMap, string>[]> = {
     [K in keyof Keys]: Keys[K] extends keyof DepsMap ? DepsMap[Keys[K]] : never;

package/dist/lib/mediator/mediator.d.ts

@@ -1,3 +1,4 @@
+import type { DevtoolsProcessorRef } from "../devtools/devtools.types.js";
 import type { AnyContract } from "./contract.types.js";
 import type { Executor, ExtractPayload } from "./handler.types.js";
 import type { ExecuteArgs, ExecuteResponse, ExecuteResponseByScenario, ExecuteRuntimeOptions, ExtractScenarioName } from "./mediator.types.js";
@@ -5,8 +6,10 @@ import type { MiddlewareResolverMap } from "./middleware.types.js";
 export declare class Mediator<C extends AnyContract> {
     private handlers;
     private middlewareResolvers;
+    private handlerType;
     private moduleName;
-    constructor(middlewareResolvers: MiddlewareResolverMap, moduleName: string);
+    private devtoolsProcessorRef;
+    constructor(middlewareResolvers: MiddlewareResolverMap, moduleName: string, handlerType: string | undefined, devtoolsProcessorRef: DevtoolsProcessorRef);
     register(key: string, executor: Executor): void;
     execute<K extends C["key"], Name extends ExtractScenarioName<C, K>>(key: K, payload: ExtractPayload<C, K>, options: ExecuteRuntimeOptions<C, K> & {
         scenario: Name;

package/dist/lib/mediator/mediator.js

@@ -4,10 +4,14 @@ import { Result } from "./result.js";
 export class Mediator {
     handlers = new Map();
     middlewareResolvers;
+    handlerType;
     moduleName;
-    constructor(middlewareResolvers, moduleName) {
+    devtoolsProcessorRef;
+    constructor(middlewareResolvers, moduleName, handlerType = "handler", devtoolsProcessorRef) {
+        this.handlerType = handlerType;
         this.moduleName = moduleName;
         this.middlewareResolvers = middlewareResolvers;
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
     }
     register(key, executor) {
         const keyStr = String(key);
@@ -45,7 +49,14 @@ export class Mediator {
         let context = {};
         let hasResultMiddleware = false;
         for (const [middlewareKey, middleware] of middlewares) {
-            const result = await middleware.execute(payload, context, executionContext);
+            const result = await (this.devtoolsProcessorRef.current?.tracer.recordSpan({
+                kind: "prehandler",
+                moduleName: this.moduleName,
+                providerKey: `${this.handlerType}:prehandler:${middlewareKey}`,
+                methodName: "execute",
+                args: [payload, context, executionContext],
+                callback: () => middleware.execute(payload, context, executionContext),
+            }) ?? middleware.execute(payload, context, executionContext));
             if (this.isResult(result)) {
                 hasResultMiddleware = true;
             }

package/dist/lib/react/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./errors.js";
+export * from "./react-di-context.js";
+export * from "./react-module.types.js";
+export * from "./react-module-factories.js";

package/dist/lib/react/index.js

@@ -0,0 +1,4 @@
+export * from "./errors.js";
+export * from "./react-di-context.js";
+export * from "./react-module.types.js";
+export * from "./react-module-factories.js";

package/dist/lib/react/react-di-context.d.ts

@@ -1,12 +1,8 @@
 import * as Awilix from "awilix";
 import { ContainerContextBase, type ContainerContextOptions, type ModuleScope, type RegisteredModuleScope } from "../di/contexts/container-context-base.js";
 import type { InternalModuleLike as M } from "../di/modules/runtime-module.types.js";
-type ReactContainerContextOptions = Omit<ContainerContextOptions, "providerOptions"> & {
-    providerOptions?: NonScopedResolverOptions;
-};
-type NonScopedResolverOptions = Omit<Partial<Awilix.BuildResolverOptions<any>>, "lifetime"> & {
-    lifetime?: Exclude<Awilix.LifetimeType, "SCOPED">;
-};
+import type { NonScopedResolverOptions } from "./react-module.types.js";
+type ReactContainerContextOptions = ContainerContextOptions<NonScopedResolverOptions<any>>;
 export declare class ReactDIContext extends ContainerContextBase {
     private readonly componentProcessor;
     private constructor();
@@ -15,7 +11,6 @@ export declare class ReactDIContext extends ContainerContextBase {
     protected ensureAdditionalNameConflicts(m: M, resolvedImports: M[]): void;
     protected beforeRegisterProviders(m: M): void;
     protected afterRegisterProviders(m: M, scope: Awilix.AwilixContainer): void;
-    private ensureProviderOptionsDoNotUseScopedLifetime;
     private hasScopedProviderLifetime;
 }
 export {};

package/dist/lib/react/react-di-context.js

@@ -7,8 +7,7 @@ export class ReactDIContext extends ContainerContextBase {
     componentProcessor = new ReactComponentProcessor();
     constructor(options) {
         super(options);
-        this.ensureProviderOptionsDoNotUseScopedLifetime("ReactDIContext", this.options.providerOptions);
-        this.providerResolver = new ProviderResolver(undefined, this.options.providerOptions || {});
+        this.providerResolver = new ProviderResolver(undefined, this.options.providerOptions || {}, {});
     }
     static create(module, options) {
         return new ReactDIContext(options ?? {}).bootstrapModule(module);
@@ -30,7 +29,10 @@ export class ReactDIContext extends ContainerContextBase {
         }
     }
     beforeRegisterProviders(m) {
-        this.ensureProviderOptionsDoNotUseScopedLifetime(m.name, m.providerOptions);
+        if (m.providerOptions?.lifetime === Awilix.Lifetime.SCOPED ||
+            this.options.providerOptions?.lifetime === Awilix.Lifetime.SCOPED) {
+            throw new REACT_ERRORS.ScopedProviderLifetimeError(m.name, "providerOptions");
+        }
         for (const [key, provider] of Object.entries(m.providers || {})) {
             if (this.hasScopedProviderLifetime(provider)) {
                 throw new REACT_ERRORS.ScopedProviderLifetimeError(m.name, key);
@@ -40,11 +42,6 @@ export class ReactDIContext extends ContainerContextBase {
     afterRegisterProviders(m, scope) {
         this.componentProcessor.processComponents(m, scope);
     }
-    ensureProviderOptionsDoNotUseScopedLifetime(moduleName, providerOptions) {
-        if (providerOptions?.lifetime !== Awilix.Lifetime.SCOPED)
-            return;
-        throw new REACT_ERRORS.ScopedProviderLifetimeError(moduleName, "providerOptions");
-    }
     hasScopedProviderLifetime(provider) {
         return (typeof provider === "object" &&
             provider !== null &&

package/dist/lib/react/react-module.types.d.ts

@@ -1,8 +1,8 @@
-import type { BuildResolverOptions, Constructor, ContainerOptions, LifetimeType } from "awilix";
+import type { BuildResolverOptions, ContainerOptions, LifetimeType } from "awilix";
 import type { EmptyObject } from "../di/common.types.js";
 import type { ModuleImport } from "../di/modules/module.types.js";
 import type { GlobalDependencies, NormalizeGlobalDependencies } from "../di/modules/module-def.types.js";
-import type { DefProviderMap } from "../di/providers/provider.types.js";
+import type { DefProviderMap, Provider } from "../di/providers/provider.types.js";
 export type ReactComponent<TProps = any, TResult = any> = (props: TProps) => TResult;
 declare const reactImportModuleDefMarker: unique symbol;
 export type ReactImportModule<TDef extends ModuleDefinition = ModuleDefinition> = {
@@ -136,27 +136,13 @@ type WithProviders<TProviders extends DefProviderMap | EmptyObject, TDeps extend
     providers: ToReactProviderMap<TProviders, TDeps>;
 };
 type ToReactProviderMap<T extends DefProviderMap, DepsMap extends object = Record<string, unknown>> = [keyof T] extends [never] ? EmptyObject : {
-    [K in keyof T]: T[K] extends object ? (ReactProvider<T[K], KnownStringKeyMap<DepsMap>> & {
+    [K in keyof T]: T[K] extends object ? (Provider<T[K], KnownStringKeyMap<DepsMap>, NonScopedResolverOptions<T>> & {
         initAfter?: readonly Extract<keyof DepsMap, string>[];
     }) | T[K] : T[K];
 };
-type NonScopedLifetime = Exclude<LifetimeType, "SCOPED">;
-type NonScopedResolverOptions<T> = Omit<BuildResolverOptions<T>, "lifetime"> & {
-    lifetime?: NonScopedLifetime;
+export type NonScopedResolverOptions<T> = Omit<BuildResolverOptions<T>, "lifetime"> & {
+    lifetime?: Exclude<LifetimeType, "SCOPED">;
 };
-type ReactFactoryProvider<T extends object, DepsMap extends Record<string, unknown>> = {
-    inject?: readonly Extract<keyof DepsMap, string>[];
-    initAfter?: readonly Extract<keyof DepsMap, string>[];
-    eager?: boolean;
-    useFactory: (...args: any[]) => T | Promise<T>;
-} & NonScopedResolverOptions<T>;
-type ReactClassProvider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>> = {
-    useClass: Constructor<T>;
-    allowCircular?: boolean;
-    eager?: boolean;
-    initAfter?: readonly Extract<keyof DepsMap, string>[];
-} & NonScopedResolverOptions<T>;
-type ReactProvider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>> = ReactFactoryProvider<T, DepsMap> | ReactClassProvider<T, DepsMap> | Constructor<T>;
 type KnownStringKeyMap<T extends object> = {
     [K in Extract<keyof T, string>]: T[K];
 };