awilixify 2.2.1 → 3.1.0

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

@@ -0,0 +1,16 @@
+import type { AnyContract } from "./contract.types.js";
+import type { EmptyContext } from "./middleware.types.js";
+export interface Handler<C extends AnyContract, K extends C["key"] = C["key"]> {
+    readonly contract: C;
+    executor: Executor<ExtractPayload<C, K>, ExtractResponse<C, K>, ExtractContractContext<C>>;
+}
+export type Executor<P = unknown, R = unknown, Ctx extends EmptyContext = EmptyContext> = (payload: P, context: Ctx) => Promise<R>;
+type ExtractContractContext<C extends AnyContract> = C extends {
+    context: infer TContext extends Record<string, unknown>;
+} ? TContext : EmptyContext;
+type ExtractContractByKey<C extends AnyContract, K extends C["key"]> = Extract<C, {
+    key: K;
+}>;
+export type ExtractPayload<C extends AnyContract, K extends C["key"]> = ExtractContractByKey<C, K>["payload"];
+export type ExtractResponse<C extends AnyContract, K extends C["key"]> = ExtractContractByKey<C, K>["response"];
+export {};

package/dist/lib/mediator/handler.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+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";
+import type { MiddlewareResolverMap } from "./middleware.types.js";
+export declare class Mediator<C extends AnyContract> {
+    private handlers;
+    private middlewareResolvers;
+    private handlerType;
+    private moduleName;
+    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;
+    }): Promise<ExecuteResponseByScenario<C, K, Name>>;
+    execute<K extends C["key"], TOptions extends ExecuteRuntimeOptions<C, K> = ExecuteRuntimeOptions<C, K>>(key: K, payload: ExtractPayload<C, K>, ...args: ExecuteArgs<C, K, TOptions>): Promise<ExecuteResponse<C, K>>;
+    private executeMiddlewares;
+    private processMiddlewareResult;
+    private resolveApplicableMiddlewares;
+    private ensureMiddlewareDependencies;
+    private mergeContext;
+    private isResult;
+}

package/dist/lib/mediator/mediator.js

