lakutata 2.0.82 → 2.0.83

package/src/lib/ioc/LoadModules.cjs

@@ -8,11 +8,11 @@ const e = require("url");
 
 const r = require("./Lifetime.cjs");
 
-const s = require("./Resolvers.cjs");
+const t = require("./Resolvers.cjs");
 
-const t = require("./Utils.cjs");
+const s = require("./Utils.cjs");
 
-const o = require("../base/internal/CamelCase.cjs");
+const n = require("../base/internal/CamelCase.cjs");
 
 const i = require("../helpers/As.cjs");
 
@@ -80,54 +80,54 @@ require("./ParamParser.cjs");
 
 require("./FunctionTokenizer.cjs");
 
-const n = {
-    camelCase: e => o.CamelCase(e)
+const o = {
+    camelCase: e => n.CamelCase(e)
 };
 
-function loadModules(e, r, s) {
-    s ??= {};
-    const t = e.container;
-    s = optsWithDefaults(s);
-    const o = e.listModules(r, s);
-    if (s.esModules) {
-        return loadEsModules(e, t, o, s);
+function c(e, r, t) {
+    t ??= {};
+    const s = e.container;
+    t = p(t);
+    const n = e.listModules(r, t);
+    if (t.esModules) {
+        return a(e, s, n, t);
     } else {
-        const r = o.map((r => {
-            const s = e.require(r.path);
-            return parseLoadedModule(s, r);
+        const r = n.map((r => {
+            const t = e.require(r.path);
+            return u(t, r);
         }));
-        return registerModules(r, t, o, s);
+        return l(r, s, n, t);
     }
 }
 
-async function loadEsModules(r, s, t, o) {
-    const n = [];
-    for (const s of t) {
-        const t = e.pathToFileURL(s.path).toString();
-        n.push(i.As(r.require(t)));
+async function a(r, t, s, n) {
+    const o = [];
+    for (const t of s) {
+        const s = e.pathToFileURL(t.path).toString();
+        o.push(i.As(r.require(s)));
     }
-    const a = await Promise.all(n);
-    const c = [];
-    for (let e = 0; e < t.length; e++) {
-        c.push(i.As(parseLoadedModule(a[e], t[e])));
+    const c = await Promise.all(o);
+    const a = [];
+    for (let e = 0; e < s.length; e++) {
+        a.push(i.As(u(c[e], s[e])));
     }
-    return registerModules(c, s, t, o);
+    return l(a, t, s, n);
 }
 
-function parseLoadedModule(e, r) {
-    const o = [];
-    if (!e) return o;
-    if (t.isFunction(e)) {
-        o.push({
+function u(e, r) {
+    const n = [];
+    if (!e) return n;
+    if (s.isFunction(e)) {
+        n.push({
             name: r.name,
             path: r.path,
             value: e,
             opts: r.opts
         });
-        return o;
+        return n;
     }
-    if (e.default && t.isFunction(e.default)) {
-        o.push({
+    if (e.default && s.isFunction(e.default)) {
+        n.push({
             name: r.name,
             path: r.path,
             value: e.default,
@@ -136,8 +136,8 @@ function parseLoadedModule(e, r) {
     }
     for (const i of Object.keys(e)) {
         if (i === "default") continue;
-        if (t.isFunction(e[i]) && s.RESOLVER in e[i]) {
-            o.push({
+        if (s.isFunction(e[i]) && t.RESOLVER in e[i]) {
+            n.push({
                 name: i,
                 path: r.path,
                 value: e[i],
@@ -145,17 +145,17 @@ function parseLoadedModule(e, r) {
             });
         }
     }
-    return o;
+    return n;
 }
 
-function registerModules(e, r, s, t) {
-    e.reduce(((e, r) => e.concat(r)), []).filter((e => e)).forEach(registerDescriptor.bind(null, r, t));
+function l(e, r, t, s) {
+    e.reduce(((e, r) => e.concat(r)), []).filter((e => e)).forEach(j.bind(null, r, s));
     return {
-        loadedModules: s
+        loadedModules: t
     };
 }
 
-function optsWithDefaults(e) {
+function p(e) {
     return {
         resolverOptions: {
             lifetime: r.Lifetime.TRANSIENT,
@@ -165,34 +165,34 @@ function optsWithDefaults(e) {
     };
 }
 
-function registerDescriptor(e, r, o) {
-    const i = o.value[s.RESOLVER];
-    let a = i && i.name;
-    if (!a) {
-        a = o.name;
+function j(e, r, n) {
+    const i = n.value[t.RESOLVER];
+    let c = i && i.name;
+    if (!c) {
+        c = n.name;
         let e = r.formatName;
         if (e) {
             if (typeof e === "string") {
-                e = n[e];
+                e = o[e];
             }
             if (e) {
-                a = e(a, o);
+                c = e(c, n);
             }
         }
     }
-    let c = o.opts;
-    if (typeof c === "string") {
-        c = {
-            lifetime: c
+    let a = n.opts;
+    if (typeof a === "string") {
+        a = {
+            lifetime: a
         };
     }
     const u = {
         ...r.resolverOptions,
-        ...c,
+        ...a,
         ...i
     };
-    const l = u.register ? u.register : t.isClass(o.value) ? s.asClass : s.asFunction;
-    e.register(a, l(o.value, u));
+    const l = u.register ? u.register : s.isClass(n.value) ? t.asClass : t.asFunction;
+    e.register(c, l(n.value, u));
 }
 
-exports.loadModules = loadModules;
+exports.loadModules = c;

package/src/lib/ioc/LoadModules.mjs

@@ -1,14 +1,14 @@
-import { pathToFileURL as e } from "url";
+import { pathToFileURL as t } from "url";
 
-import { Lifetime as t } from "./Lifetime.mjs";
+import { Lifetime as e } from "./Lifetime.mjs";
 
 import { RESOLVER as o, asClass as r, asFunction as s } from "./Resolvers.mjs";
 
-import { isFunction as i, isClass as n } from "./Utils.mjs";
+import { isFunction as n, isClass as i } from "./Utils.mjs";
 
-import { CamelCase as a } from "../base/internal/CamelCase.mjs";
+import { CamelCase as m } from "../base/internal/CamelCase.mjs";
 
-import { As as m } from "../helpers/As.mjs";
+import { As as a } from "../helpers/As.mjs";
 
 import "./Errors.mjs";
 
@@ -83,118 +83,118 @@ const __filename = cjsUrl.fileURLToPath(import.meta.url);
 const __dirname = cjsPath.dirname(__filename);
 const require = cjsModule.createRequire(import.meta.url);
 const p = {
-    camelCase: e => a(e)
+    camelCase: t => m(t)
 };
 
-function loadModules(e, t, o) {
+function c(t, e, o) {
     o ??= {};
-    const r = e.container;
-    o = optsWithDefaults(o);
-    const s = e.listModules(t, o);
+    const r = t.container;
+    o = j(o);
+    const s = t.listModules(e, o);
     if (o.esModules) {
-        return loadEsModules(e, r, s, o);
+        return l(t, r, s, o);
     } else {
-        const t = s.map((t => {
-            const o = e.require(t.path);
-            return parseLoadedModule(o, t);
+        const e = s.map((e => {
+            const o = t.require(e.path);
+            return u(o, e);
         }));
-        return registerModules(t, r, s, o);
+        return f(e, r, s, o);
     }
 }
 
-async function loadEsModules(t, o, r, s) {
-    const i = [];
+async function l(e, o, r, s) {
+    const n = [];
     for (const o of r) {
-        const r = e(o.path).toString();
-        i.push(m(t.require(r)));
+        const r = t(o.path).toString();
+        n.push(a(e.require(r)));
     }
-    const n = await Promise.all(i);
-    const a = [];
-    for (let e = 0; e < r.length; e++) {
-        a.push(m(parseLoadedModule(n[e], r[e])));
+    const i = await Promise.all(n);
+    const m = [];
+    for (let t = 0; t < r.length; t++) {
+        m.push(a(u(i[t], r[t])));
     }
-    return registerModules(a, o, r, s);
+    return f(m, o, r, s);
 }
 
-function parseLoadedModule(e, t) {
+function u(t, e) {
     const r = [];
-    if (!e) return r;
-    if (i(e)) {
+    if (!t) return r;
+    if (n(t)) {
         r.push({
-            name: t.name,
-            path: t.path,
-            value: e,
-            opts: t.opts
+            name: e.name,
+            path: e.path,
+            value: t,
+            opts: e.opts
         });
         return r;
     }
-    if (e.default && i(e.default)) {
+    if (t.default && n(t.default)) {
         r.push({
-            name: t.name,
-            path: t.path,
-            value: e.default,
-            opts: t.opts
+            name: e.name,
+            path: e.path,
+            value: t.default,
+            opts: e.opts
         });
     }
-    for (const s of Object.keys(e)) {
+    for (const s of Object.keys(t)) {
         if (s === "default") continue;
-        if (i(e[s]) && o in e[s]) {
+        if (n(t[s]) && o in t[s]) {
             r.push({
                 name: s,
-                path: t.path,
-                value: e[s],
-                opts: t.opts
+                path: e.path,
+                value: t[s],
+                opts: e.opts
             });
         }
     }
     return r;
 }
 
-function registerModules(e, t, o, r) {
-    e.reduce(((e, t) => e.concat(t)), []).filter((e => e)).forEach(registerDescriptor.bind(null, t, r));
+function f(t, e, o, r) {
+    t.reduce(((t, e) => t.concat(e)), []).filter((t => t)).forEach(d.bind(null, e, r));
     return {
         loadedModules: o
     };
 }
 
-function optsWithDefaults(e) {
+function j(t) {
     return {
         resolverOptions: {
-            lifetime: t.TRANSIENT,
-            ...e && e.resolverOptions
+            lifetime: e.TRANSIENT,
+            ...t && t.resolverOptions
         },
-        ...e
+        ...t
     };
 }
 
-function registerDescriptor(e, t, i) {
-    const a = i.value[o];
-    let m = a && a.name;
-    if (!m) {
-        m = i.name;
-        let e = t.formatName;
-        if (e) {
-            if (typeof e === "string") {
-                e = p[e];
+function d(t, e, n) {
+    const m = n.value[o];
+    let a = m && m.name;
+    if (!a) {
+        a = n.name;
+        let t = e.formatName;
+        if (t) {
+            if (typeof t === "string") {
+                t = p[t];
             }
-            if (e) {
-                m = e(m, i);
+            if (t) {
+                a = t(a, n);
             }
         }
     }
-    let l = i.opts;
-    if (typeof l === "string") {
-        l = {
-            lifetime: l
+    let c = n.opts;
+    if (typeof c === "string") {
+        c = {
+            lifetime: c
         };
     }
-    const c = {
-        ...t.resolverOptions,
-        ...l,
-        ...a
+    const l = {
+        ...e.resolverOptions,
+        ...c,
+        ...m
     };
-    const u = c.register ? c.register : n(i.value) ? r : s;
-    e.register(m, u(i.value, c));
+    const u = l.register ? l.register : i(n.value) ? r : s;
+    t.register(a, u(n.value, l));
 }
 
-export { loadModules };
+export { c as loadModules };

package/src/lib/ioc/ParamParser.cjs

@@ -6,36 +6,36 @@ Object.defineProperty(exports, Symbol.toStringTag, {
 
 const e = require("./FunctionTokenizer.cjs");
 
-function parseParameterList(t) {
-    const {next: n, done: r} = e.createTokenizer(t);
-    const a = [];
+function t(t) {
+    const {next: n, done: a} = e.createTokenizer(t);
+    const r = [];
     let o = null;
-    nextToken();
-    while (!r()) {
+    c();
+    while (!a()) {
         switch (o.type) {
           case "class":
-            skipUntilConstructor();
-            if (!isConstructorToken()) {
+            s();
+            if (!u()) {
                 return null;
             }
-            nextToken();
+            c();
             break;
 
           case "function":
             {
-                const e = nextToken();
+                const e = c();
                 if (e.type === "ident" || e.type === "*") {
-                    nextToken();
+                    c();
                 }
                 break;
             }
 
           case "(":
-            parseParams();
+            i();
             break;
 
           case ")":
-            return a;
+            return r;
 
           case "ident":
             {
@@ -44,27 +44,27 @@ function parseParameterList(t) {
                     optional: false
                 };
                 if (o.value === "async") {
-                    const e = nextToken();
+                    const e = c();
                     if (e && e.type !== "=") {
                         break;
                     }
                 }
-                a.push(e);
-                return a;
+                r.push(e);
+                return r;
             }
 
           default:
-            throw unexpected();
+            throw l();
         }
     }
-    return a;
-    function parseParams() {
+    return r;
+    function i() {
         let e = {
             name: "",
             optional: false
         };
-        while (!r()) {
-            nextToken();
+        while (!a()) {
+            c();
             switch (o.type) {
               case "ident":
                 e.name = o.value;
@@ -75,7 +75,7 @@ function parseParameterList(t) {
                 break;
 
               case ",":
-                a.push(e);
+                r.push(e);
                 e = {
                     name: "",
                     optional: false
@@ -84,30 +84,30 @@ function parseParameterList(t) {
 
               case ")":
                 if (e.name) {
-                    a.push(e);
+                    r.push(e);
                 }
                 return;
 
               default:
-                throw unexpected();
+                throw l();
             }
         }
     }
-    function skipUntilConstructor() {
-        while (!isConstructorToken() && !r()) {
-            nextToken(e.TokenizerFlags.Dumb);
+    function s() {
+        while (!u() && !a()) {
+            c(e.TokenizerFlags.Dumb);
         }
     }
-    function isConstructorToken() {
+    function u() {
         return o.type === "ident" && o.value === "constructor";
     }
-    function nextToken(t = e.TokenizerFlags.None) {
+    function c(t = e.TokenizerFlags.None) {
         o = n(t);
         return o;
     }
-    function unexpected() {
+    function l() {
         return new SyntaxError(`Parsing parameter list, did not expect ${o.type} token${o.value ? ` (${o.value})` : ""}`);
     }
 }
 
-exports.parseParameterList = parseParameterList;
+exports.parseParameterList = t;

package/src/lib/ioc/ParamParser.mjs

@@ -1,67 +1,67 @@
-import { createTokenizer as e, TokenizerFlags as n } from "./FunctionTokenizer.mjs";
+import { createTokenizer as e, TokenizerFlags as t } from "./FunctionTokenizer.mjs";
 
-function parseParameterList(t) {
-    const {next: r, done: o} = e(t);
-    const a = [];
-    let s = null;
-    nextToken();
-    while (!o()) {
-        switch (s.type) {
+function n(n) {
+    const {next: a, done: r} = e(n);
+    const o = [];
+    let u = null;
+    l();
+    while (!r()) {
+        switch (u.type) {
           case "class":
-            skipUntilConstructor();
-            if (!isConstructorToken()) {
+            c();
+            if (!s()) {
                 return null;
             }
-            nextToken();
+            l();
             break;
 
           case "function":
             {
-                const e = nextToken();
+                const e = l();
                 if (e.type === "ident" || e.type === "*") {
-                    nextToken();
+                    l();
                 }
                 break;
             }
 
           case "(":
-            parseParams();
+            i();
             break;
 
           case ")":
-            return a;
+            return o;
 
           case "ident":
             {
                 const e = {
-                    name: s.value,
+                    name: u.value,
                     optional: false
                 };
-                if (s.value === "async") {
-                    const e = nextToken();
+                if (u.value === "async") {
+                    const e = l();
                     if (e && e.type !== "=") {
                         break;
                     }
                 }
-                a.push(e);
-                return a;
+                o.push(e);
+                return o;
             }
 
           default:
-            throw unexpected();
+            throw f();
         }
     }
-    return a;
-    function parseParams() {
+    return o;
+    function i() {
         let e = {
             name: "",
             optional: false
         };
-        while (!o()) {
-            nextToken();
-            switch (s.type) {
+        while (!r()) {
+            l();
+            switch (u.type) {
               case "ident":
-                e.name = s.value;
+                e.name = u.value;
                 break;
 
               case "=":
@@ -69,7 +69,7 @@ function parseParameterList(t) {
                 break;
 
               case ",":
-                a.push(e);
+                o.push(e);
                 e = {
                     name: "",
                     optional: false
@@ -78,30 +78,30 @@ function parseParameterList(t) {
 
               case ")":
                 if (e.name) {
-                    a.push(e);
+                    o.push(e);
                 }
                 return;
 
               default:
-                throw unexpected();
+                throw f();
             }
         }
     }
-    function skipUntilConstructor() {
-        while (!isConstructorToken() && !o()) {
-            nextToken(n.Dumb);
+    function c() {
+        while (!s() && !r()) {
+            l(t.Dumb);
         }
     }
-    function isConstructorToken() {
-        return s.type === "ident" && s.value === "constructor";
+    function s() {
+        return u.type === "ident" && u.value === "constructor";
     }
-    function nextToken(e = n.None) {
-        s = r(e);
-        return s;
+    function l(e = t.None) {
+        u = a(e);
+        return u;
     }
-    function unexpected() {
-        return new SyntaxError(`Parsing parameter list, did not expect ${s.type} token${s.value ? ` (${s.value})` : ""}`);
+    function f() {
+        return new SyntaxError(`Parsing parameter list, did not expect ${u.type} token${u.value ? ` (${u.value})` : ""}`);
     }
 }
 
-export { parseParameterList };
+export { n as parseParameterList };