lakutata 2.0.82 → 2.0.83

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

@@ -10,9 +10,9 @@ import "../../../../vendor/Package.14.mjs";
 
 import i from "buffer";
 
-import a from "path";
+import s from "path";
 
-import s from "fs";
+import a from "fs";
 
 import n from "fs/promises";
 
@@ -24,51 +24,51 @@ import "../../../../vendor/Package.1.mjs";
 
 var c = {};
 
-var u;
-
 var p;
 
-function requireDist() {
-    if (p) return u;
-    p = 1;
+var u;
+
+function h() {
+    if (u) return p;
+    u = 1;
     "use strict";
     var e = Object.defineProperty;
     var t = Object.getOwnPropertyDescriptor;
     var r = Object.getOwnPropertyNames;
-    var a = Object.prototype.hasOwnProperty;
-    var __export = (t, r) => {
+    var s = Object.prototype.hasOwnProperty;
+    var a = (t, r) => {
         for (var i in r) e(t, i, {
             get: r[i],
             enumerable: true
         });
     };
-    var __copyProps = (i, s, n, o) => {
-        if (s && typeof s === "object" || typeof s === "function") {
-            for (let l of r(s)) if (!a.call(i, l) && l !== n) e(i, l, {
-                get: () => s[l],
-                enumerable: !(o = t(s, l)) || o.enumerable
+    var n = (i, a, n, o) => {
+        if (a && typeof a === "object" || typeof a === "function") {
+            for (let l of r(a)) if (!s.call(i, l) && l !== n) e(i, l, {
+                get: () => a[l],
+                enumerable: !(o = t(a, l)) || o.enumerable
             });
         }
         return i;
     };
-    var __toCommonJS = t => __copyProps(e({}, "__esModule", {
+    var o = t => n(e({}, "__esModule", {
         value: true
     }), t);
-    var s = {};
-    __export(s, {
-        defaultDeserialize: () => defaultDeserialize,
-        defaultSerialize: () => defaultSerialize
+    var l = {};
+    a(l, {
+        defaultDeserialize: () => f,
+        defaultSerialize: () => d
     });
-    u = __toCommonJS(s);
-    var n = i;
-    var _serialize = (e, t = true) => {
+    p = o(l);
+    var c = i;
+    var h = (e, t = true) => {
         if (e === void 0 || e === null) {
             return "null";
         }
         if (typeof e === "string") {
             return JSON.stringify(t && e.startsWith(":") ? `:${e}` : e);
         }
-        if (n.Buffer.isBuffer(e)) {
+        if (c.Buffer.isBuffer(e)) {
             return JSON.stringify(`:base64:${e.toString("base64")}`);
         }
         if (e?.toJSON) {
@@ -78,20 +78,20 @@ function requireDist() {
             let r = "";
             const i = Array.isArray(e);
             r = i ? "[" : "{";
-            let a = true;
-            for (const s in e) {
-                const n = typeof e[s] === "function" || !i && e[s] === void 0;
-                if (!Object.hasOwn(e, s) || n) {
+            let s = true;
+            for (const a in e) {
+                const n = typeof e[a] === "function" || !i && e[a] === void 0;
+                if (!Object.hasOwn(e, a) || n) {
                     continue;
                 }
-                if (!a) {
+                if (!s) {
                     r += ",";
                 }
-                a = false;
+                s = false;
                 if (i) {
-                    r += _serialize(e[s], t);
-                } else if (e[s] !== void 0) {
-                    r += `${_serialize(s, false)}:${_serialize(e[s], t)}`;
+                    r += h(e[a], t);
+                } else if (e[a] !== void 0) {
+                    r += `${h(a, false)}:${h(e[a], t)}`;
                 }
             }
             r += i ? "]" : "}";
@@ -99,38 +99,38 @@ function requireDist() {
         }
         return JSON.stringify(e);
     };
-    var defaultSerialize = e => _serialize(e, true);
-    var defaultDeserialize = e => JSON.parse(e, ((e, t) => {
+    var d = e => h(e, true);
+    var f = e => JSON.parse(e, ((e, t) => {
         if (typeof t === "string") {
             if (t.startsWith(":base64:")) {
-                return n.Buffer.from(t.slice(8), "base64");
+                return c.Buffer.from(t.slice(8), "base64");
             }
             return t.startsWith(":") ? t.slice(1) : t;
         }
         return t;
     }));
     0 && (module.exports = {
-        defaultDeserialize,
-        defaultSerialize
+        defaultDeserialize: f,
+        defaultSerialize: d
     });
-    return u;
+    return p;
 }
 
 var d = {};
 
-var h = {};
+var f = {};
 
-var f;
+var y;
 
-function requireSafeEncoder() {
-    if (f) return h;
-    f = 1;
+function m() {
+    if (y) return f;
+    y = 1;
     "use strict";
-    Object.defineProperty(h, "__esModule", {
+    Object.defineProperty(f, "__esModule", {
         value: true
     });
-    h.SafeFilenameEncoder = void 0;
-    h.SafeFilenameEncoder = {
+    f.SafeFilenameEncoder = void 0;
+    f.SafeFilenameEncoder = {
         encode(e) {
             return e.replace(/[^0-9a-zA-Z]/g, (e => {
                 const t = e.charCodeAt(0);
@@ -144,26 +144,26 @@ function requireSafeEncoder() {
             return decodeURIComponent(e.replace(/_/g, "%"));
         }
     };
-    return h;
+    return f;
 }
 
-var y;
+var _;
 
-function requireSeparatedFileStore() {
-    if (y) return d;
-    y = 1;
+function v() {
+    if (_) return d;
+    _ = 1;
     "use strict";
     Object.defineProperty(d, "__esModule", {
         value: true
     });
     d.SeparatedFileHelper = void 0;
-    d.handleIOError = handleIOError;
+    d.handleIOError = c;
     const e = r;
-    const t = e.__importDefault(a);
-    const i = e.__importStar(s);
+    const t = e.__importDefault(s);
+    const i = e.__importStar(a);
     const o = e.__importStar(n);
-    const l = requireSafeEncoder();
-    function handleIOError(e) {
+    const l = m();
+    function c(e) {
         if (e.code === "ENOENT") {
             return;
         } else {
@@ -185,7 +185,7 @@ function requireSeparatedFileStore() {
             try {
                 return Number(i.readFileSync(this._lastExpireFile, "utf8"));
             } catch (e) {
-                handleIOError(e);
+                c(e);
             }
             return 0;
         }
@@ -193,7 +193,7 @@ function requireSeparatedFileStore() {
             try {
                 o.writeFile(this._lastExpireFile, e.toString());
             } catch (e) {
-                handleIOError(e);
+                c(e);
             }
         }
         async get(e) {
@@ -202,7 +202,7 @@ function requireSeparatedFileStore() {
                 let r = this.opts.deserialize(t);
                 return r;
             } catch (e) {
-                handleIOError(e);
+                c(e);
             }
         }
         getSync(e) {
@@ -211,7 +211,7 @@ function requireSeparatedFileStore() {
                 let r = this.opts.deserialize(t);
                 return r;
             } catch (e) {
-                handleIOError(e);
+                c(e);
             }
         }
         _getKey(e) {
@@ -225,7 +225,7 @@ function requireSeparatedFileStore() {
                 });
                 await o.writeFile(this._getKey(e), r);
             } catch (e) {
-                handleIOError(e);
+                c(e);
             }
         }
         async delete(e) {
@@ -233,7 +233,7 @@ function requireSeparatedFileStore() {
                 await o.unlink(this._getKey(e));
                 return true;
             } catch (e) {
-                handleIOError(e);
+                c(e);
                 return false;
             }
         }
@@ -251,7 +251,7 @@ function requireSeparatedFileStore() {
                 }
                 await o.writeFile(this._lastExpireFile, Date.now().toString());
             } catch (e) {
-                handleIOError(e);
+                c(e);
             }
         }
         async entries() {
@@ -265,19 +265,19 @@ function requireSeparatedFileStore() {
     return d;
 }
 
-var m = {};
+var g = {};
 
-var _;
+var F;
 
-function requireMakeField() {
-    if (_) return m;
-    _ = 1;
+function k() {
+    if (F) return g;
+    F = 1;
     "use strict";
-    Object.defineProperty(m, "__esModule", {
+    Object.defineProperty(g, "__esModule", {
         value: true
     });
-    m.Field = void 0;
-    m.makeField = makeField$1;
+    g.Field = void 0;
+    g.makeField = e;
     class Field {
         kv;
         key;
@@ -305,276 +305,267 @@ function requireMakeField() {
             return this.kv.delete(this.key);
         }
     }
-    m.Field = Field;
-    function makeField$1(e, t, r) {
+    g.Field = Field;
+    function e(e, t, r) {
         return new Field(e, t, r);
     }
-    return m;
+    return g;
 }
 
-var v;
-
-function requireLib() {
-    if (v) return c;
-    v = 1;
-    (function(e) {
-        "use strict";
-        Object.defineProperty(e, "__esModule", {
-            value: true
-        });
-        e.KeyvFile = e.defaultOpts = void 0;
-        const t = r;
-        const i = t.__importStar(o);
-        const c = t.__importStar(s);
-        const u = t.__importStar(n);
-        const p = t.__importDefault(l);
-        const d = requireDist();
-        const h = t.__importDefault(a);
-        const f = requireSeparatedFileStore();
-        t.__exportStar(requireMakeField(), e);
-        e.defaultOpts = {
-            deserialize: e => (0, d.defaultDeserialize)(e.toString()),
-            dialect: "redis",
-            expiredCheckDelay: 24 * 3600 * 1e3,
-            filename: `${i.tmpdir()}/keyv-file/default.json`,
-            serialize: d.defaultSerialize,
-            writeDelay: 100,
-            checkFileLock: false,
-            separatedFile: false
-        };
-        function isNumber(e) {
-            return typeof e === "number";
-        }
-        class KeyvFile extends p.default {
-            ttlSupport=true;
-            namespace;
-            opts;
-            _data=new Map;
-            _lastExpire=0;
-            _separated;
-            constructor(t) {
-                super();
-                this.opts = Object.assign({}, e.defaultOpts, t);
-                this._separated = new f.SeparatedFileHelper(this.opts);
-                if (this.opts.checkFileLock) {
-                    this.acquireFileLock();
-                }
-                if (this.opts.separatedFile) {
-                    c.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;
+    const i = t.__importStar(o);
+    const c = t.__importStar(a);
+    const p = t.__importStar(n);
+    const u = t.__importDefault(l);
+    const d = h();
+    const f = t.__importDefault(s);
+    const y = v();
+    t.__exportStar(k(), e);
+    e.defaultOpts = {
+        deserialize: e => (0, d.defaultDeserialize)(e.toString()),
+        dialect: "redis",
+        expiredCheckDelay: 24 * 3600 * 1e3,
+        filename: `${i.tmpdir()}/keyv-file/default.json`,
+        serialize: d.defaultSerialize,
+        writeDelay: 100,
+        checkFileLock: false,
+        separatedFile: false
+    };
+    function m(e) {
+        return typeof e === "number";
+    }
+    class KeyvFile extends u.default {
+        ttlSupport=true;
+        namespace;
+        opts;
+        _data=new Map;
+        _lastExpire=0;
+        _separated;
+        constructor(t) {
+            super();
+            this.opts = Object.assign({}, e.defaultOpts, t);
+            this._separated = new y.SeparatedFileHelper(this.opts);
+            if (this.opts.checkFileLock) {
+                this.acquireFileLock();
+            }
+            if (this.opts.separatedFile) {
+                c.mkdirSync(this.opts.filename, {
+                    recursive: true
+                });
+                this._lastExpire = this._separated.getLastExpire();
+            } else {
+                this._loadDataSync();
             }
-            _loadDataSync() {
-                try {
-                    const e = this.opts.deserialize(c.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(c.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, f.handleIOError)(e);
-                    this._data = new Map;
-                    this._lastExpire = Date.now();
                 }
+                this._data = new Map(e.cache);
+                this._lastExpire = e.lastExpire;
+            } catch (e) {
+                (0, y.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 = c.openSync(this._lockFile, "wx");
-                    c.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 {
-                    c.unlinkSync(this._lockFile);
-                } catch (e) {
-                    (0, f.handleIOError)(e);
-                }
+            return this.opts.filename + ".lock";
+        }
+        acquireFileLock() {
+            try {
+                let e = c.openSync(this._lockFile, "wx");
+                c.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 {
+                c.unlinkSync(this._lockFile);
+            } catch (e) {
+                (0, y.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, f.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, y.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: m(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 u.mkdir(h.default.dirname(this.opts.filename), {
-                    recursive: true
-                });
-                return u.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 m(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 p.mkdir(f.default.dirname(this.opts.filename), {
+                recursive: true
+            });
+            return p.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;
-    })(c);
-    return c;
-}
-
-var F = requireLib();
+    }
+    e.KeyvFile = KeyvFile;
+    e.default = KeyvFile;
+})(c);
 
-const g = t(F);
+const S = t(c);
 
-async function CreateFileCacheAdapter(t) {
+async function w(t) {
     return new e({
-        store: new F.KeyvFile({
+        store: new c.KeyvFile({
             filename: t.filename,
             expiredCheckDelay: t.expiredCheckDelay,
             writeDelay: t.writeDelay
@@ -583,4 +574,4 @@ async function CreateFileCacheAdapter(t) {
     });
 }
 
-export { CreateFileCacheAdapter };
+export { w as CreateFileCacheAdapter };