lakutata/src/lib/ioc/LoadModules.mjs

An IoC-based universal application framework.

import { pathToFileURL as t } from "url";

import { Lifetime as e } from "./Lifetime.mjs";

import { RESOLVER as o, asClass as r, asFunction as s } from "./Resolvers.mjs";

import { isFunction as n, isClass as i } from "./Utils.mjs";

import { CamelCase as m } from "../base/internal/CamelCase.mjs";

import { As as a } from "../helpers/As.mjs";

import "./Errors.mjs";

import "../../exceptions/di/DependencyInjectionException.mjs";

import "../base/abstracts/Exception.mjs";

import "../base/internal/BasicInfo.mjs";

import "../../../vendor/Package.6.mjs";

import "../../../vendor/Package.5.mjs";

import "../../../vendor/Package.7.mjs";

import "../base/internal/ThrowWarning.mjs";

import "../helpers/Templating.mjs";

import "../helpers/NoCase.mjs";

import "../base/internal/ConstructorSymbol.mjs";

import "../../constants/DIMetadataKey.mjs";

import "../../../vendor/Package.4.mjs";

import "node:crypto";

import "../../../vendor/Package.2.mjs";

import "../../../vendor/Package.1.mjs";

import "../base/internal/DataValidator.mjs";

import "node:util/types";

import "../validation/VLD.mjs";

import "../../../vendor/Package.11.mjs";

import "../../../vendor/Package.10.mjs";

import "util";

import "../../exceptions/dto/InvalidValueException.mjs";

import "../../../vendor/Package.9.mjs";

import "../helpers/IsHtml.mjs";

import "../helpers/IsXML.mjs";

import "../../constants/DTOMetadataKey.mjs";

import "../helpers/ObjectConstructor.mjs";

import "../helpers/ObjectParentConstructors.mjs";

import "../helpers/ObjectParentConstructor.mjs";

import "../helpers/ObjectPrototype.mjs";

import "./InjectionMode.mjs";

import "./ParamParser.mjs";

import "./FunctionTokenizer.mjs";


// -- Shims --
import cjsUrl from 'node:url';
import cjsPath from 'node:path';
import cjsModule from 'node:module';
const __filename = cjsUrl.fileURLToPath(import.meta.url);
const __dirname = cjsPath.dirname(__filename);
const require = cjsModule.createRequire(import.meta.url);
const p = {
    camelCase: t => m(t)
};

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

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

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

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

function f(t) {
    return {
        resolverOptions: {
            lifetime: e.TRANSIENT,
            ...t && t.resolverOptions
        },
        ...t
    };
}

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

export { c as loadModules };