lakutata/src/lib/ioc/DependencyInjectionContainer.mjs

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
import * as e from "util";

import { DependencyInjectionRegistrationError as t, DependencyInjectionResolutionError as r, DependencyInjectionTypeError as n } from "./Errors.mjs";

import { InjectionMode as o } from "./InjectionMode.mjs";

import { Lifetime as s, isLifetimeLonger as i } from "./Lifetime.mjs";

import { listModules as c } from "./ListModules.mjs";

import { loadModules as a } from "./LoadModules.mjs";

import { asClass as m, asFunction as l } from "./Resolvers.mjs";

import { last as p, nameValueToObject as u, isClass as f } from "./Utils.mjs";

import { GetObjectLifetime as d } from "../base/internal/ObjectLifetime.mjs";

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

import { AppendObjectWeakRefs as h } from "../base/internal/ObjectWeakRefs.mjs";

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

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

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

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

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

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

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

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

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

import "../helpers/DevNull.mjs";

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

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

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

import "node:crypto";

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

import "../../../vendor/Package.internal.3.mjs";

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

import "node:util/types";

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

import "url";

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

import "../../../vendor/Package.internal.8.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 "os";

import "path";

import "stream";

import "events";

import "fs";

import "./ParamParser.mjs";

import "./FunctionTokenizer.mjs";

import "../../exceptions/di/LifetimeLockedException.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);
function g(e) {
    return import(e);
}

const b = Symbol("familyTree");

const v = Symbol("rollUpRegistrations");

const y = "DependencyInjectionContainerCradle";

function w(e = {}) {
    return O(e);
}

function O(P, S, k) {
    P = {
        injectionMode: o.PROXY,
        strict: false,
        ...P
    };
    const I = k ?? [];
    const N = {};
    const T = new Proxy({
        [e.inspect.custom]: $
    }, {
        get: (e, t) => q(t),
        set: (e, t) => {
            throw new Error(`Attempted setting property "${t}" on container cradle - this is not allowed.`);
        },
        ownKeys() {
            return Array.from(T);
        },
        getOwnPropertyDescriptor(e, t) {
            const r = M();
            if (Object.getOwnPropertyDescriptor(r, t)) {
                return {
                    enumerable: true,
                    configurable: true
                };
            }
            return undefined;
        }
    });
    const E = {
        options: P,
        cradle: T,
        inspect: D,
        cache: new Map,
        loadModules: V,
        createScope: x,
        register: A,
        build: K,
        resolve: q,
        hasRegistration: G,
        dispose: W,
        getRegistration: U,
        [e.inspect.custom]: D,
        [v]: M,
        get registrations() {
            return M();
        }
    };
    const L = S ? [ E ].concat(j(S)[b]) : [ E ];
    E[b] = L;
    const C = p(L);
    return E;
    function D() {
        return `[DependencyInjectionContainer (${S ? "scoped, " : ""}registrations: ${Object.keys(E.registrations).length})]`;
    }
    function M() {
        return {
            ...S && S[v](),
            ...N
        };
    }
    function* R() {
        const e = M();
        for (const t in e) {
            yield t;
        }
    }
    function x() {
        return O(P, E, I);
    }
    function A(e, r) {
        const n = u(e, r);
        const o = [ ...Object.keys(n), ...Object.getOwnPropertySymbols(n) ];
        for (const e of o) {
            const r = n[e];
            if (P.strict && r.lifetime === s.SINGLETON) {
                if (S) {
                    throw new t(e, "Cannot register a singleton on a scoped container.");
                }
            }
            N[e] = r;
        }
        return E;
    }
    function $() {
        return Object.prototype.toString.call(T);
    }
    function U(e) {
        const t = N[e];
        if (t) {
            return t;
        }
        if (S) {
            return S.getRegistration(e);
        }
        return null;
    }
    function q(t, n) {
        n = n || {};
        try {
            const o = U(t);
            if (I.some(({name: e}) => e === t)) {
                throw new r(t, I, "Cyclic dependencies detected.");
            }
            if (t === "toJSON") {
                return $;
            }
            if (t === "constructor") {
                return w;
            }
            if (!o) {
                switch (t) {
                  case e.inspect.custom:
                  case "inspect":
                  case "toString":
                    return $;

                  case Symbol.toStringTag:
                    return y;

                  case "then":
                    return undefined;

                  case Symbol.iterator:
                    return R;
                }
                if (n.allowUnregistered) {
                    return undefined;
                }
                throw new r(t, I);
            }
            const c = o.lifetime || s.TRANSIENT;
            if (P.strict && !o.isLeakSafe) {
                const e = I.findIndex(({lifetime: e}) => i(e, c));
                if (e > -1) {
                    throw new r(t, I, `Dependency '${t.toString()}' has a shorter lifetime than its ancestor: '${I[e].name.toString()}'`);
                }
            }
            I.push({
                name: t,
                lifetime: c
            });
            let a;
            let m;
            switch (c) {
              case s.TRANSIENT:
                m = o.resolve(E);
                break;

              case s.APPLICATION_SINGLETON:
                a = C.cache.get(t);
                if (!a) {
                    m = o.resolve(P.strict ? C : E);
                    C.cache.set(t, {
                        resolver: o,
                        value: m
                    });
                } else {
                    m = a.value;
                }
                break;

              case s.MODULE_SINGLETON:
              case s.SINGLETON:
                a = E.cache.get(t);
                if (a !== undefined) {
                    m = a.value;
                    break;
                }
                m = o.resolve(E);
                E.cache.set(t, {
                    resolver: o,
                    value: m
                });
                break;

              case s.SCOPED:
                a = E.cache.get(t);
                if (a !== undefined) {
                    m = a.value;
                    break;
                }
                m = o.resolve(E);
                E.cache.set(t, {
                    resolver: o,
                    value: m
                });
                break;

              default:
                throw new r(t, I, `Unknown lifetime "${o.lifetime}"`);
            }
            I.pop();
            if (d(m.constructor) === s.TRANSIENT) h(this, m);
            return m;
        } catch (e) {
            I.length = 0;
            throw e;
        }
    }
    function G(e) {
        return !!U(e);
    }
    function K(e, t) {
        if (e && e.resolve) {
            return e.resolve(E);
        }
        const r = "build";
        const o = "targetOrResolver";
        n.assert(e, r, o, "a registration, function or class", e);
        n.assert(typeof e === "function", r, o, "a function or class", e);
        const s = f(e) ? m(e, t) : l(e, t);
        return s.resolve(E);
    }
    function V(e, t) {
        const r = {
            require: P.require || function(e) {
                return require(e);
            },
            listModules: c,
            container: E
        };
        if (t?.esModules) {
            r.require = g;
            return a(r, e, t).then(() => E);
        } else {
            a(r, e, t);
            return E;
        }
    }
    async function W() {
        const e = Array.from(E.cache.entries());
        E.cache.clear();
        return Promise.all(e.map(async ([, e]) => {
            const {resolver: t, value: r} = e;
            const n = t;
            if (n.dispose) {
                await Promise.resolve();
                return n.dispose(r);
            }
            return Promise.resolve();
        })).then(() => undefined);
    }
}

export { w as createContainer };