@husky-di/module 1.0.0

package/README.md

@@ -0,0 +1,23 @@
+# Rslib project
+
+## Setup
+
+Install the dependencies:
+
+```bash
+pnpm install
+```
+
+## Get started
+
+Build the library:
+
+```bash
+pnpm build
+```
+
+Build the library in watch mode:
+
+```bash
+pnpm dev
+```

package/dist/factories/exported-guard-middleware.factory.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @overview
+ * @author AEPKILL
+ * @created 2025-08-18 22:01:34
+ */
+import { type ResolveMiddleware, type ServiceIdentifier } from "@husky-di/core";
+export declare function createExportedGuardMiddlewareFactory(exports: ServiceIdentifier<unknown>[]): ResolveMiddleware<any, any>;

package/dist/factories/module.factory.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @overview
+ * @author AEPKILL
+ * @created 2025-08-09 21:57:05
+ */
+import type { CreateModuleOptions, IModule } from "../interfaces/module.interface";
+export declare function createModule(options: CreateModuleOptions): IModule;

package/dist/impls/module.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @overview
+ * @author AEPKILL
+ * @created 2025-08-09 14:51:09
+ */
+import type { IContainer, IsRegisteredOptions, ResolveInstance, ResolveMiddleware, ResolveOptions, ServiceIdentifier } from "@husky-di/core";
+import type { Alias, CreateModuleOptions, Declaration, IModule, ModuleWithAliases } from "../interfaces/module.interface";
+export declare class Module implements IModule {
+    get id(): string;
+    get name(): string;
+    get declarations(): Declaration<unknown>[] | undefined;
+    get exports(): ServiceIdentifier<unknown>[] | undefined;
+    get imports(): (IModule | ModuleWithAliases)[] | undefined;
+    get displayName(): string;
+    readonly container: IContainer;
+    private _id;
+    private _name;
+    private _declarations?;
+    private _imports?;
+    private _exports?;
+    constructor(options: CreateModuleOptions);
+    resolve<T, O extends ResolveOptions<T>>(serviceIdentifier: ServiceIdentifier<T>, options?: O): ResolveInstance<T, O>;
+    isRegistered<T>(serviceIdentifier: ServiceIdentifier<T>, options?: IsRegisteredOptions): boolean;
+    getServiceIdentifiers(): ServiceIdentifier<unknown>[];
+    use(middleware: ResolveMiddleware<any, any>): void;
+    unused(middleware: ResolveMiddleware<any, any>): void;
+    withAliases(aliases: Alias[]): ModuleWithAliases;
+}

package/dist/index.cjs

