datafolder 1.0.0

package/src/QySnapshotSaver_Worker.js

@@ -0,0 +1,164 @@
+let path = require("node:path"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, QyMessageWorker = require("./QyMessageWorker.js").QyMessageWorker, QySnapshots = require("./QySnapshots.js").QySnapshots, QyKVDataCleaner = require("./QyKVDataCleaner.js").QyKVDataCleaner;
+
+class QySnapshotSaver_Worker extends QyMessageWorker {
+    constructor({
+        kvFolder: a,
+        options: s
+    }) {
+        super(s = {
+            ...getDefaultOptions("QySnapshotSaver_Worker"),
+            ...s
+        }, [ "stop", "waitForSnapshotSaved" ]);
+        var e = path.join(a, "snapshot");
+        Object.assign(this, {
+            kvFolder: a,
+            snapshotFolder: e,
+            qySnapshots: new QySnapshots(e, s),
+            qyKVDataCleaner: new QyKVDataCleaner(this, a, s),
+            aclKeyValueMap: {}
+        });
+    }
+    start(a, s, e) {
+        this.maxChangeId = a, this.qyKVDataCleaner.start(), s && this.waitForSnapshotSaved(this._createMaxSnapshot(s, a, e));
+    }
+    castSave(a, s, e) {
+        var {
+            aclKeyValueMap: t,
+            qySnapshots: n
+        } = this;
+        n.applyCmdObj(s, t, e), this.maxChangeId = a;
+    }
+    async saveSnapshot(a) {
+        var {
+            maxChangeId: s,
+            aclKeyValueMap: e
+        } = this;
+        this.aclKeyValueMap = {}, this.waitForSnapshotSaved(this._createMaxSnapshot(a, s, e));
+    }
+    releaseSnapshot(a) {
+        var s, e = this.qySnapshots, {
+            numToSnapshotMap: t,
+            keyToSnapshotMap: n
+        } = e, t = t[a], a = t.keyValueMap;
+        for (s in delete t.keyValueMap, a) delete n[s];
+        e.delSnapshot(t), global.gc && global.gc();
+    }
+    _createMaxSnapshot(a, s, e) {
+        var t = this._processOutdates(), a = {
+            snapshotNum: a,
+            keyValueMap: e,
+            outdatedCount: 0,
+            info: {
+                maxChangeId: s,
+                pMVersion: 0,
+                vLVersion: 0
+            }
+        }, e = (this.qySnapshots.addMaxSnapshot(a), this._saveKeyValueMapAndSnapshotInfo(a));
+        return {
+            saveMaxSnapshotInfoPromise: e,
+            outdates: t
+        };
+    }
+    async _saveKeyValueMapAndSnapshotInfo(a) {
+        var s = this.qySnapshots, {
+            snapshotNum: a,
+            info: e
+        } = (await s.saveKeyValueMap(a), a);
+        return await s.saveSnapshotInfo(a, e), logger.log("Created snapshot " + a), 
+        {
+            snapshotNum: a,
+            maxChangeId: e.maxChangeId
+        };
+    }
+    _processOutdates() {
+        var a, s = this.qySnapshots, {
+            emptySnapshotNumList: e,
+            combiningSnapshotList: t,
+            pMCompactSnapshotList: n
+        } = s.calOutdates(), o = {}, p = [], h = [], r = [];
+        for (a of n) {
+            var {
+                snapshotNum: i,
+                info: l
+            } = a;
+            p.push(s.savePosMap(a)), h.push([ i, l.pMVersion ]), o[i] = {
+                ...l
+            };
+        }
+        n = t.length;
+        if (0 < n) {
+            var u, S, y = s.keyToSnapshotMap, {
+                keyValueMap: M,
+                info: n,
+                snapshotNum: d
+            } = u = s.getMaxCombinedSnapshot(t);
+            for (S of t) if (u != S) {
+                var g, {
+                    keyValueMap: v,
+                    snapshotNum: m
+                } = S;
+                for (g in v) M[g] = v[g], y[g] = u;
+                s.delSnapshot(S), e.push(m);
+            }
+            p.push(s.saveKeyValueMap(u)), h.push([ d, n.pMVersion ]), r.push(d, n.vLVersion), 
+            o[d] = {
+                ...n
+            };
+        }
+        return {
+            emptySnapshotNumList: e,
+            pMChangeList: h,
+            vLChange: r,
+            snapshotInfoMap: o,
+            promises: p
+        };
+    }
+    async _op_stop() {
+        var {
+            qySnapshots: a,
+            qyKVDataCleaner: s
+        } = this;
+        a.closeAllFDs(), await s.stop();
+    }
+    async _op_waitForSnapshotSaved({
+        saveMaxSnapshotInfoPromise: a,
+        outdates: s
+    }) {
+        var e, {
+            snapshotNum: a,
+            maxChangeId: t
+        } = await a, {
+            emptySnapshotNumList: s,
+            pMChangeList: n,
+            vLChange: o,
+            snapshotInfoMap: p,
+            promises: h
+        } = s, {
+            qyKVDataCleaner: r,
+            qySnapshots: i,
+            options: l
+        } = this;
+        for (e in r.cleanAclFiles(a), 0 < h.length && await Promise.all(h), h.length = 0, 
+        p) h.push(i.saveSnapshotInfo(e, p[e]));
+        0 < h.length && await Promise.all(h), 0 < s.length && r.removeSnapshotsFiles(s), 
+        0 < n.length && r.cleanPMFiles(n), 0 < o.length && r.cleanVLFiles(o[0], o[1]);
+        let u;
+        a = i.snapshotCount;
+        0 < a && a >= l.maxInMemSnapshotCount && (delete (s = this._getMinSnapshot()).prefixPM, 
+        delete (u = {
+            ...s
+        }).keyValueMap, delete s.posMap, s.isOut = !0, logger.info("Sending snapshot " + s.snapshotNum)), 
+        this.castParent("onSnapshotSavedChangeId", t, u);
+    }
+    _getMinSnapshot() {
+        var a, s = this.qySnapshots.numToSnapshotMap;
+        let e;
+        for (a in s) {
+            var t = s[a];
+            (!e || e.snapshotNum > a) && (e = t);
+        }
+        return e;
+    }
+}
+
+module.exports = QySnapshotSaver_Worker;

package/src/QySnapshots.js

@@ -0,0 +1,354 @@
+let fs = require("node:fs"), fsPromises = require("node:fs/promises"), path = require("node:path"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, {
+    Hash_Key_Length,
+    folderOrFileExists,
+    listToMap,
+    isEmptyObj
+} = require("./QyUtils.js"), QyBinWriter = require("./QyBinWriter.js").QyBinWriter, {
+    bufferToNums,
+    numsToBuffer,
+    applyAclChange,
+    iterCmdKeys
+} = require("./QyAcl.js"), QyJsonSaver = require("./QyJsonSaver.js").QyJsonSaver, logger = require("./QyLogger.js").logger, isArray = Array.isArray;
+
+class QySnapshots {
+    constructor(t, e) {
+        (e = {
+            ...getDefaultOptions("QySnapshots"),
+            ...e
+        }).vLOutdatedPercent = 2 * e.pMOutdatedPercent;
+        var a = path.join(t, "info");
+        Object.assign(this, {
+            snapshotFolder: t,
+            snapshotInfoFolder: a,
+            options: e,
+            qyJsonSaver: new QyJsonSaver(a, e),
+            numToSnapshotMap: {},
+            keyToSnapshotMap: {},
+            fDMap: {},
+            prefixMap: {},
+            snapshotMaxChangeId: 0,
+            maxSnapshotNum: 0,
+            snapshotCount: 0
+        });
+    }
+    async loadSnapshotInfos() {
+        let {
+            snapshotInfoFolder: t,
+            qyJsonSaver: o,
+            numToSnapshotMap: n
+        } = this;
+        if (await folderOrFileExists(t)) {
+            var e = (await fsPromises.readdir(t)).filter(t => /^[1-9]/.test(t)).map(t => parseInt(t)).sort((t, e) => t - e);
+            let r = 0, s = 0;
+            await Promise.all(e.map(async t => {
+                var e = await o.loadFromFile(t + ".json"), a = n[t] = {
+                    snapshotNum: t,
+                    info: e,
+                    posMap: {},
+                    outdatedCount: 0
+                };
+                ++this.snapshotCount, t > r && (r = t, s = e.maxChangeId), await this._loadPrefixPM(a);
+            })), Object.assign(this, {
+                maxSnapshotNum: r,
+                snapshotMaxChangeId: s
+            }), this._setupPrefixMaps(e);
+        }
+    }
+    closeAllFDs() {
+        var t, e = this.fDMap;
+        for (t in e) fs.close(e[t]), delete e[t];
+    }
+    saveKeyValueMap(t) {
+        var e, {
+            keyValueMap: a,
+            info: r
+        } = t, s = (++r.vLVersion, new QyBinWriter()), o = (s.start(this.getVLFilePath(t)), 
+        Object.keys(a).sort()), n = {};
+        let i = 0, p = 0;
+        for (e of o) {
+            var u = a[e];
+            let t;
+            null == u ? t = Undefined_Mark : (u = Buffer.isBuffer(u) ? u : _valueToBuffer(e, u), 
+            u = (s.save(u), u).length, t = [ i, u ], i += u), n[e] = t, ++p;
+        }
+        return Object.assign(t, {
+            posMap: n,
+            outdatedCount: 0
+        }), Object.assign(r, {
+            totalCount: p,
+            outdatedCount: 0
+        }), Promise.all([ this.savePosMap(t, o), s.stop() ]);
+    }
+    addMaxSnapshot(t) {
+        var e, {
+            numToSnapshotMap: a,
+            keyToSnapshotMap: r
+        } = this, {
+            posMap: s,
+            keyValueMap: o,
+            snapshotNum: n,
+            info: i
+        } = t, i = i.maxChangeId, i = (Object.assign(this, {
+            maxSnapshotNum: n,
+            snapshotMaxChangeId: i
+        }), o || s);
+        for (e in i) r[e] = t;
+        a[n] = t, ++this.snapshotCount;
+    }
+    removeKey(t) {
+        var e = this.keyToSnapshotMap, a = e[t];
+        if (a) return this.removeKeyFromSnapshot(a, t), delete e[t], !0;
+    }
+    applyCmdObj(t, e, a) {
+        if (null != a) {
+            var r = a.length;
+            for (let t = 0; t < r; t += 2) {
+                var s = a[t], o = a[t + 1];
+                e[s] = null != o && _isListKey(s) ? listToMap(o) : o;
+            }
+        }
+        iterCmdKeys(t, t => {
+            t in e || (e[t] = this.getValueSync(t)), this.removeKey(t);
+        }), applyAclChange(e, t);
+    }
+    getValueSync(t) {
+        var e, a, r = this._getSnapshotByKey(t);
+        if (r) return {
+            keyValueMap: a,
+            posMap: e
+        } = r, a ? a[t] : (a = e[t]) && ([ e, a ] = a, 0 != a) ? this._readValFromFile(r, t, e, a) : void 0;
+    }
+    iterPMBuffer(e, a) {
+        var r = e.length;
+        for (let t = 0; t < r; ) {
+            var s = t + Hash_Key_Length, o = e.toString("latin1", t, s), n = [];
+            t = bufferToNums(e, s, n), a(o, n);
+        }
+    }
+    loadPartialPosMapBuffer(a, t, e) {
+        let {
+            posMap: r,
+            prefixPM: s
+        } = a, o = (delete s[t], this).keyToSnapshotMap;
+        this.iterPMBuffer(e, (t, e) => {
+            t in o ? ++a.outdatedCount : (r[t] = e, o[t] = a);
+        });
+    }
+    delSnapshot(t) {
+        delete this.numToSnapshotMap[t.snapshotNum], --this.snapshotCount, this._closeFD(this.getVLFilePath(t)), 
+        this._closeFD(this.getPMFilePath(t));
+    }
+    calOutdates() {
+        var t, e = [], a = [], r = [], s = [], {
+            options: o,
+            numToSnapshotMap: n
+        } = this, {
+            pMOutdatedPercent: i,
+            vLOutdatedPercent: p
+        } = o;
+        for (t in n) {
+            var u, h = n[t];
+            h.isOut || (100 == (u = _getTotalOutdatedPercent(h)) ? (this.delSnapshot(h), 
+            e.push(t)) : p < u ? (this._canCombine(h) ? a : s).push(h) : _getCurrentOutdatedPercent(h) > i ? r.push(h) : this._isSmallSnapshot(h) && this._canCombine(h) && a.push(h));
+        }
+        return 1 == a.length && _getTotalOutdatedPercent(a[0]) < p && (a.length = 0), 
+        0 < r.length && logger.log("pMCompacts:" + r.map(t => t.snapshotNum)), 0 < s.length && logger.log("vLCompacts:" + s.map(t => t.snapshotNum)), 
+        0 < a.length && logger.log("combiningSnapshots:" + a.map(t => t.snapshotNum)), 
+        {
+            emptySnapshotNumList: e,
+            combiningSnapshotList: a,
+            pMCompactSnapshotList: r,
+            vLCompactSnapshotList: s
+        };
+    }
+    getMaxCombinedSnapshot(t) {
+        let e, a;
+        for (var r of t) {
+            var s = r.snapshotNum;
+            (!a || a < s) && (e = r, a = s);
+        }
+        return e;
+    }
+    getPMFilePath(t) {
+        var {
+            snapshotNum: t,
+            info: e
+        } = t;
+        return path.join(this.snapshotFolder, "" + t, e.pMVersion + "_pM.txt");
+    }
+    getVLFilePath(t) {
+        var {
+            snapshotNum: t,
+            info: e
+        } = t;
+        return path.join(this.snapshotFolder, "" + t, e.vLVersion + "_vL.txt");
+    }
+    saveSnapshotInfo(t, e) {
+        var {
+            outdatedCount: a,
+            totalCount: r
+        } = e;
+        return e.outdated = Math.round(100 * a / r) + "%", this.qyJsonSaver.saveToFile(e, t + ".json", !0);
+    }
+    savePosMap(t, e) {
+        var a, {
+            outdatedCount: r,
+            info: s,
+            posMap: o
+        } = t, n = (s.outdatedCount += r, t.outdatedCount = 0, ++s.pMVersion, new QyBinWriter()), i = (n.start(this.getPMFilePath(t)), 
+        t.prefixPM = {});
+        let p = 0, u = 0, h;
+        for (a of e = e || Object.keys(o).sort()) {
+            null == h ? h = _getPrefix(a) : a.startsWith(h) || (i[h] = [ p, u ], 
+            h = _getPrefix(a), p += u, u = 0);
+            var l = Buffer.from(a), f = numsToBuffer(o[a]);
+            n.save(l), n.save(f), u += l.length + f.length;
+        }
+        return null != h && (i[h] = [ p, u ]), Promise.all([ n.stop(), this._savePrefixPM(t) ]);
+    }
+    isEmptySnapshot(t) {
+        var {
+            info: t,
+            outdatedCount: e
+        } = t;
+        return e + t.outdatedCount == t.totalCount;
+    }
+    _setupPrefixMaps(t) {
+        var e, {
+            numToSnapshotMap: a,
+            prefixMap: r
+        } = this;
+        for (e of t) {
+            var s, o = a[e], n = o.prefixPM;
+            for (s in n) {
+                var i = r[s];
+                i ? i.push(o) : r[s] = [ o ];
+            }
+        }
+    }
+    async _loadPrefixPM(t) {
+        var e = this._getPrefixPMFilePath(t), a = (logger.info("Loading " + e), 
+        await fsPromises.readFile(e)), r = a.length, s = t.prefixPM = {};
+        for (let t = 0; t < r; ) {
+            var o = t + Prefix_Length, n = s[a.toString("latin1", t, o)] = [];
+            t = bufferToNums(a, o, n);
+        }
+    }
+    _loadPartialPosMap(t, e) {
+        var a, {
+            posMap: r,
+            prefixPM: s
+        } = t, s = s[e];
+        if (s) return [ s, a ] = s, s = this._readBufferFromFile(this.getPMFilePath(t), s, a), 
+        this.loadPartialPosMapBuffer(t, e, s), r;
+    }
+    _getSnapshotByKey(t) {
+        var {
+            keyToSnapshotMap: e,
+            prefixMap: a
+        } = this;
+        let r = e[t];
+        if (r) return r;
+        var s = _getPrefix(t), o = a[s];
+        if (o) for (;0 < o.length; ) {
+            r = o.pop();
+            var n = this._loadPartialPosMap(r, s);
+            if (n && t in n) return r;
+        }
+    }
+    _readValFromFile(t, e, a, r) {
+        t = this.getVLFilePath(t), t = this._readBufferFromFile(t, a, r);
+        if (t) return _parseBuffer(e, t);
+    }
+    _readBufferFromFile(e, a, r) {
+        var s = this._getFD(e), o = Buffer.allocUnsafe(r);
+        for (let t = 0; t < r; ) {
+            var n = fs.readSync(s, o, t, r - t, a + t);
+            if (0 == n) return void logger.error(`readSync ${e} at ${a + t} returning 0 byte`);
+            t += n;
+        }
+        return o;
+    }
+    _canCombine(t) {
+        var {
+            keyValueMap: e,
+            prefixPM: a
+        } = t;
+        return e || null == a || isEmptyObj(t.prefixPM);
+    }
+    _isSmallSnapshot(t) {
+        return t.info.totalCount < this.options.minSnapshotKeyCount;
+    }
+    _getPrefixPMFilePath(t) {
+        var {
+            snapshotNum: t,
+            info: e
+        } = t;
+        return path.join(this.snapshotFolder, "" + t, e.pMVersion + "_prefixPM.txt");
+    }
+    removeKeyFromSnapshot(t, e) {
+        var {
+            posMap: a,
+            keyValueMap: r
+        } = t;
+        r && delete r[e], a && delete a[e], ++t.outdatedCount;
+    }
+    _getFD(e) {
+        var t = this.fDMap;
+        let a = t[e];
+        if (!a) {
+            logger.info("Opening " + e);
+            try {
+                a = t[e] = fs.openSync(e, "r");
+            } catch (t) {
+                throw logger.error(`Opening ${e} failed:`, t), t;
+            }
+        }
+        return a;
+    }
+    _closeFD(t) {
+        var e = this.fDMap, a = e[t];
+        null != a && (fs.close(a), delete e[t]);
+    }
+    _savePrefixPM(t) {
+        var e, a = new QyBinWriter(), r = (a.start(this._getPrefixPMFilePath(t)), 
+        t).prefixPM;
+        for (e in r) a.save(Buffer.from(e)), a.save(numsToBuffer(r[e]));
+        return a.stop();
+    }
+}
+
+let Undefined_Mark = [ 0, 0 ], Prefix_Length = 3;
+
+function _getPrefix(t) {
+    return t.substring(0, Prefix_Length);
+}
+
+function _isListKey(t) {
+    return !t.startsWith("c");
+}
+
+function _valueToBuffer(t, e) {
+    return Buffer.from(JSON.stringify(_isListKey(t) && !isArray(e) ? Object.keys(e) : e) + "\n");
+}
+
+function _parseBuffer(t, e) {
+    e = JSON.parse(e);
+    return _isListKey(t) ? listToMap(e) : e;
+}
+
+function _getTotalOutdatedPercent(t) {
+    var {
+        outdatedCount: t,
+        info: e
+    } = t, a = e.totalCount, t = t + e.outdatedCount;
+    return t == a ? 100 : Math.round(t / a * 100);
+}
+
+function _getCurrentOutdatedPercent(t) {
+    return Math.round(t.outdatedCount / t.info.totalCount * 100);
+}
+
+Object.assign(module.exports, {
+    QySnapshots: QySnapshots
+});

package/src/QyStructure.js

@@ -0,0 +1,50 @@
+let {
+    readdir,
+    rm,
+    writeFile,
+    rename
+} = require("node:fs/promises"), path = require("node:path"), ensureDir = require("./QyUtils.js").ensureDir;
+
+async function dumpStructure(e, r) {
+    let t = {};
+    for (var i of r.subdirList) {
+        let e = i.name;
+        for (;r.getFile(e); ) e += "_d";
+        e = cleanName(e), t[e] = {
+            x: i,
+            count: 0
+        };
+    }
+    await ensureDir(e);
+    var a, n = [], u = [];
+    let o = {};
+    for (a of await readdir(e, {
+        withFileTypes: !0
+    })) {
+        var s = a.name;
+        a.isFile() ? n.push(s) : (u.push(s), o[s] = 1);
+    }
+    var l, p, m, c, h, f = [];
+    for (l of u) t[l] || ((p = d((p = l) + "_d") || d(p.replace(/_d$/, ""))) ? (f.push(rename(path.join(e, l), path.join(e, p))), 
+    t[p].count = 1) : f.push(rm(path.join(e, l), {
+        recursive: !0
+    })));
+    for (m of n) r.getFile(m) || f.push(rm(path.join(e, m)));
+    await Promise.all(f), f.length = 0;
+    for (c of r.fileList) f.push(writeFile(path.join(e, cleanName(c.name)), c.contentAsText, {
+        flush: !0
+    }));
+    for (h in await Promise.all(f), f.length = 0, t) f.push(dumpStructure(path.join(e, h), t[h].x));
+    function d(e) {
+        return e && 0 == t[e]?.count && !o[e] ? e : void 0;
+    }
+    await Promise.all(f);
+}
+
+function cleanName(e) {
+    return e.replace(/"/g, "");
+}
+
+Object.assign(module.exports, {
+    dumpStructure: dumpStructure
+});

package/src/QyTrigger.js

@@ -0,0 +1,133 @@
+let util = require("node:util"), {
+    getValByNamePath,
+    setValByNamePath
+} = require("./QyFileContentUtils.js"), {
+    isEmptyObj,
+    isMatchName,
+    getMatchParam,
+    arrayLast,
+    propNameJoin
+} = require("./QyUtils.js"), isArray = Array.isArray;
+
+class QyTriggerNode {
+    constructor(e, r) {
+        Object.assign(this, {
+            name: e,
+            parent: r,
+            children: {},
+            triggerMap: {}
+        });
+    }
+    insertTrigger(e, r, t, a) {
+        let i = this;
+        for (var g of r) {
+            isMatchName(g) && (g = "*");
+            var s = i.children;
+            i = s[g] || (s[g] = new QyTriggerNode(g, i));
+        }
+        var l = i.triggerMap, o = l[e];
+        o ? Object.assign(o, {
+            triggerName: e,
+            fileNamePath: r,
+            propNamePathList: t,
+            fun: a
+        }) : l[e] = new QyTrigger(e, r, t, a);
+    }
+    removeTrigger(e, r) {
+        let t = this;
+        for (var a of r) if (isMatchName(a) && (a = "*"), !(t = t.children[a])) return !1;
+        r = t.triggerMap;
+        return !!r[e] && (delete r[e], t.isEmpty && t.removeEmptyNodes(), !0);
+    }
+    get isEmpty() {
+        return isEmptyObj(this.children) && isEmptyObj(this.triggerMap);
+    }
+    removeEmptyNodes() {
+        let e = this;
+        for (;;) {
+            var {
+                parent: r,
+                name: t
+            } = e;
+            if (!r) return;
+            if (delete r.children[t], !r.isEmpty) return;
+            e = r;
+        }
+    }
+    checkTrigger(e, r) {
+        var t, a = this.triggerMap;
+        for (t in a) a[t].checkTrigger(e, r);
+    }
+}
+
+class QyTrigger {
+    constructor(e, r, t, a) {
+        Object.assign(this, {
+            triggerName: e,
+            fileNamePath: r,
+            propNamePathList: t,
+            fun: a
+        });
+    }
+    checkTrigger(e, r) {
+        var t, {
+            triggerName: a,
+            fileNamePath: i,
+            propNamePathList: g,
+            fun: s
+        } = this, l = e.fileContent;
+        let o;
+        for (t of g) {
+            var n = getValByNamePath(r.oldValue, t), h = getValByNamePath(r.newValue, t);
+            util.isDeepStrictEqual(n, h) || (n = {
+                oldValue: n,
+                newValue: h
+            }, (isArray(h) || isArray(getValByNamePath(l, t))) && (n.isArrayDelta = !0), 
+            (o = o || {
+                _file: e,
+                _fileContent: l
+            })[propNameJoin(t)] = n, setValByNamePath(o, t, n));
+        }
+        if (o) {
+            var {
+                namePath: m,
+                qyCache: g
+            } = e;
+            for (let e = 0; e < m.length; ++e) {
+                var y = getMatchParam(i[e]);
+                y && (o[y] = m[e]);
+            }
+            try {
+                s && s(o), g.emit(a, o);
+            } catch (e) {
+                logger.error(`Running trigger ${a} failed:`, o, e);
+            }
+        }
+    }
+}
+
+let emptyArray = [];
+
+function _getMatchedSubItems(e, r) {
+    return e ? isMatchName(r) ? Object.values(e) : (e = e[r]) ? [ e ] : emptyArray : emptyArray;
+}
+
+function updateTriggerNodes(e, a) {
+    if (0 != a.length) {
+        let r = [ e ], t = [];
+        for (let e = 0; e < a.length - 1; ++e) {
+            var i, g = a[e];
+            for (i of r) for (var s of _getMatchedSubItems(i.subdirMap, g)) i.setChildTriggerNodes(s), 
+            t.push(s);
+            if (0 == t.length) return;
+            [ r, t ] = [ t, r ], t.length = 0;
+        }
+        var l, o = arrayLast(a);
+        for (l of r) for (var n of _getMatchedSubItems(l.fileMap, o)) l.setChildTriggerNodes(n);
+    }
+}
+
+Object.assign(module.exports, {
+    QyTriggerNode: QyTriggerNode,
+    updateTriggerNodes: updateTriggerNodes
+});