lakutata/src/lib/ioc/LoadModules.cjs

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

const e = require("url");

const r = require("./Lifetime.cjs");

const t = require("./Resolvers.cjs");

const s = require("./Utils.cjs");

const n = require("../base/internal/CamelCase.cjs");

const i = require("../helpers/As.cjs");

require("./Errors.cjs");

require("../../exceptions/di/DependencyInjectionException.cjs");

require("../base/abstracts/Exception.cjs");

require("../../../vendor/Package.internal.5.cjs");

require("../../../vendor/Package.internal.2.cjs");

require("../../../vendor/Package.internal.6.cjs");

require("../base/internal/ThrowWarning.cjs");

require("../helpers/Templating.cjs");

require("../helpers/DevNull.cjs");

require("../helpers/NoCase.cjs");

require("../base/internal/ConstructorSymbol.cjs");

require("../../constants/DIMetadataKey.cjs");

require("../../../vendor/Package.internal.1.cjs");

require("node:crypto");

require("../../../vendor/Package.internal.7.cjs");

require("../../../vendor/Package.internal.3.cjs");

require("../base/internal/DataValidator.cjs");

require("node:util/types");

require("../validation/VLD.cjs");

require("util");

require("../../exceptions/dto/InvalidValueException.cjs");

require("../../../vendor/Package.internal.8.cjs");

require("../helpers/IsHtml.cjs");

require("../helpers/IsXML.cjs");

require("../../constants/DTOMetadataKey.cjs");

require("../helpers/ObjectConstructor.cjs");

require("../helpers/ObjectParentConstructors.cjs");

require("../helpers/ObjectParentConstructor.cjs");

require("../helpers/ObjectPrototype.cjs");

require("./InjectionMode.cjs");

require("./ParamParser.cjs");

require("./FunctionTokenizer.cjs");

const o = {
    camelCase: e => n.CamelCase(e)
};

function a(e, r, t) {
    t ??= {};
    const s = e.container;
    t = p(t);
    const n = e.listModules(r, t);
    if (t.esModules) {
        return c(e, s, n, t);
    } else {
        const r = n.map(r => {
            const t = e.require(r.path);
            return u(t, r);
        });
        return l(r, s, n, t);
    }
}

async function c(r, t, s, n) {
    const o = [];
    for (const t of s) {
        const s = e.pathToFileURL(t.path).toString();
        o.push(i.As(r.require(s)));
    }
    const a = await Promise.all(o);
    const c = [];
    for (let e = 0; e < s.length; e++) {
        c.push(i.As(u(a[e], s[e])));
    }
    return l(c, t, s, n);
}

function u(e, r) {
    const n = [];
    if (!e) return n;
    if (s.isFunction(e)) {
        n.push({
            name: r.name,
            path: r.path,
            value: e,
            opts: r.opts
        });
        return n;
    }
    if (e.default && s.isFunction(e.default)) {
        n.push({
            name: r.name,
            path: r.path,
            value: e.default,
            opts: r.opts
        });
    }
    for (const i of Object.keys(e)) {
        if (i === "default") continue;
        if (s.isFunction(e[i]) && t.RESOLVER in e[i]) {
            n.push({
                name: i,
                path: r.path,
                value: e[i],
                opts: r.opts
            });
        }
    }
    return n;
}

function l(e, r, t, s) {
    e.reduce((e, r) => e.concat(r), []).filter(e => e).forEach(j.bind(null, r, s));
    return {
        loadedModules: t
    };
}

function p(e) {
    return {
        resolverOptions: {
            lifetime: r.Lifetime.TRANSIENT,
            ...e && e.resolverOptions
        },
        ...e
    };
}

function j(e, r, n) {
    const i = n.value[t.RESOLVER];
    let a = i && i.name;
    if (!a) {
        a = n.name;
        let e = r.formatName;
        if (e) {
            if (typeof e === "string") {
                e = o[e];
            }
            if (e) {
                a = e(a, n);
            }
        }
    }
    let c = n.opts;
    if (typeof c === "string") {
        c = {
            lifetime: c
        };
    }
    const u = {
        ...r.resolverOptions,
        ...c,
        ...i
    };
    const l = u.register ? u.register : s.isClass(n.value) ? t.asClass : t.asFunction;
    e.register(a, l(n.value, u));
}

exports.loadModules = a;