lakutata 2.0.82 → 2.0.83

package/src/lib/ioc/DependencyInjectionContainer.mjs

@@ -4,21 +4,21 @@ import { DependencyInjectionRegistrationError as t, DependencyInjectionResolutio
 
 import { InjectionMode as n } from "./InjectionMode.mjs";
 
-import { Lifetime as i, isLifetimeLonger as s } from "./Lifetime.mjs";
+import { Lifetime as s, isLifetimeLonger as i } from "./Lifetime.mjs";
 
-import { listModules as a } from "./ListModules.mjs";
+import { listModules as c } from "./ListModules.mjs";
 
-import { loadModules as c } from "./LoadModules.mjs";
+import { loadModules as a } from "./LoadModules.mjs";
 
-import { asClass as m, asFunction as l } from "./Resolvers.mjs";
+import { asClass as m, asFunction as p } from "./Resolvers.mjs";
 
-import { last as p, nameValueToObject as u, isClass as f } from "./Utils.mjs";
+import { last as l, nameValueToObject as u, isClass as f } from "./Utils.mjs";
 
 import { GetObjectLifetime as d } from "../base/internal/ObjectLifetime.mjs";
 
-import { As as g } from "../helpers/As.mjs";
+import { As as j } from "../helpers/As.mjs";
 
-import { AppendObjectWeakRefs as j } from "../base/internal/ObjectWeakRefs.mjs";
+import { AppendObjectWeakRefs as g } from "../base/internal/ObjectWeakRefs.mjs";
 
 import "../../exceptions/di/DependencyInjectionException.mjs";
 
@@ -106,40 +106,40 @@ 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 importModule(e) {
+function h(e) {
     return import(e);
 }
 
-const h = Symbol("familyTree");
+const b = Symbol("familyTree");
 
-const b = Symbol("rollUpRegistrations");
+const v = Symbol("rollUpRegistrations");
 
-const v = "DependencyInjectionContainerCradle";
+const y = "DependencyInjectionContainerCradle";
 
-function createContainer(e = {}) {
-    return createContainerInternal(e);
+function w(e = {}) {
+    return O(e);
 }
 
-function createContainerInternal(y, S, w) {
-    y = {
+function O(P, k, S) {
+    P = {
         injectionMode: n.PROXY,
         strict: false,
-        ...y
+        ...P
     };
-    const R = w ?? [];
-    const O = {};
-    const P = new Proxy({
-        [e.inspect.custom]: toStringRepresentationFn
+    const I = S ?? [];
+    const N = {};
+    const T = new Proxy({
+        [e.inspect.custom]: $
     }, {
-        get: (e, t) => resolve(t),
+        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(P);
+            return Array.from(T);
         },
         getOwnPropertyDescriptor(e, t) {
-            const r = rollUpRegistrations();
+            const r = M();
             if (Object.getOwnPropertyDescriptor(r, t)) {
                 return {
                     enumerable: true,
@@ -149,210 +149,210 @@ function createContainerInternal(y, S, w) {
             return undefined;
         }
     });
-    const I = {
-        options: y,
-        cradle: P,
-        inspect,
+    const E = {
+        options: P,
+        cradle: T,
+        inspect: D,
         cache: new Map,
-        loadModules: loadModules$1,
-        createScope,
-        register,
-        build,
-        resolve,
-        hasRegistration,
-        dispose,
-        getRegistration,
-        [e.inspect.custom]: inspect,
-        [b]: rollUpRegistrations,
+        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 rollUpRegistrations();
+            return M();
         }
     };
-    const k = S ? [ I ].concat(g(S)[h]) : [ I ];
-    I[h] = k;
-    const C = p(k);
-    return I;
-    function inspect() {
-        return `[DependencyInjectionContainer (${S ? "scoped, " : ""}registrations: ${Object.keys(I.registrations).length})]`;
+    const L = k ? [ E ].concat(j(k)[b]) : [ E ];
+    E[b] = L;
+    const C = l(L);
+    return E;
+    function D() {
+        return `[DependencyInjectionContainer (${k ? "scoped, " : ""}registrations: ${Object.keys(E.registrations).length})]`;
     }
-    function rollUpRegistrations() {
+    function M() {
         return {
-            ...S && S[b](),
-            ...O
+            ...k && k[v](),
+            ...N
         };
     }
-    function* cradleIterator() {
-        const e = rollUpRegistrations();
+    function* R() {
+        const e = M();
         for (const t in e) {
             yield t;
         }
     }
-    function createScope() {
-        return createContainerInternal(y, I, R);
+    function x() {
+        return O(P, E, I);
     }
-    function register(e, r) {
+    function A(e, r) {
         const o = u(e, r);
         const n = [ ...Object.keys(o), ...Object.getOwnPropertySymbols(o) ];
         for (const e of n) {
             const r = o[e];
-            if (y.strict && r.lifetime === i.SINGLETON) {
-                if (S) {
+            if (P.strict && r.lifetime === s.SINGLETON) {
+                if (k) {
                     throw new t(e, "Cannot register a singleton on a scoped container.");
                 }
             }
-            O[e] = r;
+            N[e] = r;
         }
-        return I;
+        return E;
     }
-    function toStringRepresentationFn() {
-        return Object.prototype.toString.call(P);
+    function $() {
+        return Object.prototype.toString.call(T);
     }
-    function getRegistration(e) {
-        const t = O[e];
+    function U(e) {
+        const t = N[e];
         if (t) {
             return t;
         }
-        if (S) {
-            return S.getRegistration(e);
+        if (k) {
+            return k.getRegistration(e);
         }
         return null;
     }
-    function resolve(t, o) {
+    function q(t, o) {
         o = o || {};
         try {
-            const n = getRegistration(t);
-            if (R.some((({name: e}) => e === t))) {
-                throw new r(t, R, "Cyclic dependencies detected.");
+            const n = U(t);
+            if (I.some((({name: e}) => e === t))) {
+                throw new r(t, I, "Cyclic dependencies detected.");
             }
             if (t === "toJSON") {
-                return toStringRepresentationFn;
+                return $;
             }
             if (t === "constructor") {
-                return createContainer;
+                return w;
             }
             if (!n) {
                 switch (t) {
                   case e.inspect.custom:
                   case "inspect":
                   case "toString":
-                    return toStringRepresentationFn;
+                    return $;
 
                   case Symbol.toStringTag:
-                    return v;
+                    return y;
 
                   case "then":
                     return undefined;
 
                   case Symbol.iterator:
-                    return cradleIterator;
+                    return R;
                 }
                 if (o.allowUnregistered) {
                     return undefined;
                 }
-                throw new r(t, R);
+                throw new r(t, I);
             }
-            const a = n.lifetime || i.TRANSIENT;
-            if (y.strict && !n.isLeakSafe) {
-                const e = R.findIndex((({lifetime: e}) => s(e, a)));
+            const c = n.lifetime || s.TRANSIENT;
+            if (P.strict && !n.isLeakSafe) {
+                const e = I.findIndex((({lifetime: e}) => i(e, c)));
                 if (e > -1) {
-                    throw new r(t, R, `Dependency '${t.toString()}' has a shorter lifetime than its ancestor: '${R[e].name.toString()}'`);
+                    throw new r(t, I, `Dependency '${t.toString()}' has a shorter lifetime than its ancestor: '${I[e].name.toString()}'`);
                 }
             }
-            R.push({
+            I.push({
                 name: t,
-                lifetime: a
+                lifetime: c
             });
-            let c;
+            let a;
             let m;
-            switch (a) {
-              case i.TRANSIENT:
-                m = n.resolve(I);
+            switch (c) {
+              case s.TRANSIENT:
+                m = n.resolve(E);
                 break;
 
-              case i.APPLICATION_SINGLETON:
-                c = C.cache.get(t);
-                if (!c) {
-                    m = n.resolve(y.strict ? C : I);
+              case s.APPLICATION_SINGLETON:
+                a = C.cache.get(t);
+                if (!a) {
+                    m = n.resolve(P.strict ? C : E);
                     C.cache.set(t, {
                         resolver: n,
                         value: m
                     });
                 } else {
-                    m = c.value;
+                    m = a.value;
                 }
                 break;
 
-              case i.MODULE_SINGLETON:
-              case i.SINGLETON:
-                c = I.cache.get(t);
-                if (c !== undefined) {
-                    m = c.value;
+              case s.MODULE_SINGLETON:
+              case s.SINGLETON:
+                a = E.cache.get(t);
+                if (a !== undefined) {
+                    m = a.value;
                     break;
                 }
-                m = n.resolve(I);
-                I.cache.set(t, {
+                m = n.resolve(E);
+                E.cache.set(t, {
                     resolver: n,
                     value: m
                 });
                 break;
 
-              case i.SCOPED:
-                c = I.cache.get(t);
-                if (c !== undefined) {
-                    m = c.value;
+              case s.SCOPED:
+                a = E.cache.get(t);
+                if (a !== undefined) {
+                    m = a.value;
                     break;
                 }
-                m = n.resolve(I);
-                I.cache.set(t, {
+                m = n.resolve(E);
+                E.cache.set(t, {
                     resolver: n,
                     value: m
                 });
                 break;
 
               default:
-                throw new r(t, R, `Unknown lifetime "${n.lifetime}"`);
+                throw new r(t, I, `Unknown lifetime "${n.lifetime}"`);
             }
-            R.pop();
-            if (d(m.constructor) === i.TRANSIENT) j(this, m);
+            I.pop();
+            if (d(m.constructor) === s.TRANSIENT) g(this, m);
             return m;
         } catch (e) {
-            R.length = 0;
+            I.length = 0;
             throw e;
         }
     }
-    function hasRegistration(e) {
-        return !!getRegistration(e);
+    function G(e) {
+        return !!U(e);
     }
-    function build(e, t) {
+    function K(e, t) {
         if (e && e.resolve) {
-            return e.resolve(I);
+            return e.resolve(E);
         }
         const r = "build";
         const n = "targetOrResolver";
         o.assert(e, r, n, "a registration, function or class", e);
         o.assert(typeof e === "function", r, n, "a function or class", e);
-        const i = f(e) ? m(e, t) : l(e, t);
-        return i.resolve(I);
+        const s = f(e) ? m(e, t) : p(e, t);
+        return s.resolve(E);
     }
-    function loadModules$1(e, t) {
+    function V(e, t) {
         const r = {
-            require: y.require || function(e) {
+            require: P.require || function(e) {
                 return require(e);
             },
-            listModules: a,
-            container: I
+            listModules: c,
+            container: E
         };
         if (t?.esModules) {
-            r.require = importModule;
-            return c(r, e, t).then((() => I));
+            r.require = h;
+            return a(r, e, t).then((() => E));
         } else {
-            c(r, e, t);
-            return I;
+            a(r, e, t);
+            return E;
         }
     }
-    async function dispose() {
-        const e = Array.from(I.cache.entries());
-        I.cache.clear();
+    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 o = t;
@@ -365,4 +365,4 @@ function createContainerInternal(y, S, w) {
     }
 }
 
-export { createContainer };
+export { w as createContainer };