@@ -0,0 +1,134 @@
+import { runInRequestScopeContext } from "../di/request-scope-context.js";
+import * as errors from "./errors.js";
+import { Result } from "./result.js";
+export class Mediator {
+    handlers = new Map();
+    middlewareResolvers;
+    handlerType;
+    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);
+        if (this.handlers.has(keyStr)) {
+            throw new errors.HandlerAlreadyRegisteredError(keyStr);
+        }
+        this.handlers.set(keyStr, executor);
+    }
+    async execute(key, payload, options) {
+        return runInRequestScopeContext(async () => {
+            const keyStr = String(key);
+            const executor = this.handlers.get(keyStr);
+            if (!executor) {
+                throw new errors.HandlerNotRegisteredError(keyStr, this.moduleName);
+            }
+            const { executionContext, includePreHandlerKeys, excludePreHandlerKeys } = options ?? {};
+            const applicableMiddlewares = this.resolveApplicableMiddlewares({
+                excludePreHandlerKeys,
+                includePreHandlerKeys,
+            });
+            const middlewareResult = await this.executeMiddlewares(applicableMiddlewares, payload, executionContext ?? {});
+            if (middlewareResult.type === "error") {
+                return middlewareResult.error;
+            }
+            const handlerResult = await executor(payload, middlewareResult.context);
+            if (middlewareResult.hasResultMiddleware) {
+                return (this.isResult(handlerResult)
+                    ? handlerResult
+                    : Result.ok(handlerResult));
+            }
+            return handlerResult;
+        });
+    }
+    async executeMiddlewares(middlewares, payload, executionContext) {
+        let context = {};
+        let hasResultMiddleware = false;
+        for (const [middlewareKey, middleware] of middlewares) {
+            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;
+            }
+            const processed = this.processMiddlewareResult(result, context, middlewareKey);
+            if (processed.shouldShortCircuit) {
+                return { type: "error", error: processed.result };
+            }
+            context = processed.context;
+        }
+        return { type: "success", context, hasResultMiddleware };
+    }
+    processMiddlewareResult(result, currentContext, middlewareKey) {
+        if (this.isResult(result)) {
+            return result.ok
+                ? {
+                    shouldShortCircuit: false,
+                    context: this.mergeContext(currentContext, result.value, middlewareKey),
+                }
+                : { shouldShortCircuit: true, result };
+        }
+        return {
+            shouldShortCircuit: false,
+            context: this.mergeContext(currentContext, result, middlewareKey),
+        };
+    }
+    resolveApplicableMiddlewares(options) {
+        const { includePreHandlerKeys = [], excludePreHandlerKeys = [] } = options ?? {};
+        const filtered = Array.from(this.middlewareResolvers.entries()).filter(([key]) => {
+            if (excludePreHandlerKeys.includes(key)) {
+                return false;
+            }
+            if (includePreHandlerKeys.length > 0) {
+                return includePreHandlerKeys.includes(key);
+            }
+            return true;
+        });
+        const resolvedMiddlewares = filtered.map(([key, resolver]) => [key, resolver()]);
+        this.ensureMiddlewareDependencies(resolvedMiddlewares);
+        return resolvedMiddlewares;
+    }
+    ensureMiddlewareDependencies(middlewares) {
+        const processedKeys = [];
+        for (const [key, middleware] of middlewares) {
+            const requires = middleware.requires || [];
+            for (const requiredKey of requires) {
+                if (!processedKeys.includes(requiredKey)) {
+                    throw new errors.MiddlewareRequiredError(key, requiredKey);
+                }
+            }
+            processedKeys.push(key);
+        }
+    }
+    mergeContext(currentContext, data, middlewareKey) {
+        if (data === undefined) {
+            return currentContext;
+        }
+        if (typeof data !== "object" || data === null) {
+            const returnedType = data === null ? "null" : typeof data;
+            throw new errors.InvalidMiddlewareReturnValueError(middlewareKey, returnedType);
+        }
+        const currentKeys = Object.keys(currentContext);
+        const newKeys = Object.keys(data);
+        const conflictingKeys = newKeys.filter((key) => currentKeys.includes(key));
+        if (conflictingKeys.length > 0) {
+            throw new errors.ContextKeyConflictError(middlewareKey, conflictingKeys);
+        }
+        return { ...currentContext, ...data };
+    }
+    isResult(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "ok" in value &&
+            typeof value.ok === "boolean");
+    }
+}

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

