koishi-plugin-noah 2.3.6 → 2.3.7

package/lib/games/sdvx/utils/param-parser.d.ts

@@ -8,6 +8,11 @@ export interface QueryParams {
     grade?: SDVXGrade | SDVXGrade[];
     clearType?: SDVXClearType | SDVXClearType[];
     vf?: number | number[];
+    excludeLevel?: number[];
+    excludeScore?: number[];
+    excludeGrade?: SDVXGrade[];
+    excludeClearType?: SDVXClearType[];
+    excludeVf?: number[];
 }
 /**
  * 解析带后缀的数字
@@ -49,7 +54,4 @@ export declare function parseSingleGrade(item: string): SDVXGrade[] | null;
  * 解析雷达特征
  */
 export declare function parseRadarFeature(item: string): string | null;
-/**
- * 解析用户输入参数
- */
 export declare function parseQueryInput(input: string): QueryParams;

package/lib/index.cjs

@@ -2668,12 +2668,12 @@ function getNextVFIncrease(level, currentScore, clearType) {
 }
 __name(getNextVFIncrease, "getNextVFIncrease");
 function getGradeRange(grade) {
-  if (!grade) return ALL_GRADES;
+  if (!grade) return ALL_GRADES.slice(0, ALL_GRADES.indexOf("A") + 1);
   return Array.isArray(grade) ? grade : [grade];
 }
 __name(getGradeRange, "getGradeRange");
 function getClearTypeRange(clearType) {
-  if (!clearType) return ALL_CLEAR_TYPES;
+  if (!clearType) return ALL_CLEAR_TYPES.slice(0, ALL_CLEAR_TYPES.indexOf("NC") + 1);
   return Array.isArray(clearType) ? clearType : [clearType];
 }
 __name(getClearTypeRange, "getClearTypeRange");
@@ -2889,7 +2889,20 @@ function generateQueryResults(params) {
       uniqueResults.push(result);
     }
   }
-  const filteredResults = uniqueResults.filter((result) => result.clearType !== "S-PUC");
+  const excludeLevelSet = params.excludeLevel ? new Set(params.excludeLevel.map((l) => Math.round(l * 10))) : null;
+  const excludeScoreSet = params.excludeScore ? new Set(params.excludeScore) : null;
+  const excludeGradeSet = params.excludeGrade ? new Set(params.excludeGrade) : null;
+  const excludeClearTypeSet = params.excludeClearType ? new Set(params.excludeClearType) : null;
+  const excludeVfSet = params.excludeVf ? new Set(params.excludeVf.map((v) => Math.round(v * 20))) : null;
+  const afterExclusion = uniqueResults.filter((result) => {
+    if (excludeLevelSet && excludeLevelSet.has(Math.round(result.level * 10))) return false;
+    if (excludeScoreSet && excludeScoreSet.has(result.score)) return false;
+    if (excludeGradeSet && excludeGradeSet.has(result.grade)) return false;
+    if (excludeClearTypeSet && excludeClearTypeSet.has(result.clearType)) return false;
+    if (excludeVfSet && excludeVfSet.has(Math.round(result.vf * 20))) return false;
+    return true;
+  });
+  const filteredResults = afterExclusion.filter((result) => result.clearType !== "S-PUC");
   return filteredResults.sort((a, b) => b.vf - a.vf);
 }
 __name(generateQueryResults, "generateQueryResults");
@@ -5388,6 +5401,249 @@ function parseRadarFeature(item) {
   return null;
 }
 __name(parseRadarFeature, "parseRadarFeature");
