datafolder 1.0.0

package/src/QyKVData.js

@@ -0,0 +1,289 @@
+let path = require("node:path"), fsPromises = require("node:fs/promises"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, QyKVDataSaver = require("./QyKVDataSaver.js").QyKVDataSaver, QySnapshotCompactor = require("./QySnapshotCompactor.js").QySnapshotCompactor, QyKVDataCleaner = require("./QyKVDataCleaner.js").QyKVDataCleaner, {
+    arrayLast,
+    readBufferAsync,
+    sleep
+} = require("./QyUtils.js"), Idle = 1, WaitForCompactUpdates = 2, WaitForSnapshotSaved = 3;
+
+class QyKVData {
+    constructor(a, t, s) {
+        t = {
+            ...getDefaultOptions("QyKVData"),
+            ...t
+        };
+        var o = path.join(a, "snapshot");
+        Object.assign(this, {
+            qyCache: s,
+            options: t,
+            kvFolder: a,
+            snapshotFolder: o,
+            qyKVDataSaver: new QyKVDataSaver(this, a, t),
+            qySnapshotCompactor: new QySnapshotCompactor(this, a, t),
+            qyKVDataCleaner: new QyKVDataCleaner(this, a, t),
+            compactState: Idle,
+            compactMaxChangeId: 0,
+            snapshotSavedChangeId: 0,
+            snapshotInfoNumList: [],
+            emptySnapshotNumList: []
+        });
+    }
+    start(a, t, s, o) {
+        var {
+            options: e,
+            qyKVDataSaver: n,
+            qySnapshotCompactor: p,
+            qyKVDataCleaner: i
+        } = this, n = (n.start(a, s.maxSnapshotNum, t, o), p.start(), i.start(), 
+        setInterval(() => this._compactSnapshots(), e.compactSnapshotsInterval)), t = setInterval(() => this._unloadMemory(), e.unloadMemInterval);
+        return Object.assign(this, {
+            maxChangeId: a,
+            qySnapshots: s,
+            aclKeyValueMap: o,
+            compactInterval: n,
+            unloadInterval: t
+        }), e.bgLoadPosMaps && this._bgLoadPosMaps(), this;
+    }
+    async stop() {
+        this.isStopping = !0;
+        var {
+            qyKVDataSaver: a,
+            qySnapshotCompactor: t,
+            qySnapshots: s,
+            compactInterval: o,
+            unloadInterval: e,
+            qyKVDataCleaner: n
+        } = this;
+        clearInterval(o), clearInterval(e), await a.stop(), s && s.closeAllFDs(), 
+        await t.stop(), await n.stop();
+    }
+    save(a, t, s, o) {
+        var e = this.qyKVDataSaver;
+        if (o) return e.callSave(a, t, s);
+        e.castSave(a, t, s);
+    }
+    increaseChangeId() {
+        return ++this.maxChangeId;
+    }
+    decreaseChangeId() {
+        --this.maxChangeId;
+    }
+    getValueSync(a) {
+        var {
+            qySnapshots: t,
+            aclKeyValueMap: s
+        } = this;
+        return a in s ? s[a] : t.getValueSync(a);
+    }
+    removeKey(a) {
+        var {
+            qySnapshots: t,
+            aclKeyValueMap: s
+        } = this;
+        if (!(a in s)) return t.removeKey(a);
+        s[a] = void 0;
+    }
+    onSnapshotSavedChangeId(a, t) {
+        this.snapshotSavedChangeId = a, this.compactState == WaitForSnapshotSaved && a >= this.compactMaxChangeId && this._finishCompactUpdates(), 
+        t && (this._addPMOnlySnapshot(t), this.qyKVDataSaver.releaseSnapshot(t.snapshotNum));
+    }
+    onCompactUpdates(a) {
+        this.compactState == WaitForCompactUpdates && (this._processCompactUpdates(a), 
+        this.snapshotSavedChangeId >= this.compactMaxChangeId ? this._finishCompactUpdates() : this.compactState = WaitForSnapshotSaved);
+    }
+    _addPMOnlySnapshot(a) {
+        var t, s = this.qySnapshots, o = s.keyToSnapshotMap;
+        for (t in a.posMap) {
+            var e = o[t];
+            e && s.removeKeyFromSnapshot(e, t);
+        }
+        s.addMaxSnapshot(a), logger.info("addPMOnlySnapshot: " + s.snapshotMaxChangeId);
+    }
+    _finishCompactUpdates() {
+        var {
+            qySnapshotCompactor: a,
+            qyKVDataCleaner: t,
+            snapshotInfoNumList: s,
+            emptySnapshotNumList: o
+        } = this;
+        a.saveSnapshotInfos(s), (s.length = 0) < o.length && (t.removeSnapshotsFiles(o), 
+        o.length = 0), this.compactState = Idle;
+    }
+    _processCompactUpdates(a) {
+        var {
+            pMUpdates: a,
+            vLUpdates: t,
+            combineUpdate: s
+        } = a;
+        a && this._processPMUpdates(a), t && this._processVLUpdates(t), s && this._processCombineUpdate(s);
+    }
+    _processCombineUpdate(a) {
+        var {
+            qySnapshots: o,
+            snapshotInfoNumList: t,
+            emptySnapshotNumList: s
+        } = this, {
+            numToSnapshotMap: e,
+            keyToSnapshotMap: n
+        } = o;
+        let {
+            snapshotNum: p,
+            combinedSnapshotNumList: i,
+            posMap: r
+        } = a;
+        var h, c = e[p];
+        let {
+            posMap: l,
+            info: d
+        } = c;
+        for (h in l) l[h] = r[h];
+        this._countLVCompact(c);
+        let u = d.totalCount, m = c.outdatedCount;
+        for (let s of i) {
+            var S, y = e[s];
+            let {
+                posMap: a,
+                info: t
+            } = y;
+            for (S in a) l[S] = r[S], n[S] = c;
+            this._countLVCompact(y), u += t.totalCount, m += y.outdatedCount, o.delSnapshot(y);
+        }
+        s.push(...i), (u == m ? s : (++d.pMVersion, ++d.vLVersion, d.totalCount = u, 
+        c.outdatedCount = m, t)).push(p);
+    }
+    _processVLUpdates(a) {
+        var t, {
+            qySnapshots: s,
+            snapshotInfoNumList: o,
+            emptySnapshotNumList: e
+        } = this, n = s.numToSnapshotMap;
+        for (t in a) {
+            var p = n[t];
+            if (s.isEmptySnapshot(p)) s.delSnapshot(p), e.push(t); else {
+                var i, r, {
+                    posMap: h,
+                    prefixPM: c
+                } = a[t], {
+                    posMap: l,
+                    prefixPM: d,
+                    info: u
+                } = p;
+                for (i in l) l[i] = h[i];
+                for (r in d) d[r] = c[r];
+                ++u.pMVersion, ++u.vLVersion, this._countLVCompact(p), o.push(t);
+            }
+        }
+    }
+    _countLVCompact(a) {
+        var {
+            info: t,
+            compactOutedCount: s
+        } = a;
+        t.totalCount -= t.outdatedCount + s, t.outdatedCount = 0, a.outdatedCount -= s, 
+        a.compactOutedCount = 0;
+    }
+    _countPMCompact(a) {
+        var {
+            info: t,
+            compactOutedCount: s
+        } = a;
+        t.outdatedCount += s, a.outdatedCount -= s, a.compactOutedCount = 0;
+    }
+    _processPMUpdates(a) {
+        var t, {
+            qySnapshots: s,
+            snapshotInfoNumList: o,
+            emptySnapshotNumList: e
+        } = this, n = s.numToSnapshotMap;
+        for (t in a) {
+            var p = n[t];
+            if (s.isEmptySnapshot(p)) s.delSnapshot(p), e.push(t); else {
+                var i, r = a[t], {
+                    prefixPM: h,
+                    info: c
+                } = p;
+                for (i in h) h[i] = r[i];
+                ++c.pMVersion, this._countPMCompact(p), o.push(t);
+            }
+        }
+    }
+    _compactSnapshots() {
+        if (this.compactState == Idle) {
+            var {
+                maxChangeId: a,
+                qySnapshots: t,
+                qySnapshotCompactor: s
+            } = this, {
+                emptySnapshotNumList: t,
+                pMCompactSnapshotList: o,
+                vLCompactSnapshotList: e,
+                combiningSnapshotList: n
+            } = t.calOutdates();
+            if (0 < t.length && this.emptySnapshotNumList.push(...t), 0 < n.length || 0 < o.length || 0 < e.length) {
+                Object.assign(this, {
+                    compactState: WaitForCompactUpdates,
+                    compactMaxChangeId: a
+                });
+                for (var p of [ o, e, n ]) for (var i of p) i.compactOutedCount = i.outdatedCount;
+                s.compactSnapshots(o, e, n);
+            }
+        }
+    }
+    async _bgLoadPosMaps() {
+        for (var a of Object.keys(this.qySnapshots.numToSnapshotMap).sort((a, t) => t - a)) {
+            if (await this._bgLoadPosMap(a), this.isStopping) break;
+            if (await sleep(0), this.isStopping) break;
+        }
+    }
+    async _bgLoadPosMap(a, t, s, o, e) {
+        if (this.isStopping) e && e.close(); else {
+            var n = this.qySnapshots, p = n.numToSnapshotMap, i = p[a];
+            if (i) {
+                var {
+                    info: r,
+                    prefixPM: h
+                } = i;
+                if (0 == (t = t || Object.keys(h).sort().reverse()).length) e && e.close(); else {
+                    if (null == s || s != r.pMVersion) return e && e.close(), o = n.getPMFilePath(i), 
+                    this._bgLoadPosMap(a, t, r.pMVersion, o, await fsPromises.open(o));
+                    for (;0 < t.length; ) {
+                        var c = arrayLast(t), l = h[c];
+                        if (l) {
+                            var [ l, d ] = l, l = await readBufferAsync(o, e, l, d);
+                            if (this.isStopping || !p[a]) return void e.close();
+                            if (s != r.pMVersion) return e.close(), this._bgLoadPosMap(a, t);
+                            c in h && n.loadPartialPosMapBuffer(i, c, l);
+                        }
+                        t.pop();
+                    }
+                    e.close(), logger.info("bgLoadPosMap:" + a);
+                }
+            } else e && e.close();
+        }
+    }
+    async _unloadMemory() {
+        if (!this.unloadingMemory) {
+            this.unloadingMemory = !0;
+            var {
+                qyCache: s,
+                options: o
+            } = this;
+            let a = 0, t = 0;
+            if (s) {
+                var e, n = o.maxFileCountToUnload, o = s.rootDir;
+                t = this._unloadDirFilesMem(o), a = t;
+                for (e of o.allLoadedSubdirs()) if ((t += this._unloadDirFilesMem(e)) > n && (a += t, 
+                t = 0, await sleep(0), this.isStopping)) break;
+            }
+            a += t, global.gc && global.gc(), this.unloadingMemory = !1;
+        }
+    }
+    _unloadDirFilesMem(a) {
+        var t = this.qySnapshots.snapshotMaxChangeId;
+        let s = 0;
+        if (a.fileMapLoaded) for (var o of a.fileList) ++s, o.cChangeId <= t && (o.visited ? o.visited = !1 : o.unloadFileContent());
+        return s;
+    }
+}
+
+Object.assign(module.exports, {
+    QyKVData: QyKVData
+});

package/src/QyKVDataCleaner.js

@@ -0,0 +1,17 @@
+let QyMessager = require("./QyMessager.js").QyMessager, getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions;
+
+class QyKVDataCleaner extends QyMessager {
+    constructor(e, s, a) {
+        super(e, "QyKVDataCleaner_Worker.js", {
+            kvFolder: s,
+            options: a = {
+                ...getDefaultOptions("QyKVDataCleaner"),
+                ...a
+            }
+        }, a, [], [ "cleanAclFiles", "cleanPMFiles", "cleanVLFiles", "removeSnapshotsFiles" ]);
+    }
+}
+
+Object.assign(module.exports, {
+    QyKVDataCleaner: QyKVDataCleaner
+});

package/src/QyKVDataCleaner_Worker.js

@@ -0,0 +1,94 @@
+let path = require("node:path"), fsPromises = require("node:fs/promises"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, QyMessageWorker = require("./QyMessageWorker.js").QyMessageWorker, {
+    folderOrFileExists,
+    ensureDir
+} = require("./QyUtils.js"), qyCompressor = require("./QyCompressor.js");
+
+class QyKVDataCleaner_Worker extends QyMessageWorker {
+    constructor({
+        kvFolder: e,
+        options: s
+    }) {
+        super(s = {
+            ...getDefaultOptions("QyKVDataCleaner_Worker"),
+            ...s
+        }, [ "start", "stop" ], [ "cleanAclFiles", "cleanPMFiles", "cleanVLFiles", "removeSnapshotsFiles" ]);
+        var s = path.join(e, "history"), a = path.join(e, "snapshot");
+        Object.assign(this, {
+            kvFolder: e,
+            snapshotFolder: a,
+            snapshotInfoFolder: path.join(a, "info"),
+            aclFolder: path.join(e, "acl"),
+            historyAclFolder: path.join(s, "acl"),
+            historySnapshotFolder: path.join(s, "snapshot")
+        });
+    }
+    _op_start() {}
+    _op_stop() {}
+    async _op_cleanAclFiles(e) {
+        await this._cleanOutdatedAclFiles(e);
+    }
+    async _op_cleanPMFiles(e) {
+        await Promise.allSettled(e.map(([ e, s ]) => this._cleanOutdatedPMFiles(e, s)));
+    }
+    async _op_cleanVLFiles(e, s) {
+        await this._cleanOutdatedVLFiles(e, s);
+    }
+    async _op_removeSnapshotsFiles(e) {
+        let {
+            snapshotFolder: s,
+            snapshotInfoFolder: a
+        } = this;
+        await Promise.all(e.map(async e => {
+            await fsPromises.rm(path.join(a, e + ".json")), await fsPromises.rm(path.join(s, "" + e), {
+                recursive: !0
+            });
+        }));
+    }
+    async _cleanOutdatedAclFiles(e) {
+        var s = this.aclFolder;
+        if (await folderOrFileExists(s)) {
+            var a, t = [];
+            for (a of (await fsPromises.readdir(s)).filter(e => /^[1-9]/.test(e))) parseInt(a) <= e && t.push(this._cleanOutdatedAclFile(a));
+            0 < t.length && await Promise.allSettled(t);
+        }
+    }
+    _cleanOutdatedPMFiles(s, a) {
+        return Promise.all([ "pM", "prefixPM" ].map(e => this._cleanOutdatedSnapshotFiles(s, a, e)));
+    }
+    _cleanOutdatedVLFiles(e, s) {
+        return this._cleanOutdatedSnapshotFiles(e, s, "vL");
+    }
+    async _cleanOutdatedSnapshotFiles(s, a, t) {
+        var {
+            snapshotFolder: e,
+            historySnapshotFolder: r
+        } = this, i = path.join(e, "" + s);
+        if (await folderOrFileExists(i)) {
+            let e;
+            var o, l = [];
+            for (o of await fsPromises.readdir(i)) {
+                var n = new RegExp("^([0-9]+)_" + t).exec(o);
+                n && (n = parseInt(n[1])) < a && (1 == n ? (e || (e = path.join(r, "" + s), 
+                await ensureDir(e)), l.push(this._cleanOutdatedFile(o, i, e))) : (n = path.join(i, o), 
+                logger.info("Removing " + n), l.push(fsPromises.rm(n))));
+            }
+            0 < l.length && await Promise.allSettled(l);
+        }
+    }
+    async _cleanOutdatedAclFile(e) {
+        var {
+            aclFolder: s,
+            historyAclFolder: a
+        } = this;
+        return await ensureDir(a), this._cleanOutdatedFile(e, s, a);
+    }
+    _cleanOutdatedFile(e, s, a) {
+        s = path.join(s, e), a = path.join(a, e);
+        return this.options.compressRedundantFile ? qyCompressor.compressFile(s, a + qyCompressor.Zip_File_Extension, {
+            override: !0,
+            removeSrcAfterSuccess: !0
+        }) : (logger.info(`rename ${s} to ` + a), fsPromises.rename(s, a));
+    }
+}
+
+module.exports = QyKVDataCleaner_Worker;

package/src/QyKVDataLoader.js

@@ -0,0 +1,65 @@
+let fsPromises = require("node:fs/promises"), path = require("node:path"), folderOrFileExists = require("./QyUtils.js").folderOrFileExists, readAclBuffer = require("./QyAcl.js").readAclBuffer, QySnapshots = require("./QySnapshots.js").QySnapshots, getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions;
+
+class QyKVDataLoader {
+    constructor(a, e) {
+        e = {
+            ...getDefaultOptions("QyKVDataLoader"),
+            ...e
+        };
+        var s = path.join(a, "snapshot");
+        Object.assign(this, {
+            kvFolder: a,
+            options: e,
+            aclFolder: path.join(a, "acl"),
+            snapshotFolder: s,
+            loadedMaxAclNum: 0,
+            aclKeyValueMap: {},
+            qySnapshots: new QySnapshots(s, e)
+        });
+    }
+    async load() {
+        var a = this.qySnapshots, [ e ] = await Promise.all([ this._listAclFiles(), a.loadSnapshotInfos() ]);
+        let {
+            maxSnapshotNum: s,
+            snapshotMaxChangeId: t
+        } = a;
+        this.maxChangeId = t, e && await this._loadAclFiles(e.filter(a => a > s));
+        var {
+            maxChangeId: e,
+            loadedMaxAclNum: l,
+            aclKeyValueMap: i
+        } = this;
+        return {
+            maxChangeId: e,
+            loadedMaxAclNum: l,
+            qySnapshots: a,
+            aclKeyValueMap: i
+        };
+    }
+    async _loadAclFiles(e) {
+        e.sort((a, e) => a - e);
+        var {
+            aclKeyValueMap: s,
+            qySnapshots: t,
+            options: a
+        } = this, l = a.autoRepairAclFile, i = await Promise.all(e.map(async a => fsPromises.readFile(this._getAclFilePath(a))));
+        for (let a = 0; a < e.length; ++a) {
+            var r = e[a], o = this._getAclFilePath(r), o = await readAclBuffer(o, i[a], l, this.maxChangeId);
+            if (0 < o.length) {
+                for (var [ n, h ] of o) t.applyCmdObj(h, s), this.maxChangeId = n;
+                this.loadedMaxAclNum = r;
+            }
+        }
+    }
+    async _listAclFiles() {
+        var a = this.aclFolder;
+        if (await folderOrFileExists(a)) return (await fsPromises.readdir(a)).filter(a => /^[1-9]/.test(a)).map(a => parseInt(a));
+    }
+    _getAclFilePath(a) {
+        return path.join(this.aclFolder, a + "_acl.txt");
+    }
+}
+
+Object.assign(module.exports, {
+    QyKVDataLoader: QyKVDataLoader
+});

package/src/QyKVDataSaver.js

@@ -0,0 +1,17 @@
+let QyMessager = require("./QyMessager.js").QyMessager, getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions;
+
+class QyKVDataSaver extends QyMessager {
+    constructor(e, a, s) {
+        super(e, "QyKVDataSaver_Worker.js", {
+            kvFolder: a,
+            options: s = {
+                ...getDefaultOptions("QyKVDataSaver"),
+                ...s
+            }
+        }, s, [ "callSave" ], [ "castSave", "releaseSnapshot" ]);
+    }
+}
+
+Object.assign(module.exports, {
+    QyKVDataSaver: QyKVDataSaver
+});

package/src/QyKVDataSaver_Worker.js

@@ -0,0 +1,81 @@
+let path = require("node:path"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, QyAclSaver = require("./QyAclSaver.js").QyAclSaver, QyMessageWorker = require("./QyMessageWorker.js").QyMessageWorker, QySnapshotSaver = require("./QySnapshotSaver.js").QySnapshotSaver, delCmdKey = require("./QyAcl.js").delCmdKey;
+
+class QyKVDataSaver_Worker extends QyMessageWorker {
+    constructor({
+        kvFolder: e,
+        options: a
+    }) {
+        super(a = {
+            ...getDefaultOptions("QyKVDataSaver_Worker"),
+            ...a
+        }), Object.assign(this, {
+            kvFolder: e,
+            aclFolder: path.join(e, "acl"),
+            qyAclSaver: new QyAclSaver(this, a),
+            qySnapshotSaver: new QySnapshotSaver(this, e, a)
+        });
+    }
+    start(e, a, s, t) {
+        var {
+            qyAclSaver: r,
+            qySnapshotSaver: n
+        } = this;
+        Object.assign(this, {
+            maxChangeId: e,
+            snapshotMaxChangeId: e,
+            currentAclNum: (s || a) + 1
+        }), r.start(this._getAclFilePath()), n.start(e, s, t);
+    }
+    async stop() {
+        var {
+            qyAclSaver: e,
+            options: a,
+            qySnapshotSaver: s,
+            currentAclNum: t,
+            maxChangeId: r,
+            snapshotMaxChangeId: n
+        } = this;
+        this.isStopping = !0, await e.stop(), a.saveSnapshotAtStop && n < r && (this.isSavingSnapshot && await new Promise(e => this.saveSnapshotResolve = e), 
+        logger.log(`Saving snapshot ${t} at stop.`), s.saveSnapshot(t)), await s.stop();
+    }
+    callSave(e, a, s) {
+        return this._save(e, a, s, !0);
+    }
+    castSave(e, a, s) {
+        return this._save(e, a, s);
+    }
+    releaseSnapshot(e) {
+        this.qySnapshotSaver.releaseSnapshot(e);
+    }
+    _save(e, a, s, t) {
+        var {
+            qyAclSaver: r,
+            qySnapshotSaver: n,
+            options: o,
+            snapshotMaxChangeId: h,
+            currentAclNum: i,
+            isSavingSnapshot: S
+        } = this;
+        let l;
+        return t ? l = r.callSave(e, a) : r.castSave(e, a), this._removeSyncedKeys(a, s), 
+        n.castSave(e, a, s), this.maxChangeId = e, !S && e - h >= o.snapshotMaxChangeCount && (++this.currentAclNum, 
+        r.switch(this._getAclFilePath()), n.saveSnapshot(i), Object.assign(this, {
+            snapshotMaxChangeId: e,
+            isSavingSnapshot: !0
+        })), l;
+    }
+    _removeSyncedKeys(a, s) {
+        if (s) {
+            var t = s.length;
+            for (let e = 0; e < t; e += 2) delCmdKey(a, s[e]);
+        }
+    }
+    _getAclFilePath() {
+        return path.join(this.aclFolder, this.currentAclNum + "_acl.txt");
+    }
+    onSnapshotSavedChangeId(e, a) {
+        this.isSavingSnapshot = !1, this.saveSnapshotResolve ? this.saveSnapshotResolve() : this.isStopping || this.castParent("onSnapshotSavedChangeId", e, a);
+    }
+}
+
+module.exports = QyKVDataSaver_Worker;

package/src/QyLogFileSaver.js

@@ -0,0 +1,14 @@
+let QyMessager = require("./QyMessager.js").QyMessager, getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions;
+
+class QyLogFileSaver extends QyMessager {
+    constructor(e, s) {
+        super(e, "QyLogFileSaver_Worker.js", s = {
+            ...getDefaultOptions("QyLogFileSaver"),
+            ...s
+        }, s, [ "switch" ], [ "save" ]);
+    }
+}
+
+Object.assign(module.exports, {
+    QyLogFileSaver: QyLogFileSaver
+});

package/src/QyLogFileSaver_Worker.js

@@ -0,0 +1,26 @@
+let getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, QyMessageWorker = require("./QyMessageWorker.js").QyMessageWorker, QyBinWriter = require("./QyBinWriter.js").QyBinWriter;
+
+class QyLogFileSaver_Worker extends QyMessageWorker {
+    constructor(e) {
+        super(e = {
+            ...getDefaultOptions("QyLogFileSaver_Worker"),
+            ...e
+        }), Object.assign(this, {
+            qyBinWriter: new QyBinWriter(e)
+        });
+    }
+    async start(e) {
+        await this.qyBinWriter.start(e);
+    }
+    async stop() {
+        await this.qyBinWriter.stop();
+    }
+    async switch(e) {
+        await this.qyBinWriter.switch(e);
+    }
+    save(e, r) {
+        this.qyBinWriter.save(e, r);
+    }
+}
+
+module.exports = QyLogFileSaver_Worker;

package/src/QyLogger.js

@@ -0,0 +1,76 @@
+let fs = require("node:fs"), path = require("node:path"), Console = require("node:console").Console, {
+    isMainThread,
+    threadId
+} = require("node:worker_threads"), ThreadMark = isMainThread ? "" : `W${threadId}:`, LOG_LEVEL = {
+    Info: 0,
+    Debug: 1,
+    Warn: 2,
+    Error: 3,
+    None: 4
+}, strToLogLevel = {
+    verbose: LOG_LEVEL.Info,
+    info: LOG_LEVEL.Info,
+    log: LOG_LEVEL.Debug,
+    debug: LOG_LEVEL.Debug,
+    warn: LOG_LEVEL.Warn,
+    error: LOG_LEVEL.Error,
+    none: LOG_LEVEL.None
+}, logLevelToStr = Object.fromEntries(Object.entries(strToLogLevel).map(([ e, o ]) => [ o, e ])), logger = {
+    currentLogLevel: LOG_LEVEL.Debug,
+    info: function() {
+        logger.currentLogLevel == LOG_LEVEL.Info && writeLog("info", arguments);
+    },
+    log: function() {
+        logger.currentLogLevel <= LOG_LEVEL.Debug && writeLog("log", arguments);
+    },
+    debug: function() {
+        logger.currentLogLevel <= LOG_LEVEL.Debug && writeLog("debug", arguments);
+    },
+    warn: function() {
+        logger.currentLogLevel <= LOG_LEVEL.Warn && writeLog("warn", arguments);
+    },
+    error: function() {
+        logger.currentLogLevel <= LOG_LEVEL.Error && writeLog("error", arguments);
+    }
+}, fileConsole, stdout, stderr;
+
+function closeFileConsole() {
+    fileConsole = void 0, stdout && (stdout.close(), stdout = void 0), stderr && (stderr.close(), 
+    stderr = void 0);
+}
+
+function setFileConsoleDateDirPath(e, o) {
+    closeFileConsole();
+    o = {
+        flags: o ? "w" : "a",
+        flush: !0,
+        autoClose: !1
+    };
+    stdout = fs.createWriteStream(path.join(e, "stdout.txt"), o), stderr = fs.createWriteStream(path.join(e, "stderr.txt"), o), 
+    fileConsole = new Console({
+        stdout: stdout,
+        stderr: stderr,
+        inspectOptions: {
+            depth: 3,
+            colors: !1
+        }
+    });
+}
+
+function writeLog(e, o) {
+    var r = new Error().stack.split("\n"), r = `${new Date().toISOString()} ${ThreadMark}${/([^/\\()]+)\)?$/.exec(r[3])[1]}:${e}:`;
+    console[e](r, ...o), fileConsole && fileConsole[e](r, ...o);
+}
+
+Object.defineProperty(logger, "level", {
+    get() {
+        return logLevelToStr[logger.currentLogLevel];
+    },
+    set(e) {
+        logger.currentLogLevel = strToLogLevel[e];
+    }
+}), globalThis.logger = logger, Object.assign(module.exports, {
+    logger: logger,
+    setFileConsoleDateDirPath: setFileConsoleDateDirPath,
+    closeFileConsole: closeFileConsole
+});