@nekosu/maa-checker 1.0.2 → 1.0.4

package/dist/main.js

@@ -2743,18 +2743,19 @@ var BundleManager = class {
         await this.delegate.loadFile(relativePath(this.root, file), file);
       }
     }
-    const resolves = this.flushResolve;
-    this.flushResolve = [];
     this.duringFlush = false;
-    process.nextTick(() => {
-      for (const func of resolves) {
-        func();
-      }
-    });
     if (this.needFlush) {
       setTimeout(() => {
         this.flush();
       }, 100);
+    } else {
+      const resolves = this.flushResolve;
+      this.flushResolve = [];
+      process.nextTick(() => {
+        for (const func of resolves) {
+          func();
+        }
+      });
     }
   }
   dispatchFlush(timeout = 100) {
@@ -4706,6 +4707,82 @@ function extractTaskRef(r) {
 // pkgs/pipeline-manager/src/diagnostic/diagnostic.ts
 function checkInterface(bundle) {
   const result = [];
+  const layer = bundle.topLayer;
+  if (layer.type === "interface") {
+    const realTasks = new Set(layer.parent?.getTaskListNotUnique() ?? []);
+    for (const ref of layer.mergedRefs) {
+      if (ref.type === "task.entry") {
+        if (!realTasks.has(ref.target)) {
+          result.push({
+            level: "error",
+            file: ref.file,
+            offset: ref.location.offset,
+            length: ref.location.length,
+            type: "int-unknown-entry-task",
+            task: ref.target
+          });
+        }
+      }
+    }
+    for (const decl of layer.mergedDecls) {
+      if (decl.type === "task.decl") {
+        if (!realTasks.has(decl.task)) {
+          result.push({
+            level: "error",
+            file: decl.file,
+            offset: decl.location.offset,
+            length: decl.location.length,
+            type: "int-override-unknown-task",
+            task: decl.task
+          });
+        }
+      }
+    }
+  }
+  const ctrlDecls = bundle.info.decls.filter((decl) => decl.type === "interface.controller");
+  const ctrls = /* @__PURE__ */ new Map();
+  for (const decl of ctrlDecls) {
+    if (ctrls.has(decl.name)) {
+      const prev = ctrls.get(decl.name);
+      result.push({
+        level: "error",
+        file: decl.file,
+        offset: decl.location.offset,
+        length: decl.location.length,
+        type: "int-conflict-controller",
+        ctrl: decl.name,
+        previous: {
+          file: prev.file,
+          offset: prev.location.offset,
+          length: prev.location.length
+        }
+      });
+    } else {
+      ctrls.set(decl.name, decl);
+    }
+  }
+  const resDecls = bundle.info.decls.filter((decl) => decl.type === "interface.resource");
+  const ress = /* @__PURE__ */ new Map();
+  for (const decl of resDecls) {
+    if (ress.has(decl.name)) {
+      const prev = ress.get(decl.name);
+      result.push({
+        level: "error",
+        file: decl.file,
+        offset: decl.location.offset,
+        length: decl.location.length,
+        type: "int-conflict-resource",
+        res: decl.name,
+        previous: {
+          file: prev.file,
+          offset: prev.location.offset,
+          length: prev.location.length
+        }
+      });
+    } else {
+      ress.set(decl.name, decl);
+    }
+  }
   const optDecls = bundle.info.decls.filter((decl) => decl.type === "interface.option");
   const options = /* @__PURE__ */ new Map();
   for (const decl of optDecls) {
@@ -4726,18 +4803,132 @@ function checkInterface(bundle) {
       });
     } else {
       options.set(decl.name, decl);
+      if (!decl.optionType || decl.optionType === "select" || decl.optionType === "switch") {
+        const caseDecls = bundle.info.decls.filter(
+          (decl2) => decl2.type === "interface.case" && decl2.option === decl.name
+        );
+        const cases = /* @__PURE__ */ new Map();
+        for (const decl2 of caseDecls) {
+          if (cases.has(decl2.name)) {
+            const prev = cases.get(decl2.name);
+            result.push({
+              level: "error",
+              file: decl2.file,
+              offset: decl2.location.offset,
+              length: decl2.location.length,
+              type: "int-conflict-case",
+              option: decl.name,
+              case: decl2.name,
+              previous: {
+                file: prev.file,
+                offset: prev.location.offset,
+                length: prev.location.length
+              }
+            });
+          } else {
+            cases.set(decl2.name, decl2);
+          }
+        }
+        const caseRefs = bundle.info.refs.filter((ref) => ref.type === "interface.case").filter((ref) => ref.option === decl.name);
+        for (const ref of caseRefs) {
+          if (!cases.has(ref.target)) {
+            result.push({
+              level: "error",
+              file: ref.file,
+              offset: ref.location.offset,
+              length: ref.location.length,
+              type: "int-unknown-case",
+              option: decl.name,
+              case: ref.target
+            });
+          }
+        }
+        if (decl.optionType === "switch") {
+          let missingYes = true;
+          let missingNo = true;
+          for (const [name, decl2] of cases) {
+            if (name === "Yes") {
+              missingYes = false;
+            } else if (name === "No") {
+              missingNo = false;
+            } else if (name.toLowerCase() === "yes") {
+              missingYes = false;
+              result.push({
+                level: "warning",
+                file: decl2.file,
+                offset: decl2.location.offset,
+                length: decl2.location.length,
+                type: "int-switch-should-fixed"
+              });
+            } else if (name.toLowerCase() === "no") {
+              missingNo = false;
+              result.push({
+                level: "warning",
+                file: decl2.file,
+                offset: decl2.location.offset,
+                length: decl2.location.length,
+                type: "int-switch-should-fixed"
+              });
+            } else {
+              result.push({
+                level: "error",
+                file: decl2.file,
+                offset: decl2.location.offset,
+                length: decl2.location.length,
+                type: "int-switch-name-invalid"
+              });
+            }
+          }
+          if (missingYes || missingNo) {
+            result.push({
+              level: "error",
+              file: decl.file,
+              offset: decl.location.offset,
+              length: decl.location.length,
+              type: "int-switch-missing",
+              option: decl.name,
+              missingYes,
+              missingNo
+            });
+          }
+        }
+      }
     }
   }
-  for (const ref of bundle.info.refs.filter((ref2) => ref2.type === "interface.option")) {
-    if (!options.has(ref.target)) {
-      result.push({
-        level: "error",
-        file: ref.file,
-        offset: ref.location.offset,
-        length: ref.location.length,
-        type: "int-unknown-option",
-        option: ref.target
-      });
+  for (const ref of bundle.info.refs) {
+    if (ref.type === "interface.controller") {
+      if (!ctrls.has(ref.target)) {
+        result.push({
+          level: "error",
+          file: ref.file,
+          offset: ref.location.offset,
+          length: ref.location.length,
+          type: "int-unknown-controller",
+          ctrl: ref.target
+        });
+      }
+    } else if (ref.type === "interface.resource") {
+      if (!ctrls.has(ref.target)) {
+        result.push({
+          level: "error",
+          file: ref.file,
+          offset: ref.location.offset,
+          length: ref.location.length,
+          type: "int-unknown-resource",
+          res: ref.target
+        });
+      }
+    } else if (ref.type === "interface.option") {
+      if (!options.has(ref.target)) {
+        result.push({
+          level: "error",
+          file: ref.file,
+          offset: ref.location.offset,
+          length: ref.location.length,
+          type: "int-unknown-option",
+          option: ref.target
+        });
+      }
     }
   }
   return result;
@@ -4899,37 +5090,6 @@ function performDiagnostic(bundle) {
         }
       }
     }
-    if (layer.type === "interface") {
-      const realTasks = new Set(layer.parent?.getTaskListNotUnique() ?? []);
-      for (const ref of refs) {
-        if (ref.type === "task.entry") {
-          if (!realTasks.has(ref.target)) {
-            result.push({
-              level: "error",
-              file: ref.file,
-              offset: ref.location.offset,
-              length: ref.location.length,
-              type: "int-unknown-entry-task",
-              task: ref.target
-            });
-          }
-        }
-      }
-      for (const decl of layer.mergedDecls) {
-        if (decl.type === "task.decl") {
-          if (!realTasks.has(decl.task)) {
-            result.push({
-              level: "error",
-              file: decl.file,
-              offset: decl.location.offset,
-              length: decl.location.length,
-              type: "int-override-unknown-task",
-              task: decl.task
-            });
-          }
-        }
-      }
-    }
   }
   result.push(...checkInterface(bundle));
   return result;