+function extractOperator(item) {
+  if (item.startsWith(">=")) return { op: ">=", value: item.slice(2) };
+  if (item.startsWith("<=")) return { op: "<=", value: item.slice(2) };
+  if (item.startsWith("!=")) return { op: "!=", value: item.slice(2) };
+  if (item.startsWith(">")) return { op: ">", value: item.slice(1) };
+  if (item.startsWith("<")) return { op: "<", value: item.slice(1) };
+  if (item.startsWith("=")) return { op: "=", value: item.slice(1) };
+  if (item.startsWith("~")) return { op: "~", value: item.slice(1) };
+  return { op: null, value: item };
+}
+__name(extractOperator, "extractOperator");
+function getAllValidLevels2() {
+  const levels = [];
+  for (let i = 1; i <= 16; i++) levels.push(i);
+  levels.push(17, 17.5);
+  for (let scaled = 180; scaled <= 209; scaled++) levels.push(scaled / 10);
+  return levels;
+}
+__name(getAllValidLevels2, "getAllValidLevels");
+function applyLevelOperator(op, levels) {
+  const allLevels = getAllValidLevels2();
+  const value = levels[0];
+  if (op === "=") return { include: levels, exclude: [] };
+  if (op === "!=") return { include: [], exclude: levels };
+  if (op === "~") {
+    const result = /* @__PURE__ */ new Set();
+    for (const lv of levels) {
+      const idx2 = allLevels.indexOf(lv);
+      if (idx2 === -1) continue;
+      if (idx2 > 0) result.add(allLevels[idx2 - 1]);
+      result.add(allLevels[idx2]);
+      if (idx2 < allLevels.length - 1) result.add(allLevels[idx2 + 1]);
+    }
+    return { include: [...result], exclude: [] };
+  }
+  const idx = allLevels.indexOf(value);
+  if (idx === -1) return { include: levels, exclude: [] };
+  switch (op) {
+    case ">":
+      return { include: allLevels.slice(idx + 1), exclude: [] };
+    case ">=":
+      return { include: allLevels.slice(idx), exclude: [] };
+    case "<":
+      return { include: allLevels.slice(0, idx), exclude: [] };
+    case "<=":
+      return { include: allLevels.slice(0, idx + 1), exclude: [] };
+  }
+}
+__name(applyLevelOperator, "applyLevelOperator");
+function applyScoreOperator(op, scores) {
+  const value = scores[0];
+  if (op === "=") return { include: [value], exclude: [] };
+  if (op === "!=") return { include: [], exclude: [value] };
+  if (op === "~") {
+    return { include: [value - 5e4, value + 5e4], exclude: [] };
+  }
+  switch (op) {
+    case ">":
+      return { include: [value + 1, 1e7], exclude: [] };
+    case ">=":
+      return { include: [value, 1e7], exclude: [] };
+    case "<":
+      return { include: [0, value - 1], exclude: [] };
+    case "<=":
+      return { include: [0, value], exclude: [] };
+  }
+}
+__name(applyScoreOperator, "applyScoreOperator");
+function applyVfOperator(op, vfValue) {
+  if (op === "=") return { include: vfValue, exclude: [] };
+  if (op === "!=") return { include: [], exclude: [vfValue] };
+  if (op === "~") {
+    return { include: [vfValue - 0.25, vfValue + 0.25], exclude: [] };
+  }
+  switch (op) {
+    case ">":
+      return { include: [vfValue + 0.05, 99], exclude: [] };
+    case ">=":
+      return { include: [vfValue, 99], exclude: [] };
+    case "<":
+      return { include: [0, vfValue - 0.05], exclude: [] };
+    case "<=":
+      return { include: [0, vfValue], exclude: [] };
+  }
+}
+__name(applyVfOperator, "applyVfOperator");
+function applyGradeOperator(op, grade) {
+  const idx = ALL_GRADES.indexOf(grade);
+  if (idx === -1) return { include: [grade], exclude: [] };
+  if (op === "=") return { include: [grade], exclude: [] };
+  if (op === "!=") return { include: [], exclude: [grade] };
+  if (op === "~") {
+    const result = [];
+    if (idx > 0) result.push(ALL_GRADES[idx - 1]);
+    result.push(ALL_GRADES[idx]);
+    if (idx < ALL_GRADES.length - 1) result.push(ALL_GRADES[idx + 1]);
+    return { include: result, exclude: [] };
+  }
+  switch (op) {
+    case ">":
+      return { include: ALL_GRADES.slice(0, idx), exclude: [] };
+    case ">=":
+      return { include: ALL_GRADES.slice(0, idx + 1), exclude: [] };
+    case "<":
+      return { include: ALL_GRADES.slice(idx + 1), exclude: [] };
+    case "<=":
+      return { include: ALL_GRADES.slice(idx), exclude: [] };
+  }
+}
+__name(applyGradeOperator, "applyGradeOperator");
+function applyClearTypeOperator(op, clearType) {
+  const idx = ALL_CLEAR_TYPES.indexOf(clearType);
+  if (idx === -1) return { include: [clearType], exclude: [] };
+  if (op === "=") return { include: [clearType], exclude: [] };
+  if (op === "!=") return { include: [], exclude: [clearType] };
+  if (op === "~") {
+    const result = [];
+    if (idx > 0) result.push(ALL_CLEAR_TYPES[idx - 1]);
+    result.push(ALL_CLEAR_TYPES[idx]);
+    if (idx < ALL_CLEAR_TYPES.length - 1) result.push(ALL_CLEAR_TYPES[idx + 1]);
+    return { include: result, exclude: [] };
+  }
+  switch (op) {
+    case ">":
+      return { include: ALL_CLEAR_TYPES.slice(0, idx), exclude: [] };
+    case ">=":
+      return { include: ALL_CLEAR_TYPES.slice(0, idx + 1), exclude: [] };
+    case "<":
+      return { include: ALL_CLEAR_TYPES.slice(idx + 1), exclude: [] };
+    case "<=":
+      return { include: ALL_CLEAR_TYPES.slice(idx), exclude: [] };
+  }
+}
+__name(applyClearTypeOperator, "applyClearTypeOperator");
+function mergeLevels(params, levels) {
+  if (params.level !== void 0) {
+    const existing = Array.isArray(params.level) ? params.level : [params.level];
+    params.level = [.../* @__PURE__ */ new Set([...existing, ...levels])];
+  } else {
+    params.level = levels.length === 1 ? levels[0] : levels;
+  }
+}
+__name(mergeLevels, "mergeLevels");
+function mergeScores(params, scores) {
+  if (params.score !== void 0) {
+    const existing = Array.isArray(params.score) ? params.score : [params.score];
+    params.score = [.../* @__PURE__ */ new Set([...existing, ...scores])];
+  } else {
+    params.score = scores.length === 1 ? scores[0] : scores;
+  }
+}
+__name(mergeScores, "mergeScores");
+function mergeVf(params, vf2) {
+  if (params.vf !== void 0) {
+    const existing = Array.isArray(params.vf) ? params.vf : [params.vf];
+    const newVf = Array.isArray(vf2) ? vf2 : [vf2];
+    params.vf = [...existing, ...newVf];
+  } else {
+    params.vf = vf2;
+  }
+}
+__name(mergeVf, "mergeVf");
+function mergeGrades(params, grades) {
+  if (params.grade) {
+    const existing = Array.isArray(params.grade) ? params.grade : [params.grade];
+    params.grade = [.../* @__PURE__ */ new Set([...existing, ...grades])];
+  } else {
+    params.grade = grades.length === 1 ? grades[0] : grades;
+  }
+}
+__name(mergeGrades, "mergeGrades");
+function mergeClearTypes(params, clearTypes) {
+  if (params.clearType) {
+    const existing = Array.isArray(params.clearType) ? params.clearType : [params.clearType];
+    params.clearType = [.../* @__PURE__ */ new Set([...existing, ...clearTypes])];
+  } else {
+    params.clearType = clearTypes;
+  }
+}
+__name(mergeClearTypes, "mergeClearTypes");
+function parseWithOperator(params, op, value) {
+  const vf2 = parseVfValue(value);
+  if (vf2 !== null) {
+    const vfNum = Array.isArray(vf2) ? vf2[0] : vf2;
+    const result = applyVfOperator(op, vfNum);
+    if (result.exclude.length > 0) {
+      params.excludeVf = [...params.excludeVf || [], ...result.exclude];
+    }
+    if (Array.isArray(result.include) && result.include.length > 0) {
+      mergeVf(params, result.include);
+    } else if (typeof result.include === "number") {
+      mergeVf(params, result.include);
+    }
+    return true;
+  }
+  const levels = parseLevelRange(value);
+  if (levels !== null && levels.length === 1) {
+    const result = applyLevelOperator(op, levels);
+    if (result.exclude.length > 0) {
+      params.excludeLevel = [...params.excludeLevel || [], ...result.exclude];
+    }
+    if (result.include.length > 0) {
+      mergeLevels(params, result.include);
+    }
+    return true;
+  }
+  const scores = parseScoreRange(value);
+  if (scores !== null && scores.length === 1) {
+    const result = applyScoreOperator(op, scores);
+    if (result.exclude.length > 0) {
+      params.excludeScore = [...params.excludeScore || [], ...result.exclude];
+    }
+    if (result.include.length > 0) {
+      mergeScores(params, result.include);
+    }
+    return true;
+  }
+  const singleClearTypes = parseSingleClearType(value);
+  if (singleClearTypes !== null) {
+    const ct = singleClearTypes[0];
+    const result = applyClearTypeOperator(op, ct);
+    if (result.exclude.length > 0) {
+      params.excludeClearType = [...params.excludeClearType || [], ...result.exclude];
+    }
+    if (result.include.length > 0) {
+      mergeClearTypes(params, result.include);
+    }
+    return true;
+  }
+  const singleGrades = parseSingleGrade(value);
+  if (singleGrades !== null) {
+    const result = applyGradeOperator(op, singleGrades[0]);
+    if (result.exclude.length > 0) {
+      params.excludeGrade = [...params.excludeGrade || [], ...result.exclude];
+    }
+    if (result.include.length > 0) {
+      mergeGrades(params, result.include);
+    }
+    return true;
+  }
+  return false;
+}
+__name(parseWithOperator, "parseWithOperator");
 function parseQueryInput(input) {
   const params = {};
   if (!input || input.trim() === "") {
@@ -5395,6 +5651,10 @@ function parseQueryInput(input) {
   }
   const items = input.split(/\s+/).map((s) => s.trim()).filter(Boolean);
   for (const item of items) {
+    const { op, value } = extractOperator(item);
+    if (op) {
+      if (parseWithOperator(params, op, value)) continue;
+    }
     const vf2 = parseVfValue(item);
     if (vf2 !== null) {
       if (params.vf !== void 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-noah",
-  "version": "2.3.6",
+  "version": "2.3.7",
   "contributors": [
     "Logthm <logthm@outlook.com>"
   ],