lakutata 2.0.82 → 2.0.83

package/src/lib/ioc/Resolvers.cjs

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

package/src/lib/ioc/Resolvers.mjs

@@ -1,10 +1,10 @@
-import { DependencyInjectionTypeError as e } from "./Errors.mjs";
+import { DependencyInjectionTypeError as t } from "./Errors.mjs";
 
-import { InjectionMode as t } from "./InjectionMode.mjs";
+import { InjectionMode as e } from "./InjectionMode.mjs";
 
-import { Lifetime as r } from "./Lifetime.mjs";
+import { Lifetime as n } from "./Lifetime.mjs";
 
-import { parseParameterList as n } from "./ParamParser.mjs";
+import { parseParameterList as r } 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 asValue(e) {
+function c(t) {
     return {
-        resolve: () => e,
+        resolve: () => t,
         isLeakSafe: true
     };
 }
 
-function asFunction(t, n) {
-    if (!o(t)) {
-        throw new e("asFunction", "fn", "function", t);
+function m(e, r) {
+    if (!o(e)) {
+        throw new t("asFunction", "fn", "function", e);
     }
     const i = {
-        lifetime: r.TRANSIENT
+        lifetime: n.TRANSIENT
     };
-    n = makeOptions(i, n, t[s]);
-    const a = generateResolve(t);
-    const c = {
-        resolve: a,
-        ...n
+    r = j(i, r, e[s]);
+    const c = g(e);
+    const m = {
+        resolve: c,
+        ...r
     };
-    return createDisposableResolver(createBuildResolver(c));
+    return f(p(m));
 }
 
-function asClass(t, n) {
-    if (!o(t)) {
-        throw new e("asClass", "Type", "class", t);
+function a(e, r) {
+    if (!o(e)) {
+        throw new t("asClass", "Type", "class", e);
     }
     const i = {
-        lifetime: r.TRANSIENT
+        lifetime: n.TRANSIENT
     };
-    n = makeOptions(i, n, t[s]);
-    const a = function newClass(...e) {
-        return Reflect.construct(t, e);
+    r = j(i, r, e[s]);
+    const c = function t(...n) {
+        return Reflect.construct(e, n);
     };
-    const c = generateResolve(a, t);
-    return createDisposableResolver(createBuildResolver({
-        ...n,
-        resolve: c
+    const m = g(c, e);
+    return f(p({
+        ...r,
+        resolve: m
     }));
 }
 
-function aliasTo(e) {
+function u(t) {
     return {
-        resolve(t) {
-            return t.resolve(e);
+        resolve(e) {
+            return e.resolve(t);
         },
         isLeakSafe: true
     };
 }
 
-function createBuildResolver(e) {
-    function setLifetime(e) {
-        return createBuildResolver({
+function p(t) {
+    function r(t) {
+        return p({
             ...this,
-            lifetime: e
+            lifetime: t
         });
     }
-    function setInjectionMode(e) {
-        return createBuildResolver({
+    function o(t) {
+        return p({
             ...this,
-            injectionMode: e
+            injectionMode: t
         });
     }
-    function inject(e) {
-        return createBuildResolver({
+    function i(t) {
+        return p({
             ...this,
-            injector: e
+            injector: t
         });
     }
-    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)
+    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)
     });
 }
 
-function createDisposableResolver(e) {
-    function disposer(e) {
-        return createDisposableResolver({
+function f(t) {
+    function e(t) {
+        return f({
             ...this,
-            dispose: e
+            dispose: t
         });
     }
-    return updateResolver(e, {
-        disposer
+    return d(t, {
+        disposer: e
     });
 }
 
-function partial(e, t) {
-    return function partiallyApplied() {
-        return e.call(this, t);
+function l(t, e) {
+    return function n() {
+        return t.call(this, e);
     };
 }
 
-function makeOptions(e, ...t) {
-    return Object.assign({}, e, ...t);
+function j(t, ...e) {
+    return Object.assign({}, t, ...e);
 }
 
-function updateResolver(e, t) {
-    const r = {
-        ...e,
-        ...t
+function d(t, e) {
+    const n = {
+        ...t,
+        ...e
     };
-    return r;
+    return n;
 }
 
-function wrapWithLocals(e, t) {
-    return function wrappedResolve(r, n) {
-        if (r in t) {
-            return t[r];
+function h(t, e) {
+    return function n(r, o) {
+        if (r in e) {
+            return e[r];
         }
-        return e.resolve(r, n);
+        return t.resolve(r, o);
     };
 }
 
-function createInjectorProxy(e, t) {
-    const r = t(e);
-    const n = i([ ...Reflect.ownKeys(e.cradle), ...Reflect.ownKeys(r) ]);
+function y(t, e) {
+    const n = e(t);
+    const r = i([ ...Reflect.ownKeys(t.cradle), ...Reflect.ownKeys(n) ]);
     const o = new Proxy({}, {
-        get(t, n) {
-            if (n === Symbol.iterator) {
-                return function* iterateRegistrationsAndLocals() {
-                    for (const t in e.cradle) {
-                        yield t;
-                    }
-                    for (const e in r) {
+        get(e, r) {
+            if (r === Symbol.iterator) {
+                return function* e() {
+                    for (const e in t.cradle) {
                         yield e;
                     }
+                    for (const t in n) {
+                        yield t;
+                    }
                 };
             }
-            if (n in r) {
-                return r[n];
+            if (r in n) {
+                return n[r];
             }
-            return e.resolve(n);
+            return t.resolve(r);
         },
         ownKeys() {
-            return n;
+            return r;
         },
-        getOwnPropertyDescriptor(e, t) {
-            if (n.indexOf(t) > -1) {
+        getOwnPropertyDescriptor(t, e) {
+            if (r.indexOf(e) > -1) {
                 return {
                     enumerable: true,
                     configurable: true
@@ -230,38 +230,38 @@ function createInjectorProxy(e, t) {
     return o;
 }
 
-function generateResolve(e, r) {
-    if (!r) {
-        r = e;
+function g(t, n) {
+    if (!n) {
+        n = t;
     }
-    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);
+    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);
         }
-        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
+        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
             })));
-            return e(...o);
+            return t(...n);
         }
-        return e();
+        return t();
     };
 }
 
-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);
+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);
         }
         return [];
     }
-    return t;
+    return e;
 }
 
-export { s as RESOLVER, aliasTo, asClass, asFunction, asValue };
+export { s as RESOLVER, u as aliasTo, a as asClass, m as asFunction, c as asValue };

package/src/lib/ioc/Utils.cjs

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