lakutata/src/lib/ioc/Resolvers.cjs

An IoC-based universal application framework.

"use strict";

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

const e = require("./Errors.cjs");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

require("../../../vendor/Package.4.cjs");

require("node:crypto");

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

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

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

require("node:util/types");

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

require("../../../vendor/Package.11.cjs");

require("url");

require("../../../vendor/Package.10.cjs");

require("util");

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

require("../../../vendor/Package.9.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("./FunctionTokenizer.cjs");

const o = Symbol("Dependency Injection Resolver Config");

function s(e) {
    return {
        resolve: () => e,
        isLeakSafe: true
    };
}

function c(r, t) {
    if (!i.isFunction(r)) {
        throw new e.DependencyInjectionTypeError("asFunction", "fn", "function", r);
    }
    const s = {
        lifetime: n.Lifetime.TRANSIENT
    };
    t = p(s, t, r[o]);
    const c = g(r);
    const u = {
        resolve: c,
        ...t
    };
    return f(l(u));
}

function u(r, t) {
    if (!i.isFunction(r)) {
        throw new e.DependencyInjectionTypeError("asClass", "Type", "class", r);
    }
    const s = {
        lifetime: n.Lifetime.TRANSIENT
    };
    t = p(s, t, r[o]);
    const c = function e(...n) {
        return Reflect.construct(r, n);
    };
    const u = g(c, r);
    return f(l({
        ...t,
        resolve: u
    }));
}

function a(e) {
    return {
        resolve(r) {
            return r.resolve(e);
        },
        isLeakSafe: true
    };
}

function l(e) {
    function t(e) {
        return l({
            ...this,
            lifetime: e
        });
    }
    function i(e) {
        return l({
            ...this,
            injectionMode: e
        });
    }
    function o(e) {
        return l({
            ...this,
            injector: e
        });
    }
    return d(e, {
        setLifetime: t,
        inject: o,
        transient: j(t, n.Lifetime.TRANSIENT),
        scoped: j(t, n.Lifetime.SCOPED),
        singleton: j(t, n.Lifetime.SINGLETON),
        setInjectionMode: i,
        proxy: j(i, r.InjectionMode.PROXY),
        classic: j(i, r.InjectionMode.CLASSIC)
    });
}

function f(e) {
    function r(e) {
        return f({
            ...this,
            dispose: e
        });
    }
    return d(e, {
        disposer: r
    });
}

function j(e, r) {
    return function n() {
        return e.call(this, r);
    };
}

function p(e, ...r) {
    return Object.assign({}, e, ...r);
}

function d(e, r) {
    const n = {
        ...e,
        ...r
    };
    return n;
}

function q(e, r) {
    return function n(t, i) {
        if (t in r) {
            return r[t];
        }
        return e.resolve(t, i);
    };
}

function y(e, r) {
    const n = r(e);
    const t = i.uniq([ ...Reflect.ownKeys(e.cradle), ...Reflect.ownKeys(n) ]);
    const o = new Proxy({}, {
        get(r, t) {
            if (t === Symbol.iterator) {
                return function* r() {
                    for (const r in e.cradle) {
                        yield r;
                    }
                    for (const e in n) {
                        yield e;
                    }
                };
            }
            if (t in n) {
                return n[t];
            }
            return e.resolve(t);
        },
        ownKeys() {
            return t;
        },
        getOwnPropertyDescriptor(e, r) {
            if (t.indexOf(r) > -1) {
                return {
                    enumerable: true,
                    configurable: true
                };
            }
            return undefined;
        }
    });
    return o;
}

function g(e, n) {
    if (!n) {
        n = e;
    }
    const t = h(n);
    return function n(i) {
        const o = this.injectionMode || i.options.injectionMode || r.InjectionMode.PROXY;
        if (o !== r.InjectionMode.CLASSIC) {
            const r = this.injector ? y(i, this.injector) : i.cradle;
            return e(r);
        }
        if (t.length > 0) {
            const r = this.injector ? q(i, this.injector(i)) : i.resolve;
            const n = t.map((e => r(e.name, {
                allowUnregistered: e.optional
            })));
            return e(...n);
        }
        return e();
    };
}

function h(e) {
    const r = t.parseParameterList(e.toString());
    if (!r) {
        const r = Object.getPrototypeOf(e);
        if (typeof r === "function" && r !== Function.prototype) {
            return h(r);
        }
        return [];
    }
    return r;
}

exports.RESOLVER = o;

exports.aliasTo = a;

exports.asClass = u;

exports.asFunction = c;

exports.asValue = s;