lakutata 2.0.80 → 2.0.81

package/vendor/Package.68.mjs

@@ -1,163 +1,14 @@
-import { createClient as t, createCluster as e } from "@redis/client";
+import { createClient as t, createSentinel as e, createCluster as s } from "@redis/client";
 
-export { createClient, createCluster } from "@redis/client";
-
-import { K as s } from "./Package.67.mjs";
+export { createClient, createCluster, createSentinel } from "@redis/client";
 
 import r from "cluster-key-slot";
 
-import "buffer";
+import { H as i } from "./Package.66.mjs";
 
-var i = class {
-    _eventListeners;
-    _maxListeners;
-    _logger;
-    constructor(t) {
-        this._eventListeners = new Map, this._maxListeners = 100, this._logger = t?.logger;
-    }
-    once(t, e) {
-        let s = (...r) => {
-            this.off(t, s), e(...r);
-        };
-        return this.on(t, s), this;
-    }
-    listenerCount(t) {
-        if (!t) return this.getAllListeners().length;
-        let e = this._eventListeners.get(t);
-        return e ? e.length : 0;
-    }
-    eventNames() {
-        return [ ...this._eventListeners.keys() ];
-    }
-    rawListeners(t) {
-        return t ? this._eventListeners.get(t) ?? [] : this.getAllListeners();
-    }
-    prependListener(t, e) {
-        let s = this._eventListeners.get(t) ?? [];
-        return s.unshift(e), this._eventListeners.set(t, s), this;
-    }
-    prependOnceListener(t, e) {
-        let s = (...r) => {
-            this.off(t, s), e(...r);
-        };
-        return this.prependListener(t, s), this;
-    }
-    maxListeners() {
-        return this._maxListeners;
-    }
-    addListener(t, e) {
-        return this.on(t, e), this;
-    }
-    on(t, e) {
-        this._eventListeners.has(t) || this._eventListeners.set(t, []);
-        let s = this._eventListeners.get(t);
-        return s && (s.length >= this._maxListeners && console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length + 1} ${t} listeners added. Use setMaxListeners() to increase limit.`), 
-        s.push(e)), this;
-    }
-    removeListener(t, e) {
-        return this.off(t, e), this;
-    }
-    off(t, e) {
-        let s = this._eventListeners.get(t) ?? [], r = s.indexOf(e);
-        return r !== -1 && s.splice(r, 1), s.length === 0 && this._eventListeners.delete(t), 
-        this;
-    }
-    emit(t, ...e) {
-        let s = !1, r = this._eventListeners.get(t);
-        if (r && r.length > 0) for (let t of r) t(...e), s = !0;
-        return s;
-    }
-    listeners(t) {
-        return this._eventListeners.get(t) ?? [];
-    }
-    removeAllListeners(t) {
-        return t ? this._eventListeners.delete(t) : this._eventListeners.clear(), this;
-    }
-    setMaxListeners(t) {
-        this._maxListeners = t;
-        for (let e of this._eventListeners.values()) e.length > t && e.splice(t);
-    }
-    getAllListeners() {
-        let t = new Array;
-        for (let e of this._eventListeners.values()) t = [ ...t, ...e ];
-        return t;
-    }
-};
+import { K as n } from "./Package.67.mjs";
 
-var n = class extends i {
-    _hooks;
-    _throwHookErrors=!1;
-    constructor(t) {
-        super({
-            logger: t?.logger
-        }), this._hooks = new Map, t?.throwHookErrors !== void 0 && (this._throwHookErrors = t.throwHookErrors);
-    }
-    get hooks() {
-        return this._hooks;
-    }
-    get throwHookErrors() {
-        return this._throwHookErrors;
-    }
-    set throwHookErrors(t) {
-        this._throwHookErrors = t;
-    }
-    get logger() {
-        return this._logger;
-    }
-    set logger(t) {
-        this._logger = t;
-    }
-    onHook(t, e) {
-        let s = this._hooks.get(t);
-        s ? s.push(e) : this._hooks.set(t, [ e ]);
-    }
-    addHook(t, e) {
-        this.onHook(t, e);
-    }
-    onHooks(t) {
-        for (let e of t) this.onHook(e.event, e.handler);
-    }
-    prependHook(t, e) {
-        let s = this._hooks.get(t);
-        s ? s.unshift(e) : this._hooks.set(t, [ e ]);
-    }
-    prependOnceHook(t, e) {
-        let s = async (...r) => (this.removeHook(t, s), e(...r));
-        this.prependHook(t, s);
-    }
-    onceHook(t, e) {
-        let s = async (...r) => (this.removeHook(t, s), e(...r));
-        this.onHook(t, s);
-    }
-    removeHook(t, e) {
-        let s = this._hooks.get(t);
-        if (s) {
-            let t = s.indexOf(e);
-            t !== -1 && s.splice(t, 1);
-        }
-    }
-    removeHooks(t) {
-        for (let e of t) this.removeHook(e.event, e.handler);
-    }
-    async hook(t, ...e) {
-        let s = this._hooks.get(t);
-        if (s) for (let r of s) try {
-            await r(...e);
-        } catch (e) {
-            let s = `${t}: ${e.message}`;
-            if (this.emit("error", new Error(s)), this._logger && this._logger.error(s), this._throwHookErrors) throw new Error(s);
-        }
-    }
-    async callHook(t, ...e) {
-        await this.hook(t, ...e);
-    }
-    getHooks(t) {
-        return this._hooks.get(t);
-    }
-    clearHooks() {
-        this._hooks.clear();
-    }
-};
+import "buffer";
 
 var o = (t => {
     t["RedisClientNotConnectedThrown"] = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.";
@@ -170,7 +21,53 @@ var a = t => {
     return e + s;
 };
 
-var c = class extends n {
+function c(t, e) {
+    t ??= "redis://localhost:6379";
+    const s = new l(t, e);
+    if (e?.namespace) {
+        s.namespace = e.namespace;
+        const t = new n(s, {
+            namespace: e?.namespace,
+            useKeyPrefix: false
+        });
+        if (e?.throwOnConnectError) {
+            t.throwOnErrors = true;
+        }
+        if (e?.throwOnErrors) {
+            t.throwOnErrors = true;
+        }
+        return t;
+    }
+    const r = new n(s, {
+        useKeyPrefix: false
+    });
+    if (e?.throwOnConnectError) {
+        r.throwOnErrors = true;
+    }
+    if (e?.throwOnErrors) {
+        r.throwOnErrors = true;
+    }
+    r.namespace = void 0;
+    return r;
+}
+
+function h(t, e) {
+    const s = c(t, e);
+    const r = s.store;
+    r.throwOnConnectError = false;
+    r.throwOnErrors = false;
+    const i = r.client;
+    if (i.options) {
+        i.options.disableOfflineQueue = true;
+        if (i.options.socket) {
+            i.options.socket.reconnectStrategy = false;
+        }
+    }
+    s.throwOnErrors = false;
+    return s;
+}
+
+var l = class extends i {
     _client=t();
     _namespace;
     _keyPrefixSeparator="::";
@@ -178,26 +75,38 @@ var c = class extends n {
     _useUnlink=true;
     _noNamespaceAffectsAll=false;
     _throwOnConnectError=true;
-    _throwErrors=false;
+    _throwOnErrors=false;
     _connectionTimeout;
-    constructor(s, r) {
+    constructor(r, i) {
         super();
-        const i = {
+        const n = {
             reconnectStrategy: a
         };
-        if (s) {
-            if (typeof s === "string") {
+        if (r) {
+            if (typeof r === "string") {
                 this._client = t({
-                    url: s,
-                    socket: i
+                    url: r,
+                    socket: n
                 });
-            } else if (s.connect !== void 0) {
-                this._client = this.isClientCluster(s) ? s : s;
-            } else if (s instanceof Object) {
-                this._client = s.rootNodes === void 0 ? t(s) : e(s);
+            } else if (r.connect !== void 0) {
+                if (this.isClientSentinel(r)) {
+                    this._client = r;
+                } else if (this.isClientCluster(r)) {
+                    this._client = r;
+                } else {
+                    this._client = r;
+                }
+            } else if (r instanceof Object) {
+                if (r.sentinelRootNodes !== void 0) {
+                    this._client = e(r);
+                } else if (r.rootNodes === void 0) {
+                    this._client = t(r);
+                } else {
+                    this._client = s(r);
+                }
             }
         }
-        this.setOptions(r);
+        this.setOptions(i);
         this.initClient();
     }
     get client() {
@@ -222,7 +131,7 @@ var c = class extends n {
             noNamespaceAffectsAll: this._noNamespaceAffectsAll,
             useUnlink: this._useUnlink,
             throwOnConnectError: this._throwOnConnectError,
-            throwErrors: this._throwErrors,
+            throwOnErrors: this._throwOnErrors,
             connectionTimeout: this._connectionTimeout,
             dialect: "redis",
             url: t
@@ -272,11 +181,11 @@ var c = class extends n {
     set throwOnConnectError(t) {
         this._throwOnConnectError = t;
     }
-    get throwErrors() {
-        return this._throwErrors;
+    get throwOnErrors() {
+        return this._throwOnErrors;
     }
-    set throwErrors(t) {
-        this._throwErrors = t;
+    set throwOnErrors(t) {
+        this._throwOnErrors = t;
     }
     get connectionTimeout() {
         return this._connectionTimeout;
@@ -296,10 +205,10 @@ var c = class extends n {
             }
         } catch (t) {
             this.emit("error", t);
+            await this.disconnect(true);
             if (this._throwOnConnectError) {
                 throw new Error("Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.");
             }
-            await this.disconnect(true);
         }
         this.initClient();
         return this._client;
@@ -317,29 +226,59 @@ var c = class extends n {
             }
         } catch (t) {
             this.emit("error", t);
-            if (this._throwErrors) {
+            if (this._throwOnErrors) {
                 throw t;
             }
         }
     }
     async setMany(t) {
-        const e = await this.getClient();
         try {
-            const s = e.multi();
-            for (const {key: e, value: r, ttl: i} of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                if (i) {
-                    s.set(t, r, {
-                        PX: i
-                    });
-                } else {
-                    s.set(t, r);
+            if (this.isCluster()) {
+                await this.getClient();
+                const e = new Map;
+                for (const s of t) {
+                    const t = this.createKeyPrefix(s.key, this._namespace);
+                    const i = r(t);
+                    const n = e.get(i) ?? [];
+                    n.push(s);
+                    e.set(i, n);
                 }
+                await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
+                    const s = await this.getSlotMaster(t);
+                    const r = s.multi();
+                    for (const {key: t, value: s, ttl: i} of e) {
+                        const e = this.createKeyPrefix(t, this._namespace);
+                        if (i) {
+                            r.set(e, s, {
+                                PX: i
+                            });
+                        } else {
+                            r.set(e, s);
+                        }
+                    }
+                    await r.exec();
+                })));
+            } else {
+                const e = await this.getClient();
+                const s = e.multi();
+                for (const {key: e, value: r, ttl: i} of t) {
+                    const t = this.createKeyPrefix(e, this._namespace);
+                    if (i) {
+                        s.set(t, r, {
+                            PX: i
+                        });
+                    } else {
+                        s.set(t, r);
+                    }
+                }
+                await s.exec();
             }
-            await s.exec();
         } catch (t) {
             this.emit("error", t);
-            if (this._throwErrors) {
+            if (this._throwOnConnectError && t.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
+                throw t;
+            }
+            if (this._throwOnErrors) {
                 throw t;
             }
         }
@@ -352,25 +291,45 @@ var c = class extends n {
             return s === 1;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwErrors) {
+            if (this._throwOnErrors) {
                 throw t;
             }
             return false;
         }
     }
     async hasMany(t) {
-        const e = await this.getClient();
         try {
-            const s = e.multi();
-            for (const e of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                s.exists(t);
+            const e = t.map((t => this.createKeyPrefix(t, this._namespace)));
+            if (this.isCluster()) {
+                const t = this.getSlotMap(e);
+                const s = new Map;
+                await Promise.all(Array.from(t.entries(), (async ([t, e]) => {
+                    const r = await this.getSlotMaster(t);
+                    const i = r.multi();
+                    for (const t of e) {
+                        i.exists(t);
+                    }
+                    const n = await i.exec();
+                    for (const [t, r] of n.entries()) {
+                        s.set(e[t], typeof r === "number" && r === 1);
+                    }
+                })));
+                return e.map((t => s.get(t) ?? false));
+            } else {
+                const t = await this.getClient();
+                const s = t.multi();
+                for (const t of e) {
+                    s.exists(t);
+                }
+                const r = await s.exec();
+                return r.map((t => typeof t === "number" && t === 1));
             }
-            const r = await s.exec();
-            return r.map((t => t === 1));
         } catch (e) {
             this.emit("error", e);
-            if (this._throwErrors) {
+            if (this._throwOnConnectError && e.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
+                throw e;
+            }
+            if (this._throwOnErrors) {
                 throw e;
             }
             return Array.from({
@@ -389,7 +348,7 @@ var c = class extends n {
             return s;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwErrors) {
+            if (this._throwOnErrors) {
                 throw t;
             }
             return void 0;
@@ -405,7 +364,7 @@ var c = class extends n {
             return e;
         } catch (e) {
             this.emit("error", e);
-            if (this._throwErrors) {
+            if (this._throwOnErrors) {
                 throw e;
             }
             return Array.from({
@@ -422,7 +381,7 @@ var c = class extends n {
             return s > 0;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwErrors) {
+            if (this._throwOnErrors) {
                 throw t;
             }
             return false;
@@ -430,26 +389,50 @@ var c = class extends n {
     }
     async deleteMany(t) {
         let e = false;
-        const s = await this.getClient();
         try {
-            const r = s.multi();
-            for (const e of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                if (this._useUnlink) {
-                    r.unlink(t);
-                } else {
-                    r.del(t);
+            const s = t.map((t => this.createKeyPrefix(t, this._namespace)));
+            if (this.isCluster()) {
+                const t = this.getSlotMap(s);
+                await Promise.all(Array.from(t.entries(), (async ([t, s]) => {
+                    const r = await this.getSlotMaster(t);
+                    const i = r.multi();
+                    for (const t of s) {
+                        if (this._useUnlink) {
+                            i.unlink(t);
+                        } else {
+                            i.del(t);
+                        }
+                    }
+                    const n = await i.exec();
+                    for (const t of n) {
+                        if (typeof t === "number" && t > 0) {
+                            e = true;
+                        }
+                    }
+                })));
+            } else {
+                const t = await this.getClient();
+                const r = t.multi();
+                for (const t of s) {
+                    if (this._useUnlink) {
+                        r.unlink(t);
+                    } else {
+                        r.del(t);
+                    }
                 }
-            }
-            const i = await r.exec();
-            for (const t of i) {
-                if (typeof t === "number" && t > 0) {
-                    e = true;
+                const i = await r.exec();
+                for (const t of i) {
+                    if (typeof t === "number" && t > 0) {
+                        e = true;
+                    }
                 }
             }
         } catch (t) {
             this.emit("error", t);
-            if (this._throwErrors) {
+            if (this._throwOnConnectError && t.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
+                throw t;
+            }
+            if (this._throwOnErrors) {
                 throw t;
             }
         }
@@ -457,7 +440,7 @@ var c = class extends n {
     }
     async disconnect(t) {
         if (this._client.isOpen) {
-            await (t ? this._client.disconnect() : this._client.quit());
+            await (t ? this._client.destroy() : this._client.close());
         }
     }
     createKeyPrefix(t, e) {
@@ -475,10 +458,14 @@ var c = class extends n {
     isCluster() {
         return this.isClientCluster(this._client);
     }
+    isSentinel() {
+        return this.isClientSentinel(this._client);
+    }
     async getMasterNodes() {
         if (this.isCluster()) {
             const t = await this.getClient();
-            return Promise.all(t.masters.map((async e => t.nodeClient(e))));
+            const e = t.masters.map((async e => t.nodeClient(e)));
+            return Promise.all(e);
         }
         return [ await this.getClient() ];
     }
@@ -488,7 +475,7 @@ var c = class extends n {
             const e = t ? `${t}${this._keyPrefixSeparator}*` : "*";
             let r = "0";
             do {
-                const i = await s.scan(Number.parseInt(r, 10), {
+                const i = await s.scan(r, {
                     MATCH: e,
                     TYPE: "string"
                 });
@@ -521,7 +508,7 @@ var c = class extends n {
                 const r = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
                 const i = [];
                 do {
-                    const n = await t.scan(Number.parseInt(e, 10), {
+                    const n = await t.scan(e, {
                         MATCH: r,
                         COUNT: s,
                         TYPE: "string"
@@ -543,16 +530,24 @@ var c = class extends n {
         }
     }
     async mget(t) {
-        const e = this.getSlotMap(t);
-        const s = new Map;
-        await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
-            const r = await this.getSlotMaster(t);
-            const i = await r.mGet(e);
-            for (const [t, r] of i.entries()) {
-                s.set(e[t], r ?? void 0);
+        const e = new Map;
+        if (this.isCluster()) {
+            const s = this.getSlotMap(t);
+            await Promise.all(Array.from(s.entries(), (async ([t, s]) => {
+                const r = await this.getSlotMaster(t);
+                const i = await r.mGet(s);
+                for (const [t, r] of i.entries()) {
+                    e.set(s[t], r ?? void 0);
+                }
+            })));
+        } else {
+            const s = await this.getClient();
+            const r = await s.mGet(t);
+            for (const [s, i] of r.entries()) {
+                e.set(t[s], i ?? void 0);
             }
-        })));
-        return t.map((t => s.get(t)));
+        }
+        return t.map((t => e.get(t)));
     }
     async clearWithClusterSupport(t) {
         if (t.length > 0) {
@@ -587,10 +582,10 @@ var c = class extends n {
         return e;
     }
     isClientCluster(t) {
-        if (t.options === void 0 && t.scan === void 0) {
-            return true;
-        }
-        return false;
+        return t.slots !== void 0;
+    }
+    isClientSentinel(t) {
+        return t.getSentinelNode !== void 0;
     }
     setOptions(t) {
         if (!t) {
@@ -614,8 +609,8 @@ var c = class extends n {
         if (t.throwOnConnectError !== void 0) {
             this._throwOnConnectError = t.throwOnConnectError;
         }
-        if (t.throwErrors !== void 0) {
-            this._throwErrors = t.throwErrors;
+        if (t.throwOnErrors !== void 0) {
+            this._throwOnErrors = t.throwOnErrors;
         }
         if (t.connectionTimeout !== void 0) {
             this._connectionTimeout = t.connectionTimeout;
@@ -639,14 +634,4 @@ var c = class extends n {
     }
 };
 
-function h(t, e) {
-    t ??= "redis://localhost:6379";
-    const r = new c(t, e);
-    const i = new s(r, {
-        namespace: e?.namespace,
-        useKeyPrefix: false
-    });
-    return i;
-}
-
-export { s as Keyv, o as RedisErrorMessages, h as createKeyv, c as default, a as defaultReconnectStrategy };
+export { n as Keyv, o as RedisErrorMessages, c as createKeyv, h as createKeyvNonBlocking, l as default, a as defaultReconnectStrategy };

package/vendor/Package.8.cjs

@@ -4,10 +4,6 @@ require("os");
 
 require("path");
 
-require("util");
-
-require("stream");
-
 require("events");
 
 require("fs");

package/vendor/Package.8.mjs

@@ -2,10 +2,6 @@ import "os";
 
 import "path";
 
-import "util";
-
-import "stream";
-
 import "events";
 
 import "fs";