@@ -0,0 +1,64 @@
+import type { AnyContract } from "./contract.types.js";
+import type { ExecutionContext } from "./middleware.types.js";
+export type ExtractScenarioName<C extends AnyContract, K extends C["key"]> = Extract<keyof ExtractContractScenarios<C, K>, string>;
+export type ExecuteResponseByScenario<C extends AnyContract, K extends C["key"], Name extends ExtractScenarioName<C, K>> = ExtractScenarioReturnType<C, K, Name>;
+export type ExecuteRuntimeOptions<C extends AnyContract, K extends C["key"]> = ExecutionContextOption & ExecuteOptions<C, K>;
+export type ExecuteArgs<C extends AnyContract, K extends C["key"], TOptions extends ExecuteRuntimeOptions<C, K> = ExecuteRuntimeOptions<C, K>> = IsExecuteOptionsRequired<C, K> extends true ? [options: TOptions] : [options?: never];
+export type ExecuteResponse<C extends AnyContract, K extends C["key"]> = ExtractContractReturnType<C, K>;
+type ExtractContractScenarios<C extends AnyContract, K extends C["key"]> = Extract<C, {
+    key: K;
+}> extends {
+    scenarios: infer S extends Record<string, unknown>;
+} ? S : never;
+type ExtractScenarioByName<C extends AnyContract, K extends C["key"], Name extends string> = Name extends keyof ExtractContractScenarios<C, K> ? ExtractContractScenarios<C, K>[Name] : never;
+type ExtractScenarioConfig<C extends AnyContract, K extends C["key"], Name extends string> = ExtractScenarioByName<C, K, Name> extends {
+    config: infer Config;
+} ? Config : never;
+type ExtractScenarioReturnType<C extends AnyContract, K extends C["key"], Name extends string> = ExtractScenarioByName<C, K, Name> extends {
+    returnType: infer ReturnType;
+} ? ReturnType : ExtractContractReturnType<C, K>;
+type ExecuteNoScenarioOptions = {
+    scenario?: never;
+    includePreHandlerKeys?: never;
+    excludePreHandlerKeys?: never;
+};
+type ExecuteOptions<C extends AnyContract, K extends C["key"]> = [
+    ExtractContractScenarios<C, K>
+] extends [never] ? ExecuteNoScenarioOptions : ExecuteScenarioOptions<C, K>;
+type ScenarioIncludeOption<C extends AnyContract, K extends C["key"], Name extends string> = ExtractScenarioConfig<C, K, Name> extends {
+    includePreHandlerKeys: infer Include extends readonly any[];
+} ? {
+    includePreHandlerKeys: Include;
+} : {
+    includePreHandlerKeys?: never;
+};
+type ScenarioExcludeOption<C extends AnyContract, K extends C["key"], Name extends string> = ExtractScenarioConfig<C, K, Name> extends {
+    excludePreHandlerKeys: infer Exclude extends readonly any[];
+} ? {
+    excludePreHandlerKeys: Exclude;
+} : {
+    excludePreHandlerKeys?: never;
+};
+type ExecuteScenarioOptions<C extends AnyContract, K extends C["key"]> = {
+    [Name in ExtractScenarioName<C, K>]: {
+        scenario: Name;
+    } & ScenarioIncludeOption<C, K, Name> & ScenarioExcludeOption<C, K, Name>;
+}[ExtractScenarioName<C, K>];
+type ExecutionContextOption = [keyof ExecutionContext] extends [never] ? {
+    executionContext?: never;
+} : {
+    executionContext: ExecutionContext;
+};
+type HasScenarios<C extends AnyContract, K extends C["key"]> = [
+    ExtractContractScenarios<C, K>
+] extends [never] ? false : true;
+type IsExecutionContextRequired = [keyof ExecutionContext] extends [never] ? false : true;
+type IsExecuteOptionsRequired<C extends AnyContract, K extends C["key"]> = HasScenarios<C, K> extends true ? true : IsExecutionContextRequired;
+type ExtractContractReturnType<C extends AnyContract, K extends C["key"]> = Extract<C, {
+    key: K;
+}> extends {
+    returnType: infer ReturnType;
+} ? ReturnType : Extract<C, {
+    key: K;
+}>["response"];
+export {};

