lakutata 2.0.82 → 2.0.83

package/src/components/cacher/adapters/CreateFileCacheAdapter.cjs

@@ -28,43 +28,43 @@ const l = require("events");
 
 require("../../../../vendor/Package.1.cjs");
 
-const _interopDefault = e => e && e.__esModule ? e : {
+const c = e => e && e.__esModule ? e : {
     default: e
 };
 
-const c = _interopDefault(i);
+const u = c(i);
 
-const u = _interopDefault(s);
+const d = c(s);
 
-const d = _interopDefault(a);
+const p = c(a);
 
-const h = _interopDefault(n);
+const h = c(n);
 
-const p = _interopDefault(o);
+const f = c(o);
 
-const f = _interopDefault(l);
+const y = c(l);
 
-var y = {};
-
-var _;
+var _ = {};
 
 var v;
 
-function requireDist() {
-    if (v) return _;
-    v = 1;
+var g;
+
+function m() {
+    if (g) return v;
+    g = 1;
     "use strict";
     var e = Object.defineProperty;
     var t = Object.getOwnPropertyDescriptor;
     var r = Object.getOwnPropertyNames;
     var i = Object.prototype.hasOwnProperty;
-    var __export = (t, r) => {
+    var s = (t, r) => {
         for (var i in r) e(t, i, {
             get: r[i],
             enumerable: true
         });
     };
-    var __copyProps = (s, a, n, o) => {
+    var a = (s, a, n, o) => {
         if (a && typeof a === "object" || typeof a === "function") {
             for (let l of r(a)) if (!i.call(s, l) && l !== n) e(s, l, {
                 get: () => a[l],
@@ -73,24 +73,24 @@ function requireDist() {
         }
         return s;
     };
-    var __toCommonJS = t => __copyProps(e({}, "__esModule", {
+    var n = t => a(e({}, "__esModule", {
         value: true
     }), t);
-    var s = {};
-    __export(s, {
-        defaultDeserialize: () => defaultDeserialize,
-        defaultSerialize: () => defaultSerialize
+    var o = {};
+    s(o, {
+        defaultDeserialize: () => p,
+        defaultSerialize: () => d
     });
-    _ = __toCommonJS(s);
-    var a = c.default;
-    var _serialize = (e, t = true) => {
+    v = n(o);
+    var l = u.default;
+    var c = (e, t = true) => {
         if (e === void 0 || e === null) {
             return "null";
         }
         if (typeof e === "string") {
             return JSON.stringify(t && e.startsWith(":") ? `:${e}` : e);
         }
-        if (a.Buffer.isBuffer(e)) {
+        if (l.Buffer.isBuffer(e)) {
             return JSON.stringify(`:base64:${e.toString("base64")}`);
         }
         if (e?.toJSON) {
@@ -111,9 +111,9 @@ function requireDist() {
                 }
                 s = false;
                 if (i) {
-                    r += _serialize(e[a], t);
+                    r += c(e[a], t);
                 } else if (e[a] !== void 0) {
-                    r += `${_serialize(a, false)}:${_serialize(e[a], t)}`;
+                    r += `${c(a, false)}:${c(e[a], t)}`;
                 }
             }
             r += i ? "]" : "}";
@@ -121,38 +121,38 @@ function requireDist() {
         }
         return JSON.stringify(e);
     };
-    var defaultSerialize = e => _serialize(e, true);
-    var defaultDeserialize = e => JSON.parse(e, ((e, t) => {
+    var d = e => c(e, true);
+    var p = e => JSON.parse(e, ((e, t) => {
         if (typeof t === "string") {
             if (t.startsWith(":base64:")) {
-                return a.Buffer.from(t.slice(8), "base64");
+                return l.Buffer.from(t.slice(8), "base64");
             }
             return t.startsWith(":") ? t.slice(1) : t;
         }
         return t;
     }));
     0 && (module.exports = {
-        defaultDeserialize,
-        defaultSerialize
+        defaultDeserialize: p,
+        defaultSerialize: d
     });
-    return _;
+    return v;
 }
 
-var m = {};
-
 var F = {};
 
-var g;
+var k = {};
 
-function requireSafeEncoder() {
-    if (g) return F;
-    g = 1;
+var S;
+
+function w() {
+    if (S) return k;
+    S = 1;
     "use strict";
-    Object.defineProperty(F, "__esModule", {
+    Object.defineProperty(k, "__esModule", {
         value: true
     });
-    F.SafeFilenameEncoder = void 0;
-    F.SafeFilenameEncoder = {
+    k.SafeFilenameEncoder = void 0;
+    k.SafeFilenameEncoder = {
         encode(e) {
             return e.replace(/[^0-9a-zA-Z]/g, (e => {
                 const t = e.charCodeAt(0);
@@ -166,26 +166,26 @@ function requireSafeEncoder() {
             return decodeURIComponent(e.replace(/_/g, "%"));
         }
     };
-    return F;
+    return k;
 }
 
-var k;
+var x;
 
-function requireSeparatedFileStore() {
-    if (k) return m;
-    k = 1;
+function E() {
+    if (x) return F;
+    x = 1;
     "use strict";
-    Object.defineProperty(m, "__esModule", {
+    Object.defineProperty(F, "__esModule", {
         value: true
     });
-    m.SeparatedFileHelper = void 0;
-    m.handleIOError = handleIOError;
+    F.SeparatedFileHelper = void 0;
+    F.handleIOError = n;
     const e = r.require$$0;
-    const t = e.__importDefault(u.default);
-    const i = e.__importStar(d.default);
+    const t = e.__importDefault(d.default);
+    const i = e.__importStar(p.default);
     const s = e.__importStar(h.default);
-    const a = requireSafeEncoder();
-    function handleIOError(e) {
+    const a = w();
+    function n(e) {
         if (e.code === "ENOENT") {
             return;
         } else {
@@ -207,7 +207,7 @@ function requireSeparatedFileStore() {
             try {
                 return Number(i.readFileSync(this._lastExpireFile, "utf8"));
             } catch (e) {
-                handleIOError(e);
+                n(e);
             }
             return 0;
         }
@@ -215,7 +215,7 @@ function requireSeparatedFileStore() {
             try {
                 s.writeFile(this._lastExpireFile, e.toString());
             } catch (e) {
-                handleIOError(e);
+                n(e);
             }
         }
         async get(e) {
@@ -224,7 +224,7 @@ function requireSeparatedFileStore() {
                 let r = this.opts.deserialize(t);
                 return r;
             } catch (e) {
-                handleIOError(e);
+                n(e);
             }
         }
         getSync(e) {
@@ -233,7 +233,7 @@ function requireSeparatedFileStore() {
                 let r = this.opts.deserialize(t);
                 return r;
             } catch (e) {
-                handleIOError(e);
+                n(e);
             }
         }
         _getKey(e) {
@@ -247,7 +247,7 @@ function requireSeparatedFileStore() {
                 });
                 await s.writeFile(this._getKey(e), r);
             } catch (e) {
-                handleIOError(e);
+                n(e);
             }
         }
         async delete(e) {
@@ -255,7 +255,7 @@ function requireSeparatedFileStore() {
                 await s.unlink(this._getKey(e));
                 return true;
             } catch (e) {
-                handleIOError(e);
+                n(e);
                 return false;
             }
         }
@@ -273,7 +273,7 @@ function requireSeparatedFileStore() {
                 }
                 await s.writeFile(this._lastExpireFile, Date.now().toString());
             } catch (e) {
-                handleIOError(e);
+                n(e);
             }
         }
         async entries() {
@@ -283,23 +283,23 @@ function requireSeparatedFileStore() {
             })))));
         }
     }
-    m.SeparatedFileHelper = SeparatedFileHelper;
-    return m;
+    F.SeparatedFileHelper = SeparatedFileHelper;
+    return F;
 }
 
-var S = {};
+var O = {};
 
-var E;
+var P;
 
-function requireMakeField() {
-    if (E) return S;
-    E = 1;
+function D() {
+    if (P) return O;
+    P = 1;
     "use strict";
-    Object.defineProperty(S, "__esModule", {
+    Object.defineProperty(O, "__esModule", {
         value: true
     });
-    S.Field = void 0;
-    S.makeField = makeField$1;
+    O.Field = void 0;
+    O.makeField = e;
     class Field {
         kv;
         key;
@@ -327,276 +327,267 @@ function requireMakeField() {
             return this.kv.delete(this.key);
         }
     }
-    S.Field = Field;
-    function makeField$1(e, t, r) {
+    O.Field = Field;
+    function e(e, t, r) {
         return new Field(e, t, r);
     }
-    return S;
+    return O;
 }
 
-var w;
-
-function requireLib() {
-    if (w) return y;
-    w = 1;
-    (function(e) {
-        "use strict";
-        Object.defineProperty(e, "__esModule", {
-            value: true
-        });
-        e.KeyvFile = e.defaultOpts = void 0;
-        const t = r.require$$0;
-        const i = t.__importStar(p.default);
-        const s = t.__importStar(d.default);
-        const a = t.__importStar(h.default);
-        const n = t.__importDefault(f.default);
-        const o = requireDist();
-        const l = t.__importDefault(u.default);
-        const c = requireSeparatedFileStore();
-        t.__exportStar(requireMakeField(), e);
-        e.defaultOpts = {
-            deserialize: e => (0, o.defaultDeserialize)(e.toString()),
-            dialect: "redis",
-            expiredCheckDelay: 24 * 3600 * 1e3,
-            filename: `${i.tmpdir()}/keyv-file/default.json`,
-            serialize: o.defaultSerialize,
-            writeDelay: 100,
-            checkFileLock: false,
-            separatedFile: false
-        };
-        function isNumber(e) {
-            return typeof e === "number";
-        }
-        class KeyvFile extends n.default {
-            ttlSupport=true;
-            namespace;
-            opts;
-            _data=new Map;
-            _lastExpire=0;
-            _separated;
-            constructor(t) {
-                super();
-                this.opts = Object.assign({}, e.defaultOpts, t);
-                this._separated = new c.SeparatedFileHelper(this.opts);
-                if (this.opts.checkFileLock) {
-                    this.acquireFileLock();
-                }
-                if (this.opts.separatedFile) {
-                    s.mkdirSync(this.opts.filename, {
-                        recursive: true
-                    });
-                    this._lastExpire = this._separated.getLastExpire();
-                } else {
-                    this._loadDataSync();
-                }
+(function(e) {
+    "use strict";
+    Object.defineProperty(e, "__esModule", {
+        value: true
+    });
+    e.KeyvFile = e.defaultOpts = void 0;
+    const t = r.require$$0;
+    const i = t.__importStar(f.default);
+    const s = t.__importStar(p.default);
+    const a = t.__importStar(h.default);
+    const n = t.__importDefault(y.default);
+    const o = m();
+    const l = t.__importDefault(d.default);
+    const c = E();
+    t.__exportStar(D(), e);
+    e.defaultOpts = {
+        deserialize: e => (0, o.defaultDeserialize)(e.toString()),
+        dialect: "redis",
+        expiredCheckDelay: 24 * 3600 * 1e3,
+        filename: `${i.tmpdir()}/keyv-file/default.json`,
+        serialize: o.defaultSerialize,
+        writeDelay: 100,
+        checkFileLock: false,
+        separatedFile: false
+    };
+    function u(e) {
+        return typeof e === "number";
+    }
+    class KeyvFile extends n.default {
+        ttlSupport=true;
+        namespace;
+        opts;
+        _data=new Map;
+        _lastExpire=0;
+        _separated;
+        constructor(t) {
+            super();
+            this.opts = Object.assign({}, e.defaultOpts, t);
+            this._separated = new c.SeparatedFileHelper(this.opts);
+            if (this.opts.checkFileLock) {
+                this.acquireFileLock();
+            }
+            if (this.opts.separatedFile) {
+                s.mkdirSync(this.opts.filename, {
+                    recursive: true
+                });
+                this._lastExpire = this._separated.getLastExpire();
+            } else {
+                this._loadDataSync();
             }
-            _loadDataSync() {
-                try {
-                    const e = this.opts.deserialize(s.readFileSync(this.opts.filename));
-                    if (!Array.isArray(e.cache)) {
-                        const t = e.cache;
-                        e.cache = [];
-                        for (const r in t) {
-                            if (t.hasOwnProperty(r)) {
-                                e.cache.push([ r, t[r] ]);
-                            }
+        }
+        _loadDataSync() {
+            try {
+                const e = this.opts.deserialize(s.readFileSync(this.opts.filename));
+                if (!Array.isArray(e.cache)) {
+                    const t = e.cache;
+                    e.cache = [];
+                    for (const r in t) {
+                        if (t.hasOwnProperty(r)) {
+                            e.cache.push([ r, t[r] ]);
                         }
                     }
-                    this._data = new Map(e.cache);
-                    this._lastExpire = e.lastExpire;
-                } catch (e) {
-                    (0, c.handleIOError)(e);
-                    this._data = new Map;
-                    this._lastExpire = Date.now();
                 }
+                this._data = new Map(e.cache);
+                this._lastExpire = e.lastExpire;
+            } catch (e) {
+                (0, c.handleIOError)(e);
+                this._data = new Map;
+                this._lastExpire = Date.now();
             }
-            get _lockFile() {
-                if (this.opts.separatedFile) {
-                    return this._separated.lockFile;
-                }
-                return this.opts.filename + ".lock";
-            }
-            acquireFileLock() {
-                try {
-                    let e = s.openSync(this._lockFile, "wx");
-                    s.closeSync(e);
-                    process.on("SIGINT", (() => {
-                        this.releaseFileLock();
-                        process.exit(0);
-                    }));
-                    process.on("exit", (() => {
-                        this.releaseFileLock();
-                    }));
-                } catch (e) {
-                    console.error(`[keyv-file] There is another process using this file`);
-                    throw e;
-                }
+        }
+        get _lockFile() {
+            if (this.opts.separatedFile) {
+                return this._separated.lockFile;
             }
-            releaseFileLock() {
-                try {
-                    s.unlinkSync(this._lockFile);
-                } catch (e) {
-                    (0, c.handleIOError)(e);
-                }
+            return this.opts.filename + ".lock";
+        }
+        acquireFileLock() {
+            try {
+                let e = s.openSync(this._lockFile, "wx");
+                s.closeSync(e);
+                process.on("SIGINT", (() => {
+                    this.releaseFileLock();
+                    process.exit(0);
+                }));
+                process.on("exit", (() => {
+                    this.releaseFileLock();
+                }));
+            } catch (e) {
+                console.error(`[keyv-file] There is another process using this file`);
+                throw e;
             }
-            async get(e) {
-                if (this.opts.separatedFile) {
-                    let t = await this._separated.get(e);
-                    return this._getWithExpire(e, t);
-                }
-                return this.getSync(e);
+        }
+        releaseFileLock() {
+            try {
+                s.unlinkSync(this._lockFile);
+            } catch (e) {
+                (0, c.handleIOError)(e);
             }
-            getSync(e) {
-                if (this.opts.separatedFile) {
-                    let t = this._separated.getSync(e);
-                    return this._getWithExpire(e, t);
-                }
-                let t = void 0;
-                try {
-                    const t = this._data.get(e);
-                    return this._getWithExpire(e, t);
-                } catch (e) {
-                    (0, c.handleIOError)(e);
-                }
-                return t;
+        }
+        async get(e) {
+            if (this.opts.separatedFile) {
+                let t = await this._separated.get(e);
+                return this._getWithExpire(e, t);
             }
-            async getMany(e) {
-                if (this.opts.separatedFile) {
-                    return Promise.all(e.map((e => this.get(e))));
-                }
-                return e.map((e => this.getSync(e)));
+            return this.getSync(e);
+        }
+        getSync(e) {
+            if (this.opts.separatedFile) {
+                let t = this._separated.getSync(e);
+                return this._getWithExpire(e, t);
             }
-            async set(e, t, r) {
-                if (r === 0) {
-                    r = undefined;
-                }
-                t = {
-                    expire: isNumber(r) ? Date.now() + r : undefined,
-                    value: t
-                };
-                this.clearExpire();
-                if (this.opts.separatedFile) {
-                    return this._separated.set(e, t);
-                }
-                this._data.set(e, t);
-                return this.save();
+            let t = void 0;
+            try {
+                const t = this._data.get(e);
+                return this._getWithExpire(e, t);
+            } catch (e) {
+                (0, c.handleIOError)(e);
             }
-            async delete(e) {
-                if (this.opts.separatedFile) {
-                    return this._separated.delete(e);
-                }
-                const t = this._data.delete(e);
-                await this.save();
-                return t;
-            }
-            async deleteMany(e) {
-                if (this.opts.separatedFile) {
-                    let t = await Promise.all(e.map((e => this.delete(e))));
-                    return t.every((e => e));
-                }
-                let t = e.every((e => this._data.delete(e)));
-                await this.save();
-                return t;
-            }
-            async clear() {
-                if (this.opts.separatedFile) {
-                    await this._separated.clear();
-                    this._lastExpire = 0;
-                    return true;
-                }
-                this._data = new Map;
-                this._lastExpire = Date.now();
-                return this.save();
+            return t;
+        }
+        async getMany(e) {
+            if (this.opts.separatedFile) {
+                return Promise.all(e.map((e => this.get(e))));
             }
-            async has(e) {
-                const t = await this.get(e);
-                return t !== undefined;
+            return e.map((e => this.getSync(e)));
+        }
+        async set(e, t, r) {
+            if (r === 0) {
+                r = undefined;
             }
-            isExpired(e) {
-                return isNumber(e.expire) && e.expire <= Date.now();
+            t = {
+                expire: u(r) ? Date.now() + r : undefined,
+                value: t
+            };
+            this.clearExpire();
+            if (this.opts.separatedFile) {
+                return this._separated.set(e, t);
             }
-            _getWithExpire(e, t) {
-                if (!t) {
-                    return;
-                }
-                if (this.isExpired(t)) {
-                    this.delete(e);
-                    return;
-                }
-                return t.value;
+            this._data.set(e, t);
+            return this.save();
+        }
+        async delete(e) {
+            if (this.opts.separatedFile) {
+                return this._separated.delete(e);
             }
-            clearExpire() {
-                const e = Date.now();
-                if (e - this._lastExpire <= this.opts.expiredCheckDelay) {
-                    return;
-                }
-                this._lastExpire = e;
-                if (this.opts.separatedFile) {
-                    this._separated.clearExpire((e => this.get(e)));
-                    return;
-                }
-                for (const e of this._data.keys()) {
-                    const t = this._data.get(e);
-                    this._getWithExpire(e, t);
-                }
+            const t = this._data.delete(e);
+            await this.save();
+            return t;
+        }
+        async deleteMany(e) {
+            if (this.opts.separatedFile) {
+                let t = await Promise.all(e.map((e => this.delete(e))));
+                return t.every((e => e));
             }
-            async saveToDisk() {
-                const e = [];
-                for (const [t, r] of this._data) {
-                    e.push([ t, r ]);
-                }
-                const t = this.opts.serialize({
-                    cache: e,
-                    lastExpire: this._lastExpire
-                });
-                await a.mkdir(l.default.dirname(this.opts.filename), {
-                    recursive: true
-                });
-                return a.writeFile(this.opts.filename, t);
+            let t = e.every((e => this._data.delete(e)));
+            await this.save();
+            return t;
+        }
+        async clear() {
+            if (this.opts.separatedFile) {
+                await this._separated.clear();
+                this._lastExpire = 0;
+                return true;
             }
-            _savePromise;
-            save() {
-                this.clearExpire();
-                if (this._savePromise) {
-                    return this._savePromise;
-                }
-                this._savePromise = new Promise(((e, t) => {
-                    setTimeout((() => {
-                        this.saveToDisk().then(e, t).finally((() => {
-                            this._savePromise = void 0;
-                        }));
-                    }), this.opts.writeDelay);
-                }));
-                return this._savePromise;
+            this._data = new Map;
+            this._lastExpire = Date.now();
+            return this.save();
+        }
+        async has(e) {
+            const t = await this.get(e);
+            return t !== undefined;
+        }
+        isExpired(e) {
+            return u(e.expire) && e.expire <= Date.now();
+        }
+        _getWithExpire(e, t) {
+            if (!t) {
+                return;
             }
-            disconnect() {
-                return Promise.resolve();
+            if (this.isExpired(t)) {
+                this.delete(e);
+                return;
             }
-            async* iterator(e) {
-                let t = this.opts.separatedFile ? await this._separated.entries() : this._data.entries();
-                for (const [r, i] of t) {
-                    if (r === undefined || i === undefined) {
-                        continue;
-                    }
-                    if (!e || r.includes(e)) {
-                        yield [ r, i.value ];
-                    }
+            return t.value;
+        }
+        clearExpire() {
+            const e = Date.now();
+            if (e - this._lastExpire <= this.opts.expiredCheckDelay) {
+                return;
+            }
+            this._lastExpire = e;
+            if (this.opts.separatedFile) {
+                this._separated.clearExpire((e => this.get(e)));
+                return;
+            }
+            for (const e of this._data.keys()) {
+                const t = this._data.get(e);
+                this._getWithExpire(e, t);
+            }
+        }
+        async saveToDisk() {
+            const e = [];
+            for (const [t, r] of this._data) {
+                e.push([ t, r ]);
+            }
+            const t = this.opts.serialize({
+                cache: e,
+                lastExpire: this._lastExpire
+            });
+            await a.mkdir(l.default.dirname(this.opts.filename), {
+                recursive: true
+            });
+            return a.writeFile(this.opts.filename, t);
+        }
+        _savePromise;
+        save() {
+            this.clearExpire();
+            if (this._savePromise) {
+                return this._savePromise;
+            }
+            this._savePromise = new Promise(((e, t) => {
+                setTimeout((() => {
+                    this.saveToDisk().then(e, t).finally((() => {
+                        this._savePromise = void 0;
+                    }));
+                }), this.opts.writeDelay);
+            }));
+            return this._savePromise;
+        }
+        disconnect() {
+            return Promise.resolve();
+        }
+        async* iterator(e) {
+            let t = this.opts.separatedFile ? await this._separated.entries() : this._data.entries();
+            for (const [r, i] of t) {
+                if (r === undefined || i === undefined) {
+                    continue;
+                }
+                if (!e || r.includes(e)) {
+                    yield [ r, i.value ];
                 }
             }
         }
-        e.KeyvFile = KeyvFile;
-        e.default = KeyvFile;
-    })(y);
-    return y;
-}
-
-var x = requireLib();
+    }
+    e.KeyvFile = KeyvFile;
+    e.default = KeyvFile;
+})(_);
 
-const O = t.getDefaultExportFromCjs(x);
+const b = t.getDefaultExportFromCjs(_);
 
-async function CreateFileCacheAdapter(t) {
+async function j(t) {
     return new e.index_default({
-        store: new x.KeyvFile({
+        store: new _.KeyvFile({
             filename: t.filename,
             expiredCheckDelay: t.expiredCheckDelay,
             writeDelay: t.writeDelay
@@ -605,4 +596,4 @@ async function CreateFileCacheAdapter(t) {
     });
 }
 
-exports.CreateFileCacheAdapter = CreateFileCacheAdapter;
+exports.CreateFileCacheAdapter = j;