lakutata 2.0.95 → 2.0.97

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

@@ -1,59 +1,585 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:10:51 GMT+0800 (China Standard Time) */
 "use strict";
 
 Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-const e = require("../../../../vendor/Package.internal.13.cjs");
+const e = require("../../../../vendor/Package.internal.56.cjs");
 
-const r = require("../../../../vendor/Package.internal.130.cjs");
+const t = require("../../../../vendor/Package.internal.310.cjs");
 
-require("../../../../vendor/Package.internal.11.cjs");
+const r = require("os");
 
-require("buffer");
+const i = require("fs");
 
-require("@redis/client");
+const s = require("fs/promises");
 
-require("../../../../vendor/Package.internal.12.cjs");
+const a = require("events");
 
-require("cluster-key-slot");
+const n = require("buffer");
 
-require("events");
+const o = require("path");
 
-require("memjs");
+require("../../../../vendor/Package.internal.2.cjs");
 
-require("mongodb");
+require("../../../../vendor/Package.internal.3.cjs");
 
-require("util");
+const l = e => e && e.__esModule ? e : {
+    default: e
+};
 
-require("sqlite3");
+const c = l(r);
 
-require("pg");
+const u = l(i);
 
-require("mysql2");
+const d = l(s);
 
-require("../../../../vendor/Package.internal.131.cjs");
+const p = l(a);
 
-require("../../../../vendor/Package.internal.8.cjs");
+const h = l(n);
 
-require("os");
+const f = l(o);
 
-require("fs");
+var y = {};
 
-require("fs/promises");
+var _;
 
-require("path");
+var v;
 