@@ -5134,10 +5294,18 @@ function parseInputRef(node, info, option, names, ctx) {
   }
 }
 function parseOptionSec(node, info, option, ctx) {
+  let type = void 0;
   let inputNames = [];
   let overrideNode = null;
   for (const [key, obj] of parseObject(node)) {
     switch (key) {
+      case "type":
+        if (isString(obj)) {
+          if (["select", "switch", "input"].includes(obj.value)) {
+            type = obj.value;
+          }
+        }
+        break;
       case "cases":
         parseCases(obj, info, option, ctx);
         break;
@@ -5168,16 +5336,18 @@ function parseOptionSec(node, info, option, ctx) {
     parseInputRef(overrideNode, info, option, names, ctx);
     parseOverride(overrideNode, info, ctx);
   }
+  return type;
 }
 function parseOption(node, info, ctx) {
   for (const [key, obj, prop] of parseObject(node)) {
+    const type = parseOptionSec(obj, info, key, ctx);
     info.decls.push({
       file: ctx.file,
       location: prop,
       type: "interface.option",
-      name: key
+      name: key,
+      optionType: type
     });
-    parseOptionSec(obj, info, key, ctx);
   }
 }
 
@@ -5664,7 +5834,7 @@ var InterfaceBundle = class extends import_node_events3.default {
 // pkgs/maa-checker/package.json
 var package_default = {
   name: "@nekosu/maa-checker",
-  version: "1.0.2",
+  version: "1.0.4",
   bin: {
     "maa-checker": "bin/maa-checker"
   },
@@ -5780,6 +5950,24 @@ async function main() {
         case "unknown-attr":
           brief = `Unknown attribute \`${diag.attr}\``;
           break;
+        case "int-conflict-controller": {
+          const prelative2 = path5.relative(bundle.root, diag.previous.file);
+          const [pline, pcol] = await locate(diag.previous.file, diag.previous.offset);
+          brief = `Conflict controller \`${diag.ctrl}\`, previous defined in ${prelative2}:${pline}:${pcol}`;
+          break;
+        }
+        case "int-unknown-controller":
+          brief = `Unknown controlle \`${diag.ctrl}\``;
+          break;
+        case "int-conflict-resource": {
+          const prelative2 = path5.relative(bundle.root, diag.previous.file);
+          const [pline, pcol] = await locate(diag.previous.file, diag.previous.offset);
+          brief = `Conflict resource \`${diag.res}\`, previous defined in ${prelative2}:${pline}:${pcol}`;
+          break;
+        }
+        case "int-unknown-resource":
+          brief = `Unknown resource \`${diag.res}\``;
+          break;
         case "int-conflict-option": {
           const prelative2 = path5.relative(bundle.root, diag.previous.file);
           const [pline, pcol] = await locate(diag.previous.file, diag.previous.offset);
@@ -5789,6 +5977,30 @@ async function main() {
         case "int-unknown-option":
           brief = `Unknown option \`${diag.option}\``;
           break;
+        case "int-conflict-case": {
+          const prelative2 = path5.relative(bundle.root, diag.previous.file);
+          const [pline, pcol] = await locate(diag.previous.file, diag.previous.offset);
+          brief = `Conflict case \`${diag.case}\` for option \`${diag.option}\`, previous defined in ${prelative2}:${pline}:${pcol}`;
+          break;
+        }
+        case "int-unknown-case":
+          brief = `Unknown case \`${diag.case}\` for option \`${diag.option}\``;
+          break;
+        case "int-switch-name-invalid":
+          brief = `Switch name invalid`;
+          break;
+        case "int-switch-missing":
+          if (diag.missingYes && diag.missingNo) {
+            brief = `Switch option missing \`Yes\` and \`No\``;
+          } else if (diag.missingYes) {
+            brief = `Switch option missing \`Yes\``;
+          } else {
+            brief = `Switch option missing \`No\``;
+          }
+          break;
+        case "int-switch-should-fixed":
+          brief = `Switch name should use \`Yes\` or \`No\``;
+          break;
         case "int-unknown-entry-task":
           brief = `Unknown entry task \`${diag.task}\``;
           break;