lakutata 2.0.81 → 2.0.82

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