-async function i(i) {
+function m() {
+    if (v) return _;
+    v = 1;
+    var e = Object.defineProperty;
+    var t = Object.getOwnPropertyDescriptor;
+    var r = Object.getOwnPropertyNames;
+    var i = Object.prototype.hasOwnProperty;
+    var s = (t, r) => {
+        for (var i in r) e(t, i, {
+            get: r[i],
+            enumerable: true
+        });
+    };
+    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],
+                enumerable: !(o = t(a, l)) || o.enumerable
+            });
+        }
+        return s;
+    };
+    var n = t => a(e({}, "__esModule", {
+        value: true
+    }), t);
+    var o = {};
+    s(o, {
+        defaultDeserialize: () => d,
+        defaultSerialize: () => u
+    });
+    _ = n(o);
+    var l = h.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 (l.Buffer.isBuffer(e)) {
+            return JSON.stringify(`:base64:${e.toString("base64")}`);
+        }
+        if (e?.toJSON) {
+            e = e.toJSON();
+        }
+        if (typeof e === "object") {
+            let r = "";
+            const i = Array.isArray(e);
+            r = i ? "[" : "{";
+            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 (!s) {
+                    r += ",";
+                }
+                s = false;
+                if (i) {
+                    r += c(e[a], t);
+                } else if (e[a] !== void 0) {
+                    r += `${c(a, false)}:${c(e[a], t)}`;
+                }
+            }
+            r += i ? "]" : "}";
+            return r;
+        }
+        return JSON.stringify(e);
+    };
+    var u = e => c(e, true);
+    var d = e => JSON.parse(e, (e, t) => {
+        if (typeof t === "string") {
+            if (t.startsWith(":base64:")) {
+                return l.Buffer.from(t.slice(8), "base64");
+            }
+            return t.startsWith(":") ? t.slice(1) : t;
+        }
+        return t;
+    });
+    return _;
+}
+
+var g = {};
+
+var F = {};
+
+var k;
+
+function S() {
+    if (k) return F;
+    k = 1;
+    Object.defineProperty(F, "__esModule", {
+        value: true
+    });
+    F.SafeFilenameEncoder = void 0;
+    F.SafeFilenameEncoder = {
+        encode(e) {
+            return e.replace(/[^0-9a-zA-Z]/g, e => {
+                const t = e.charCodeAt(0);
+                if (t < 0 || t > 126) {
+                    return e;
+                }
+                return "%" + e.charCodeAt(0).toString(16).padStart(2, "0");
+            }).replace(/%/g, "_");
+        },
+        decode(e) {
+            return decodeURIComponent(e.replace(/_/g, "%"));
+        }
+    };
+    return F;
+}
+
+var w;
+
+function x() {
+    if (w) return g;
+    w = 1;
+    Object.defineProperty(g, "__esModule", {
+        value: true
+    });
+    g.SeparatedFileHelper = void 0;
+    g.handleIOError = n;
+    const e = t.require$$0;
+    const r = e.__importDefault(f.default);
+    const i = e.__importStar(u.default);
+    const s = e.__importStar(d.default);
+    const a = S();
+    function n(e) {
+        if (e.code === "ENOENT") {
+            return;
+        } else {
+            console.error(e);
+        }
+    }
+    class SeparatedFileHelper {
+        opts;
+        get lockFile() {
+            return r.default.join(this.opts.filename, ".lock");
+        }
+        get _lastExpireFile() {
+            return r.default.join(this.opts.filename, ".lastExpire");
+        }
+        constructor(e) {
+            this.opts = e;
+        }
+        getLastExpire() {
+            try {
+                return Number(i.readFileSync(this._lastExpireFile, "utf8"));
+            } catch (e) {
+                n(e);
+            }
+            return 0;
+        }
+        setLastExpire(e) {
+            try {
+                s.writeFile(this._lastExpireFile, e.toString());
+            } catch (e) {
+                n(e);
+            }
+        }
+        async get(e) {
+            try {
+                let t = await s.readFile(this._getKey(e));
+                let r = this.opts.deserialize(t);
+                return r;
+            } catch (e) {
+                n(e);
+            }
+        }
+        getSync(e) {
+            try {
+                let t = i.readFileSync(this._getKey(e));
+                let r = this.opts.deserialize(t);
+                return r;
+            } catch (e) {
+                n(e);
+            }
+        }
+        _getKey(e) {
+            return r.default.join(this.opts.filename, a.SafeFilenameEncoder.encode(e));
+        }
+        async set(e, t) {
+            try {
+                let r = this.opts.serialize(t);
+                await s.mkdir(this.opts.filename, {
+                    recursive: true
+                });
+                await s.writeFile(this._getKey(e), r);
+            } catch (e) {
+                n(e);
+            }
+        }
+        async delete(e) {
+            try {
+                await s.unlink(this._getKey(e));
+                return true;
+            } catch (e) {
+                n(e);
+                return false;
+            }
+        }
+        async clear() {
+            await s.rm(this.opts.filename, {
+                recursive: true,
+                force: true
+            });
+        }
+        async clearExpire(e) {
+            try {
+                let t = await s.readdir(this.opts.filename);
+                for (const r of t) {
+                    e(r);
+                }
+                await s.writeFile(this._lastExpireFile, Date.now().toString());
+            } catch (e) {
+                n(e);
+            }
+        }
+        async entries() {
+            return s.readdir(this.opts.filename).then(e => Promise.all(e.map(async e => {
+                e = a.SafeFilenameEncoder.decode(e);
+                return [ e, await this.get(e) ];
+            })));
+        }
+    }
+    g.SeparatedFileHelper = SeparatedFileHelper;
+    return g;
+}
+
+var E = {};
+
+var O;
+
+function P() {
+    if (O) return E;
+    O = 1;
+    Object.defineProperty(E, "__esModule", {
+        value: true
+    });
+    E.Field = void 0;
+    E.makeField = e;
+    class Field {
+        kv;
+        key;
+        defaults;
+        constructor(e, t, r) {
+            this.kv = e;
+            this.key = t;
+            this.defaults = r;
+        }
+        async get(e = this.defaults) {
+            return await this.kv.get(this.key) ?? e;
+        }
+        getSync(e = this.defaults) {
+            if (this.kv instanceof Map) {
+                return this.kv.get(this.key) ?? e;
+            } else if ("getSync" in this.kv) {
+                return this.kv.getSync(this.key) ?? e;
+            }
+            throw new Error("kv does not support getSync");
+        }
+        set(e, t) {
+            return this.kv.set(this.key, e, t);
+        }
+        delete() {
+            return this.kv.delete(this.key);
+        }
+    }
+    E.Field = Field;
+    function e(e, t, r) {
+        return new Field(e, t, r);
+    }
+    return E;
+}
+
+(function(e) {
+    Object.defineProperty(e, "__esModule", {
+        value: true
+    });
+    e.KeyvFile = e.defaultOpts = void 0;
+    const r = t.require$$0;
+    const i = r.__importStar(c.default);
+    const s = r.__importStar(u.default);
+    const a = r.__importStar(d.default);
+    const n = r.__importDefault(p.default);
+    const o = m();
+    const l = r.__importDefault(f.default);
+    const h = x();
+    r.__exportStar(P(), 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 y(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 h.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] ]);
+                        }
+                    }
+                }
+                this._data = new Map(e.cache);
+                this._lastExpire = e.lastExpire;
+            } catch (e) {
+                (0, h.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;
+            }
+        }
+        releaseFileLock() {
+            try {
+                s.unlinkSync(this._lockFile);
+            } catch (e) {
+                (0, h.handleIOError)(e);
+            }
+        }
+        async get(e) {
+            if (this.opts.separatedFile) {
+                let t = await this._separated.get(e);
+                return this._getWithExpire(e, t);
+            }
+            return this.getSync(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, h.handleIOError)(e);
+            }
+            return t;
+        }
+        async getMany(e) {
+            if (this.opts.separatedFile) {
+                return Promise.all(e.map(e => this.get(e)));
+            }
+            return e.map(e => this.getSync(e));
+        }
+        async set(e, t, r) {
+            if (r === 0) {
+                r = undefined;
+            }
+            t = {
+                expire: y(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();
+        }
+        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();
+        }
+        async has(e) {
+            const t = await this.get(e);
+            return t !== undefined;
+        }
+        isExpired(e) {
+            return y(e.expire) && e.expire <= Date.now();
+        }
+        _getWithExpire(e, t) {
+            if (!t) {
+                return;
+            }
+            if (this.isExpired(t)) {
+                this.delete(e);
+                return;
+            }
+            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);
+
+async function b(t) {
     return new e.index_default({
-        store: new r.lib.KeyvFile({
-            filename: i.filename,
-            expiredCheckDelay: i.expiredCheckDelay,
-            writeDelay: i.writeDelay
+        store: new y.KeyvFile({
+            filename: t.filename,
+            expiredCheckDelay: t.expiredCheckDelay,
+            writeDelay: t.writeDelay
         }),
-        namespace: i.namespace
+        namespace: t.namespace
     });
 }
 
-exports.CreateFileCacheAdapter = i;
+exports.CreateFileCacheAdapter = b;