datafolder 1.0.2 → 1.0.4

package/src/QyLogger.js

@@ -1,55 +1,64 @@
-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 = {
+import r from "node:fs";
+
+import n from "node:path";
+
+import {
+    Console as t
+} from "node:console";
+
+import {
+    isMainThread as e,
+    threadId as o
+} from "node:worker_threads";
+
+let i = e ? "" : `W${o}:`, s = {
     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,
+}, l = {
+    verbose: s.Info,
+    info: s.Info,
+    log: s.Debug,
+    debug: s.Debug,
+    warn: s.Warn,
+    error: s.Error,
+    none: s.None
+}, a = Object.fromEntries(Object.entries(l).map(([ e, o ]) => [ o, e ])), c = {
+    currentLogLevel: s.Debug,
     info: function() {
-        logger.currentLogLevel == LOG_LEVEL.Info && writeLog("info", arguments);
+        c.currentLogLevel == s.Info && b("info", arguments);
     },
     log: function() {
-        logger.currentLogLevel <= LOG_LEVEL.Debug && writeLog("log", arguments);
+        c.currentLogLevel <= s.Debug && b("log", arguments);
     },
     debug: function() {
-        logger.currentLogLevel <= LOG_LEVEL.Debug && writeLog("debug", arguments);
+        c.currentLogLevel <= s.Debug && b("debug", arguments);
     },
     warn: function() {
-        logger.currentLogLevel <= LOG_LEVEL.Warn && writeLog("warn", arguments);
+        c.currentLogLevel <= s.Warn && b("warn", arguments);
     },
     error: function() {
-        logger.currentLogLevel <= LOG_LEVEL.Error && writeLog("error", arguments);
+        c.currentLogLevel <= s.Error && b("error", arguments);
     }
-}, fileConsole, stdout, stderr;
+}, u, g, f;
 