package/dist/lib/mediator/mediator.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,41 @@
+import type { Result } from "./result.js";
+type EmptyObject = Record<never, never>;
+export interface ExecutionContext {
+}
+export type EmptyContext = EmptyObject;
+export type AnyMiddlewareContract = MiddlewareContract<string, unknown, any>;
+export type AnyContext = Record<string, unknown>;
+export type MiddlewareResolver = () => Middleware;
+export type MiddlewareResolverMap = Map<string, () => Middleware>;
+export type Middleware<C extends AnyMiddlewareContract = AnyMiddlewareContract> = MiddlewareRequires<C> & {
+    readonly contract: C;
+    execute: MiddlewareFn<ExtractContractContext<C>, ExtractMiddlewareReturnType<C>>;
+};
+export type ExtractMiddlewareContext<T> = [T] extends [Result<infer Data, any>] ? Data extends Record<string, unknown> ? Data : EmptyObject : T extends Record<string, unknown> ? T : EmptyObject;
+export type MiddlewareContract<K extends string, ReturnType, RequiredContracts extends readonly AnyMiddlewareContract[] = readonly []> = {
+    key: K;
+    returnType: ReturnType;
+    requires: ExtractRequiredKeysTupleFromContracts<RequiredContracts>;
+    context: MergeContextFromContracts<RequiredContracts>;
+    executionContext: ExecutionContext;
+};
+type ExtractRequiredKeysTupleFromContracts<Contracts extends readonly AnyMiddlewareContract[]> = number extends Contracts["length"] ? readonly string[] : Contracts extends readonly [] ? readonly [] : Contracts extends readonly [infer First, ...infer Rest] ? First extends AnyMiddlewareContract ? Rest extends readonly AnyMiddlewareContract[] ? readonly [
+    First["key"],
+    ...ExtractRequiredKeysTupleFromContracts<Rest>
+] : readonly [First["key"]] : readonly [] : readonly [];
+type MergeContextFromContracts<Contracts extends readonly AnyMiddlewareContract[]> = number extends Contracts["length"] ? AnyContext : Contracts extends readonly [] ? EmptyObject : Contracts extends readonly [infer First, ...infer Rest] ? First extends AnyMiddlewareContract ? Rest extends readonly AnyMiddlewareContract[] ? ExtractMiddlewareContext<First["returnType"]> & MergeContextFromContracts<Rest> : ExtractMiddlewareContext<First["returnType"]> : EmptyObject : EmptyObject;
+type ExtractMiddlewareReturnType<C extends AnyMiddlewareContract> = C["returnType"];
+type ExtractRequiredKeys<C extends AnyMiddlewareContract> = C["requires"][number];
+type ExtractRequiredList<C extends AnyMiddlewareContract> = C["requires"];
+type ExtractContractContext<C extends AnyMiddlewareContract> = C["context"];
+type MiddlewareFn<RequiredContext extends AnyContext = EmptyContext, ReturnType = unknown> = (payload: unknown, context: RequiredContext, executionContext: ExecutionContext) => Promise<ReturnType>;
+type MiddlewareRequires<C extends AnyMiddlewareContract> = [
+    ExtractRequiredKeys<C>
+] extends [never] ? {
+    readonly requires?: readonly [];
+} : string extends ExtractRequiredKeys<C> ? {
+    readonly requires?: readonly string[];
+} : {
+    readonly requires: ExtractRequiredList<C>;
+};
+export {};

package/dist/lib/mediator/middleware.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+export type Result<T, E> = Ok<T> | Err<E>;
+declare class Ok<T> {
+    readonly value: T;
+    readonly ok: true;
+    readonly error: undefined;
+    constructor(value: T);
+}
+declare class Err<E> {
+    readonly error: E;
+    readonly ok: false;
+    readonly value: undefined;
+    constructor(error: E);
+}
+export declare const Result: {
+    ok<T>(value: T): Result<T, never>;
+    error<E>(error: E): Result<never, E>;
+};
+export {};

package/dist/lib/mediator/result.js

@@ -0,0 +1,24 @@
+class Ok {
+    value;
+    ok = true;
+    error = undefined;
+    constructor(value) {
+        this.value = value;
+    }
+}
+class Err {
+    error;
+    ok = false;
+    value = undefined;
+    constructor(error) {
+        this.error = error;
+    }
+}
+export const Result = {
+    ok(value) {
+        return new Ok(value);
+    },
+    error(error) {
+        return new Err(error);
+    },
+};

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

@@ -0,0 +1,12 @@
+export declare class ComponentNameConflictError extends Error {
+    constructor(moduleName: string, conflictingKeys: string[]);
+}
+export declare class InvalidComponentExportError extends Error {
+    constructor(moduleName: string, componentKey: string);
+}
+export declare class ComponentDepsOverrideError extends Error {
+    constructor(componentKey: string);
+}
+export declare class ScopedProviderLifetimeError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}

package/dist/lib/react/errors.js

