lakutata 2.0.96 → 2.0.97

package/vendor/Package.internal.59.mjs

@@ -1,195 +1,326 @@
-/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
-import e from "tty";
-
-var t = {};
-
-Object.defineProperty(t, "__esModule", {
-    value: true
-});
-
-var g = e;
-
-function r(e) {
-    if (e && e.__esModule) return e;
-    var t = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function(g) {
-            if (g !== "default") {
-                var r = Object.getOwnPropertyDescriptor(e, g);
-                Object.defineProperty(t, g, r.get ? r : {
-                    enumerable: true,
-                    get: function() {
-                        return e[g];
+/* Build Date: Mon Nov 24 2025 18:10:51 GMT+0800 (China Standard Time) */
+import { Buffer as t } from "buffer";
+
+import e from "events";
+
+import { MongoClient as n, GridFSBucket as s, MongoServerError as a } from "mongodb";
+
+var o = new Set([ "url", "collection", "namespace", "serialize", "deserialize", "uri", "useGridFS", "dialect", "db" ]);
+
+var i = class extends e {
+    ttlSupport=false;
+    opts;
+    connect;
+    namespace;
+    constructor(t, e) {
+        super();
+        t ??= {};
+        if (typeof t === "string") {
+            t = {
+                url: t
+            };
+        }
+        if (t.uri) {
+            t = {
+                url: t.uri,
+                ...t
+            };
+        }
+        this.opts = {
+            url: "mongodb://127.0.0.1:27017",
+            collection: "keyv",
+            ...t,
+            ...e
+        };
+        delete this.opts.emitErrors;
+        const a = Object.fromEntries(Object.entries(this.opts).filter(([t]) => !o.has(t)));
+        this.opts = Object.fromEntries(Object.entries(this.opts).filter(([t]) => o.has(t)));
+        this.connect = new Promise(async (t, e) => {
+            try {
+                let e = "";
+                if (this.opts.url) {
+                    e = this.opts.url;
+                }
+                const o = new n(e, a);
+                await o.connect();
+                const i = o.db(this.opts.db);
+                if (this.opts.useGridFS) {
+                    const e = new s(i, {
+                        readPreference: this.opts.readPreference,
+                        bucketName: this.opts.collection
+                    });
+                    const n = i.collection(`${this.opts.collection}.files`);
+                    await n.createIndex({
+                        uploadDate: -1
+                    });
+                    await n.createIndex({
+                        "metadata.expiresAt": 1
+                    });
+                    await n.createIndex({
+                        "metadata.lastAccessed": 1
+                    });
+                    await n.createIndex({
+                        "metadata.filename": 1
+                    });
+                    t({
+                        bucket: e,
+                        store: n,
+                        db: i,
+                        mongoClient: o
+                    });
+                } else {
+                    let e = "keyv";
+                    if (this.opts.collection) {
+                        e = this.opts.collection;
                     }
+                    const n = i.collection(e);
+                    await n.createIndex({
+                        key: 1
+                    }, {
+                        unique: true,
+                        background: true
+                    });
+                    await n.createIndex({
+                        expiresAt: 1
+                    }, {
+                        expireAfterSeconds: 0,
+                        background: true
+                    });
+                    t({
+                        store: n,
+                        mongoClient: o
+                    });
+                }
+            } catch (t) {
+                this.emit("error", t);
+            }
+        });
+    }
+    async get(e) {
+        const n = await this.connect;
+        if (this.opts.useGridFS) {
+            await n.store.updateOne({
+                filename: String(e)
+            }, {
+                $set: {
+                    "metadata.lastAccessed": new Date
+                }
+            });
+            const s = n.bucket.openDownloadStreamByName(e);
+            return new Promise(e => {
+                const n = [];
+                s.on("error", () => {
+                    e(void 0);
                 });
+                s.on("end", () => {
+                    const s = t.concat(n).toString("utf8");
+                    e(s);
+                });
+                s.on("data", t => {
+                    n.push(t);
+                });
+            });
+        }
+        const s = await n.store.findOne({
+            key: {
+                $eq: e
             }
         });
+        if (!s) {
+            return void 0;
+        }
+        return s.value;
+    }
+    async getMany(t) {
+        if (this.opts.useGridFS) {
+            const e = [];
+            for (const n of t) {
+                e.push(this.get(n));
+            }
+            const n = await Promise.allSettled(e);
+            const s = [];
+            for (const t of n) {
+                s.push(t.value);
+            }
+            return s;
+        }
+        const e = await this.connect;
+        const n = await e.store.s.db.collection(this.opts.collection).find({
+            key: {
+                $in: t
+            }
+        }).project({
+            _id: 0,
+            value: 1,
+            key: 1
+        }).toArray();
+        const s = [ ...t ];
+        let a = 0;
+        for (const e of t) {
+            const t = n.findIndex(t => t.key === e);
+            s[a] = t > -1 ? n[t].value : void 0;
+            a++;
+        }
+        return s;
+    }
+    async set(t, e, n) {
+        const s = typeof n === "number" ? new Date(Date.now() + n) : null;
+        if (this.opts.useGridFS) {
+            const n = await this.connect;
+            const a = n.bucket.openUploadStream(t, {
+                metadata: {
+                    expiresAt: s,
+                    lastAccessed: new Date
+                }
+            });
+            return new Promise(t => {
+                a.on("finish", () => {
+                    t(a);
+                });
+                a.end(e);
+            });
+        }
+        const a = await this.connect;
+        await a.store.updateOne({
+            key: {
+                $eq: t
+            }
+        }, {
+            $set: {
+                key: t,
+                value: e,
+                expiresAt: s
+            }
+        }, {
+            upsert: true
+        });
+    }
+    async delete(t) {
+        if (typeof t !== "string") {
+            return false;
+        }
+        const e = await this.connect;
+        if (this.opts.useGridFS) {
+            try {
+                const n = e.db;
+                const a = new s(n, {
+                    bucketName: this.opts.collection
+                });
+                const o = await a.find({
+                    filename: t
+                }).toArray();
+                await e.bucket.delete(o[0]._id);
+                return true;
+            } catch {
+                return false;
+            }
+        }
+        const n = await e.store.deleteOne({
+            key: {
+                $eq: t
+            }
+        });
+        return n.deletedCount > 0;
+    }
+    async deleteMany(t) {
+        const e = await this.connect;
+        if (this.opts.useGridFS) {
+            const n = e.db;
+            const a = new s(n, {
+                bucketName: this.opts.collection
+            });
+            const o = await a.find({
+                filename: {
+                    $in: t
+                }
+            }).toArray();
+            if (o.length === 0) {
+                return false;
+            }
+            await Promise.all(o.map(async t => e.bucket.delete(t._id)));
+            return true;
+        }
+        const n = await e.store.deleteMany({
+            key: {
+                $in: t
+            }
+        });
+        return n.deletedCount > 0;
+    }
+    async clear() {
+        const t = await this.connect;
+        if (this.opts.useGridFS) {
+            try {
+                await t.bucket.drop();
+            } catch (t) {
+                if (!(t instanceof a && t.code === 26)) {
+                    throw t;
+                }
+            }
+        }
+        await t.store.deleteMany({
+            key: {
+                $regex: this.namespace ? `^${this.namespace}:*` : ""
+            }
+        });
+    }
+    async clearExpired() {
+        if (!this.opts.useGridFS) {
+            return false;
+        }
+        return this.connect.then(async t => {
+            const e = t.db;
+            const n = new s(e, {
+                bucketName: this.opts.collection
+            });
+            return n.find({
+                "metadata.expiresAt": {
+                    $lte: new Date(Date.now())
+                }
+            }).toArray().then(async e => Promise.all(e.map(async e => t.bucket.delete(e._id))).then(() => true));
+        });
+    }
+    async clearUnusedFor(t) {
+        if (!this.opts.useGridFS) {
+            return false;
+        }
+        const e = await this.connect;
+        const n = e.db;
+        const a = new s(n, {
+            bucketName: this.opts.collection
+        });
+        const o = await a.find({
+            "metadata.lastAccessed": {
+                $lte: new Date(Date.now() - t * 1e3)
+            }
+        }).toArray();
+        await Promise.all(o.map(async t => e.bucket.delete(t._id)));
+        return true;
+    }
+    async* iterator(t) {
+        const e = await this.connect;
+        const n = new RegExp(`^${t ? t + ":" : ".*"}`);
+        const s = this.opts.useGridFS ? e.store.find({
+            filename: n
+        }).map(async t => [ t.filename, await this.get(t.filename) ]) : e.store.find({
+            key: n
+        }).map(t => [ t.key, t.value ]);
+        yield* s;
+    }
+    async has(t) {
+        const e = await this.connect;
+        const n = {
+            [this.opts.useGridFS ? "filename" : "key"]: {
+                $eq: t
+            }
+        };
+        const s = await e.store.count(n);
+        return s !== 0;
+    }
+    async disconnect() {
+        const t = await this.connect;
+        await t.mongoClient.close();
     }
-    t["default"] = e;
-    return Object.freeze(t);
-}
-
-var i = r(g);
-
-const {env: n = {}, argv: l = [], platform: b = ""} = typeof process === "undefined" ? {} : process;
-
-const h = "NO_COLOR" in n || l.includes("--no-color");
-
-const a = "FORCE_COLOR" in n || l.includes("--color");
-
-const o = b === "win32";
-
-const B = n.TERM === "dumb";
-
-const c = i && i.isatty && i.isatty(1) && n.TERM && !B;
-
-const s = "CI" in n && ("GITHUB_ACTIONS" in n || "GITLAB_CI" in n || "CIRCLECI" in n);
-
-const d = !h && (a || o && !B || c || s);
-
-const u = (e, t, g, r, i = t.substring(0, e) + r, n = t.substring(e + g.length), l = n.indexOf(g)) => i + (l < 0 ? n : u(l, n, g, r));
-
-const y = (e, t, g, r, i) => e < 0 ? g + t + r : g + u(e, t, r, i) + r;
-
-const m = (e, t, g = e, r = e.length + 1) => i => i || !(i === "" || i === undefined) ? y(("" + i).indexOf(t, r), i, e, t, g) : "";
-
-const w = (e, t, g) => m(`[${e}m`, `[${t}m`, g);
-
-const f = {
-    reset: w(0, 0),
-    bold: w(1, 22, ""),
-    dim: w(2, 22, ""),
-    italic: w(3, 23),
-    underline: w(4, 24),
-    inverse: w(7, 27),
-    hidden: w(8, 28),
-    strikethrough: w(9, 29),
-    black: w(30, 39),
-    red: w(31, 39),
-    green: w(32, 39),
-    yellow: w(33, 39),
-    blue: w(34, 39),
-    magenta: w(35, 39),
-    cyan: w(36, 39),
-    white: w(37, 39),
-    gray: w(90, 39),
-    bgBlack: w(40, 49),
-    bgRed: w(41, 49),
-    bgGreen: w(42, 49),
-    bgYellow: w(43, 49),
-    bgBlue: w(44, 49),
-    bgMagenta: w(45, 49),
-    bgCyan: w(46, 49),
-    bgWhite: w(47, 49),
-    blackBright: w(90, 39),
-    redBright: w(91, 39),
-    greenBright: w(92, 39),
-    yellowBright: w(93, 39),
-    blueBright: w(94, 39),
-    magentaBright: w(95, 39),
-    cyanBright: w(96, 39),
-    whiteBright: w(97, 39),
-    bgBlackBright: w(100, 49),
-    bgRedBright: w(101, 49),
-    bgGreenBright: w(102, 49),
-    bgYellowBright: w(103, 49),
-    bgBlueBright: w(104, 49),
-    bgMagentaBright: w(105, 49),
-    bgCyanBright: w(106, 49),
-    bgWhiteBright: w(107, 49)
 };
 
-const C = ({useColor: e = d} = {}) => e ? f : Object.keys(f).reduce((e, t) => ({
-    ...e,
-    [t]: String
-}), {});
-
-const {reset: k, bold: O, dim: p, italic: R, underline: v, inverse: M, hidden: G, strikethrough: _, black: j, red: I, green: W, yellow: Y, blue: E, magenta: T, cyan: L, white: x, gray: P, bgBlack: S, bgRed: A, bgGreen: N, bgYellow: $, bgBlue: z, bgMagenta: D, bgCyan: F, bgWhite: H, blackBright: U, redBright: q, greenBright: J, yellowBright: K, blueBright: Q, magentaBright: V, cyanBright: X, whiteBright: Z, bgBlackBright: ee, bgRedBright: te, bgGreenBright: ge, bgYellowBright: re, bgBlueBright: ie, bgMagentaBright: ne, bgCyanBright: le, bgWhiteBright: be} = C();
-
-t.bgBlack = S;
-
-t.bgBlackBright = ee;
-
-t.bgBlue = z;
-
-t.bgBlueBright = ie;
-
-t.bgCyan = F;
-
-t.bgCyanBright = le;
-
-t.bgGreen = N;
-
-t.bgGreenBright = ge;
-
-t.bgMagenta = D;
-
-t.bgMagentaBright = ne;
-
-t.bgRed = A;
-
-t.bgRedBright = te;
-
-t.bgWhite = H;
-
-t.bgWhiteBright = be;
-
-t.bgYellow = $;
-
-t.bgYellowBright = re;
-
-t.black = j;
-
-t.blackBright = U;
-
-t.blue = E;
-
-t.blueBright = Q;
-
-t.bold = O;
-
-t.createColors = C;
-
-t.cyan = L;
-
-t.cyanBright = X;
-
-t.dim = p;
-
-t.gray = P;
-
-t.green = W;
-
-t.greenBright = J;
-
-t.hidden = G;
-
-t.inverse = M;
-
-t.isColorSupported = d;
-
-t.italic = R;
-
-t.magenta = T;
-
-t.magentaBright = V;
-
-t.red = I;
-
-t.redBright = q;
-
-t.reset = k;
-
-t.strikethrough = _;
-
-t.underline = v;
-
-t.white = x;
-
-t.whiteBright = Z;
-
-t.yellow = Y;
-
-t.yellowBright = K;
-
-export { t as c };
+export { i as KeyvMongo };