-function closeFileConsole() {
-    fileConsole = void 0, stdout && (stdout.close(), stdout = void 0), stderr && (stderr.close(), 
-    stderr = void 0);
+function d() {
+    u = void 0, g && (g.close(), g = void 0), f && (f.close(), f = void 0);
 }
 
-function setFileConsoleDateDirPath(e, o) {
-    closeFileConsole();
+function L(e, o) {
+    d();
     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,
+    g = r.createWriteStream(n.join(e, "stdout.txt"), o), f = r.createWriteStream(n.join(e, "stderr.txt"), o), 
+    u = new t({
+        stdout: g,
+        stderr: f,
         inspectOptions: {
             depth: 3,
             colors: !1
@@ -57,20 +66,22 @@ function setFileConsoleDateDirPath(e, o) {
     });
 }
 
-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);
+function b(e, o) {
+    var r = new Error().stack.split("\n"), r = `${new Date().toISOString()} ${i}${/([^/\\()]+)\)?$/.exec(r[3])[1]}:${e}:`;
+    console[e](r, ...o), u && u[e](r, ...o);
 }
 
-Object.defineProperty(logger, "level", {
+Object.defineProperty(c, "level", {
     get() {
-        return logLevelToStr[logger.currentLogLevel];
+        return a[c.currentLogLevel];
     },
     set(e) {
-        logger.currentLogLevel = strToLogLevel[e];
+        c.currentLogLevel = l[e];
     }
-}), globalThis.logger = logger, Object.assign(module.exports, {
-    logger: logger,
-    setFileConsoleDateDirPath: setFileConsoleDateDirPath,
-    closeFileConsole: closeFileConsole
-});
+}), globalThis.logger = c;
+
+export {
+    c as logger,
+    L as setFileConsoleDateDirPath,
+    d as closeFileConsole
+};

package/src/QyMessageWorker.js

@@ -1,41 +1,55 @@
-let parentPort = require("node:worker_threads").parentPort, getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, logger = require("./QyLogger.js").logger, QyOpRunner = require("./QyOpRunner.js").QyOpRunner;
+import {
+    parentPort as t
+} from "node:worker_threads";
 
-class QyMessageWorker extends QyOpRunner {
-    constructor(e, r, s) {
-        super(e = {
-            ...getDefaultOptions("QyMessageWorker"),
-            ...e
-        }, r, s), parentPort.on("message", async e => {
+import {
+    getDefaultOptions as a
+} from "./QyDefaultOptions.js";
+
+import {
+    logger as n
+} from "./QyLogger.js";
+
+import {
+    QyOpRunner as s
+} from "./QyOpRunner.js";
+
+class e extends s {
+    constructor(s, e, r) {
+        super(s = {
+            ...a("QyMessageWorker"),
+            ...s
+        }, e, r), t.on("message", async s => {
             var {
-                opName: r,
-                _cast: s
-            } = e;
-            if (r) {
-                var t = e.args || [];
+                opName: e,
+                _cast: r
+            } = s;
+            if (e) {
+                var a = s.args || [];
                 try {
-                    var a = await this[r](...t);
-                    s || parentPort.postMessage({
-                        ack: r,
-                        result: a
-                    }), "stop" == r && process.exit();
-                } catch (e) {
-                    logger.error(`Running ${r} failed:`, e), s || parentPort.postMessage({
-                        ack: r,
-                        exception: e
+                    var o = await this[e](...a);
+                    r || t.postMessage({
+                        ack: e,
+                        result: o
+                    }), "stop" == e && process.exit();
+                } catch (s) {
+                    n.error(`Running ${e} failed:`, s), r || t.postMessage({
+                        ack: e,
+                        exception: s
                     });
                 }
-            } else logger.warn("Msg ignored:", e);
+            } else n.warn("Msg ignored:", s);
         });
     }
-    castParent(e, ...r) {
-        parentPort.postMessage({
-            opName: e,
-            args: r,
+    castParent(s, ...e) {
+        t.postMessage({
+            opName: s,
+            args: e,
             _cast: !0
         });
     }
 }
 
-Object.assign(module.exports, {
-    QyMessageWorker: QyMessageWorker
-});
+export {
+    e as QyMessageWorker
+};

package/src/QyMessager.js

@@ -1,26 +1,76 @@
-let path = require("node:path"), {
-    Worker,
-    setEnvironmentData
-} = require("node:worker_threads"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, logger = require("./QyLogger.js").logger, setPromise = require("./QyUtils.js").setPromise, QyQueue = require("./QyQueue.js").QyQueue;
+import {
+    join as s
+} from "node:path";
 
-class QyMessager {
-    constructor(e, r, t, s, o = [], i = []) {
-        s = {
-            ...getDefaultOptions("QyMessager"),
-            ...s
+import {
+    Worker as p,
+    setEnvironmentData as t
+} from "node:worker_threads";
+
+import {
+    getDefaultOptions as i
+} from "./QyDefaultOptions.js";
+
+import {
+    logger as n
+} from "./QyLogger.js";
+
+import {
+    setPromise as l,
+    __dirname as m
+} from "./QyUtils.js";
+
+import {
+    QyQueue as h
+} from "./QyQueue.js";
+
+class e {
+    constructor(e, r, s, t, o = [], a = []) {
+        t = {
+            ...i("QyMessager"),
+            ...t
         }, Object.assign(this, {
             parent: e,
             workerTypeFileName: r,
-            initArgMap: t,
-            options: s,
+            initArgMap: s,
+            options: t,
             receiverQueueMap: {}
         });
         for (let r of o) this[r] || (this[r] = (...e) => this.callWorker(r, e));
-        for (let r of i) this[r] || (this[r] = (...e) => this.castWorker(r, e));
+        for (let r of a) this[r] || (this[r] = (...e) => this.castWorker(r, e));
     }
     start(...e) {
-        return this.started = !0, setEnvironmentData("logLevel", logger.level), 
-        this._startWorker(), this.callWorker("start", e);
+        this.started = !0, t("logLevel", n.level);
+        var i = this;
+        if (!i.worker) {
+            let {
+                workerTypeFileName: t,
+                initArgMap: e,
+                receiverQueueMap: o
+            } = i;
+            var r = {
+                workerTypeFileName: t,
+                initArgMap: e
+            };
+            let a = i.worker = new p(s(m, "QyMessager_Run.js"), {
+                workerData: r
+            });
+            a.on("error", e => {
+                n.error(`Worker ${t} error:`, e);
+            }), a.on("message", e => {
+                var {
+                    opName: r,
+                    ack: s,
+                    result: t
+                } = e;
+                r ? (e = e.args || [], (i.parent || i)[r](...e)) : o[s]?.shift().resolve(t);
+            }), a.on("exit", e => {
+                for (var r in a.removeAllListeners(), 0 != e ? n.warn(`Worker ${t} stopped with exitCode ` + e) : n.info(`Worker ${t} stopped.`), 
+                o) for (var s = o[r]; !s.isEmpty; ) s.shift()?.resolve();
+                i.worker = void 0;
+            });
+        }
+        return this.callWorker("start", e);
     }
     stop(...e) {
         if (this.started) return this.started = !1, this.callWorker("stop", e);
@@ -34,51 +84,21 @@ class QyMessager {
     }
     callWorker(e, r) {
         var {
-            worker: t,
-            receiverQueueMap: s,
+            worker: s,
+            receiverQueueMap: t,
             options: o
         } = this;
-        t.postMessage({
+        s.postMessage({
             opName: e,
             args: r
         });
-        let i = s[e];
-        i = i || (s[e] = new QyQueue(o));
-        t = setPromise({});
-        return i.push(t), t.promise;
-    }
-    _startWorker() {
-        if (!this.worker) {
-            let {
-                workerTypeFileName: s,
-                initArgMap: e,
-                receiverQueueMap: o
-            } = this;
-            var r = {
-                workerTypeFileName: s,
-                initArgMap: e
-            };
-            let i = this.worker = new Worker(path.join(__dirname, "QyMessager_Run.js"), {
-                workerData: r
-            });
-            i.on("error", e => {
-                logger.error(`Worker ${s} error:`, e);
-            }), i.on("message", e => {
-                var {
-                    opName: r,
-                    ack: t,
-                    result: s
-                } = e;
-                r ? (e = e.args || [], (this.parent || this)[r](...e)) : o[t]?.shift().resolve(s);
-            }), i.on("exit", e => {
-                for (var r in i.removeAllListeners(), 0 != e ? logger.warn(`Worker ${s} stopped with exitCode ` + e) : logger.info(`Worker ${s} stopped.`), 
-                o) for (var t = o[r]; !t.isEmpty; ) t.shift()?.resolve();
-                this.worker = void 0;
-            });
-        }
+        let a = t[e];
+        a = a || (t[e] = new h(o));
+        s = l({});
+        return a.push(s), s.promise;
     }
 }
 
-Object.assign(module.exports, {
-    QyMessager: QyMessager
-});
+export {
+    e as QyMessager
+};

package/src/QyMessager_Run.js

@@ -1,13 +1,26 @@
-let path = require("node:path"), {
-    getEnvironmentData,
-    workerData
-} = require("node:worker_threads"), logger = require("./QyLogger.js").logger;
+import {
+    resolve as a,
+    join as o
+} from "node:path";
+
+import {
+    getEnvironmentData as t,
+    workerData as i
+} from "node:worker_threads";
+
+import {
+    logger as m
+} from "./QyLogger.js";
+
+import {
+    __dirname as s
+} from "./QyUtils.js";
 
 (async () => {
-    logger.level = getEnvironmentData("logLevel");
+    m.level = t("logLevel");
     var {
         workerTypeFileName: e,
         initArgMap: r
-    } = workerData;
-    new (require(path.join(__dirname, e)))(r);
+    } = i;
+    new (await import("file://" + a(o(s, e)))).default(r);
 })();

package/src/QyMod.js

@@ -1,15 +1,19 @@
-let Module = require("node:module"), logger = require("./QyLogger.js").logger;
+import m from "node:module";
 
-function requireFromModCode(o, r, d, e) {
-    if (d) try {
-        var l = o + "_" + r, i = `_${l}_qydb`, u = (globalThis[i] = e, new Module(r));
-        return u._compile(`(function(qyDB){${d}})(${i});`, l + ".js"), delete globalThis[i], 
-        u.exports;
-    } catch (e) {
-        logger.error("requireFromModCode failed:", o, r, d, e);
+import {
+    logger as a
+} from "./QyLogger.js";
+
+function o(r, e, i, o) {
+    if (i) try {
+        var t = r + "_" + e, d = `_${t}_qydb`, l = (globalThis[d] = o, new m(e));
+        return l._compile(`(function(qyDB){${i}})(${d});`, t + ".js"), delete globalThis[d], 
+        l.exports;
+    } catch (o) {
+        a.error("requireFromModCode failed:", r, e, i, o);
     }
 }
 
-Object.assign(module.exports, {
-    requireFromModCode: requireFromModCode
-});
+export {
+    o as requireFromModCode
+};

package/src/QyOpRunner.js

@@ -1,29 +1,31 @@
-let EventEmitter = require("node:events"), setPromise = require("./QyUtils.js").setPromise, logger = require("./QyLogger.js").logger, getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, QyQueue = require("./QyQueue.js").QyQueue;
+import s from "node:events";
 
-class QyOpRunner extends EventEmitter {
-    constructor(e, s = [], t = []) {
-        super(), e = {
-            ...getDefaultOptions("QyOpRunner"),
-            ...e
+import {
+    setPromise as t
+} from "./QyUtils.js";
+
+import {
+    logger as u
+} from "./QyLogger.js";
+
+import {
+    getDefaultOptions as i
+} from "./QyDefaultOptions.js";
+
+import {
+    QyQueue as n
+} from "./QyQueue.js";
+
+class e extends s {
+    constructor(s, t = [], e = []) {
+        super(), s = {
+            ...i("QyOpRunner"),
+            ...s
         }, Object.assign(this, {
-            options: e,
+            options: s,
             running: !1,
-            opQueue: new QyQueue(e)
-        }), this._setupOpNames(s, !0), this._setupOpNames(t);
-    }
-    _setupOpNames(e, i) {
-        for (let t of e) {
-            let s = "_op_" + t;
-            this[t] || (this[t] = i ? (...e) => this.pushAndRunWithPromise({
-                opName: t,
-                opFunName: s,
-                args: e
-            }) : (...e) => this.pushAndRun({
-                opName: t,
-                opFunName: s,
-                args: e
-            })), this[s] || (this[s] = () => logger.error(`Class method ${s} not implemented.`));
-        }
+            opQueue: new n(s)
+        }), r(this, t, !0), r(this, e);
     }
     get firstOp() {
         return this.opQueue.first;
@@ -34,31 +36,31 @@ class QyOpRunner extends EventEmitter {
     finish() {
         return this.lastOp?.promise || this.runningOp?.promise;
     }
-    pushAndRunWithPromise(e) {
-        return setPromise(e), this.pushAndRun(e), e.promise;
+    pushAndRunWithPromise(s) {
+        return t(s), this.pushAndRun(s), s.promise;
     }
-    pushAndRun(...e) {
-        var s = this.opQueue, t = this.lastOp;
-        "_op_stop" === t?.opFunName ? (s.pop(), s.push(...e, t)) : s.push(...e), 
+    pushAndRun(...s) {
+        var t = this.opQueue, e = this.lastOp;
+        "_op_stop" === e?.opFunName ? (t.pop(), t.push(...s, e)) : t.push(...s), 
         this.run();
     }
     async run() {
         if (!this.running) {
             this.running = !0;
-            for (var e = this.opQueue; !e.isEmpty; ) {
-                var s = e.shift(), {
-                    opFunName: t,
+            for (var s = this.opQueue; !s.isEmpty; ) {
+                var t = s.shift(), {
+                    opFunName: e,
                     eventName: i,
                     resolve: n,
                     args: r
-                } = s;
-                if (t) {
-                    this.runningOp = s;
+                } = t;
+                if (e) {
+                    this.runningOp = t;
                     try {
-                        var u = await (r ? this[t](...r) : this[t]());
-                        n && n(u), i && this.emit(i, u);
-                    } catch (e) {
-                        logger.error(`Run ${t} failed:`, e), i && this.emit(i, e);
+                        var o = await (r ? this[e](...r) : this[e]());
+                        n && n(o), i && this.emit(i, o);
+                    } catch (s) {
+                        u.error(`Run ${e} failed:`, s), i && this.emit(i, s);
                     }
                     this.runningOp = void 0;
                 } else n && n(), i && this.emit(i);
@@ -68,6 +70,21 @@ class QyOpRunner extends EventEmitter {
     }
 }
 
-Object.assign(module.exports, {
-    QyOpRunner: QyOpRunner
-});
+function r(i, s, n) {
+    for (let e of s) {
+        let t = "_op_" + e;
+        i[e] || (i[e] = n ? (...s) => i.pushAndRunWithPromise({
+            opName: e,
+            opFunName: t,
+            args: s
+        }) : (...s) => i.pushAndRun({
+            opName: e,
+            opFunName: t,
+            args: s
+        })), i[t] || (i[t] = () => u.error(`Class method ${t} not implemented.`));
+    }
+}
+
+export {
+    e as QyOpRunner
+};

package/src/QyQueue.js

@@ -1,12 +1,18 @@
-let arrayLast = require("./QyUtils.js").arrayLast, getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, logger = require("./QyLogger.js").logger;
+import {
+    arrayLast as t
+} from "./QyUtils.js";
 
-class QyQueue {
-    constructor(e) {
-        e = {
-            ...getDefaultOptions("QyQueue"),
-            ...e
+import {
+    getDefaultOptions as e
+} from "./QyDefaultOptions.js";
+
+class s {
+    constructor(t) {
+        t = {
+            ...e("QyQueue"),
+            ...t
         }, Object.assign(this, {
-            options: e,
+            options: t,
             queue: [],
             firstIdx: 0,
             _waterMark: 0
@@ -16,7 +22,7 @@ class QyQueue {
         return this.queue[this.firstIdx];
     }
     get last() {
-        return this.isEmpty ? void 0 : arrayLast(this.queue);
+        return this.isEmpty ? void 0 : t(this.queue);
     }
     get isEmpty() {
         return this.firstIdx >= this.queue.length;
@@ -30,31 +36,30 @@ class QyQueue {
     reset() {
         this.firstIdx = 0, this.queue.length = 0;
     }
-    push(...e) {
-        this.queue.push(...e);
-        e = this.queue.length;
-        e > this._waterMark && (this._waterMark = e);
+    push(...t) {
+        this.queue.push(...t);
+        t = this.queue.length;
+        t > this._waterMark && (this._waterMark = t);
     }
     shift() {
-        var e;
-        if (!this.isEmpty) return e = this.first, this._advanceIdx(), e;
-    }
-    _advanceIdx() {
-        var {
-            queue: t,
-            firstIdx: e,
-            options: s
-        } = this, r = t.length, i = e + 1;
-        if (r <= i) this.reset(); else {
-            var u = r - i;
-            if (i > s.maxLenBeforeRecycle || u <= i) {
-                for (let e = 0; e < u; ++e) t[e] = t[e + i];
-                this.firstIdx = 0, t.length = u;
-            } else this.firstIdx = i, t[e] = void 0;
+        if (!this.isEmpty) {
+            var t = this.first, e = this, {
+                queue: s,
+                firstIdx: r,
+                options: i
+            } = e, u = s.length, h = r + 1;
+            if (u <= h) e.reset(); else {
+                var a = u - h;
+                if (h > i.maxLenBeforeRecycle || a <= h) {
+                    for (let t = 0; t < a; ++t) s[t] = s[t + h];
+                    e.firstIdx = 0, s.length = a;
+                } else e.firstIdx = h, s[r] = void 0;
+            }
+            return t;
         }
     }
 }
 
-Object.assign(module.exports, {
-    QyQueue: QyQueue
-});
+export {
+    s as QyQueue
+};