@@ -0,0 +1,24 @@
+export class ComponentNameConflictError extends Error {
+    constructor(moduleName, conflictingKeys) {
+        super(`Module "${moduleName}" has component name conflicts with providers or imported features: ${conflictingKeys.join(", ")}`);
+        this.name = "ComponentNameConflictError";
+    }
+}
+export class InvalidComponentExportError extends Error {
+    constructor(moduleName, componentKey) {
+        super(`Module "${moduleName}" exports component "${componentKey}", but that component is not declared by the module.`);
+        this.name = "InvalidComponentExportError";
+    }
+}
+export class ComponentDepsOverrideError extends Error {
+    constructor(componentKey) {
+        super(`Component "${componentKey}" received a "deps" prop. React component dependencies are injected by ReactDIContext and cannot be overridden from JSX.`);
+        this.name = "ComponentDepsOverrideError";
+    }
+}
+export class ScopedProviderLifetimeError extends Error {
+    constructor(moduleName, providerKey) {
+        super(`Provider "${providerKey}" in React module "${moduleName}" uses SCOPED lifetime. ReactDIContext supports SINGLETON and TRANSIENT providers only.`);
+        this.name = "ScopedProviderLifetimeError";
+    }
+}

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-component-processor.d.ts

@@ -0,0 +1,10 @@
+import * as Awilix from "awilix";
+import type { RegisteredModuleScope } from "../di/contexts/container-context-base.js";
+import type { InternalModuleLike as M } from "../di/modules/runtime-module.types.js";
+export declare class ReactComponentProcessor {
+    processComponents(m: M, scope: Awilix.AwilixContainer): void;
+    registerExportedComponents(scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+    getExportedComponentKeys(module: M): string[];
+    private wrapComponent;
+    private createDepsProxy;
+}

package/dist/lib/react/react-component-processor.js

@@ -0,0 +1,62 @@
+import * as Awilix from "awilix";
+import { createElement } from "react";
+import * as ERRORS from "./errors.js";
+export class ReactComponentProcessor {
+    processComponents(m, scope) {
+        if (!m.components)
+            return;
+        const componentKeys = Object.keys(m.components);
+        const conflicts = componentKeys.filter((key) => scope.registrations[key]);
+        if (conflicts.length > 0) {
+            throw new ERRORS.ComponentNameConflictError(m.name, conflicts);
+        }
+        for (const [key, component] of Object.entries(m.components)) {
+            scope.register({
+                [key]: Awilix.asValue(this.wrapComponent(key, component, scope)),
+            });
+        }
+    }
+    registerExportedComponents(scope, importedModulesWithScope) {
+        for (const { module, moduleScope } of importedModulesWithScope) {
+            for (const key of module.componentExports || []) {
+                if (!module.components?.[key]) {
+                    throw new ERRORS.InvalidComponentExportError(module.name, key);
+                }
+                if (scope.registrations[key]) {
+                    throw new ERRORS.ComponentNameConflictError(module.name, [key]);
+                }
+                scope.register({
+                    [key]: Awilix.asFunction(() => moduleScope.scope.resolve(key), {
+                        lifetime: Awilix.Lifetime.TRANSIENT,
+                        isLeakSafe: true,
+                    }),
+                });
+            }
+        }
+    }
+    getExportedComponentKeys(module) {
+        return module.componentExports ? [...module.componentExports] : [];
+    }
+    wrapComponent(key, component, scope) {
+        return (props = {}) => {
+            if (Object.hasOwn(props, "deps")) {
+                throw new ERRORS.ComponentDepsOverrideError(key);
+            }
+            return createElement(component, {
+                ...props,
+                deps: this.createDepsProxy(scope),
+            });
+        };
+    }
+    createDepsProxy(scope) {
+        return new Proxy({}, {
+            get: (_target, prop) => {
+                if (typeof prop !== "string")
+                    return undefined;
+                if (!scope.registrations[prop])
+                    return undefined;
+                return scope.resolve(prop);
+            },
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+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";
+import type { NonScopedResolverOptions } from "./react-module.types.js";
+type ReactContainerContextOptions = ContainerContextOptions<NonScopedResolverOptions<any>>;
+export declare class ReactDIContext extends ContainerContextBase {
+    private readonly componentProcessor;
+    private constructor();
+    static create(module: M, options?: ReactContainerContextOptions): ModuleScope;
+    protected registerImportedFeatures(scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+    protected ensureAdditionalNameConflicts(m: M, resolvedImports: M[]): void;
+    protected beforeRegisterProviders(m: M): void;
+    protected afterRegisterProviders(m: M, scope: Awilix.AwilixContainer): void;
+    private hasScopedProviderLifetime;
+}
+export {};

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

@@ -0,0 +1,52 @@
+import * as Awilix from "awilix";
+import { ContainerContextBase, } from "../di/contexts/container-context-base.js";
+import { ProviderResolver } from "../di/providers/provider-resolver.js";
+import * as REACT_ERRORS from "./errors.js";
+import { ReactComponentProcessor } from "./react-component-processor.js";
+export class ReactDIContext extends ContainerContextBase {
+    componentProcessor = new ReactComponentProcessor();
+    constructor(options) {
+        super(options);
+        this.providerResolver = new ProviderResolver(undefined, this.options.providerOptions || {}, {});
+    }
+    static create(module, options) {
+        return new ReactDIContext(options ?? {}).bootstrapModule(module);
+    }
+    registerImportedFeatures(scope, importedModulesWithScope) {
+        this.registerExportedProviders(scope, importedModulesWithScope);
+        this.componentProcessor.registerExportedComponents(scope, importedModulesWithScope);
+    }
+    ensureAdditionalNameConflicts(m, resolvedImports) {
+        const componentKeys = Object.keys(m.components || {});
+        const providerConflicts = Object.keys(m.providers || {}).filter((key) => componentKeys.includes(key));
+        const importComponentConflicts = [
+            ...this.globalModulesWithScope.flatMap(({ module: globalModule }) => this.componentProcessor.getExportedComponentKeys(globalModule)),
+            ...resolvedImports.flatMap((importItem) => this.componentProcessor.getExportedComponentKeys(importItem)),
+        ].filter((key) => componentKeys.includes(key));
+        const conflicts = [...providerConflicts, ...importComponentConflicts];
+        if (conflicts.length > 0) {
+            throw new REACT_ERRORS.ComponentNameConflictError(m.name, conflicts);
+        }
+    }
+    beforeRegisterProviders(m) {
+        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);
+            }
+        }
+    }
+    afterRegisterProviders(m, scope) {
+        this.componentProcessor.processComponents(m, scope);
+    }
+    hasScopedProviderLifetime(provider) {
+        return (typeof provider === "object" &&
+            provider !== null &&
+            ("useClass" in provider || "useFactory" in provider) &&
+            "lifetime" in provider &&
+            provider.lifetime === Awilix.Lifetime.SCOPED);
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { Module, ModuleDefinition } from "./react-module.types.js";
+export type ModuleOptions = {
+    hashNameFrom?: unknown;
+    hashLength?: number;
+};
+export declare function createModule<TDef extends ModuleDefinition>(module: Module<TDef>, options?: ModuleOptions): Module<TDef>;

package/dist/lib/react/react-module-factories.js

@@ -0,0 +1,34 @@
+export function createModule(module, options) {
+    if (options?.hashNameFrom === undefined) {
+        return module;
+    }
+    const hash = hashString(stableStringify(options.hashNameFrom)).slice(0, Math.max(4, options.hashLength ?? 8));
+    return {
+        ...module,
+        name: `${module.name}_${hash}`,
+    };
+}
+function hashString(value) {
+    let hash = 5381;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = (hash * 33) ^ value.charCodeAt(index);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function stableStringify(value) {
+    return JSON.stringify(sortRecursively(value));
+}
+function sortRecursively(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortRecursively);
+    }
+    if (value && typeof value === "object") {
+        return Object.keys(value)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = sortRecursively(value[key]);
+            return acc;
+        }, {});
+    }
+    return value;
+}