lakutata 2.0.80 → 2.0.82

package/src/lib/ioc/Resolvers.cjs

@@ -8,9 +8,9 @@ const e = require("./Errors.cjs");
 
 const r = require("./InjectionMode.cjs");
 
-const n = require("./Lifetime.cjs");
+const t = require("./Lifetime.cjs");
 
-const t = require("./ParamParser.cjs");
+const n = require("./ParamParser.cjs");
 
 const i = require("./Utils.cjs");
 
@@ -78,50 +78,50 @@ require("../helpers/ObjectPrototype.cjs");
 
 require("./FunctionTokenizer.cjs");
 
-const o = Symbol("Dependency Injection Resolver Config");
+const s = Symbol("Dependency Injection Resolver Config");
 
-function s(e) {
+function asValue(e) {
     return {
         resolve: () => e,
         isLeakSafe: true
     };
 }
 
-function c(r, t) {
+function asFunction(r, n) {
     if (!i.isFunction(r)) {
         throw new e.DependencyInjectionTypeError("asFunction", "fn", "function", r);
     }
-    const s = {
-        lifetime: n.Lifetime.TRANSIENT
+    const o = {
+        lifetime: t.Lifetime.TRANSIENT
     };
-    t = p(s, t, r[o]);
-    const c = h(r);
-    const u = {
+    n = makeOptions(o, n, r[s]);
+    const c = generateResolve(r);
+    const a = {
         resolve: c,
-        ...t
+        ...n
     };
-    return f(l(u));
+    return createDisposableResolver(createBuildResolver(a));
 }
 
-function u(r, t) {
+function asClass(r, n) {
     if (!i.isFunction(r)) {
         throw new e.DependencyInjectionTypeError("asClass", "Type", "class", r);
     }
-    const s = {
-        lifetime: n.Lifetime.TRANSIENT
+    const o = {
+        lifetime: t.Lifetime.TRANSIENT
     };
-    t = p(s, t, r[o]);
-    const c = function e(...n) {
-        return Reflect.construct(r, n);
+    n = makeOptions(o, n, r[s]);
+    const c = function newClass(...e) {
+        return Reflect.construct(r, e);
     };
-    const u = h(c, r);
-    return f(l({
-        ...t,
-        resolve: u
+    const a = generateResolve(c, r);
+    return createDisposableResolver(createBuildResolver({
+        ...n,
+        resolve: a
     }));
 }
 
-function a(e) {
+function aliasTo(e) {
     return {
         resolve(r) {
             return r.resolve(e);
@@ -130,101 +130,101 @@ function a(e) {
     };
 }
 
-function l(e) {
-    function t(e) {
-        return l({
+function createBuildResolver(e) {
+    function setLifetime(e) {
+        return createBuildResolver({
             ...this,
             lifetime: e
         });
     }
-    function i(e) {
-        return l({
+    function setInjectionMode(e) {
+        return createBuildResolver({
             ...this,
             injectionMode: e
         });
     }
-    function o(e) {
-        return l({
+    function inject(e) {
+        return createBuildResolver({
             ...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)
+    return updateResolver(e, {
+        setLifetime,
+        inject,
+        transient: partial(setLifetime, t.Lifetime.TRANSIENT),
+        scoped: partial(setLifetime, t.Lifetime.SCOPED),
+        singleton: partial(setLifetime, t.Lifetime.SINGLETON),
+        setInjectionMode,
+        proxy: partial(setInjectionMode, r.InjectionMode.PROXY),
+        classic: partial(setInjectionMode, r.InjectionMode.CLASSIC)
     });
 }
 
-function f(e) {
-    function r(e) {
-        return f({
+function createDisposableResolver(e) {
+    function disposer(e) {
+        return createDisposableResolver({
             ...this,
             dispose: e
         });
     }
-    return d(e, {
-        disposer: r
+    return updateResolver(e, {
+        disposer
     });
 }
 
-function j(e, r) {
-    return function n() {
+function partial(e, r) {
+    return function partiallyApplied() {
         return e.call(this, r);
     };
 }
 
-function p(e, ...r) {
+function makeOptions(e, ...r) {
     return Object.assign({}, e, ...r);
 }
 
-function d(e, r) {
-    const n = {
+function updateResolver(e, r) {
+    const t = {
         ...e,
         ...r
     };
-    return n;
+    return t;
 }
 
-function q(e, r) {
-    return function n(t, i) {
+function wrapWithLocals(e, r) {
+    return function wrappedResolve(t, n) {
         if (t in r) {
             return r[t];
         }
-        return e.resolve(t, i);
+        return e.resolve(t, n);
     };
 }
 
-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() {
+function createInjectorProxy(e, r) {
+    const t = r(e);
+    const n = i.uniq([ ...Reflect.ownKeys(e.cradle), ...Reflect.ownKeys(t) ]);
+    const s = new Proxy({}, {
+        get(r, n) {
+            if (n === Symbol.iterator) {
+                return function* iterateRegistrationsAndLocals() {
                     for (const r in e.cradle) {
                         yield r;
                     }
-                    for (const e in n) {
+                    for (const e in t) {
                         yield e;
                     }
                 };
             }
-            if (t in n) {
-                return n[t];
+            if (n in t) {
+                return t[n];
             }
-            return e.resolve(t);
+            return e.resolve(n);
         },
         ownKeys() {
-            return t;
+            return n;
         },
         getOwnPropertyDescriptor(e, r) {
-            if (t.indexOf(r) > -1) {
+            if (n.indexOf(r) > -1) {
                 return {
                     enumerable: true,
                     configurable: true
@@ -233,49 +233,49 @@ function y(e, r) {
             return undefined;
         }
     });
-    return o;
+    return s;
 }
 
-function h(e, n) {
-    if (!n) {
-        n = e;
+function generateResolve(e, t) {
+    if (!t) {
+        t = e;
     }
-    const t = m(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;
+    const n = parseDependencies(t);
+    return function resolve(t) {
+        const i = this.injectionMode || t.options.injectionMode || r.InjectionMode.PROXY;
+        if (i !== r.InjectionMode.CLASSIC) {
+            const r = this.injector ? createInjectorProxy(t, this.injector) : t.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, {
+        if (n.length > 0) {
+            const r = this.injector ? wrapWithLocals(t, this.injector(t)) : t.resolve;
+            const i = n.map((e => r(e.name, {
                 allowUnregistered: e.optional
             })));
-            return e(...n);
+            return e(...i);
         }
         return e();
     };
 }
 
-function m(e) {
-    const r = t.parseParameterList(e.toString());
+function parseDependencies(e) {
+    const r = n.parseParameterList(e.toString());
     if (!r) {
         const r = Object.getPrototypeOf(e);
         if (typeof r === "function" && r !== Function.prototype) {
-            return m(r);
+            return parseDependencies(r);
         }
         return [];
     }
     return r;
 }
 
-exports.RESOLVER = o;
+exports.RESOLVER = s;
 
-exports.aliasTo = a;
+exports.aliasTo = aliasTo;
 
-exports.asClass = u;
+exports.asClass = asClass;
 
-exports.asFunction = c;
+exports.asFunction = asFunction;
 
-exports.asValue = s;
+exports.asValue = asValue;

package/src/lib/ioc/Resolvers.mjs

@@ -1,10 +1,10 @@
-import { DependencyInjectionTypeError as t } from "./Errors.mjs";
+import { DependencyInjectionTypeError as e } from "./Errors.mjs";
 
-import { InjectionMode as e } from "./InjectionMode.mjs";
+import { InjectionMode as t } from "./InjectionMode.mjs";
 
-import { Lifetime as n } from "./Lifetime.mjs";
+import { Lifetime as r } from "./Lifetime.mjs";
 
-import { parseParameterList as r } from "./ParamParser.mjs";
+import { parseParameterList as n } from "./ParamParser.mjs";
 
 import { isFunction as o, uniq as i } from "./Utils.mjs";
 
@@ -74,151 +74,151 @@ import "./FunctionTokenizer.mjs";
 
 const s = Symbol("Dependency Injection Resolver Config");
 
-function c(t) {
+function asValue(e) {
     return {
-        resolve: () => t,
+        resolve: () => e,
         isLeakSafe: true
     };
 }
 
-function m(e, r) {
-    if (!o(e)) {
-        throw new t("asFunction", "fn", "function", e);
+function asFunction(t, n) {
+    if (!o(t)) {
+        throw new e("asFunction", "fn", "function", t);
     }
     const i = {
-        lifetime: n.TRANSIENT
+        lifetime: r.TRANSIENT
     };
-    r = j(i, r, e[s]);
-    const c = g(e);
-    const m = {
-        resolve: c,
-        ...r
+    n = makeOptions(i, n, t[s]);
+    const a = generateResolve(t);
+    const c = {
+        resolve: a,
+        ...n
     };
-    return f(p(m));
+    return createDisposableResolver(createBuildResolver(c));
 }
 
-function a(e, r) {
-    if (!o(e)) {
-        throw new t("asClass", "Type", "class", e);
+function asClass(t, n) {
+    if (!o(t)) {
+        throw new e("asClass", "Type", "class", t);
     }
     const i = {
-        lifetime: n.TRANSIENT
+        lifetime: r.TRANSIENT
     };
-    r = j(i, r, e[s]);
-    const c = function t(...n) {
-        return Reflect.construct(e, n);
+    n = makeOptions(i, n, t[s]);
+    const a = function newClass(...e) {
+        return Reflect.construct(t, e);
     };
-    const m = g(c, e);
-    return f(p({
-        ...r,
-        resolve: m
+    const c = generateResolve(a, t);
+    return createDisposableResolver(createBuildResolver({
+        ...n,
+        resolve: c
     }));
 }
 
-function u(t) {
+function aliasTo(e) {
     return {
-        resolve(e) {
-            return e.resolve(t);
+        resolve(t) {
+            return t.resolve(e);
         },
         isLeakSafe: true
     };
 }
 
-function p(t) {
-    function r(t) {
-        return p({
+function createBuildResolver(e) {
+    function setLifetime(e) {
+        return createBuildResolver({
             ...this,
-            lifetime: t
+            lifetime: e
         });
     }
-    function o(t) {
-        return p({
+    function setInjectionMode(e) {
+        return createBuildResolver({
             ...this,
-            injectionMode: t
+            injectionMode: e
         });
     }
-    function i(t) {
-        return p({
+    function inject(e) {
+        return createBuildResolver({
             ...this,
-            injector: t
+            injector: e
         });
     }
-    return d(t, {
-        setLifetime: r,
-        inject: i,
-        transient: l(r, n.TRANSIENT),
-        scoped: l(r, n.SCOPED),
-        singleton: l(r, n.SINGLETON),
-        setInjectionMode: o,
-        proxy: l(o, e.PROXY),
-        classic: l(o, e.CLASSIC)
+    return updateResolver(e, {
+        setLifetime,
+        inject,
+        transient: partial(setLifetime, r.TRANSIENT),
+        scoped: partial(setLifetime, r.SCOPED),
+        singleton: partial(setLifetime, r.SINGLETON),
+        setInjectionMode,
+        proxy: partial(setInjectionMode, t.PROXY),
+        classic: partial(setInjectionMode, t.CLASSIC)
     });
 }
 
-function f(t) {
-    function e(t) {
-        return f({
+function createDisposableResolver(e) {
+    function disposer(e) {
+        return createDisposableResolver({
             ...this,
-            dispose: t
+            dispose: e
         });
     }
-    return d(t, {
-        disposer: e
+    return updateResolver(e, {
+        disposer
     });
 }
 
-function l(t, e) {
-    return function n() {
-        return t.call(this, e);
+function partial(e, t) {
+    return function partiallyApplied() {
+        return e.call(this, t);
     };
 }
 
-function j(t, ...e) {
-    return Object.assign({}, t, ...e);
+function makeOptions(e, ...t) {
+    return Object.assign({}, e, ...t);
 }
 
-function d(t, e) {
-    const n = {
-        ...t,
-        ...e
+function updateResolver(e, t) {
+    const r = {
+        ...e,
+        ...t
     };
-    return n;
+    return r;
 }
 
-function h(t, e) {
-    return function n(r, o) {
-        if (r in e) {
-            return e[r];
+function wrapWithLocals(e, t) {
+    return function wrappedResolve(r, n) {
+        if (r in t) {
+            return t[r];
         }
-        return t.resolve(r, o);
+        return e.resolve(r, n);
     };
 }
 
-function y(t, e) {
-    const n = e(t);
-    const r = i([ ...Reflect.ownKeys(t.cradle), ...Reflect.ownKeys(n) ]);
+function createInjectorProxy(e, t) {
+    const r = t(e);
+    const n = i([ ...Reflect.ownKeys(e.cradle), ...Reflect.ownKeys(r) ]);
     const o = new Proxy({}, {
-        get(e, r) {
-            if (r === Symbol.iterator) {
-                return function* e() {
-                    for (const e in t.cradle) {
-                        yield e;
-                    }
-                    for (const t in n) {
+        get(t, n) {
+            if (n === Symbol.iterator) {
+                return function* iterateRegistrationsAndLocals() {
+                    for (const t in e.cradle) {
                         yield t;
                     }
+                    for (const e in r) {
+                        yield e;
+                    }
                 };
             }
-            if (r in n) {
-                return n[r];
+            if (n in r) {
+                return r[n];
             }
-            return t.resolve(r);
+            return e.resolve(n);
         },
         ownKeys() {
-            return r;
+            return n;
         },
-        getOwnPropertyDescriptor(t, e) {
-            if (r.indexOf(e) > -1) {
+        getOwnPropertyDescriptor(e, t) {
+            if (n.indexOf(t) > -1) {
                 return {
                     enumerable: true,
                     configurable: true
@@ -230,38 +230,38 @@ function y(t, e) {
     return o;
 }
 
-function g(t, n) {
-    if (!n) {
-        n = t;
+function generateResolve(e, r) {
+    if (!r) {
+        r = e;
     }
-    const r = b(n);
-    return function n(o) {
-        const i = this.injectionMode || o.options.injectionMode || e.PROXY;
-        if (i !== e.CLASSIC) {
-            const e = this.injector ? y(o, this.injector) : o.cradle;
-            return t(e);
+    const n = parseDependencies(r);
+    return function resolve(r) {
+        const o = this.injectionMode || r.options.injectionMode || t.PROXY;
+        if (o !== t.CLASSIC) {
+            const t = this.injector ? createInjectorProxy(r, this.injector) : r.cradle;
+            return e(t);
         }
-        if (r.length > 0) {
-            const e = this.injector ? h(o, this.injector(o)) : o.resolve;
-            const n = r.map((t => e(t.name, {
-                allowUnregistered: t.optional
+        if (n.length > 0) {
+            const t = this.injector ? wrapWithLocals(r, this.injector(r)) : r.resolve;
+            const o = n.map((e => t(e.name, {
+                allowUnregistered: e.optional
             })));
-            return t(...n);
+            return e(...o);
         }
-        return t();
+        return e();
     };
 }
 
-function b(t) {
-    const e = r(t.toString());
-    if (!e) {
-        const e = Object.getPrototypeOf(t);
-        if (typeof e === "function" && e !== Function.prototype) {
-            return b(e);
+function parseDependencies(e) {
+    const t = n(e.toString());
+    if (!t) {
+        const t = Object.getPrototypeOf(e);
+        if (typeof t === "function" && t !== Function.prototype) {
+            return parseDependencies(t);
         }
         return [];
     }
-    return e;
+    return t;
 }
 
-export { s as RESOLVER, u as aliasTo, a as asClass, m as asFunction, c as asValue };
+export { s as RESOLVER, aliasTo, asClass, asFunction, asValue };

package/src/lib/ioc/Utils.cjs

@@ -60,7 +60,7 @@ require("../helpers/ObjectParentConstructor.cjs");
 
 require("../helpers/ObjectPrototype.cjs");
 
-function s(e) {
+function flatten(e) {
     const r = [];
     e.forEach((e => {
         e.forEach((e => {
@@ -70,7 +70,7 @@ function s(e) {
     return r;
 }
 
-function n(e, s) {
+function nameValueToObject(e, s) {
     const n = e;
     if (typeof n === "string" || r.IsSymbol(n)) return {
         [e]: s
@@ -78,11 +78,11 @@ function n(e, s) {
     return t.As(n);
 }
 
-function c(e) {
+function last(e) {
     return e[e.length - 1];
 }
 
-function i(r) {
+function isClass(r) {
     if (typeof r !== "function") return false;
     const t = e.createTokenizer(r.toString());
     const s = t.next();
@@ -96,22 +96,22 @@ function i(r) {
     return false;
 }
 
-function o(e) {
+function isFunction(e) {
     return typeof e === "function";
 }
 
-function u(e) {
+function uniq(e) {
     return Array.from(new Set(e));
 }
 
-exports.flatten = s;
+exports.flatten = flatten;
 
-exports.isClass = i;
+exports.isClass = isClass;
 
-exports.isFunction = o;
+exports.isFunction = isFunction;
 
-exports.last = c;
+exports.last = last;
 
-exports.nameValueToObject = n;
+exports.nameValueToObject = nameValueToObject;
 
-exports.uniq = u;
+exports.uniq = uniq;