lakutata 2.0.81 → 2.0.82

package/src/lib/helpers/UniqueArray.mjs

@@ -1,5 +1,5 @@
-function r(r) {
+function UniqueArray(r) {
     return Array.from(new Set(r));
 }
 
-export { r as UniqueArray };
+export { UniqueArray };

package/src/lib/helpers/UnsignedToHex.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-function t(t, e = 32) {
-    return BigInt(t).toString(16).toUpperCase().padStart(e / 4, "0");
+function UnsignedToHex(e, t = 32) {
+    return BigInt(e).toString(16).toUpperCase().padStart(t / 4, "0");
 }
 
-exports.UnsignedToHex = t;
+exports.UnsignedToHex = UnsignedToHex;

package/src/lib/helpers/UnsignedToHex.mjs

@@ -1,5 +1,5 @@
-function t(t, r = 32) {
-    return BigInt(t).toString(16).toUpperCase().padStart(r / 4, "0");
+function UnsignedToHex(n, t = 32) {
+    return BigInt(n).toString(16).toUpperCase().padStart(t / 4, "0");
 }
 
-export { t as UnsignedToHex };
+export { UnsignedToHex };

package/src/lib/ioc/DependencyInjectionContainer.cjs

@@ -14,9 +14,9 @@ const n = require("./Lifetime.cjs");
 
 const i = require("./ListModules.cjs");
 
-const s = require("./LoadModules.cjs");
+const o = require("./LoadModules.cjs");
 
-const o = require("./Resolvers.cjs");
+const s = require("./Resolvers.cjs");
 
 const c = require("./Utils.cjs");
 
@@ -104,7 +104,7 @@ require("./FunctionTokenizer.cjs");
 
 require("../../exceptions/di/LifetimeLockedException.cjs");
 
-function f(e) {
+function _interopNamespace(e) {
     if (e && e.__esModule) return e;
     const r = Object.create(null, {
         [Symbol.toStringTag]: {
@@ -126,42 +126,42 @@ function f(e) {
     return Object.freeze(r);
 }
 
-const d = f(e);
+const d = _interopNamespace(e);
 
-function j(e) {
+function importModule(e) {
     return import(e);
 }
 
 const p = Symbol("familyTree");
 
-const q = Symbol("rollUpRegistrations");
+const f = Symbol("rollUpRegistrations");
 
 const g = "DependencyInjectionContainerCradle";
 
-function m(e = {}) {
-    return b(e);
+function createContainer(e = {}) {
+    return createContainerInternal(e);
 }
 
-function b(e, f, y) {
+function createContainerInternal(e, j, m) {
     e = {
         injectionMode: t.InjectionMode.PROXY,
         strict: false,
         ...e
     };
-    const h = y ?? [];
-    const v = {};
-    const O = new Proxy({
-        [d.inspect.custom]: D
+    const q = m ?? [];
+    const b = {};
+    const y = new Proxy({
+        [d.inspect.custom]: toStringRepresentationFn
     }, {
-        get: (e, r) => C(r),
+        get: (e, r) => resolve(r),
         set: (e, r) => {
             throw new Error(`Attempted setting property "${r}" on container cradle - this is not allowed.`);
         },
         ownKeys() {
-            return Array.from(O);
+            return Array.from(y);
         },
         getOwnPropertyDescriptor(e, r) {
-            const t = S();
+            const t = rollUpRegistrations();
             if (Object.getOwnPropertyDescriptor(t, r)) {
                 return {
                     enumerable: true,
@@ -171,93 +171,93 @@ function b(e, f, y) {
             return undefined;
         }
     });
-    const P = {
+    const h = {
         options: e,
-        cradle: O,
-        inspect: L,
+        cradle: y,
+        inspect,
         cache: new Map,
-        loadModules: x,
-        createScope: E,
-        register: T,
-        build: R,
-        resolve: C,
-        hasRegistration: N,
-        dispose: A,
-        getRegistration: M,
-        [d.inspect.custom]: L,
-        [q]: S,
+        loadModules,
+        createScope,
+        register,
+        build,
+        resolve,
+        hasRegistration,
+        dispose,
+        getRegistration,
+        [d.inspect.custom]: inspect,
+        [f]: rollUpRegistrations,
         get registrations() {
-            return S();
+            return rollUpRegistrations();
         }
     };
-    const w = f ? [ P ].concat(u.As(f)[p]) : [ P ];
-    P[p] = w;
-    const I = c.last(w);
-    return P;
-    function L() {
-        return `[DependencyInjectionContainer (${f ? "scoped, " : ""}registrations: ${Object.keys(P.registrations).length})]`;
+    const v = j ? [ h ].concat(u.As(j)[p]) : [ h ];
+    h[p] = v;
+    const O = c.last(v);
+    return h;
+    function inspect() {
+        return `[DependencyInjectionContainer (${j ? "scoped, " : ""}registrations: ${Object.keys(h.registrations).length})]`;
     }
-    function S() {
+    function rollUpRegistrations() {
         return {
-            ...f && f[q](),
-            ...v
+            ...j && j[f](),
+            ...b
         };
     }
-    function* k() {
-        const e = S();
+    function* cradleIterator() {
+        const e = rollUpRegistrations();
         for (const r in e) {
             yield r;
         }
     }
-    function E() {
-        return b(e, P, h);
+    function createScope() {
+        return createContainerInternal(e, h, q);
     }
-    function T(t, i) {
-        const s = c.nameValueToObject(t, i);
-        const o = [ ...Object.keys(s), ...Object.getOwnPropertySymbols(s) ];
-        for (const t of o) {
-            const i = s[t];
+    function register(t, i) {
+        const o = c.nameValueToObject(t, i);
+        const s = [ ...Object.keys(o), ...Object.getOwnPropertySymbols(o) ];
+        for (const t of s) {
+            const i = o[t];
             if (e.strict && i.lifetime === n.Lifetime.SINGLETON) {
-                if (f) {
+                if (j) {
                     throw new r.DependencyInjectionRegistrationError(t, "Cannot register a singleton on a scoped container.");
                 }
             }
-            v[t] = i;
+            b[t] = i;
         }
-        return P;
+        return h;
     }
-    function D() {
-        return Object.prototype.toString.call(O);
+    function toStringRepresentationFn() {
+        return Object.prototype.toString.call(y);
     }
-    function M(e) {
-        const r = v[e];
+    function getRegistration(e) {
+        const r = b[e];
         if (r) {
             return r;
         }
-        if (f) {
-            return f.getRegistration(e);
+        if (j) {
+            return j.getRegistration(e);
         }
         return null;
     }
-    function C(t, i) {
+    function resolve(t, i) {
         i = i || {};
         try {
-            const s = M(t);
-            if (h.some((({name: e}) => e === t))) {
-                throw new r.DependencyInjectionResolutionError(t, h, "Cyclic dependencies detected.");
+            const o = getRegistration(t);
+            if (q.some((({name: e}) => e === t))) {
+                throw new r.DependencyInjectionResolutionError(t, q, "Cyclic dependencies detected.");
             }
             if (t === "toJSON") {
-                return D;
+                return toStringRepresentationFn;
             }
             if (t === "constructor") {
-                return m;
+                return createContainer;
             }
-            if (!s) {
+            if (!o) {
                 switch (t) {
                   case d.inspect.custom:
                   case "inspect":
                   case "toString":
-                    return D;
+                    return toStringRepresentationFn;
 
                   case Symbol.toStringTag:
                     return g;
@@ -266,37 +266,37 @@ function b(e, f, y) {
                     return undefined;
 
                   case Symbol.iterator:
-                    return k;
+                    return cradleIterator;
                 }
                 if (i.allowUnregistered) {
                     return undefined;
                 }
-                throw new r.DependencyInjectionResolutionError(t, h);
+                throw new r.DependencyInjectionResolutionError(t, q);
             }
-            const o = s.lifetime || n.Lifetime.TRANSIENT;
-            if (e.strict && !s.isLeakSafe) {
-                const e = h.findIndex((({lifetime: e}) => n.isLifetimeLonger(e, o)));
+            const s = o.lifetime || n.Lifetime.TRANSIENT;
+            if (e.strict && !o.isLeakSafe) {
+                const e = q.findIndex((({lifetime: e}) => n.isLifetimeLonger(e, s)));
                 if (e > -1) {
-                    throw new r.DependencyInjectionResolutionError(t, h, `Dependency '${t.toString()}' has a shorter lifetime than its ancestor: '${h[e].name.toString()}'`);
+                    throw new r.DependencyInjectionResolutionError(t, q, `Dependency '${t.toString()}' has a shorter lifetime than its ancestor: '${q[e].name.toString()}'`);
                 }
             }
-            h.push({
+            q.push({
                 name: t,
-                lifetime: o
+                lifetime: s
             });
             let c;
             let u;
-            switch (o) {
+            switch (s) {
               case n.Lifetime.TRANSIENT:
-                u = s.resolve(P);
+                u = o.resolve(h);
                 break;
 
               case n.Lifetime.APPLICATION_SINGLETON:
-                c = I.cache.get(t);
+                c = O.cache.get(t);
                 if (!c) {
-                    u = s.resolve(e.strict ? I : P);
-                    I.cache.set(t, {
-                        resolver: s,
+                    u = o.resolve(e.strict ? O : h);
+                    O.cache.set(t, {
+                        resolver: o,
                         value: u
                     });
                 } else {
@@ -306,75 +306,75 @@ function b(e, f, y) {
 
               case n.Lifetime.MODULE_SINGLETON:
               case n.Lifetime.SINGLETON:
-                c = P.cache.get(t);
+                c = h.cache.get(t);
                 if (c !== undefined) {
                     u = c.value;
                     break;
                 }
-                u = s.resolve(P);
-                P.cache.set(t, {
-                    resolver: s,
+                u = o.resolve(h);
+                h.cache.set(t, {
+                    resolver: o,
                     value: u
                 });
                 break;
 
               case n.Lifetime.SCOPED:
-                c = P.cache.get(t);
+                c = h.cache.get(t);
                 if (c !== undefined) {
                     u = c.value;
                     break;
                 }
-                u = s.resolve(P);
-                P.cache.set(t, {
-                    resolver: s,
+                u = o.resolve(h);
+                h.cache.set(t, {
+                    resolver: o,
                     value: u
                 });
                 break;
 
               default:
-                throw new r.DependencyInjectionResolutionError(t, h, `Unknown lifetime "${s.lifetime}"`);
+                throw new r.DependencyInjectionResolutionError(t, q, `Unknown lifetime "${o.lifetime}"`);
             }
-            h.pop();
+            q.pop();
             if (a.GetObjectLifetime(u.constructor) === n.Lifetime.TRANSIENT) l.AppendObjectWeakRefs(this, u);
             return u;
         } catch (e) {
-            h.length = 0;
+            q.length = 0;
             throw e;
         }
     }
-    function N(e) {
-        return !!M(e);
+    function hasRegistration(e) {
+        return !!getRegistration(e);
     }
-    function R(e, t) {
+    function build(e, t) {
         if (e && e.resolve) {
-            return e.resolve(P);
+            return e.resolve(h);
         }
         const n = "build";
         const i = "targetOrResolver";
         r.DependencyInjectionTypeError.assert(e, n, i, "a registration, function or class", e);
         r.DependencyInjectionTypeError.assert(typeof e === "function", n, i, "a function or class", e);
-        const s = c.isClass(e) ? o.asClass(e, t) : o.asFunction(e, t);
-        return s.resolve(P);
+        const o = c.isClass(e) ? s.asClass(e, t) : s.asFunction(e, t);
+        return o.resolve(h);
     }
-    function x(r, t) {
+    function loadModules(r, t) {
         const n = {
             require: e.require || function(e) {
                 return require(e);
             },
             listModules: i.listModules,
-            container: P
+            container: h
         };
         if (t?.esModules) {
-            n.require = j;
-            return s.loadModules(n, r, t).then((() => P));
+            n.require = importModule;
+            return o.loadModules(n, r, t).then((() => h));
         } else {
-            s.loadModules(n, r, t);
-            return P;
+            o.loadModules(n, r, t);
+            return h;
         }
     }
-    async function A() {
-        const e = Array.from(P.cache.entries());
-        P.cache.clear();
+    async function dispose() {
+        const e = Array.from(h.cache.entries());
+        h.cache.clear();
         return Promise.all(e.map((async ([, e]) => {
             const {resolver: r, value: t} = e;
             const n = r;
@@ -387,4 +387,4 @@ function b(e, f, y) {
     }
 }
 
-exports.createContainer = m;
+exports.createContainer = createContainer;