lakutata 2.0.82 → 2.0.83

package/src/components/cacher/Cacher.mjs

@@ -22,9 +22,9 @@ import { CreateMongoCacheAdapter as m } from "./adapters/CreateMongoCacheAdapter
 
 import { CreateSqliteCacheAdapter as u } from "./adapters/CreateSqliteCacheAdapter.mjs";
 
-import { CreatePostgresCacheAdapter as d } from "./adapters/CreatePostgresCacheAdapter.mjs";
+import { CreatePostgresCacheAdapter as f } from "./adapters/CreatePostgresCacheAdapter.mjs";
 
-import { CreateMysqlCacheAdapter as f } from "./adapters/CreateMysqlCacheAdapter.mjs";
+import { CreateMysqlCacheAdapter as d } from "./adapters/CreateMysqlCacheAdapter.mjs";
 
 import { D as p } from "../../../vendor/Package.2.mjs";
 
@@ -306,7 +306,7 @@ var x = class {
     }
 };
 
-var C = class {
+var P = class {
     _seed;
     constructor(e = 0) {
         this._seed = e >>> 0;
@@ -388,7 +388,7 @@ var C = class {
     }
 };
 
-var P = class {
+var z = class {
     _providers=new Map;
     _getFuzzy=true;
     constructor(e) {
@@ -435,10 +435,10 @@ var P = class {
     }
 };
 
-var z = class extends s {
+var C = class extends s {
     _parse=JSON.parse;
     _stringify=JSON.stringify;
-    _providers=new P;
+    _providers=new z;
     _defaultAlgorithm="SHA-256";
     _defaultAlgorithmSync="djb2";
     constructor(e) {
@@ -599,12 +599,12 @@ var z = class extends s {
             this.providers.add(new S);
             this.providers.add(new k);
             this.providers.add(new x);
-            this.providers.add(new C);
+            this.providers.add(new P);
         }
     }
 };
 
-var shorthandToMilliseconds = e => {
+var H = e => {
     let t;
     if (e === void 0) {
         return void 0;
@@ -673,58 +673,58 @@ var shorthandToMilliseconds = e => {
     return t;
 };
 
-var shorthandToTime = (e, t) => {
+var O = (e, t) => {
     t ??= new Date;
-    const r = shorthandToMilliseconds(e);
+    const r = H(e);
     if (r === void 0) {
         return t.getTime();
     }
     return t.getTime() + r;
 };
 
-var H = new Map;
+var L = new Map;
 
-function hasKey(e) {
-    return H.has(e);
+function M(e) {
+    return L.has(e);
 }
 
-function addKey(e) {
-    H.set(e, []);
+function I(e) {
+    L.set(e, []);
 }
 
-function removeKey(e) {
-    H.delete(e);
+function N(e) {
+    L.delete(e);
 }
 
-function addCallbackToKey(e, t) {
-    const r = getCallbacksByKey(e);
+function E(e, t) {
+    const r = U(e);
     r.push(t);
-    H.set(e, r);
+    L.set(e, r);
 }
 
-function getCallbacksByKey(e) {
-    return H.get(e) ?? [];
+function U(e) {
+    return L.get(e) ?? [];
 }
 
-async function enqueue(e) {
+async function B(e) {
     return new Promise(((t, r) => {
         const s = {
             resolve: t,
             reject: r
         };
-        addCallbackToKey(e, s);
+        E(e, s);
     }));
 }
 
-function dequeue(e) {
-    const t = getCallbacksByKey(e);
-    removeKey(e);
+function D(e) {
+    const t = U(e);
+    N(e);
     return t;
 }
 
-function coalesce(e) {
+function $(e) {
     const {key: t, error: r, result: s} = e;
-    for (const e of dequeue(t)) {
+    for (const e of D(t)) {
         if (r) {
             e.reject(r);
         } else {
@@ -733,28 +733,28 @@ function coalesce(e) {
     }
 }
 
-async function coalesceAsync(e, t) {
-    if (!hasKey(e)) {
-        addKey(e);
+async function T(e, t) {
+    if (!M(e)) {
+        I(e);
         try {
             const r = await Promise.resolve(t());
-            coalesce({
+            $({
                 key: e,
                 result: r
             });
             return r;
         } catch (t) {
-            coalesce({
+            $({
                 key: e,
                 error: t
             });
             throw t;
         }
     }
-    return enqueue(e);
+    return B(e);
 }
 
-var O = (e => {
+var F = (e => {
     e["SHA256"] = "SHA-256";
     e["SHA384"] = "SHA-384";
     e["SHA512"] = "SHA-512";
@@ -763,35 +763,35 @@ var O = (e => {
     e["MURMER"] = "murmer";
     e["CRC32"] = "crc32";
     return e;
-})(O || {});
+})(F || {});
 
-async function hash(e, t = {
+async function V(e, t = {
     algorithm: "SHA-256",
     serialize: JSON.stringify
 }) {
     const r = t?.algorithm ?? "SHA-256";
     const s = t?.serialize ?? JSON.stringify;
     const i = s(e);
-    const n = new z;
+    const n = new C;
     return n.toHash(i, {
         algorithm: r
     });
 }
 
-function hashSync(e, t = {
+function J(e, t = {
     algorithm: "djb2",
     serialize: JSON.stringify
 }) {
     const r = t?.algorithm ?? "djb2";
     const s = t?.serialize ?? JSON.stringify;
     const i = s(e);
-    const n = new z;
+    const n = new C;
     return n.toHashSync(i, {
         algorithm: r
     });
 }
 
-async function hashToNumber(e, t = {
+async function R(e, t = {
     min: 0,
     max: 10,
     algorithm: "SHA-256",
@@ -806,7 +806,7 @@ async function hashToNumber(e, t = {
         throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
     }
     const a = n(e);
-    const c = new z;
+    const c = new C;
     return c.toNumber(a, {
         algorithm: i,
         min: r,
@@ -815,7 +815,7 @@ async function hashToNumber(e, t = {
     });
 }
 
-function hashToNumberSync(e, t = {
+function K(e, t = {
     min: 0,
     max: 10,
     algorithm: "djb2",
@@ -830,7 +830,7 @@ function hashToNumberSync(e, t = {
         throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
     }
     const a = n(e);
-    const c = new z;
+    const c = new C;
     return c.toNumberSync(a, {
         algorithm: i,
         min: r,
@@ -839,7 +839,7 @@ function hashToNumberSync(e, t = {
     });
 }
 
-function isKeyvInstance(e) {
+function q(e) {
     if (e === null || e === void 0) {
         return false;
     }
@@ -850,18 +850,18 @@ function isKeyvInstance(e) {
     return t.every((t => typeof e[t] === "function"));
 }
 
-function isObject(e) {
+function G(e) {
     return e !== null && typeof e === "object" && !Array.isArray(e);
 }
 
-function lessThan(e, t) {
+function W(e, t) {
     return typeof e === "number" && typeof t === "number" ? e < t : false;
 }
 
-function wrapSync(e, t) {
+function X(e, t) {
     const {ttl: r, keyPrefix: s, cache: i, serialize: n} = t;
     return (...o) => {
-        let a = createWrapKey(e, o, {
+        let a = Z(e, o, {
             keyPrefix: s,
             serialize: n
         });
@@ -884,13 +884,13 @@ function wrapSync(e, t) {
     };
 }
 
-async function getOrSet(e, t, r) {
+async function Q(e, t, r) {
     const s = typeof e === "function" ? e(r) : e;
     let i = await r.cache.get(s);
     if (i === void 0) {
         const e = r.cacheId ?? "default";
         const n = `${e}::${s}`;
-        i = await coalesceAsync(n, (async () => {
+        i = await T(n, (async () => {
             try {
                 const e = await t();
                 await r.cache.set(s, e, r.ttl);
@@ -909,39 +909,39 @@ async function getOrSet(e, t, r) {
     return i;
 }
 
-function wrap(e, t) {
+function Y(e, t) {
     const {keyPrefix: r, serialize: s} = t;
     return async (...i) => {
-        let n = createWrapKey(e, i, {
+        let n = Z(e, i, {
             keyPrefix: r,
             serialize: s
         });
         if (t.createKey) {
             n = t.createKey(e, i, t);
         }
-        return getOrSet(n, (async () => e(...i)), t);
+        return Q(n, (async () => e(...i)), t);
     };
 }
 
-function createWrapKey(e, t, r) {
+function Z(e, t, r) {
     const {keyPrefix: s, serialize: i} = r || {};
     if (!s) {
-        return `${e.name}::${hashSync(t, {
+        return `${e.name}::${J(t, {
             serialize: i
         })}`;
     }
-    return `${s}::${e.name}::${hashSync(t, {
+    return `${s}::${e.name}::${J(t, {
         serialize: i
     })}`;
 }
 
-function runIfFn(e, ...t) {
+function ee(e, ...t) {
     return typeof e === "function" ? e(...t) : e;
 }
 
-var sleep = async e => new Promise((t => setTimeout(t, e)));
+var te = async e => new Promise((t => setTimeout(t, e)));
 
-var L = class {
+var re = class {
     _hits=0;
     _misses=0;
     _gets=0;
@@ -1118,7 +1118,7 @@ var L = class {
     }
 };
 
-function getTtlFromExpires(e) {
+function se(e) {
     if (e === void 0 || e === null) {
         return void 0;
     }
@@ -1129,12 +1129,12 @@ function getTtlFromExpires(e) {
     return e - t;
 }
 
-function getCascadingTtl(e, t, r) {
-    return r ?? t ?? shorthandToMilliseconds(e);
+function ie(e, t, r) {
+    return r ?? t ?? H(e);
 }
 
-function calculateTtlFromExpiration(e, t) {
-    const r = getTtlFromExpires(t);
+function ne(e, t) {
+    const r = se(t);
     const s = e ? Date.now() + e : void 0;
     if (r === void 0) {
         return e;
@@ -1148,7 +1148,7 @@ function calculateTtlFromExpiration(e, t) {
     return r;
 }
 
-var I = class {
+var oe = class {
     opts;
     namespace;
     _cache;
@@ -1196,9 +1196,9 @@ var I = class {
     }
 };
 
-var _storeLabel = e => e === 0 ? "primary" : `secondary:${e - 1}`;
+var ae = e => e === 0 ? "primary" : `secondary:${e - 1}`;
 
-var createCache = e => {
+var ce = e => {
     const t = new r;
     const s = new i;
     s.serialize = void 0;
@@ -1206,7 +1206,7 @@ var createCache = e => {
     const n = e?.stores?.length ? e.stores : [ s ];
     const o = e?.nonBlocking ?? false;
     const a = e?.cacheId ?? Math.random().toString(36).slice(2);
-    const get = async e => {
+    const c = async e => {
         let r;
         if (o) {
             try {
@@ -1230,7 +1230,7 @@ var createCache = e => {
                         t.emit("get", {
                             key: e,
                             value: r,
-                            store: _storeLabel(s)
+                            store: ae(s)
                         });
                         break;
                     }
@@ -1238,14 +1238,14 @@ var createCache = e => {
                     t.emit("get", {
                         key: e,
                         error: r,
-                        store: _storeLabel(s)
+                        store: ae(s)
                     });
                 }
             }
         }
         return r;
     };
-    const mget = async e => {
+    const l = async e => {
         let r = e.map((() => void 0));
         if (o) {
             try {
@@ -1289,7 +1289,7 @@ var createCache = e => {
         });
         return r;
     };
-    const ttl = async e => {
+    const h = async e => {
         let r;
         if (o) {
             try {
@@ -1332,14 +1332,14 @@ var createCache = e => {
         }
         return void 0;
     };
-    const set = async (r, s, i, n) => {
+    const m = async (r, s, i, n) => {
         try {
             const a = r.map((async (r, o) => {
                 await r.set(s, i, n ?? e?.ttl);
                 t.emit("set", {
                     key: s,
                     value: i,
-                    store: _storeLabel(o)
+                    store: ae(o)
                 });
             }));
             if (o) {
@@ -1365,7 +1365,7 @@ var createCache = e => {
             return Promise.reject(e);
         }
     };
-    const mset = async (r, s) => {
+    const u = async (r, s) => {
         const i = s.map((({key: t, value: r, ttl: s}) => ({
             key: t,
             value: r,
@@ -1393,7 +1393,7 @@ var createCache = e => {
             return Promise.reject(e);
         }
     };
-    const del = async e => {
+    const f = async e => {
         try {
             if (o) {
                 Promise.all(n.map((async t => t.delete(e))));
@@ -1415,7 +1415,7 @@ var createCache = e => {
             return Promise.reject(r);
         }
     };
-    const mdel = async e => {
+    const d = async e => {
         try {
             const r = [];
             for (const t of e) {
@@ -1441,7 +1441,7 @@ var createCache = e => {
             return Promise.reject(r);
         }
     };
-    const clear = async () => {
+    const p = async () => {
         try {
             if (o) {
                 Promise.all(n.map((async e => e.clear())));
@@ -1456,16 +1456,16 @@ var createCache = e => {
             return Promise.reject(e);
         }
     };
-    const wrap = async (r, s, i, o) => coalesceAsync(`${a}::${r}`, (async () => {
+    const y = async (r, s, i, o) => T(`${a}::${r}`, (async () => {
         let c;
         let l;
         let h = 0;
-        let m;
-        const {ttl: u, refreshThreshold: d, raw: f} = isObject(i) ? i : {
+        let u;
+        const {ttl: f, refreshThreshold: d, raw: p} = G(i) ? i : {
             ttl: i,
             refreshThreshold: o
         };
-        const resolveTtl = t => runIfFn(u, t) ?? e?.ttl;
+        const y = t => ee(f, t) ?? e?.ttl;
         for (;h < n.length; h++) {
             try {
                 const e = await n[h].get(r, {
@@ -1475,7 +1475,7 @@ var createCache = e => {
                     c = e.value;
                     l = e;
                     if (typeof e.expires === "number") {
-                        m = Math.max(0, e.expires - Date.now());
+                        u = Math.max(0, e.expires - Date.now());
                     }
                     break;
                 }
@@ -1483,18 +1483,18 @@ var createCache = e => {
         }
         if (c === void 0) {
             const e = await s();
-            const t = resolveTtl(e);
-            await set(n, r, e, t);
-            return f ? {
+            const t = y(e);
+            await m(n, r, e, t);
+            return p ? {
                 value: e,
                 expires: Date.now() + t
             } : e;
         }
-        const p = lessThan(m, runIfFn(d, c) ?? e?.refreshThreshold);
-        if (p) {
-            coalesceAsync(`+++${a}__${r}`, s).then((async s => {
+        const g = W(u, ee(d, c) ?? e?.refreshThreshold);
+        if (g) {
+            T(`+++${a}__${r}`, s).then((async s => {
                 try {
-                    await set(e?.refreshAllStores ? n : n.slice(0, h + 1), r, s, resolveTtl(s));
+                    await m(e?.refreshAllStores ? n : n.slice(0, h + 1), r, s, y(s));
                     t.emit("refresh", {
                         key: r,
                         value: s
@@ -1514,40 +1514,40 @@ var createCache = e => {
                 });
             }));
         }
-        if (!p && h > 0) {
-            await set(n.slice(0, h), r, c, resolveTtl(c));
+        if (!g && h > 0) {
+            await m(n.slice(0, h), r, c, y(c));
         }
-        return f ? l : c;
+        return p ? l : c;
     }));
-    const on = (e, r) => t.addListener(e, r);
-    const off = (e, r) => t.removeListener(e, r);
-    const disconnect = async () => {
+    const g = (e, r) => t.addListener(e, r);
+    const b = (e, r) => t.removeListener(e, r);
+    const v = async () => {
         try {
             await Promise.all(n.map((async e => e.disconnect())));
         } catch (e) {
             return Promise.reject(e);
         }
     };
-    const cacheId = () => a;
+    const _ = () => a;
     return {
-        get,
-        mget,
-        ttl,
-        set: async (e, t, r) => set(n, e, t, r),
-        mset: async e => mset(n, e),
-        del,
-        mdel,
-        clear,
-        wrap,
-        on,
-        off,
-        disconnect,
-        cacheId,
+        get: c,
+        mget: l,
+        ttl: h,
+        set: async (e, t, r) => m(n, e, t, r),
+        mset: async e => u(n, e),
+        del: f,
+        mdel: d,
+        clear: p,
+        wrap: y,
+        on: g,
+        off: b,
+        disconnect: v,
+        cacheId: _,
         stores: n
     };
 };
 
-const BuildCacherOptions = e => ({
+const le = e => ({
     class: Cacher,
     stores: e?.stores,
     ttl: e?.ttl,
@@ -1578,17 +1578,17 @@ class Cacher extends n {
                 return u(e);
 
               case "postgres":
-                return d(e);
+                return f(e);
 
               case "mysql":
-                return f(e);
+                return d(e);
 
               default:
                 return undefined;
             }
         })));
         const r = t.filter((e => !!e));
-        this.cache = createCache({
+        this.cache = ce({
             stores: r.length ? r : undefined,
             ttl: this.ttl,
             refreshThreshold: this.refreshThreshold,
@@ -1647,4 +1647,4 @@ e([ o(p.Boolean().optional()), t("design:type", Boolean) ], Cacher.prototype, "n
 
 e([ o(p.String().optional()), t("design:type", String) ], Cacher.prototype, "cacheId", void 0);
 
-export { BuildCacherOptions, Cacher };
+export { le as BuildCacherOptions, Cacher };