EE*s4jK9UY`a4*l5tFWUf+^
ziW8*%6O<8UGxu}(X&(!$MkB~AkJf|Kl$DtQ05~t#yt^$?k;+!m@Jp0oiRPI5xioxL
zeDJmW=ne#ZzyJ{7Tq`~H`$ScFhf0bI0RZnSE7_f1{UK?(fQ&iHU*=tqhOSC851Gd<
zjop@h{uaW~15&gqmp1O|v!<#70B}iB!7glD8*Taw=}l4g>XJD4Z)vs%gdixnFnU8C
zy9Gitfsv_1b>s_NSex8!MY$CKaK0tCth6YJ9c{jdw9ykP^R0;em*gk+V=w?=WS
zia2sTx-TGvG7E{VEs4*Xs!CHYevjDqjXd2A;?9E!6M|Cz
zWoh_2Vhk}RGZ}EQB>dn+3&(K?A)KCWXsEBvF`E*Zik)9Eznl3S(!IaP6P+N53G4*%
z{y)T?uOZ@R?m21jN+O5FMFq`G^-2o?xnE4VJ>G9FU%PR;<1N2wQW3`Z%Rl_)Tzf0e
z^Pn6xO<9>O&5fnSg?rsfK?qg9U(wQhP+>#tpj}yEJ$>r9A;l8(rZQ(|{p!5!6*JrjVtNqLejSY2s5rJNxcB=K*u_K3c
zI_=i+ZQGr-tmML{=Kx?}a5NMSzbkfny5Z!p!ylhJW6sXnaf$r-Pk)3h=c=r%42va)
zG1=jCzt&M8t}w=VxjF4;PM<%eUmlC^3Wh-3^!9)BT|DZb$dr^MyCgMxN&@%dMx|
zjyD~wGaB{ryBp4h$9PMHiortR@Z{8NPwznAz{rZz{aRo`NKv8X@S%q0#sg)gMI6UL
zqTbH@^oUl=;{-L*?eRXhzZe`I8yOpaHfP@v;x&c@5j-yE;0D!f%b*IbyV#zUYU!0q_udKM-9&a!d5=DvQR9dYj*PLz6Hd(EuMFkd1
zUT(H2Gc8S*92~{ZP7KMi%yCqs;gt?pTrtKZNeYF+!BAKb1VPx8BuQqBU`z<+IF92~
zTCG;2<}t>pS5LIO_$;u#8tbd7DEWW(bkXLfu)gNHq)$
literal 0
HcmV?d00001
diff --git a/repo/js/FullyAutoAndSemiAutoTools/assets/Quick Setup Button.png b/repo/js/FullyAutoAndSemiAutoTools/assets/Quick Setup Button.png
new file mode 100644
index 0000000000000000000000000000000000000000..4b7e37512f40bfd647f38ddab4bee296ab96b2d5
GIT binary patch
literal 2499
zcmV;!2|V_RP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGqB>(^xB>_oNB=7(L30O%)K~!i%%~^MI
zQ&%26&)r6H?*?~cV=#f376T!HWOjCEw*9yJ&Gw7zPBJ0XNfrVagA49eZn9*{U9x4r
zJ?Ba?a(@qIXL82Z^K@T3_jiB&S$&WGWqV5-aHg;tX&E`NZ5ul~TiD&*0brZI-y>4;
z%9`LUu0?8ECU&A*91++e%?12kNek9WV9bVPlx-JmwL2PHTie*&3?m$gU~79D
z(d{UowacedGFA%G)6+Q8k(HH+?5r$voSK>vf6Ax9T3zzlJ6mC@2T4oH4k5BDE2~%x
zh2UQZVs_4tU~mzk&kMh9T;7w=Byt3(3jJMtNxo+Ag-B{mV8q)Yl@{>p@CNOoepaNw5Ml{U@rm2x;4A
zX8ri>&0GBUWhW*leOTYvH0t#^NF~Ya>?~AQpT(W8uH(kFtEeb1G3xW##5coX43CWC
z$-2uRZ5a0I;{2JypBkJ0(I
z8>`gg|0m8+|J$#$;g5g#7OfY~8xM4xmS5_etd-2o$no!)_YP?DaEwd
z(D5m|z6aUME57UBKm3e73QW6wob4RxOtEdtKpve0tdLP?E<%rih{4hhu2%r#z*?S@px34(n0tIl`m
z?(N6Q>e?Zx?;|ev=JUbBxl_=*Rf6
zM_gfhaA*|cjEeFqu0TO-EK@?8@!v-vOm7-qqYAi;T?r32G2x?&4##InT$0w|M)vDjP7tp*{(~--u&dItTd4y?Gc}unWJup;=kM@
zLW1L6Hr_w9G4x^=Q@yqsI_`dCW3t=E=89}7euGO$umQTrgr4saS23W%;8P*bBK=+Q
z+nD}fWAsgIDENftY_KZiMX_r?1xu8+ij+eVmy_RMxOIyRCUFH7z}Z%ynStig0}E{r
zQgHcu3tw=w-A}>Adls5*TIL#Eo36yq9{O*n|Xm#D1pi^2O6$hxb_zd
zcmA1z_CJvze^)fc{CWY0@|NZf3pf61;r2gx&7UnaT(gj08heIQM96K6_LuPGd&K2-
z+~nB`-);9TT>qPedgdp&#W6`H{CUEu=s1mYI+w?L8rm(~{JVu#?t-T<{xAoSyN;^F
zJV;z6Q=)8g0_7oDUW-I6>bDq*DNh_X;@9Zf6yB4a$3i-r^A2J7$&e%s{WkvzwGPxq
zaEiH6pzo=T*+EwPALGKQP>`Dbz
zh=|-`?lk3n$jxM&hA)4WVm_>%gahp
zQdD%P(r|*s8RaSQAae|qqbxC(QAOmoNuYLJX-SdMinO#i@r1H#8`M?OmbisN`8?h|cpt_N+GT2Otq(zUKjhvgpq<2+8%byf9p
zeHsyUIh+gIaF8&i2?hCi`!r!6aWx~=Mg8J(D+&wp_qN3el>00*Go0$B5z=!=vKpZ|
zE@(jK+!>|bT|_UUrf5CYWxBnNB*q*x`H_=GxE6h5DbX__=!J=VifD7PIa9X2|
zyYVD?XJca>I&NJGLF$O+SwblTx^3K3I3yuP*u_rJMK6=^qyc@jvR
zig<$6Nc#G|^RDLuo;`nITF*O&~c6BAiau$frZl_n`atI&k^Yg=5tt8IFhx
zB04tVGtJQMo_^EUQ(H`*2NQLmQ^-TeZoD3k>BL@cYemP+b`v2J_H-)o;4J+YP5vb5
zC7%=7;gKu%WW4J8SCIV
z^D$bVMq02!{xREpnB@!i2%dhQS-`~9wD}5WzHu&w5L#Zw+UmObl91@GN)@EPBBmHo
zz`#~jS%!wX8so8~7M}tuG(SSR7NeZLb;h^c0dYYKm4syjf#8zqeP}^ybBMSeV?GTs
zn0UP+o^Om!$D02fSpLzMc6xRpY;KQ;$E1F|+8ji(8o7ZJbvPct{{R5Wz^L~J0Eqwq
N002ovPDHLkV1idH(&YdE
literal 0
HcmV?d00001
diff --git a/repo/js/FullyAutoAndSemiAutoTools/assets/Slider Bottom.png b/repo/js/FullyAutoAndSemiAutoTools/assets/Slider Bottom.png
new file mode 100644
index 0000000000000000000000000000000000000000..4af2e3cb2cbfae1e2b64dab230b8f1753fab2fbd
GIT binary patch
literal 307
zcmeAS@N?(olHy`uVBq!ia0vp^>_9BS!3HE91=ODbDaPU;cPEB*=VV?2IV|apzK#qG
z8~eHcB(eheoCO|{#S9E$svykh8Km+7D0srt#W6%9c
zvKIZZNAqcu;7g^`mj4Vw7JX~8?b3Hkc5&@bE#7s}sJG)xz|Grt{^-RRa&25V;gP=9Lq-J>PB=pSVaTU~+}n;T;R@gFbLD
zu^gPtuOD%;``MHqz7E%YzqDzwJ(ko97giLEGdUCS=E|v1J)oZ$JYD@<);T3K0RVgU
Bbaem#
literal 0
HcmV?d00001
diff --git a/repo/js/FullyAutoAndSemiAutoTools/assets/Slider Top.png b/repo/js/FullyAutoAndSemiAutoTools/assets/Slider Top.png
new file mode 100644
index 0000000000000000000000000000000000000000..7334e462d3aaf4a0dcf36f6b50a4da22abfb8fc4
GIT binary patch
literal 517
zcmV+g0{Z=lP)#2meK|Hies_SI
zLX+l+xgzHDUlXw%yshMd@ZuNJ^SYw00000NkvXX
Hu0mjf5ToL$
literal 0
HcmV?d00001
diff --git a/repo/js/FullyAutoAndSemiAutoTools/assets/paimon_menu.png b/repo/js/FullyAutoAndSemiAutoTools/assets/paimon_menu.png
new file mode 100644
index 0000000000000000000000000000000000000000..c424325b17a4956f7802352e7609bfcff2721afa
GIT binary patch
literal 2372
zcmV-K3A^@*P)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D2-!(QK~z{rt(SRF
zR96@7{OrIrs3OB6ST-
zP@DTTKA&cd-_x`4ifbQ;v^!UEWYd=r=ft5o>jaWdZ$#*F1Dp=`Lw#i>UdiRG$$NWQ
zlS!qJbxWbLunJ)v#?D#+4Ko*L&U1#Kww~+hpIblw8}X6L@I3V>qTOd=&jwpmmE@tP
zN6PlU71k%NS0-b{sVwYPN+w3?*E%@$g9jWc1ShNWOUqVas)}Z=D&g
zor^(ddmGo&$7^Bli&I(H`jA5yHPeBFc|eOy)65lLn65z7v3Rt#cd}#T%%3oS_UaWY
zP8XsoYg`}%_!_r5rlgw?!gfco5(B+3n1mL!af6==BzpXu8{&uT3qW6mS~El
zkk8E=nsSFID@2ckOt;?zeTP8kFWU_L<(r{v?++`_P}J1FJ
zrGzD=Wn-M71IC)Hz~luUn6cEC1O>prF&HzQw!v`aH!xiFElga#ftK|K6j!LeQ~fcd
zu+pkpT)duyod@HvcufdKo4P~8+8;*FJ6JPb9Y(ejI`+W`*mDLlI_jSS1!4JxCG0UD
zjGX)uI0x;=R2zR7yM)5TEgZ8vA~DL$8>v}OxltdFg0S1arJ|~;ihCNEj?QkRP&zVj
z41%F+IE+Xf^I2P(TeuM)kAkquN&(Ks|A_jR&0Ndi6qZ$E%2INE=P)evj^tWD4GO}l
zs|660<>Kz0L`bDQTlvJ_
zd*fhAC$o!g1)mB9VKP}S5-webP*{r6(tI2{eg@gOg$bAczCL=vv$<53XC
zkeQu}q9VFy$(tdpeg^M=ojCvFHMF#d*ud8xObT(KlbXT*a1qj;9&~keb5F|ifiUJp
zNhv9icK(5G$#b-d>yYrnMFa##prLW#L-Bw@#s88sxTm*NR@Wfn@W}xeH4txvNhA_-
zcq#jW+`Iw^Y1d>OFVNK}fV`&#XU@hWEkpUF{2C@MnmesS7C)bBQI0pl_)qhZ`REaH
zbDpBOT!@R8ZXho^3q6ur^t9F?BQ1rEbE?8D^!SPMuy^t0T9ku#bS|6c^{Bu}MgWpb_a$GGT7-OE0cORWTp;=~E8}W|#CW
zR${z~Eqp`wL7jee<~rcixt~x{E}+8X!^F>HL`^VR!V1gg=di+jLJq*rB>)Q@{g7Lj
zN99xl$_gIiNnRc|O*L9+cNVVl#e~`R*dBe9y@5R87vNS>8Xjb1<5}5<`I$FqjvfA{
zJ{#fD2dJ13WAB0QFoW(@F(=Q`N}ACvu7
z94CBkV1wTuWpOIxN6it998EI_F8V*b>3*K`Kbcg3(3`{ZXAAT4bR7q)3
zi8tS63pzXdYS4k;sTtc~=+|VZ=M}SYR<;_3-Qba3-?kI
z@t^~J`z(Eg++aT0lFm2#AOF&x$eXiTPDp7
z;rzyS?wDrzH8d>N!Q5>Jw(UO$fv{#+$=c8<2qR6M$*06z3(!p0ZLKAKm_<8f>KcaW
zD?;EHxOd1!^DJDqu(_;R)XLV2!$I8I4&R6q7;oW)^}CL8txPKF!PbNS!W0rV$88s8
zyGKB6kw0#xq;n$%hBwJN2#F7dP7#9<6del#`#`8ISPy>D+c2;{HUVl@8(`$M2PW>3
z7-Q~*9Wn7r`7O`VI~H~U2hk!@J|r+OaV_~#E-csV!lVV>RK9J;^`s2e1q2j4nK*SX
zGZ)dZKfxvV0K9gdz}34C(5Yl$!kg!F3Wgp>VC)%%!qQ5vd2ljv^5GwL7@MQMN9={`
zxc~SmS}1mjByBi&DgoNon-Ca%l1BE@0_1GH$rL%t!bs",
+ "default": "2"
+ },
+ {
+ "name": "the_layer",
+ "type": "checkbox",
+ "label": "只加载指定层级<配置模式 加载 生效>",
+ "default": false
+ },
+ {
+ "name": "high_level_filtering",
+ "type": "input-text",
+ "label": "高阶过滤{语法看文档}<配置模式 加载 生效>",
+ "default": ""
+ },
+ {
+ "name": "order_rules",
+ "type": "input-text",
+ "label": "执行顺序规则(可留空)\n{语法:父文件夹名称->文件夹名称=顺序请填整数,.....}",
+ "default": ""
+ },
+ {
+ "type": "separator"
+ },
+ {
+ "name": "config_white_list",
+ "type": "input-text",
+ "label": "刷新白名单 以,分割",
+ "default": "晶蝶"
+ },
+ {
+ "name": "config_black_list",
+ "type": "input-text",
+ "label": "刷新黑名单 以,分割",
+ "default": "其他,锄地专区,食材与炼金"
+ },
+ {
+ "type": "separator"
+ },
+ {
+ "name": "open_cd",
+ "type": "checkbox",
+ "label": "启用CD算法",
+ "default": false
+ },
+ {
+ "name": "http_api",
+ "type": "input-text",
+ "label": "[默认CD算法api]\ncron解析Http地址\n[请部署bettergi-scripts-tools可支持]",
+ "default": "http:///bgi/cron/next-timestamp/all"
+ },
+ {
+ "type": "separator"
+ },
+ {
+ "name": "real_time_missions",
+ "type": "multi-checkbox",
+ "label": "实时任务",
+ "options": [
+ "自动对话",
+ "自动战斗(已弃用)",
+ "自动拾取"
+ ],
+ "default": [
+ "自动拾取"
+ ]
+ },
+ {
+ "type": "separator"
+ },
+ {
+ "name": "choose_best",
+ "type": "checkbox",
+ "label": "择优模式(默认关闭 优先跑之前没跑过的)",
+ "default": false
+ },
+ {
+ "name": "mode",
+ "type": "select",
+ "label": "模式",
+ "options": [
+ "全自动",
+ "半自动"
+ ],
+ "default": "全自动"
+ },
+ {
+ "name": "auto_semi_key_mode",
+ "type": "select",
+ "label": "[半自动]快捷键模式",
+ "options": [
+ "继续运行",
+ "跳过"
+ ],
+ "default": "继续运行"
+ },
+ {
+ "name": "auto_key",
+ "type": "input-text",
+ "label": "<继续运行|跳过>本次路线快捷键 (独立BGI的快捷键请勿冲突)"
+ },
+ {
+ "type": "separator"
+ },
+ {
+ "name": "open_limit_max",
+ "type": "checkbox",
+ "label": "开启执行组最大路径设置"
+ },
+ {
+ "name": "limit_max_group",
+ "type": "input-text",
+ "label": "配置执行组最大路径数\n{语法:父文件夹名称->文件夹名称=最大路径数,.....}\n如:敌人与魔物->蕈兽=50",
+ "default": ""
+ },
+ {
+ "type": "separator"
+ },
+ {
+ "name": "team_fight",
+ "type": "input-text",
+ "label": "战斗队伍配置(同时也是行走队伍配置)\n已禁用战斗检测,战斗队伍配置失效\n只留行走队伍配置"
+ },
+ {
+ "name": "team_hoe_ground",
+ "type": "input-text",
+ "label": "锄地队伍配置\n{语法:父文件夹名称->文件夹名称=队伍名称,.....}\n如:敌人与魔物->蕈兽=队伍名称",
+ "default": ""
+ },
+ {
+ "name": "team_seven_elements",
+ "type": "input-text",
+ "label": "队伍配置 按 `矿物,火,水,风,雷,草,冰,岩` 该顺序填写(建议草神请填至`草`位)",
+ "default": ""
+ },
+ {
+ "type": "separator"
+ },
+ {
+ "name": "is_debug",
+ "type": "checkbox",
+ "label": "开发者模式",
+ "default": false
+ },
+ {
+ "name": "debug",
+ "type": "input-text",
+ "label": "调试快捷键(开发者)"
+ }
+]
\ No newline at end of file
diff --git a/repo/js/FullyAutoAndSemiAutoTools/main.js b/repo/js/FullyAutoAndSemiAutoTools/main.js
new file mode 100644
index 000000000..72ed59b45
--- /dev/null
+++ b/repo/js/FullyAutoAndSemiAutoTools/main.js
@@ -0,0 +1,2215 @@
+let manifest_json = "manifest.json";
+let manifest = undefined
+let configSettings = undefined
+const auto = {
+ semi: false,//半自动
+ run: false,//运行
+ skip: false,//跳过
+ key: "",
+}
+const dev = {
+ isDebug: false,
+ debug: undefined,
+}
+const cd = {
+ open: settings.open_cd || false,
+ http_api: settings.http_api || undefined,
+}
+const pathingName = "pathing"
+let loadingLevel = 2
+// const pathAsMap = new Map([])
+// const pathRunMap = new Map([])
+const needRunMap = new Map([])
+const PATHING_ALL = new Array({
+ id: `${pathingName}`,
+ level: 0,
+ name: `${pathingName}`,
+ parent_name: "",
+ child_names: []
+})
+let settingsNameList = new Array()
+const settingsNameAsList = new Array()
+let PATH_JSON_LIST = new Array()
+const config_root = 'config'
+const levelName = "treeLevel"
+const json_path_name = {
+ RecordText: `${config_root}\\record.json`,
+ RecordPathText: `${config_root}\\PathRecord.json`,
+ uidSettingsJson: `${config_root}\\uidSettings.json`,
+ templateMatchSettingsJson: `${config_root}\\settings.json`,
+ cdPath: `${config_root}\\cd-${pathingName}.json`,
+ SevenElement: `${config_root}\\SevenElement.json`,
+ RefreshSettings: `${config_root}\\RefreshSettings.json`,
+ pathJsonByUid: `${config_root}\\path-json-by-uid.json`,
+ PathOrder: `${config_root}\\PathOrder.json`,
+ HoeGround: `${config_root}\\HoeGround.json`,
+ LimitMax: `${config_root}\\LimitMax.json`,
+}
+// 定义记录文件的路径
+// let RecordText = `${config_root}\\record.json`
+// let RecordPathText = `${config_root}\\PathRecord.json`
+let RecordList = new Array()
+let RecordPathList = new Array()
+let RecordLast = {
+ uid: "",
+ data: undefined,
+ timestamp: 0,
+ paths: new Set(), // 记录路径
+ errorPaths: new Set(),
+ groupPaths: new Set(),
+}
+const Record = {
+ uid: "",
+ data: undefined,
+ timestamp: 0,
+ paths: new Set(), // 记录路径
+ errorPaths: new Set(), // 记录错误路径
+ groupPaths: new Set(), // 记录分组路径
+}
+let RecordPath = {
+ uid: "",
+ paths: new Set(), // 记录路径
+ //{timestamp,path}
+}
+const config_list = {
+ black: [],
+ white: [],
+}
+
+const SevenElement = {
+ SevenElements: ['矿物', '火', '水', '风', '雷', '草', '冰', '岩'],
+ SevenElementsMap: new Map([
+ ['矿物', ['夜泊石', '石珀', '清水玉', '万相石', '矿物']],
+ ['火', []],
+ ['水', ['海露花']],
+ ['风', ['蒲公英籽']],
+ ['雷', ['琉鳞石', '绯樱绣球']],
+ ['草', []],
+ ['冰', []],
+ ['岩', []],
+ ]),
+}
+
+
+const team = {
+ current: undefined,
+ fight: false,
+ fightName: settings.team_fight,
+ fightKeys: ['锄地专区', "敌人与魔物"],
+ SevenElements: settings.team_seven_elements ? settings.team_seven_elements.split(',').map(item => item.trim()) : [],
+ HoeGroundMap: new Map([]),
+
+}
+const timeType = Object.freeze({
+ hours: 'hours',//小时
+ cron: 'cron',//cron表达式
+ // 添加反向映射（可选）
+ fromValue(value) {
+ return Object.keys(this).find(key => this[key] === value);
+ }
+});
+
+/**
+ * 实时任务处理函数
+ * @param {boolean} is_common - 是否为通用任务标志
+ * @returns {void} 无返回值
+ */
+async function realTimeMissions(is_common = true) {
+ let real_time_missions = settings.real_time_missions // 从设置中获取实时任务列表
+ if (!Array.isArray(real_time_missions)) {
+ real_time_missions = [...real_time_missions]
+ }
+ if (!is_common) { // 处理非通用任务
+ if (real_time_missions.includes("自动战斗")) {
+ // await dispatcher.runAutoFightTask(new AutoFightParam());
+ await dispatcher.runTask(new SoloTask("AutoFight")); // 执行自动战斗任务
+ }
+ return // 非通用任务处理完毕后直接返回
+ }
+ // 处理通用任务
+ if (real_time_missions.includes("自动对话")) {
+ dispatcher.addTrigger(new RealtimeTimer("AutoSkip")); // 添加自动对话触发器
+ }
+ if (real_time_missions.includes("自动拾取")) {
+ // 启用自动拾取的实时任务
+ dispatcher.addTrigger(new RealtimeTimer("AutoPick")); // 添加自动拾取触发器
+ }
+
+}
+
+/**
+ * 根据用户ID加载路径JSON列表
+ * 该函数尝试从指定路径读取并解析JSON文件，将解析后的数据转换为Map对象，
+ * 然后根据当前用户ID获取对应的路径列表
+ *
+ * @returns {boolean} 加载成功返回true，失败返回false
+ */
+function loadPathJsonListByUid() {
+ try {
+ // 读取并解析JSON文件内容
+ const raw = JSON.parse(file.readTextSync(json_path_name.pathJsonByUid));
+ // 将解析后的数组转换为Map对象
+ const map = new Map(raw);
+
+ // 获取当前用户ID对应的路径列表
+ const list = map.get(Record.uid);
+ // 检查获取的列表是否为有效数组且不为空
+ if (Array.isArray(list) && list.length > 0) {
+ // 更新全局PATH_JSON_LIST变量
+ PATH_JSON_LIST = list;
+ // 记录成功日志，包含用户ID和路径数量
+ log.info(
+ "[PATH] 已加载 PATH_JSON_LIST，uid={0}，count={1}",
+ Record.uid,
+ PATH_JSON_LIST.length
+ );
+ return true;
+ }
+ } catch (e) {
+ // 捕获并记录异常信息
+ log.warn("[PATH] 加载 PATH_JSON_LIST 失败: {0}", e.message);
+ }
+ return false;
+}
+
+async function initRefresh(settingsConfig) {
+ let level = 0
+ const parent_level = level + 1
+ // 获取当前路径下的所有文件/文件夹
+ let pathSyncList = file.readPathSync(`${PATHING_ALL[level].name}`);
+ log.debug("{0}文件夹下有{1}个文件/文件夹", `${pathingName}`, pathSyncList.length);
+ // 预处理黑白名单数组，移除空字符串并trim
+ const processedBlackList = config_list.black
+ .map(item => item.trim())
+ .filter(item => item !== "");
+
+ const processedWhiteList = config_list.white
+ .map(item => item.trim())
+ .filter(item => item !== "");
+ let blacklistSet = new Set(processedBlackList)
+ processedWhiteList.forEach(item => {
+ blacklistSet.delete(item)
+ })
+ const blacklist = Array.from(blacklistSet)
+
+ let settingsList = settingsConfig
+ let settingsRefreshList = []
+ let parentJson = {
+ name: `${levelName}_${level}_${level}`,
+ type: "multi-checkbox",
+ label: `选择要执行的${parent_level}级路径`,
+ options: []
+ }
+ for (const element of pathSyncList) {
+ // log.warn("element={0}", element)
+ const item = element.replace(`${pathingName}\\`, "");
+ if (!blacklist.find(black => item === black)) {
+ parentJson.options.push(item)
+ }
+ }
+ // settingsRefreshList.push({type: "separator"})
+
+ let treePathList = await readPaths(`${pathingName}`)
+ await debugKey('[init-refresh]_log-treePathList.json', JSON.stringify(treePathList))
+ let pathJsonList = await treeToList(treePathList)
+ await debugKey('[init-refresh]_log-pathJsonList.json', JSON.stringify(pathJsonList))
+ let obj = {
+ id: `${pathingName}`,
+ level: level,
+ name: `${pathingName}`,
+ parentId: undefined,
+ parentName: undefined,
+ rootName: undefined, // 最父级下一级名称
+ child_names: parentJson.options
+ };
+ await addUniquePath(obj)
+
+ PATH_JSON_LIST = pathJsonList
+
+ const forList = pathJsonList.filter(item => item.isFile)
+ for (const element of forList) {
+ const pathRun = element.path
+
+ // 检查路径是否被允许
+ const isBlacklisted = processedBlackList.some(item => pathRun?.includes(item));
+ const isWhitelisted = processedWhiteList.some(item => pathRun?.includes(item));
+
+ if (isBlacklisted && !isWhitelisted) {
+ continue;
+ }
+ //方案1
+ try {
+ loadingLevel = parseInt(settings.loading_level)
+ } catch (e) {
+ log.warn("配置 {0} 错误，将使用默认值{0}", "加载路径层级", loadingLevel)
+ } finally {
+ //
+ loadingLevel = loadingLevel < 1 ? 2 : loadingLevel
+ }
+ // 优化版本
+ for (let i = 0; i < loadingLevel; i++) {
+ const currentLevel = parent_level + 1 + i;
+ const parentLevel = parent_level + i;
+
+ const currentName = getChildFolderNameFromRoot(pathRun, currentLevel);
+ const childName = getChildFolderNameFromRoot(pathRun, currentLevel + 1);
+
+ // 检查当前层级是否存在
+ if (!currentName) {
+ break; // 没有当前层级，停止处理
+ }
+
+ // 过滤JSON文件
+ const filteredChildName = childName?.endsWith(".json") ? undefined : childName;
+ let child_names = Array.from(new Set(filteredChildName ? [filteredChildName] : []).difference(new Set(blacklist)))
+ // 获取父级名称用于建立层级关系
+ const parentName = getChildFolderNameFromRoot(pathRun, parentLevel);
+ const rootName = getChildFolderNameFromRoot(pathRun, parent_level + 1);
+
+ let obj1 = {
+ id: undefined,
+ parentId: element.parentId,
+ level: parentLevel, // 存储到目标层级 属于目标层级
+ name: currentName, // 当前层级名称
+ parentName: parentName, // 父级名称
+ rootName: rootName, // 最父级下一级名称
+ child_names: [...child_names]
+ };
+ await addUniquePath(obj1);
+ }
+ }
+ // 正确的排序方式
+ PATHING_ALL.sort((a, b) => {
+ // 首先按 level 排序
+ if (a.level !== b.level) {
+ return a.level - b.level;
+ }
+ const pathA = a?.path || '';
+ const pathB = b?.path || '';
+ // if (a.parent_name !== b.parent_name) {
+ // return a.parent_name.localeCompare(b.parent_name);
+ // }
+ // level 相同时按 path 排序
+ return pathA.localeCompare(pathB);
+ });
+
+ await debugKey('[init-refresh]_log-PATHING_ALL.json', JSON.stringify(PATHING_ALL))
+ const groupLevel = groupByLevel(PATHING_ALL);
+ await debugKey('[init-refresh]_log-groupLevel.json', JSON.stringify(groupLevel))
+ // const initLength = settingsList.length
+ let parentNameLast = undefined
+ // let parentNameNow = undefined
+ // const line = 30
+ // const br = `${"=".repeat(line)}\n`
+ let idx = 0
+ // const settingsSortMap = new Map([])
+ settingsRefreshList.push({type: "separator"})
+ settingsRefreshList.push({type: "separator"})
+ groupLevel.filter(list => list.length > 0).forEach(
+ (list) => {
+ let i = 0
+ list.filter(item => item && item.child_names && item.child_names.length > 0).forEach(item => {
+ const name = `${levelName}_${item.level}_${i}`
+ let prefix = ''
+ log.debug(`[{2}]Last{0},Current{1},Name{5}`, "比对", parentNameLast, item.parentName, item.name)
+ const isCommonLastAndCurrent = item.parentName !== parentNameLast;
+ if (isCommonLastAndCurrent) {
+ parentNameLast = item.parentName;
+ // let b = (line - item.parentName.length) % 2 === 0;
+ // const localLine = b ? ((line - item.parentName.length) / 2) : (Math.ceil((line - item.parentName.length) / 2))
+ // prefix = br + `${"=".repeat(localLine)}${item.parentName}${"=".repeat(localLine)}\n` + br
+ }
+ // const p = idx === 0 ? "【地图追踪】\n" : `${prefix}[${item.parent_name}-${item.name}]\n`
+ const p = `\n${prefix}${(item.rootName && item.name !== item.rootName) ? "《" + item.rootName + "》->" : ""}[${item.name}]`
+ idx++
+ let leveJson = {
+ name: `${name}`,
+ type: "multi-checkbox",
+ label: `选择要执行的${item.level + 1}级路径${p}`,
+ options: []
+ }
+ // todo: 待优化
+ const targetItem = PATH_JSON_LIST.filter(list_item => !list_item.levelName)
+ .find(list_item => list_item.id === item.parentId);
+ if (targetItem) {
+ targetItem.levelName = name || undefined;
+ }
+
+ // leveJson.options = leveJson.options.concat(item.child_names)
+ leveJson.options = [...item.child_names]
+ if (leveJson.options && leveJson.options.length > 0) {
+ settingsNameAsList.push({
+ settings_name: name,
+ settings_as_name: item.name
+ })
+ settingsNameList.push(name)
+ const existingIndex = settingsRefreshList.findIndex(item => item.name === leveJson.name);
+ if (existingIndex !== -1) {
+ // 替换已存在的配置项
+ settingsRefreshList[existingIndex] = leveJson;
+ } else {
+ if (isCommonLastAndCurrent) {
+ settingsRefreshList.push({type: "separator"})
+ }
+ parentNameLast = item.parentName;
+ settingsRefreshList.push({type: "separator"})
+ // 添加新的配置项
+ settingsRefreshList.push(leveJson);
+ }
+ i++
+ }
+ })
+ }
+ )
+ await debugKey('[init-refresh]_log-settingsRefreshList.json', JSON.stringify(settingsRefreshList))
+ //settingsRefreshList 二级排序 todo:
+ level++
+ settingsList = Array.from(new Set(settingsList.concat(settingsRefreshList)))
+
+ settingsList.filter(
+ item => item.name === 'key'
+ ).forEach(item => {
+ // 刷新settings自动设置密钥
+ item.default = manifest.key
+ })
+ settingsList.filter(
+ item => item.name === 'config_run'
+ ).forEach(item => {
+ // 刷新settings自动设置执行
+ item.default = "执行"
+ })
+ const uidSettingsMap = new Map([])
+ // 更新当前用户的配置
+ uidSettingsMap.set(Record.uid, settingsList)
+ // 安全写入配置文件
+ try {
+ file.writeTextSync(json_path_name.uidSettingsJson, JSON.stringify([...uidSettingsMap]))
+ log.debug("用户配置已保存: {uid}", Record.uid)
+ } catch (error) {
+ log.error("保存用户配置失败: {error}", error.message)
+ }
+ settingsList.filter(
+ item => item.name === 'config_uid'
+ ).forEach(item => {
+ // 刷新settings自动设置执行
+ item.label = "当前配置uid:\{" + Record.uid + "\}\n(仅仅显示配置uid无其他作用)"
+ })
+ file.writeTextSync(manifest.settings_ui, JSON.stringify(settingsList))
+
+ // ===== 保存 PATH_JSON_LIST（按 uid）=====
+ try {
+ let pathJsonMap = new Map();
+
+ try {
+ const raw = JSON.parse(file.readTextSync(json_path_name.pathJsonByUid));
+ pathJsonMap = new Map(raw);
+ } catch (e) {
+ log.debug("PATH_JSON_LIST 映射文件不存在，将新建");
+ }
+
+ pathJsonMap.set(Record.uid, PATH_JSON_LIST);
+
+ file.writeTextSync(
+ json_path_name.pathJsonByUid,
+ JSON.stringify([...pathJsonMap])
+ );
+
+ log.info(
+ "[PATH] 已保存 PATH_JSON_LIST，uid={0}，count={1}",
+ Record.uid,
+ PATH_JSON_LIST.length
+ );
+ } catch (e) {
+ log.error("[PATH] 保存 PATH_JSON_LIST 失败: {0}", e.message);
+ }
+ if (settings.refresh_record) {
+ if (settings.refresh_record_mode === "UID") {
+ RecordList = RecordList.filter(item => item.uid !== Record.uid)
+ RecordPathList = RecordPathList.filter(item => item.uid !== Record.uid)
+ file.writeTextSync(json_path_name.RecordPathText, JSON.stringify(RecordPathList))
+ file.writeTextSync(json_path_name.RecordText, JSON.stringify(RecordList))
+ log.info("已清空UID:{0}记录文件", Record.uid)
+ return
+ }
+ file.writeTextSync(json_path_name.RecordPathText, JSON.stringify([]))
+ file.writeTextSync(json_path_name.RecordText, JSON.stringify([]))
+ log.info("已清空全部记录文件")
+ }
+}
+
+
+/**
+ * 初始化用户ID设置映射表
+ * @param {Map} uidSettingsMap - 用于存储用户ID设置的Map对象
+ * @returns {Map} 返回初始化后的用户ID设置映射表
+ */
+async function initUidSettingsMap(uidSettingsMap) {
+ // 获取用户设置JSON文件的路径
+ const uidSettingsJson = json_path_name.uidSettingsJson;
+ try {
+ // 读取并解析JSON文件内容，转换为Map对象
+ const existingData = JSON.parse(file.readTextSync(uidSettingsJson))
+ uidSettingsMap = new Map(existingData)
+ } catch (e) {
+ // 文件不存在时使用空Map
+ log.debug("配置文件不存在，将创建新的");
+ }
+ return uidSettingsMap;
+}
+
+/**
+ * 加载用户ID设置映射表
+ * @param {Map} uidSettingsMap - 用户ID到设置项的映射表
+ */
+async function loadUidSettingsMap(uidSettingsMap) {
+ // 从映射表中获取当前用户的设置
+ let uidSettings = uidSettingsMap.get(Record.uid);
+ // 如果存在用户设置
+ if (uidSettings) {
+ if (!loadPathJsonListByUid()) {
+ throw new Error(
+ "未找到 PATH_JSON_LIST，请先执行一次【刷新配置】"
+ );
+ }
+ try {
+ let templateMatchSettings = JSON.parse(file.readTextSync(json_path_name.templateMatchSettingsJson));
+ // 筛选出名称为'config_run'的设置项
+ templateMatchSettings.filter(
+ item => item.name === 'config_run'
+ ).forEach(item => {
+ // 刷新settings自动设置执行
+ item.default = "执行"
+ })
+ templateMatchSettings.filter(
+ item => item.name === 'config_uid'
+ ).forEach(item => {
+ // 刷新settings自动设置执行
+ item.label = "当前配置uid:\{" + Record.uid + "\}\n(仅仅显示配置uid无其他作用)"
+ })
+ let filterSettings = []
+ const filterUidSettings = uidSettings.filter(item => item?.name?.startsWith(levelName))
+ let tempFilterUidSettings = []
+
+ let last_parent_level = undefined
+ for (let i = 0; i < filterUidSettings.length; i++) {
+ let item = filterUidSettings[i]
+ // log.warn(`item:{0}`,item)
+ if (item?.name?.startsWith(levelName)) {
+ if (i === 0) {
+ tempFilterUidSettings.push({type: "separator"})
+ tempFilterUidSettings.push({type: "separator"})
+ }
+
+ tempFilterUidSettings.push({type: "separator"})
+
+ let parent_level = item?.name?.replace(levelName + "_", "")?.split("_")[0] || undefined
+ if (i !== 0 && parent_level && parent_level !== last_parent_level) {
+ tempFilterUidSettings.push({type: "separator"})
+ }
+ tempFilterUidSettings.push(item)
+ last_parent_level = parent_level
+ }
+ }
+ // log.debug("用户配置: {0}", tempFilterUidSettings)
+ filterSettings = tempFilterUidSettings
+ // filterSettings = filterUidSettings
+ // templateMatchSettings = Array.from(new Set(templateMatchSettings).difference(new Set(filterUidSettings)))
+ try {
+ loadingLevel = parseInt(settings.loading_level)
+ } catch (e) {
+ log.warn("配置 {0} 错误，将使用默认值{0}", "加载路径层级", loadingLevel)
+ } finally {
+ //
+ loadingLevel = loadingLevel < 1 ? 2 : loadingLevel
+ }
+ //todo: 高阶层级过滤
+ const highLevelFiltering = settings.high_level_filtering || undefined
+ if (highLevelFiltering && highLevelFiltering?.trim() !== "") {
+ /**
+ * 实例：pathing\地方特产\
+ * 地方特产
+ * 实例：pathing\地方特产\枫丹\
+ * 地方特产->枫丹
+ * 实例：pathing\地方特产\枫丹\幽光星星\
+ * 地方特产->枫丹->幽光星星
+ * 实例：pathing\地方特产\枫丹\幽光星星\幽光星星@jbcaaa\
+ * 地方特产->枫丹->幽光星星->幽光星星@jbcaaa
+ */
+ let keys = new Set([])
+
+ if (highLevelFiltering) {
+ const set = new Set(highLevelFiltering.split("->"));
+ keys = keys.union(set)
+ }
+
+ // function countMatchingElements(mainSet, subset) {
+ // const mainSetObj = new Set(mainSet);
+ // return subset.filter(item => mainSetObj.has(item)).length;
+ // }
+
+ // const key = keys[keys.size - 1]
+ // PATH_JSON_LIST.filter(item => item.level > 0)
+ // 预先建立 levelName 到路径信息的映射
+ const levelNameMap = new Map();
+ PATH_JSON_LIST.forEach(item => {
+ log.debug(`item:{0}`, JSON.stringify(item))
+ if (item.levelName) {
+ levelNameMap.set(item.levelName, item);
+ }
+ });
+ log.warn("levelNameMap:{0}", JSON.stringify([...levelNameMap]))
+ //中间一段路径名称
+ const dir_key = Array.from(keys).join("\\")
+ filterSettings = filterSettings.filter(item => {
+ if (!item?.name?.startsWith(levelName)) {
+ return true
+ }
+ // const settings_level = PATH_JSON_LIST.filter(list_item => list_item.levelName === item.name).find();
+ const settings_level = levelNameMap.get(item.name);
+ if (settings_level) {
+ //只加载指定目录
+ return (settings_level.path.includes(dir_key))
+ }
+ return false
+ })
+ }
+ const theLayer = settings.the_layer || false
+ const levelSettings = filterSettings.filter(item => {
+ if (!item?.name?.startsWith(levelName)) {
+ return true
+ }
+ const level_all = item.name.replaceAll(levelName + "_", "");
+ // 获取级别
+ const level = level_all.split("_").map(parseInt)[0]
+ if (theLayer) {
+ //只加载指定级别的设置
+ return (loadingLevel === level + 1)
+ }
+ // 检查级别是否小于等于加载层级
+ return (loadingLevel > level - 1)
+ })
+ templateMatchSettings = [...templateMatchSettings, ...levelSettings]
+ while (templateMatchSettings.length > 0 &&
+ templateMatchSettings[templateMatchSettings.length - 1]?.type === "separator") {
+ templateMatchSettings.pop();
+ }
+
+ /**
+ * 限制连续的分隔符数量不超过3个
+ * @param {Array} settings - 设置项数组
+ * @returns {Array} 处理后的设置项数组
+ */
+ function limitConsecutiveSeparators(settings) {
+ if (!Array.isArray(settings) || settings.length === 0) {
+ return settings;
+ }
+
+ const result = [];
+ let consecutiveSeparatorCount = 0;
+
+ for (const item of settings) {
+ if (item?.type === "separator") {
+ consecutiveSeparatorCount++;
+
+ // 只有当连续分隔符数量不超过3个时才添加
+ if (consecutiveSeparatorCount <= 3) {
+ result.push(item);
+ }
+ } else {
+ // 遇到非分隔符时重置计数
+ consecutiveSeparatorCount = 0;
+ result.push(item);
+ }
+ }
+
+ return result;
+ }
+
+ templateMatchSettings = limitConsecutiveSeparators(templateMatchSettings)
+ // uidSettings.push(levelSettings)
+ // 将更新后的设置写入配置文件
+ file.writeTextSync(manifest.settings_ui, JSON.stringify(templateMatchSettings))
+ } catch (e) {
+ // 记录错误日志
+ log.error("加载用户配置失败: {error}", e.message)
+ }
+ }
+ // 初始化配置设置
+ configSettings = await initSettings()
+}
+
+async function initRun(config_run) {
+ if (!loadPathJsonListByUid()) {
+ throw new Error(
+ "未找到 PATH_JSON_LIST，请先执行一次【刷新配置】"
+ );
+ }
+ log.info(`初始{0}配置`, config_run)
+ const cdPath = json_path_name.cdPath;
+ const timeJson = (!cd.open) ? new Set() : new Set(JSON.parse(file.readTextSync(cdPath)).sort(
+ (a, b) => b.level - a.level
+ ))
+
+ const multiCheckboxMap = await getMultiCheckboxMap();
+ if (dev.isDebug) {
+ await debugKey('[init-run]_log-multiCheckboxMap.json', JSON.stringify(Array.from(multiCheckboxMap)))
+ const keysList = Array.from(multiCheckboxMap.keys());
+ await debugKey('[init-run]_log-keysList.json', JSON.stringify(keysList))
+ }
+
+ settingsNameList = settingsNameList.concat(
+ Array.from(multiCheckboxMap.keys().filter(key =>
+ typeof key === "string" &&
+ key.startsWith(levelName) &&
+ multiCheckboxMap.get(key)?.options?.length > 0
+ ))
+ )
+
+
+ settingsNameList = settingsNameList
+ .filter(key => typeof key === "string" && key.trim() !== "")
+
+ log.debug(`settingsNameList:{0}`, JSON.stringify(settingsNameList))
+
+
+ // todo:补齐执行前配置
+ // ================= 执行前配置（补齐 needRunMap） =================
+ await debugKey(
+ '[init-run]_log-PATH_JSON_LIST.json',
+ JSON.stringify(PATH_JSON_LIST)
+ );
+
+ for (const settingsName of settingsNameList) {
+
+ // 1. 读取 multi-checkbox 的 JSON 描述
+ const multiJson = await getJsonByMultiCheckboxName(settingsName);
+ if (!multiJson || !multiJson.options || multiJson.options.length === 0) continue;
+
+ const labelParentName = getBracketContent(multiJson.label); // [xxx]
+ const selectedOptions = multiJson.options;
+
+ // 2. 从 PATH_JSON_LIST 中筛选命中的路径
+ const filter = PATH_JSON_LIST.filter(item => item.children.length === 0);
+ await debugKey(`[init-run]_log-filtermatchedPaths.json`, JSON.stringify(filter))
+ let matchedPaths = filter.filter(item => {
+ const hitParent = item.fullPathNames.includes(labelParentName) || labelParentName === `${pathingName}`;
+ const hitOption = selectedOptions.some(opt =>
+ item.fullPathNames.some(name => name.includes(opt))
+ );
+
+ return hitParent && hitOption;
+ }).map(item => {
+ const selected = selectedOptions.find(opt =>
+ item.fullPathNames.some(name => name.includes(opt))
+ );
+
+ return {
+ level: item.level,
+ name: item.name,
+ id: item.id,
+ parentId: item.parentId,
+ parentName: item.parentName,
+ rootName: item.rootName,
+ selected: selected,
+ path: item.path,
+ fullPathNames: item.fullPathNames
+ };
+ });
+ await debugKey(`[init-run]_log-matchedPaths.json`, JSON.stringify(matchedPaths))
+
+ function generatedKey(item, useParent = false) {
+ const separator = "->";
+
+ if (useParent) {
+ // 使用父级名称的逻辑
+ if (item?.parent_name && !item?.parentName) {
+ return `${item.parent_name}${separator}${item.name}`;
+ } else if (item?.parentName) {
+ return `${item.parentName}${separator}${item.name}`;
+ }
+ } else {
+ // 三层结构的逻辑
+ if (item?.rootName && item?.parentName && item?.rootName !== "" && item?.parentName !== item?.rootName) {
+ return `${item.rootName}${separator}${item.parentName}${separator}${item.name}`;
+ } else if (item?.root_name && item?.parent_name && item?.root_name !== "" && item?.parent_name !== item?.root_name) {
+ return `${item.root_name}${separator}${item.parent_name}${separator}${item.name}`;
+ }
+ // 二层结构的逻辑
+ if (item?.parent_name && !item?.parentName) {
+ return `${item.parent_name}${separator}${item.name}`;
+ } else if (item?.parentName) {
+ return `${item.parentName}${separator}${item.name}`;
+ }
+ }
+
+ // 默认返回名称
+ return item.name;
+ }
+
+ // 3. CD 过滤（可选）
+ if (cd.open && matchedPaths.length > 0) {
+ let recordPaths = [];
+ try {
+ recordPaths = Array.from(RecordPath.paths);
+ } catch (e) {
+ log.error("读取记录路径失败: {error}", e.message)
+ }
+ recordPaths.sort((a, b) => b.timestamp - a.timestamp)
+
+ const timeConfigs = Array.from(timeJson);
+ await debugKey(`[init-run]_log-timeConfigs.json`, JSON.stringify(timeConfigs))
+ await debugKey(`[init-run]_log-recordPaths.json`, JSON.stringify(recordPaths))
+ let bodyList = []
+ const now = Date.now();
+ //首次过滤
+ let cdFilterMatchedPaths = matchedPaths.filter(item => {
+ const timeConfig = timeConfigs.find(cfg =>
+ item.fullPathNames.includes(cfg.name)
+ );
+ if (!timeConfig) return false;
+
+ const record = recordPaths.find(r =>
+ r.path.includes(item.path)
+ );
+ if (!record || !record.timestamp) return false;
+ switch (timeType.fromValue(timeConfig.type)) {
+ case timeType.cron:
+ // timeConfig.name
+ // const key = generatedKey(item);
+ const item_key = bodyList.find(cfg => cfg.key === item.path)
+ if (!item_key) {
+ bodyList.push({
+ key: item.path,
+ cronExpression: timeConfig.value,
+ startTimestamp: record.timestamp,
+ endTimestamp: now
+ })
+ } else if (item_key.startTimestamp < record.timestamp) {
+ item_key.startTimestamp = record.timestamp
+ item_key.cronExpression = timeConfig.value
+ }
+
+ return true;
+ default:
+ return true;
+ }
+ return true
+ })
+ await debugKey(`[init-run]_log-cdFilterMatchedPaths.json`, JSON.stringify(cdFilterMatchedPaths))
+ //多次请求改一次请求
+ const nextMap = bodyList.length <= 0 ? new Map() : await cronUtil.getNextCronTimestampAll(bodyList, cd.http_api) ?? new Map();
+ await debugKey(``, JSON.stringify({nextMap: [...nextMap]}), true)
+ //还在cd中的path
+ const in_cd_paths = cdFilterMatchedPaths.filter(async item => {
+ const timeConfig = timeConfigs.find(cfg =>
+ item.fullPathNames.includes(cfg.name)
+ );
+
+ switch (timeType.fromValue(timeConfig.type)) {
+ case timeType.hours: {
+ const diff = getTimeDifference(record.timestamp, now);
+ return (diff.total.hours < timeConfig.value);
+ }
+ case timeType.cron: {
+ // const next = await cronUtil.getNextCronTimestamp(
+ // `${timeConfig.value}`,
+ // record.timestamp,
+ // now,
+ // cd.http_api
+ // );
+ // return (next && now >= next);
+ // const key = generatedKey(item);
+ const cron_ok = nextMap.get(item.path)
+ return !(cron_ok?.ok); // 不应该在CD中时返回true
+ }
+ default:
+ return false;
+ }
+ });
+ await debugKey(`[init-run]_log-in_cd_paths.json`, JSON.stringify(in_cd_paths))
+ // 移除 CD 未到的路径
+ if (in_cd_paths.length > 0) {
+ const cdPathSet = new Set(in_cd_paths.map(item => item.path));
+ matchedPaths = matchedPaths.filter(item => !cdPathSet.has(item.path));
+ }
+
+ }
+
+ // 4. 写入 needRunMap
+ if (matchedPaths.length > 0) {
+ //锄地队对应
+ try {
+ // {
+ // uid:"",
+ // parent_name:"",
+ // root_name: "",
+ // name:"",
+ // team_name:""
+ // } json支持
+ let teamHoeGroundList = JSON.parse(file.readTextSync(json_path_name.HoeGround)) ?? [{
+ uid: "",
+ is_common: false,
+ parent_name: undefined,
+ root_name: undefined,
+ name: undefined,
+ team_name: ""
+ }]
+ teamHoeGroundList = teamHoeGroundList.filter(item => item?.uid === Record.uid || item?.is_common)
+ teamHoeGroundList.sort((a, b) => {
+ const orderA = a?.is_common ? 1 : 0;
+ const orderB = b?.is_common ? 1 : 0;
+ return orderB - orderA; // 这样 is_common 为 true 的会排在前面
+ });
+ // 自定义锄地队对应可覆盖公共锄地队对应
+ teamHoeGroundList.forEach(item => {
+ if (item?.root_name?.trim() !== "") {
+ const key = generatedKey(item);
+ team.HoeGroundMap.set(key, item.team_name);
+
+ } else {
+ const key_parent = generatedKey(item, true);
+ team.HoeGroundMap.set(key_parent, item.team_name);
+ }
+
+ })
+ log.info(`{0}加载完成`, json_path_name.HoeGround)
+ } catch (e) {
+ log.error(`加载失败:{0}`, e.message)
+ }
+ //输入值优先覆盖
+ try {
+ const teamHoeGroundStr = settings.team_hoe_ground || "parentName->name=key"
+ teamHoeGroundStr.split(",").forEach(item => {
+ const [key, team_name] = item.split("=");
+ team.HoeGroundMap.set(key, team_name)
+ })
+ } catch (e) {
+ log.error(`加载失败:{0}`, e.message)
+ }
+
+ // 排序
+ const orderMap = new Map()
+ try {
+ // {
+ // uid:"",
+ // parent_name:"",
+ // root_name: "",
+ // name:"",
+ // order:0
+ // } json支持
+ let orderList = JSON.parse(file.readTextSync(json_path_name.PathOrder)) ?? [{
+ uid: "",
+ is_common: false,
+ parent_name: undefined,
+ root_name: undefined,
+ name: undefined,
+ order: 0
+ }]
+ orderList = orderList.filter(item => item?.uid === Record.uid || item?.is_common)
+ orderList.sort((a, b) => {
+ const orderA = a?.is_common ? 1 : 0;
+ const orderB = b?.is_common ? 1 : 0;
+ return orderB - orderA; // 这样 is_common 为 true 的会排在前面
+ });
+ // 自定义排序可覆盖公共排序
+ orderList.forEach(item => {
+ if (item.root_name) {
+ const key = generatedKey(item);
+ orderMap.set(key, item.order)
+ } else {
+ const key_parent = generatedKey(item, true);
+ orderMap.set(key_parent, item.order)
+ }
+ })
+ log.info(`{0}加载完成`, json_path_name.PathOrder)
+ } catch (e) {
+ log.error(`加载失败:{0}`, e.message)
+ }
+ await debugKey("[init-run]_log-orderMap-By-json.json", JSON.stringify([...orderMap]))
+ //输入值优先覆盖
+ try {
+ // 支持多条规则，例如: "rootName->parentName->name1=1,rootName->parentName->name2=2"
+ const orderStr = settings.order_rules || "rootName->parentName->name=1"
+ orderStr.split(",").forEach(item => {
+ const [key, order] = item.split("=");
+ orderMap.set(key, parseInt(order))
+ })
+ } catch (e) {
+ log.error(`加载失败:{0}`, e.message)
+ }
+ await debugKey("[init-run]_log-orderMap-All.json", JSON.stringify([...orderMap]))
+ //限制组最大执行数
+ const openLimitMax = settings.open_limit_max
+ let limitMaxByGroup = new Map()
+ if (openLimitMax) {
+ log.info(`{0}`, '已开启限制组最大执行数')
+ try {
+ let limitMaxList = JSON.parse(file.readTextSync(json_path_name.LimitMax)) ?? [{
+ uid: "",
+ is_common: false,
+ parent_name: undefined,
+ root_name: undefined,
+ name: undefined,
+ max: 0
+ }]
+ limitMaxList = limitMaxList.filter(item => item?.uid === Record.uid || item?.is_common)
+ limitMaxList.sort((a, b) => {
+ const orderA = a?.is_common ? 1 : 0;
+ const orderB = b?.is_common ? 1 : 0;
+ return orderB - orderA; // 这样 is_common 为 true 的会排在前面
+ });
+ // 自定义排序可覆盖公共排序
+ limitMaxList.forEach(item => {
+ if (item?.root_name?.trim() !== "") {
+ const key = generatedKey(item);
+ limitMaxByGroup.set(key, parseInt(item.max))
+ log.debug(`limitMaxList=>{0}->{1}`, key, item.max)
+ } else {
+ const key_parent = generatedKey(item, true);
+ limitMaxByGroup.set(key_parent, parseInt(item.max))
+ log.debug(`limitMaxList=>{0}->{1}`, key_parent, item.max)
+ }
+ })
+
+ //输入值优先覆盖
+ try {
+ // 支持多条规则，例如: "rootName->parentName->name1=1,rootName->parentName->name2=2"
+ const limitMaxStr = settings.limit_max_group || "rootName->parentName->name=1"
+ limitMaxStr.split(",").forEach(item => {
+ const [key, max] = item.split("=");
+ limitMaxByGroup.set(key, parseInt(max))
+ })
+ } catch (e) {
+ log.error(`加载失败:{0}`, e.message)
+ }
+ } catch (e) {
+ log.error(`加载失败:{0}`, e.message)
+
+ }
+ }
+
+
+ function groupByParentAndName(list) {
+ const map = new Map();
+
+ list.forEach(item => {
+ // const key = `${item.parentName}->${item.name}`;
+ const key = generatedKey(item);
+ // const key_parent = generatedKey(item, true);
+ if (!map.has(key)) map.set(key, []);
+ map.get(key).push(item);
+ // if (!map.has(key_parent)) map.set(key_parent, []);
+ // map.get(key_parent).push(item);
+ });
+
+ return Array.from(map.values()); // 转成二维数组 [[], []]
+ }
+
+ let groups = groupByParentAndName(matchedPaths);
+ groups.sort((a, b) => {
+ const a_key = generatedKey(a)
+ const b_key = generatedKey(b)
+ const orderA = orderMap.get(a_key) ?? 0; // 没在 JSON 中的排到最后
+ const orderB = orderMap.get(b_key) ?? 0;
+ if (orderA === orderB) {
+ return a_key?.localeCompare(b_key);
+ }
+ return orderB - orderA; // 修改为倒序数字比较
+ })
+ const asMap = new Map()
+ groups.forEach(group => {
+ const groupOne = group[0]
+ let groupKey_parent = generatedKey(groupOne, true);
+ if (orderMap.has(groupKey_parent) || team.HoeGroundMap.has(groupKey_parent)) {
+ let groupKey = generatedKey(groupOne);
+ asMap.set(groupKey, groupKey_parent)
+ }
+ })
+ groups.forEach(group => {
+ const groupOne = group[0]
+ let groupKey = generatedKey(groupOne);
+ let key = groupKey
+ if (asMap.has(key)) {
+ key = asMap.get(key)
+ }
+ let runGroup = group
+ //限制组最大执行数
+ if (openLimitMax && (limitMaxByGroup.has(key) || limitMaxByGroup.has(groupKey))) {
+ const limitMax = (limitMaxByGroup.get(key) || limitMaxByGroup.get(groupKey)) ?? 99999
+ const max = Math.min(group.length, limitMax)
+ runGroup = group.slice(0, max)
+ log.debug("[限制组最大执行数] groupKey={0},max={1},limitMax={2},group.length={3}", key, max, limitMax, group.length)
+ }
+ needRunMap.set(key, {
+ order: (orderMap.get(key) || orderMap.get(groupKey)) ?? 0,
+ paths: runGroup,
+ parent_name: groupOne.parentName,
+ key: key,
+ current_name: groupOne.name,
+ name: settingsName //多选项 名称 如 treeLevel_0_0
+ });
+ })
+ // todo 对 needRunMap 进行排序
+ // 对 needRunMap 进行整体排序
+ const sortedNeedRunMap = new Map(
+ [...needRunMap.entries()].sort((a, b) => {
+ // 使用值中的 order 字段进行排序
+ const orderA = a[1].order ?? 0;
+ const orderB = b[1].order ?? 0;
+
+ // 按降序排序（数值大的优先）
+ return orderB - orderA;
+ })
+ );
+
+ // 替换原来的 needRunMap
+ needRunMap.clear();
+ for (const [key, value] of sortedNeedRunMap) {
+ needRunMap.set(key, value);
+ }
+
+
+ await debugKey(
+ '[init-run]_log-needRunMap.json',
+ JSON.stringify([...needRunMap])
+ );
+ }
+ log.info("[执行前配置完成] needRunMap.size={0}", needRunMap.size);
+ }
+}
+
+async function init() {
+ let settingsConfig = await initSettings(`${config_root}\\`);
+ let utils = [
+ "cron",
+ "SwitchTeam",
+ "uid",
+ ]
+ for (let util of utils) {
+ eval(file.readTextSync(`utils/${util}.js`));
+ }
+ if (manifest.key !== settings.key) {
+ let message = "密钥不匹配";
+ if (settings.key) {
+ message += ",脚本可能存在升级 密钥已经改变 请查看文档功能后重新获取密钥"
+ }
+ throw new Error(message)
+ }
+ auto.semi = settings.mode === "半自动"
+ if (auto.semi) {
+ auto.run = settings.auto_semi_key_mode === "继续运行"
+ auto.skip = settings.auto_semi_key_mode === "跳过"
+ auto.key = settings.auto_key
+ if (!auto.key) {
+ throw new Error(settings.mode + "模式下必须开启快捷键设置")
+ }
+ }
+
+ dev.debug = (dev.debug) ? dev.debug : settings.debug
+ dev.isDebug = settings.is_debug
+
+ cd.open = (cd.open) ? cd.open : settings.cd_open
+ cd.http_api = (cd.http_api) ? cd.http_api : settings.http_api
+ await debugKey("[init]_log-cd-settings.json", JSON.stringify(cd))
+ config_list.black = settings.config_black_list ? settings.config_black_list.split(",") : []
+ config_list.white = settings.config_white_list ? settings.config_white_list.split(",") : []
+
+
+ if (!file.IsFolder(`${pathingName}`)) {
+ let batFile = "SymLink.bat";
+ log.error("{0}文件夹不存在，请在BetterGI中右键点击本脚本，选择{1}。然后双击脚本目录下的{2}文件以创建文件夹链接", `${pathingName}`, "打开所在目录", batFile);
+ return false;
+ }
+ try {
+ let parse = JSON.parse(file.readTextSync(json_path_name.SevenElement));
+ if (parse) {
+ parse?.sort((a, b) => a.level - b.level)
+ SevenElement.SevenElements = Array.from(new Set(SevenElement.SevenElements.concat(parse.map(item => item.name))))
+ parse.forEach(item => {
+ const name = item.name
+ let value = item.value
+ if (SevenElement.SevenElementsMap.has(name)) {
+ value = Array.from(new Set(SevenElement.SevenElementsMap.get(name).concat(value)))
+ }
+ SevenElement.SevenElementsMap.set(name, value)
+ })
+ }
+ } catch (e) {
+ log.warn("[SevenElement]初始化失败error:{0}", e.message)
+
+ }
+ //记录初始化
+ await initRecord();
+
+ // 读取现有配置并合并
+ let uidSettingsMap = new Map()
+ uidSettingsMap = await initUidSettingsMap(uidSettingsMap);
+
+//总控
+//刷新settings
+ const config_run = settings.config_run;
+ log.info("开始执行配置: {config_run}", config_run)
+ if (config_run === "刷新") {
+ await initRefresh(settingsConfig);
+ log.info("配置{0}完成", config_run)
+ } else if (config_run === "加载") {
+ //直接从配置文件中加载对应账号的配置
+ await loadUidSettingsMap(uidSettingsMap);
+ log.info("配置{0}完成", config_run)
+ } else
+ // 初始化needRunMap
+ if (config_run === "执行") {
+ await initRun(config_run);
+ await realTimeMissions()
+ }
+ return true
+}
+
+(async function () {
+ try {
+ if (await init()) {
+ await main()
+ }
+ } finally {
+ await saveRecordPaths();
+ await saveRecord();
+ }
+
+})()
+
+async function main() {
+ let lastRunMap = new Map()
+
+ function chooseBestRun() {
+ if (settings.choose_best && RecordLast.paths.size > 0) {
+ // 由于在迭代过程中删除元素会影响迭代，先收集要删除的键
+ const keysToDelete = [];
+ // 优先跑上次没跑过的路径
+ // 使用 Set 提高性能
+ const lastListSet = new Set([...RecordLast.paths]);
+
+ for (const [key, one] of needRunMap.entries()) {
+ // 检查当前任务的路径是否都不在上次执行的路径中
+ const allPathsInLast = one.paths.every(pathObj => lastListSet.has(pathObj.path));
+
+ if (!allPathsInLast) {
+ lastRunMap.set(key, one);
+ keysToDelete.push(key);
+ }
+ }
+
+
+ // 然后批量删除
+ for (const key of keysToDelete) {
+ needRunMap.delete(key);
+ }
+ //保持排序
+ // 对 lastRunMap 进行整体排序
+ const sortedNeedRunMap = new Map(
+ [...lastRunMap.entries()].sort((a, b) => {
+ // 使用值中的 order 字段进行排序
+ const orderA = a[1].order ?? 0;
+ const orderB = b[1].order ?? 0;
+
+ // 按降序排序（数值大的优先）
+ return orderB - orderA;
+ })
+ );
+
+ // 替换原来的 lastRunMap
+ lastRunMap.clear();
+ for (const [key, value] of sortedNeedRunMap) {
+ lastRunMap.set(key, value);
+ }
+ }
+ }
+
+ chooseBestRun();
+ await debugKey("[run]_log-lastRunMap.json", JSON.stringify([...lastRunMap]))
+ await debugKey("[run]_log-needRunMap.json", JSON.stringify([...needRunMap]))
+
+ if (needRunMap.size > 0) {
+ if (settings.choose_best) {
+ log.info(`[{0}] [{1}]`, settings.mode, "择优模式-启动")
+ }
+ await runMap(needRunMap)
+ }
+ if (lastRunMap.size > 0) {
+ log.info(`[{0}] [{1}]`, settings.mode, "择优模式-收尾")
+ await runMap(lastRunMap)
+ }
+
+ // if (needRunMap.size <= 0 && lastRunMap.size <= 0) {
+ // log.info(`设置目录{0}完成`, "刷新")
+ // }
+ // log.info(`[{mode}] path==>{path},请按下{key}以继续执行[${manifest.name} JS]`, settings.mode, "path", AUTO_STOP)
+ // await keyMousePressStart(AUTO_STOP);
+ // log.info(`[{mode}] path==>{path},请按下{key}以继续执行[${manifest.name} JS]`, settings.mode, "path", AUTO_STOP)
+}
+
+/**
+ * 保存记录路径的函数
+ * 该函数将RecordPath对象中的Set类型数据转换为数组后保存到文件
+ */
+async function saveRecordPaths() {
+ // 保存前将 Set 转换为数组，因为JSON不支持Set类型
+ // 创建一个新的记录对象，包含原始记录的所有属性
+ const recordToSave = {
+ // 使用展开运算符复制Record对象的所有属性，保持其他数据不变
+ ...RecordPath,
+ // 处理 paths 数组
+ paths: (() => {
+ // 1. 使用 Map 来辅助去重，Map 的 key 是 path，value 是完整的 item 对象
+ const pathMap = new Map();
+
+ // 假设 RecordPath.paths 是一个 Set，先转为数组进行遍历
+ [...RecordPath.paths].forEach(item => {
+ // 获取当前项的路径字符串
+ const currentPath = item.path;
+
+ // 检查 Map 中是否已经存在该路径
+ if (pathMap.has(currentPath)) {
+ // 如果存在，比较时间戳
+ const existingItem = pathMap.get(currentPath);
+ // 如果当前项的时间戳比已存在的大，则更新 Map 中的值
+ if (item.timestamp > existingItem.timestamp) {
+ pathMap.set(currentPath, item);
+ }
+ } else {
+ // 如果不存在，直接存入 Map
+ pathMap.set(currentPath, item);
+ }
+ });
+
+ // 2. 将 Map 中的值（去重后的对象数组）转换回我们需要的格式
+ return Array.from(pathMap.values()).map(item => ({
+ timestamp: item.timestamp,
+ path: item.path
+ }));
+ })()
+ };
+
+ // 确保 RecordPathList 是数组
+ if (!Array.isArray(RecordPathList)) {
+ RecordPathList = Array.from(RecordPathList);
+ }
+ let temp = RecordPathList.find(item => item.uid === Record.uid)
+ if (temp) {
+ // RecordList.splice(RecordList.indexOf(temp),1)
+ temp.paths = [...recordToSave.paths, ...temp.paths]
+ // temp.errorPaths = [...recordToSave.errorPaths, ...temp.errorPaths]
+ // temp.groupPaths = [...recordToSave.groupPaths, ...temp.groupPaths]
+ } else {
+ // 将记录对象添加到记录列表中
+ RecordPathList.push(recordToSave)
+ }
+ // 将记录列表转换为JSON字符串并同步写入文件
+ file.writeTextSync(json_path_name.RecordPathText, JSON.stringify(RecordPathList))
+ log.info("saveRecordPath保存记录文件成功")
+}
+
+/**
+ * 保存当前记录到记录列表并同步到文件
+ * 该函数在保存前会将Set类型的数据转换为数组格式，确保JSON序列化正常进行
+ */
+async function saveRecord() {
+ // 保存前将 Set 转换为数组
+ // 创建一个新的记录对象，包含原始记录的所有属性
+ const recordToSave = {
+ // 使用展开运算符复制Record对象的所有属性
+ ...Record,
+ // 将paths Set转换为数组
+ paths: [...Record.paths],
+ // 将errorPaths Set转换为数组
+ errorPaths: [...Record.errorPaths],
+ // 将groupPaths Set转换为数组，并对每个元素进行特殊处理
+ groupPaths: [...Record.groupPaths].map(item => ({
+ // 保留name属性
+ name: item.name,
+ // 将item中的paths Set转换为数组
+ paths: [...item.paths]
+ }))
+ };
+
+ // 将记录对象添加到记录列表中
+ RecordList.push(recordToSave)
+ // 将记录列表转换为JSON字符串并同步写入文件
+ file.writeTextSync(json_path_name.RecordText, JSON.stringify(RecordList))
+ log.info("saveRecord保存记录文件成功")
+}
+
+/**
+ * 计算两个时间之间的差值，并返回指定格式的JSON
+ * @param {number|Date} startTime - 开始时间（时间戳或Date对象）
+ * @param {number|Date} endTime - 结束时间（时间戳或Date对象）
+ * @returns {Object} diff_json - 包含info和total的对象
+ */
+function getTimeDifference(startTime, endTime) {
+ // 确保输入是时间戳
+ const start = typeof startTime === 'object' ? startTime.getTime() : startTime;
+ const end = typeof endTime === 'object' ? endTime.getTime() : endTime;
+
+ // 计算总差值（毫秒）
+ const diffMs = Math.abs(end - start);
+
+ // 计算总时间（小数）
+ const totalSeconds = diffMs / 1000;
+ const totalMinutes = totalSeconds / 60;
+ const totalHours = totalSeconds / 3600;
+
+ // 计算info部分（整数）
+ const infoHours = Math.floor(totalHours % 24);
+ const remainingAfterHours = (totalHours % 24) - infoHours;
+ const infoMinutes = Math.floor(remainingAfterHours * 60);
+ const remainingAfterMinutes = (remainingAfterHours * 60) - infoMinutes;
+ const infoSeconds = Math.floor(remainingAfterMinutes * 60);
+// 输出类似：
+// {
+// info: { hours: 1, minutes: 0, seconds: 0 },
+// total: { hours: 1, minutes: 60, seconds: 3600 }
+// }
+ const diff_json = {
+ info: {
+ hours: infoHours,
+ minutes: infoMinutes,
+ seconds: infoSeconds
+ },
+ total: {
+ hours: parseFloat(totalHours.toFixed(6)),
+ minutes: parseFloat(totalMinutes.toFixed(6)),
+ seconds: parseFloat(totalSeconds.toFixed(6))
+ }
+ };
+
+ return diff_json;
+}
+
+
+/**
+ * 初始化记录函数
+ * 该函数用于初始化一条新的记录，包括设置UID、时间戳和调整后的日期数据
+ * 同时会检查记录列表中是否存在相同UID的最新记录，并进行更新
+ */
+async function initRecord() {
+ // 设置记录的唯一标识符，通过OCR技术获取
+ Record.uid = await uidUtil.ocrUID()
+ // 设置记录的时间戳为当前时间
+ Record.timestamp = Date.now()
+ // 获取并设置调整后的日期数据
+ Record.data = getAdjustedDate()
+
+ try {
+ // 尝试读取记录文件
+ // 读取后将数组转换回 Set，处理特殊的数据结构
+ RecordList = JSON.parse(file.readTextSync(json_path_name.RecordText), (key, value) => {
+ // 处理普通路径集合
+ if (key === 'paths' || key === 'errorPaths') {
+ return new Set(value);
+ }
+ // 处理分组路径集合，保持嵌套的Set结构
+ if (key === 'groupPaths') {
+ return new Set(value.map(item => ({
+ name: item.name,
+ paths: new Set(item.paths)
+ })));
+ }
+ return value;
+ }) ?? RecordList;
+ } catch (e) {
+ // 如果读取文件出错，则忽略错误（可能是文件不存在或格式错误）
+ }
+ try {
+ // 尝试读取记录文件
+ // 读取后将数组转换回 Set，处理特殊的数据结构
+ RecordPathList = JSON.parse(file.readTextSync(json_path_name.RecordPathText), (key, value) => {
+ // 处理分组路径集合，保持嵌套的Set结构
+ if (key === 'paths') {
+ return new Set(value.map(item => ({
+ timestamp: item.timestamp,
+ path: item.path
+ })));
+ }
+ return value;
+ }) ?? RecordPathList
+ RecordPath = RecordPathList.find(item => item.uid === Record.uid) ?? RecordPath
+ } catch (e) {
+ // 如果读取文件出错，则忽略错误（可能是文件不存在或格式错误）
+ }
+ RecordPath.uid ||= Record.uid
+ RecordPath.paths ||= new Set()
+ // 如果记录列表不为空，则查找最新记录
+ if (RecordList.length > 0) {
+ // 最优解：一次遍历找到最新的记录
+ let latestRecord = undefined;
+ // 遍历记录列表，查找相同UID且时间戳最大的记录
+ for (const item of RecordList) {
+ // 检查当前记录项的UID是否匹配，并且是最新记录
+ if (item.uid === Record.uid &&
+ // 如果还没有找到记录，或者当前记录的时间戳比已找到的记录更新
+ (!latestRecord || item.timestamp > latestRecord.timestamp)) {
+ // 更新最新记录为当前项
+ latestRecord = item;
+ }
+ }
+ // 如果找到最新记录，则更新RecordLast；否则保持原有RecordLast的值
+ RecordLast = latestRecord ? latestRecord : RecordLast;
+ }
+ if (RecordLast.uid === Record.uid && Record.data === RecordLast.data) {
+ // 判断是否为同一天 合并跑过的数据
+ // 确保 RecordLast 的 Set 属性存在
+ if (!RecordLast.paths || !(RecordLast.paths instanceof Set)) {
+ RecordLast.paths = new Set();
+ }
+ if (!RecordLast.groupPaths || !(RecordLast.groupPaths instanceof Set)) {
+ RecordLast.groupPaths = new Set();
+ }
+
+ // 判断是否为同一天 合并跑过的数据
+ Record.paths = new Set([...Record.paths, ...RecordLast.paths])
+ Record.groupPaths = new Set([...Record.groupPaths, ...RecordLast.groupPaths])
+ // 删除RecordLast
+ const index = RecordList.indexOf(RecordLast);
+ if (index > -1) {
+ RecordList.splice(index, 1);
+ }
+ }
+}
+
+function getAdjustedDate() {
+ const now = new Date();
+ // 减去4小时（4 * 60 * 60 * 1000 毫秒）
+ now.setHours(now.getHours() - 4);
+
+ const year = now.getFullYear();
+ const month = String(now.getMonth() + 1).padStart(2, '0');
+ const day = String(now.getDate()).padStart(2, '0');
+
+ return `${year}-${month}-${day}`;
+}
+
+// 解析日期字符串
+function parseDate(dateString) {
+ const [year, month, day] = dateString.split('-').map(Number);
+ return new Date(year, month - 1, day); // month - 1 因为月份从0开始
+}
+
+// Record.groupPaths.add({
+// name: "",
+// paths:new Set()
+// })
+// const pathingALLSize = []
+// 使用函数来添加唯一元素
+// 优化后的函数
+function addUniquePath(obj, list = PATHING_ALL) {
+ const existingIndex = list.findIndex(item =>
+ item.level === obj.level && item.name === obj.name && item.parentName === obj.parentName && item.rootName === obj.rootName
+ );
+
+ if (existingIndex === -1) {
+ list.push(obj);
+ } else {
+ // 合并 child_names 数组，避免重复元素
+ const existingItem = list[existingIndex];
+ if (obj.child_names) {
+ const newChildren = obj.child_names || [];
+
+ // 使用 Set 去重并合并数组
+ const combinedChildren = [...new Set([
+ ...(existingItem.child_names || []),
+ ...newChildren
+ ])];
+
+ existingItem.child_names = combinedChildren;
+ } else {
+ const newChildren = obj.children || [];
+
+ // 使用 Set 去重并合并数组
+ const combinedChildren = [...new Set([
+ ...(existingItem.children || []),
+ ...newChildren
+ ])];
+
+ existingItem.children = combinedChildren;
+ }
+
+ }
+}
+
+/**
+ * 初始化设置函数
+ * 从配置文件中读取设置信息并返回
+ * @returns {Object} 返回解析后的JSON设置对象
+ */
+async function initSettings(prefix = undefined) {
+ // 默认设置文件路径
+ let settings_ui = "settings.json";
+ if (!configSettings) {
+ try {
+ // 读取并解析manifest.json文件
+ manifest = manifest ? manifest : JSON.parse(file.readTextSync(manifest_json));
+ // 调试日志：输出manifest内容
+ // log.debug("manifest={key}", manifest);
+ // 调试日志：输出manifest中的settings_ui配置
+ log.debug("settings_ui={key}", manifest.settings_ui);
+ log.info(`|脚本名称:{name},版本:{version}`, manifest.name, manifest.version);
+ if (manifest.bgi_version) {
+ log.info(`|最小可执行BGI版本:{bgi_version}`, manifest.bgi_version);
+ }
+ log.info(`|脚本作者:{authors}\n`, manifest.authors.map(a => a.name).join(","));
+ // 更新settings_ui变量为manifest中指定的路径
+ settings_ui = manifest.settings_ui
+ settings_ui = prefix ? prefix + settings_ui : settings_ui
+ } catch (error) {
+ // 捕获并记录可能的错误
+ log.warn("{error}", error.message);
+ }
+ }
+ // 读取并解析设置文件
+ const settingsJson = JSON.parse(file.readTextSync(settings_ui));
+ // 如果configSettings未定义，则将其设置为解析后的设置对象
+ if (!configSettings) {
+ configSettings = settingsJson
+ }
+ // 调试日志：输出最终解析的设置对象
+ log.debug("settingsJson={key}", settingsJson);
+ // 返回设置对象
+ return settingsJson
+}
+
+/**
+ * 获取多复选框的映射表
+ * 该函数会从初始化的设置中提取所有类型为"multi-checkbox"的条目，
+ * 并将这些条目的名称和对应的选项值存储在一个Map对象中返回
+ * @returns {Promise