@@ -0,0 +1,281 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createModule: ()=>createModule
+});
+const core_namespaceObject = require("@husky-di/core");
+function createExportedGuardMiddlewareFactory(exports1) {
+    const exportedSet = new Set(exports1);
+    return {
+        name: "ExportGuard",
+        executor (params, next) {
+            const { serviceIdentifier, container, resolveRecord } = params;
+            const previousContainer = findPreviousContainer(resolveRecord.getPaths());
+            if (previousContainer === container) return next(params);
+            if (!exportedSet.has(serviceIdentifier)) {
+                if (container.isRegistered(serviceIdentifier, {
+                    recursive: true
+                })) throw new core_namespaceObject.ResolveException(`Service identifier "${(0, core_namespaceObject.getServiceIdentifierName)(serviceIdentifier)}" is not exported from ${container.displayName}.`, resolveRecord);
+            }
+            return next(params);
+        }
+    };
+}
+function findPreviousContainer(paths) {
+    let lastContainer;
+    for (const path of paths)if ((0, core_namespaceObject.isResolveServiceIdentifierRecord)(path.value)) {
+        if (lastContainer) return path.value.container;
+        lastContainer = path.value.container;
+    }
+}
+function isModuleWithAliases(moduleImport) {
+    return moduleImport.module instanceof Module;
+}
+function getModuleByImport(moduleImport) {
+    return isModuleWithAliases(moduleImport) ? moduleImport.module : moduleImport;
+}
+function build(module) {
+    const builder = new ModuleBuilder(module);
+    return builder.build();
+}
+class ModuleBuilder {
+    module;
+    serviceIdentifierMap = new Map();
+    availableServiceIdentifiers = new Set();
+    importAliasesCache = new Map();
+    constructor(module){
+        this.module = module;
+    }
+    build() {
+        this.validateAndCollectInfo();
+        if (this.module.container) return this.module.container;
+        const container = (0, core_namespaceObject.createContainer)(this.module.name);
+        if (this.module.exports?.length) container.use(createExportedGuardMiddlewareFactory(this.module.exports));
+        this.registerDeclarations(container);
+        this.registerImports(container);
+        return container;
+    }
+    validateAndCollectInfo() {
+        this.validateImportUniqueness();
+        this.validateExportUniqueness();
+        this.validateCircularDependencies();
+        this.collectServiceInfoAndValidateConflicts();
+        this.validateExportValidity();
+    }
+    validateImportUniqueness() {
+        const { imports } = this.module;
+        if (!imports?.length) return;
+        const importModules = new Set();
+        for (const importModule of imports)try {
+            const importedModule = getModuleByImport(importModule);
+            if (importModules.has(importedModule)) throw new Error(`Duplicate import module: "${importedModule.displayName}" in "${this.module.displayName}".`);
+            importModules.add(importedModule);
+        } catch (error) {
+            throw new Error(`Invalid module import in "${this.module.displayName}": ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    validateExportUniqueness() {
+        const { exports: exports1 } = this.module;
+        if (!exports1?.length) return;
+        const existingExportServiceIdentifiers = new Set();
+        for (const exported of exports1){
+            if (existingExportServiceIdentifiers.has(exported)) throw new Error(`Duplicate export service identifier: "${(0, core_namespaceObject.getServiceIdentifierName)(exported)}" in "${this.module.displayName}".`);
+            existingExportServiceIdentifiers.add(exported);
+        }
+    }
+    validateCircularDependencies() {
+        const visited = new Set();
+        const visiting = new Set();
+        const dependencyPath = [];
+        this.detectCircularDependency(this.module, visited, visiting, dependencyPath);
+    }
+    detectCircularDependency(currentModule, visited, visiting, dependencyPath) {
+        if (visited.has(currentModule)) return;
+        if (visiting.has(currentModule)) {
+            const cycleStartIndex = dependencyPath.findIndex((module)=>module === currentModule);
+            const cyclePath = dependencyPath.slice(cycleStartIndex).concat(currentModule).map((module)=>module.displayName).join(" -> ");
+            throw new Error(`Circular dependency detected: ${cyclePath}. Modules cannot have circular import relationships.`);
+        }
+        visiting.add(currentModule);
+        dependencyPath.push(currentModule);
+        const imports = currentModule.imports ?? [];
+        for (const importModule of imports)try {
+            const importedModule = getModuleByImport(importModule);
+            this.detectCircularDependency(importedModule, visited, visiting, dependencyPath);
+        } catch (error) {
+            if (error instanceof Error && error.message.includes("Circular dependency detected")) throw error;
+            throw new Error(`Failed to validate circular dependencies for "${currentModule.displayName}": ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        visiting.delete(currentModule);
+        dependencyPath.pop();
+        visited.add(currentModule);
+    }
+    collectServiceInfoAndValidateConflicts() {
+        const { imports, declarations } = this.module;
+        if (declarations?.length) for (const declaration of declarations){
+            this.serviceIdentifierMap.set(declaration.serviceIdentifier, {
+                type: "declaration",
+                source: "declarations"
+            });
+            this.availableServiceIdentifiers.add(declaration.serviceIdentifier);
+        }
+        if (imports?.length) for (const importModule of imports)try {
+            const importedModule = getModuleByImport(importModule);
+            const exportedServices = importedModule.exports ?? [];
+            const aliasesMap = this.buildAndCacheAliasesMap(importModule, importedModule);
+            for (const exported of exportedServices){
+                const existing = this.serviceIdentifierMap.get(exported);
+                if (existing) {
+                    const conflictInfo = {
+                        serviceName: (0, core_namespaceObject.getServiceIdentifierName)(exported),
+                        currentModule: importedModule.displayName,
+                        existing,
+                        targetModule: this.module.displayName
+                    };
+                    throw new Error(this.buildConflictMessage(conflictInfo));
+                }
+                this.serviceIdentifierMap.set(exported, {
+                    type: "import",
+                    source: importedModule.displayName
+                });
+                this.availableServiceIdentifiers.add(exported);
+                const alias = aliasesMap.get(exported);
+                if (alias) this.availableServiceIdentifiers.add(alias);
+            }
+        } catch (error) {
+            throw new Error(`Failed to validate imports in "${this.module.displayName}": ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    validateExportValidity() {
+        const { exports: exports1 } = this.module;
+        if (!exports1?.length) return;
+        for (const exported of exports1)if (!this.availableServiceIdentifiers.has(exported)) throw new Error(`Cannot export service identifier "${(0, core_namespaceObject.getServiceIdentifierName)(exported)}" from "${this.module.displayName}": it is not declared in this module or imported from any imported module.`);
+    }
+    buildAndCacheAliasesMap(importModule, importedModule) {
+        const cached = this.importAliasesCache.get(importedModule);
+        if (cached) return cached;
+        const aliasesMap = new Map();
+        const moduleWithAliases = importModule;
+        const aliases = moduleWithAliases.aliases ?? [];
+        for (const alias of aliases)aliasesMap.set(alias.serviceIdentifier, alias.as);
+        this.importAliasesCache.set(importedModule, aliasesMap);
+        return aliasesMap;
+    }
+    registerDeclarations(container) {
+        const { declarations } = this.module;
+        if (!declarations?.length) return;
+        for (const declaration of declarations){
+            const { serviceIdentifier, ...rest } = declaration;
+            container.register(serviceIdentifier, rest);
+        }
+    }
+    registerImports(container) {
+        const { imports } = this.module;
+        if (!imports?.length) return;
+        for (const importModule of imports){
+            const importedModule = getModuleByImport(importModule);
+            const aliasesMap = this.importAliasesCache.get(importedModule) ?? new Map();
+            for (const exported of importedModule.exports ?? [])container.register(aliasesMap.get(exported) ?? exported, {
+                useAlias: exported,
+                getContainer () {
+                    return importedModule.container;
+                }
+            });
+        }
+    }
+    buildConflictMessage(conflictInfo) {
+        const { serviceName, currentModule, existing, targetModule } = conflictInfo;
+        const conflictType = "declaration" === existing.type ? "declared in" : "exported by";
+        const conflictSource = existing.source;
+        return `Service identifier conflict: "${serviceName}" is exported by "${currentModule}" and ${conflictType} "${conflictSource}" in "${targetModule}".`;
+    }
+}
+const createModuleId = (0, core_namespaceObject.incrementalIdFactory)("MODULE");
+class Module {
+    get id() {
+        return this._id;
+    }
+    get name() {
+        return this._name;
+    }
+    get declarations() {
+        return this._declarations;
+    }
+    get exports() {
+        return this._exports;
+    }
+    get imports() {
+        return this._imports;
+    }
+    get displayName() {
+        return `${String(this._name)}#${this._id}`;
+    }
+    container;
+    _id;
+    _name;
+    _declarations;
+    _imports;
+    _exports;
+    constructor(options){
+        this._id = createModuleId();
+        this._name = options.name;
+        this._declarations = options.declarations;
+        this._imports = options.imports;
+        this._exports = options.exports;
+        this.container = build(this);
+    }
+    resolve(serviceIdentifier, options) {
+        return this.container.resolve(serviceIdentifier, options);
+    }
+    isRegistered(serviceIdentifier, options) {
+        return this.container.isRegistered(serviceIdentifier, options);
+    }
+    getServiceIdentifiers() {
+        return this.container.getServiceIdentifiers();
+    }
+    use(middleware) {
+        this.container.use(middleware);
+    }
+    unused(middleware) {
+        this.container.unused(middleware);
+    }
+    withAliases(aliases) {
+        return {
+            module: this,
+            aliases
+        };
+    }
+}
+function createModule(options) {
+    return new Module(options);
+}
+exports.createModule = __webpack_exports__.createModule;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createModule"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @overview
+ * @author AEPKILL
+ * @created 2025-08-12 22:53:27
+ */
+export { createModule } from "./factories/module.factory";
+export type { CreateModuleOptions, IModule, } from "./interfaces/module.interface";

package/dist/index.js

@@ -0,0 +1,247 @@
+import { ResolveException, createContainer, getServiceIdentifierName, incrementalIdFactory, isResolveServiceIdentifierRecord } from "@husky-di/core";
+function createExportedGuardMiddlewareFactory(exports) {
+    const exportedSet = new Set(exports);
+    return {
+        name: "ExportGuard",
+        executor (params, next) {
+            const { serviceIdentifier, container, resolveRecord } = params;
+            const previousContainer = findPreviousContainer(resolveRecord.getPaths());
+            if (previousContainer === container) return next(params);
+            if (!exportedSet.has(serviceIdentifier)) {
+                if (container.isRegistered(serviceIdentifier, {
+                    recursive: true
+                })) throw new ResolveException(`Service identifier "${getServiceIdentifierName(serviceIdentifier)}" is not exported from ${container.displayName}.`, resolveRecord);
+            }
+            return next(params);
+        }
+    };
+}
+function findPreviousContainer(paths) {
+    let lastContainer;
+    for (const path of paths)if (isResolveServiceIdentifierRecord(path.value)) {
+        if (lastContainer) return path.value.container;
+        lastContainer = path.value.container;
+    }
+}
+function isModuleWithAliases(moduleImport) {
+    return moduleImport.module instanceof Module;
+}
+function getModuleByImport(moduleImport) {
+    return isModuleWithAliases(moduleImport) ? moduleImport.module : moduleImport;
+}
+function build(module) {
+    const builder = new ModuleBuilder(module);
+    return builder.build();
+}
+class ModuleBuilder {
+    module;
+    serviceIdentifierMap = new Map();
+    availableServiceIdentifiers = new Set();
+    importAliasesCache = new Map();
+    constructor(module){
+        this.module = module;
+    }
+    build() {
+        this.validateAndCollectInfo();
+        if (this.module.container) return this.module.container;
+        const container = createContainer(this.module.name);
+        if (this.module.exports?.length) container.use(createExportedGuardMiddlewareFactory(this.module.exports));
+        this.registerDeclarations(container);
+        this.registerImports(container);
+        return container;
+    }
+    validateAndCollectInfo() {
+        this.validateImportUniqueness();
+        this.validateExportUniqueness();
+        this.validateCircularDependencies();
+        this.collectServiceInfoAndValidateConflicts();
+        this.validateExportValidity();
+    }
+    validateImportUniqueness() {
+        const { imports } = this.module;
+        if (!imports?.length) return;
+        const importModules = new Set();
+        for (const importModule of imports)try {
+            const importedModule = getModuleByImport(importModule);
+            if (importModules.has(importedModule)) throw new Error(`Duplicate import module: "${importedModule.displayName}" in "${this.module.displayName}".`);
+            importModules.add(importedModule);
+        } catch (error) {
+            throw new Error(`Invalid module import in "${this.module.displayName}": ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    validateExportUniqueness() {
+        const { exports } = this.module;
+        if (!exports?.length) return;
+        const existingExportServiceIdentifiers = new Set();
+        for (const exported of exports){
+            if (existingExportServiceIdentifiers.has(exported)) throw new Error(`Duplicate export service identifier: "${getServiceIdentifierName(exported)}" in "${this.module.displayName}".`);
+            existingExportServiceIdentifiers.add(exported);
+        }
+    }
+    validateCircularDependencies() {
+        const visited = new Set();
+        const visiting = new Set();
+        const dependencyPath = [];
+        this.detectCircularDependency(this.module, visited, visiting, dependencyPath);
+    }
+    detectCircularDependency(currentModule, visited, visiting, dependencyPath) {
+        if (visited.has(currentModule)) return;
+        if (visiting.has(currentModule)) {
+            const cycleStartIndex = dependencyPath.findIndex((module)=>module === currentModule);
+            const cyclePath = dependencyPath.slice(cycleStartIndex).concat(currentModule).map((module)=>module.displayName).join(" -> ");
+            throw new Error(`Circular dependency detected: ${cyclePath}. Modules cannot have circular import relationships.`);
+        }
+        visiting.add(currentModule);
+        dependencyPath.push(currentModule);
+        const imports = currentModule.imports ?? [];
+        for (const importModule of imports)try {
+            const importedModule = getModuleByImport(importModule);
+            this.detectCircularDependency(importedModule, visited, visiting, dependencyPath);
+        } catch (error) {
+            if (error instanceof Error && error.message.includes("Circular dependency detected")) throw error;
+            throw new Error(`Failed to validate circular dependencies for "${currentModule.displayName}": ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        visiting.delete(currentModule);
+        dependencyPath.pop();
+        visited.add(currentModule);
+    }
+    collectServiceInfoAndValidateConflicts() {
+        const { imports, declarations } = this.module;
+        if (declarations?.length) for (const declaration of declarations){
+            this.serviceIdentifierMap.set(declaration.serviceIdentifier, {
+                type: "declaration",
+                source: "declarations"
+            });
+            this.availableServiceIdentifiers.add(declaration.serviceIdentifier);
+        }
+        if (imports?.length) for (const importModule of imports)try {
+            const importedModule = getModuleByImport(importModule);
+            const exportedServices = importedModule.exports ?? [];
+            const aliasesMap = this.buildAndCacheAliasesMap(importModule, importedModule);
+            for (const exported of exportedServices){
+                const existing = this.serviceIdentifierMap.get(exported);
+                if (existing) {
+                    const conflictInfo = {
+                        serviceName: getServiceIdentifierName(exported),
+                        currentModule: importedModule.displayName,
+                        existing,
+                        targetModule: this.module.displayName
+                    };
+                    throw new Error(this.buildConflictMessage(conflictInfo));
+                }
+                this.serviceIdentifierMap.set(exported, {
+                    type: "import",
+                    source: importedModule.displayName
+                });
+                this.availableServiceIdentifiers.add(exported);
+                const alias = aliasesMap.get(exported);
+                if (alias) this.availableServiceIdentifiers.add(alias);
+            }
+        } catch (error) {
+            throw new Error(`Failed to validate imports in "${this.module.displayName}": ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    validateExportValidity() {
+        const { exports } = this.module;
+        if (!exports?.length) return;
+        for (const exported of exports)if (!this.availableServiceIdentifiers.has(exported)) throw new Error(`Cannot export service identifier "${getServiceIdentifierName(exported)}" from "${this.module.displayName}": it is not declared in this module or imported from any imported module.`);
+    }
+    buildAndCacheAliasesMap(importModule, importedModule) {
+        const cached = this.importAliasesCache.get(importedModule);
+        if (cached) return cached;
+        const aliasesMap = new Map();
+        const moduleWithAliases = importModule;
+        const aliases = moduleWithAliases.aliases ?? [];
+        for (const alias of aliases)aliasesMap.set(alias.serviceIdentifier, alias.as);
+        this.importAliasesCache.set(importedModule, aliasesMap);
+        return aliasesMap;
+    }
+    registerDeclarations(container) {
+        const { declarations } = this.module;
+        if (!declarations?.length) return;
+        for (const declaration of declarations){
+            const { serviceIdentifier, ...rest } = declaration;
+            container.register(serviceIdentifier, rest);
+        }
+    }
+    registerImports(container) {
+        const { imports } = this.module;
+        if (!imports?.length) return;
+        for (const importModule of imports){
+            const importedModule = getModuleByImport(importModule);
+            const aliasesMap = this.importAliasesCache.get(importedModule) ?? new Map();
+            for (const exported of importedModule.exports ?? [])container.register(aliasesMap.get(exported) ?? exported, {
+                useAlias: exported,
+                getContainer () {
+                    return importedModule.container;
+                }
+            });
+        }
+    }
+    buildConflictMessage(conflictInfo) {
+        const { serviceName, currentModule, existing, targetModule } = conflictInfo;
+        const conflictType = "declaration" === existing.type ? "declared in" : "exported by";
+        const conflictSource = existing.source;
+        return `Service identifier conflict: "${serviceName}" is exported by "${currentModule}" and ${conflictType} "${conflictSource}" in "${targetModule}".`;
+    }
+}
+const createModuleId = incrementalIdFactory("MODULE");
+class Module {
+    get id() {
+        return this._id;
+    }
+    get name() {
+        return this._name;
+    }
+    get declarations() {
+        return this._declarations;
+    }
+    get exports() {
+        return this._exports;
+    }
+    get imports() {
+        return this._imports;
+    }
+    get displayName() {
+        return `${String(this._name)}#${this._id}`;
+    }
+    container;
+    _id;
+    _name;
+    _declarations;
+    _imports;
+    _exports;
+    constructor(options){
+        this._id = createModuleId();
+        this._name = options.name;
+        this._declarations = options.declarations;
+        this._imports = options.imports;
+        this._exports = options.exports;
+        this.container = build(this);
+    }
+    resolve(serviceIdentifier, options) {
+        return this.container.resolve(serviceIdentifier, options);
+    }
+    isRegistered(serviceIdentifier, options) {
+        return this.container.isRegistered(serviceIdentifier, options);
+    }
+    getServiceIdentifiers() {
+        return this.container.getServiceIdentifiers();
+    }
+    use(middleware) {
+        this.container.use(middleware);
+    }
+    unused(middleware) {
+        this.container.unused(middleware);
+    }
+    withAliases(aliases) {
+        return {
+            module: this,
+            aliases
+        };
+    }
+}
+function createModule(options) {
+    return new Module(options);
+}
+export { createModule };

package/dist/interfaces/module.interface.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @overview
+ * @author AEPKILL
+ * @created 2025-08-09 14:42:25
+ */
+import type { CreateRegistrationOptions, IContainer, IDisplayName, IUnique, ServiceIdentifier } from "@husky-di/core";
+export type Declaration<T> = CreateRegistrationOptions<T> & {
+    serviceIdentifier: ServiceIdentifier<T> | string;
+};
+export type Alias = {
+    serviceIdentifier: ServiceIdentifier<unknown>;
+    as: ServiceIdentifier<unknown>;
+};
+export type CreateModuleOptions = {
+    readonly name: string;
+    readonly declarations?: Declaration<unknown>[];
+    readonly imports?: Array<IModule | ModuleWithAliases>;
+    readonly exports?: ServiceIdentifier<unknown>[];
+};
+export type ModuleWithAliases = {
+    module: IModule;
+    aliases?: Alias[];
+};
+export interface IModule extends IUnique, IDisplayName, Pick<IContainer, "resolve" | "isRegistered" | "getServiceIdentifiers" | "use" | "unused"> {
+    readonly name: string;
+    readonly declarations?: Declaration<unknown>[];
+    readonly imports?: Array<IModule | ModuleWithAliases>;
+    readonly exports?: ServiceIdentifier<unknown>[];
+    readonly container: IContainer;
+    withAliases(aliases: Alias[]): ModuleWithAliases;
+}

package/dist/utils/module.utils.d.ts

@@ -0,0 +1,126 @@
+/**
+ * @overview 模块工具函数，包含模块构建和验证逻辑
+ * @author AEPKILL
+ * @created 2025-08-12 19:57:50
+ */
+import { type IContainer } from "@husky-di/core";
+import type { CreateModuleOptions, IModule, ModuleWithAliases } from "../interfaces/module.interface";
+/**
+ * 类型守卫：检查模块导入是否包含别名映射
+ *
+ * @param moduleImport 模块导入对象
+ * @returns 如果包含别名映射则返回 true，否则返回 false
+ */
+export declare function isModuleWithAliases(moduleImport: NonNullable<CreateModuleOptions["imports"]>[number]): moduleImport is ModuleWithAliases;
+/**
+ * 从模块导入中获取实际的模块对象
+ *
+ * @param moduleImport 模块导入（可能包含别名）
+ * @returns 实际的模块对象
+ */
+export declare function getModuleByImport(moduleImport: NonNullable<CreateModuleOptions["imports"]>[number]): IModule;
+/**
+ * 构建模块容器的公共函数
+ *
+ * @param module 要构建的模块
+ * @returns 构建好的容器
+ */
+export declare function build(module: IModule): IContainer;
+/**
+ * 模块构建器类，整合模块验证和构建逻辑
+ *
+ * 在验证过程中收集服务标识符信息，并在构建过程中复用这些信息
+ */
+export declare class ModuleBuilder {
+    /** 要构建的模块 */
+    private readonly module;
+    /** 服务标识符映射表（验证时构建，构建时复用） */
+    private readonly serviceIdentifierMap;
+    /** 可用服务标识符集合（验证时构建，构建时复用） */
+    private readonly availableServiceIdentifiers;
+    /** 导入模块的别名映射缓存 */
+    private readonly importAliasesCache;
+    constructor(module: IModule);
+    /**
+     * 构建模块容器
+     *
+     * @returns 构建好的容器
+     * @throws {Error} 当模块配置无效时抛出错误
+     */
+    build(): IContainer;
+    /**
+     * 验证模块并收集信息
+     *
+     * @throws {Error} 当模块配置无效时抛出错误
+     */
+    validateAndCollectInfo(): void;
+    /**
+     * 验证导入模块的唯一性
+     *
+     * @throws {Error} 当存在重复导入时抛出错误
+     */
+    private validateImportUniqueness;
+    /**
+     * 验证导出服务标识符的唯一性
+     *
+     * @throws {Error} 当存在重复导出时抛出错误
+     */
+    private validateExportUniqueness;
+    /**
+     * 验证循环依赖
+     *
+     * 使用深度优先搜索（DFS）算法检测模块之间的循环依赖
+     *
+     * @throws {Error} 当检测到循环依赖时抛出错误
+     */
+    private validateCircularDependencies;
+    /**
+     * 递归检测循环依赖的核心方法
+     *
+     * @param currentModule 当前检查的模块
+     * @param visited 已完全访问过的模块集合（白色节点）
+     * @param visiting 正在访问中的模块集合（灰色节点）
+     * @param dependencyPath 当前依赖路径，用于构建错误信息
+     * @throws {Error} 当检测到循环依赖时抛出错误
+     */
+    private detectCircularDependency;
+    /**
+     * 收集服务标识符信息并验证冲突
+     *
+     * @throws {Error} 当存在服务标识符冲突时抛出错误
+     */
+    private collectServiceInfoAndValidateConflicts;
+    /**
+     * 验证导出服务标识符的有效性
+     *
+     * @throws {Error} 当导出的服务标识符不可用时抛出错误
+     */
+    private validateExportValidity;
+    /**
+     * 构建并缓存别名映射
+     *
+     * @param importModule 导入模块配置
+     * @param importedModule 实际导入的模块
+     * @returns 别名映射
+     */
+    private buildAndCacheAliasesMap;
+    /**
+     * 注册声明的服务
+     *
+     * @param container 目标容器
+     */
+    private registerDeclarations;
+    /**
+     * 注册导入的服务
+     *
+     * @param container 目标容器
+     */
+    private registerImports;
+    /**
+     * 构建服务标识符冲突的详细错误消息
+     *
+     * @param conflictInfo 包含冲突详细信息的对象
+     * @returns 格式化的错误消息字符串
+     */
+    private buildConflictMessage;
+}

package/dist/utils/uuid.utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @overview
+ * @author AEPKILL
+ * @created 2025-08-09 14:55:21
+ */
+export declare const createModuleId: import("@husky-di/core").IdGenerator;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@husky-di/module",
+  "version": "1.0.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@husky-di/core": "1.0.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.11.2",
+    "@types/node": "^22.17.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "vitest run"
+  }
+}