@dicelette/core 1.26.0 → 1.27.1

package/dist/index.mjs

@@ -92,14 +92,6 @@ var NoStatisticsError = class extends Error {
   }
 };
 
-// src/interfaces/index.ts
-var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
-  SortOrder2["Ascending"] = "sa";
-  SortOrder2["Descending"] = "sd";
-  SortOrder2["None"] = "none";
-  return SortOrder2;
-})(SortOrder || {});
-
 // src/interfaces/constant.ts
 var COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(?<comment>.*)/gi;
 var SIGN_REGEX = /==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=/;
@@ -107,6 +99,15 @@ var SIGN_REGEX_SPACE = /(==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)
 var SYMBOL_DICE = "&";
 var DETECT_CRITICAL = /\{\*?c[fs]:([<>=]|!=)+(.+?)}/gim;
 var OPTIONAL_COMMENT = /\s+(#|\/{2}|\[|\/\*)?(?<comment>.*)/gi;
+var MIN_THRESHOLD_MATCH = 0.5;
+
+// src/interfaces/index.ts
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["Ascending"] = "sa";
+  SortOrder2["Descending"] = "sd";
+  SortOrder2["None"] = "none";
+  return SortOrder2;
+})(SortOrder || {});
 
 // src/interfaces/zod.ts
 import { z } from "zod";
@@ -164,6 +165,45 @@ var templateSchema = z.object({
   damage: damageSchema
 });
 
+// src/regex.ts
+var regexCache = /* @__PURE__ */ new Map();
+var NORMALIZE_SINGLE_DICE = (str) => str.replace(/\b1d(\d+)/gi, "d$1");
+var REMOVER_PATTERN = {
+  ASTERISK_ESCAPE: /\*/g,
+  CRITICAL_BLOCK: /\{\*?c[fs]:([<>=]|!=)+.+?\}/gim,
+  EXP_REMOVER: /\{exp(.*?)\}/g,
+  SIGN_REMOVER: /([><=]|!=)+.*$/,
+  STAT_COMMENTS_REMOVER: /%%.*%%/,
+  STAT_MATCHER: /\(?\$([\p{L}\p{M}_.][\p{L}\p{M}0-9_.]*)\)?/giu
+};
+function getCachedRegex(pattern, flags = "") {
+  const key = `${pattern}|${flags}`;
+  let regex = regexCache.get(key);
+  if (!regex) {
+    regex = new RegExp(pattern, flags);
+    regexCache.set(key, regex);
+  }
+  return regex;
+}
+function includeDiceType(dice, diceType, userStats) {
+  if (!diceType) return false;
+  diceType = NORMALIZE_SINGLE_DICE(diceType);
+  dice = NORMALIZE_SINGLE_DICE(dice);
+  if (userStats && diceType.includes("$")) {
+    diceType = diceType.replace("$", ".+?");
+  }
+  if (SIGN_REGEX.test(diceType)) {
+    diceType = diceType.replace(REMOVER_PATTERN.SIGN_REMOVER, "").trim();
+    dice = dice.replace(REMOVER_PATTERN.SIGN_REMOVER, "").trim();
+  }
+  if (diceType.includes("{exp")) {
+    diceType = diceType.replace(REMOVER_PATTERN.EXP_REMOVER, "").trim();
+    dice = dice.replace(REMOVER_PATTERN.EXP_REMOVER, "").trim();
+  }
+  const detectDiceType = getCachedRegex(`\\b${diceType}\\b`, "i");
+  return detectDiceType.test(dice);
+}
+
 // src/roll.ts
 import { DiceRoller as DiceRoller3, NumberGenerator as NumberGenerator7 } from "@dice-roller/rpg-dice-roller";
 import { evaluate as evaluate8 } from "mathjs";
@@ -183,7 +223,6 @@ import { NumberGenerator as NumberGenerator2 } from "@dice-roller/rpg-dice-rolle
 import { Random } from "random-js";
 
 // src/similarity.ts
-var MIN_THRESHOLD_MATCH = 0.5;
 function calculateSimilarity(str1, str2) {
   const longer = str1.length > str2.length ? str1 : str2;
   const shorter = str1.length > str2.length ? str2 : str1;
@@ -210,23 +249,18 @@ function levenshteinDistance(str1, str2) {
   }
   return matrix[str2.length][str1.length];
 }
-function findBestStatMatch(searchTerm, normalizedStats, similarityThreshold = MIN_THRESHOLD_MATCH, partialSearch = true) {
+function findBestStatMatch(searchTerm, normalizedStats, similarityThreshold = MIN_THRESHOLD_MATCH) {
   const exact = normalizedStats.get(searchTerm);
   if (exact) return exact;
-  if (partialSearch) {
-    const candidates = [];
-    for (const [normalizedKey, original] of normalizedStats) {
-      if (normalizedKey.startsWith(searchTerm))
-        candidates.push([original, normalizedKey.length]);
-      else if (normalizedKey.endsWith(searchTerm))
-        candidates.push([original, normalizedKey.length]);
-      else if (normalizedKey.includes(searchTerm))
-        candidates.push([original, normalizedKey.length]);
-    }
-    if (candidates.length > 0) {
-      candidates.sort((a, b) => a[1] - b[1]);
-      return candidates[0][0];
-    }
+  const candidates = [];
+  for (const [normalizedKey, original] of normalizedStats) {
+    if (normalizedKey.startsWith(searchTerm))
+      candidates.push([original, calculateSimilarity(searchTerm, normalizedKey)]);
+  }
+  if (candidates.length === 1) return candidates[0][0];
+  if (candidates.length > 0) {
+    candidates.sort((a, b) => b[1] - a[1]);
+    if (candidates[0][1] >= similarityThreshold) return candidates[0][0];
   }
   let bestMatch;
   let bestSimilarity = 0;
@@ -248,10 +282,22 @@ function findBestRecord(record, searchTerm, similarityThreshold = MIN_THRESHOLD_
   return findBestStatMatch(
     searchTerm.standardize(),
     normalizeRecord,
-    similarityThreshold,
-    false
+    similarityThreshold
   ) || null;
 }
+function replaceUnknown(dice, replacer) {
+  return dice.replaceAll(REMOVER_PATTERN.STAT_MATCHER, replacer).replaceAll("+0", "").replaceAll("-0", "");
+}
+function verifyStatMatcherPattern(dice, replaceUnknow) {
+  if (REMOVER_PATTERN.STAT_MATCHER.test(dice)) {
+    if (replaceUnknow)
+      return replaceUnknown(dice, replaceUnknow);
+    const matched = dice.matchAll(new RegExp(REMOVER_PATTERN.STAT_MATCHER));
+    const stats = matched ? Array.from(matched, (m) => m?.[0]).map((s) => `\`${s}\``).join(", ") : "unknown";
+    throw new DiceTypeError("error.invalidDice.stats");
+  }
+  return dice.replaceAll("+0", "").replaceAll("-0", "");
+}
 
 // src/utils.ts
 function escapeRegex(string) {
@@ -268,7 +314,7 @@ function handleDiceAfterD(tokenStd, normalizedStats) {
   if (!diceMatch) return null;
   const diceCount = diceMatch[1] || "";
   const afterD = diceMatch[2];
-  const bestMatch = findBestStatMatch(afterD, normalizedStats, 1, false);
+  const bestMatch = findBestStatMatch(afterD, normalizedStats, 1);
   if (bestMatch) {
     const [, value] = bestMatch;
     return `${diceCount}d${value.toString()}`;
@@ -276,7 +322,7 @@ function handleDiceAfterD(tokenStd, normalizedStats) {
   return null;
 }
 function handleSimpleToken(tokenStd, token, normalizedStats, minThreshold) {
-  const bestMatch = findBestStatMatch(tokenStd, normalizedStats, minThreshold, false);
+  const bestMatch = findBestStatMatch(tokenStd, normalizedStats, minThreshold);
   if (bestMatch) {
     const [, value] = bestMatch;
     return value.toString();
@@ -1472,9 +1518,12 @@ export {
   DiceTypeError,
   EmptyObjectError,
   FormulaError,
+  MIN_THRESHOLD_MATCH,
   MaxGreater,
+  NORMALIZE_SINGLE_DICE,
   NoStatisticsError,
   OPTIONAL_COMMENT,
+  REMOVER_PATTERN,
   SIGN_REGEX,
   SIGN_REGEX_SPACE,
   SYMBOL_DICE,
@@ -1493,19 +1542,23 @@ export {
   findBestStatMatch,
   generateRandomStat,
   generateStatsDice,
+  getCachedRegex,
   getEngine,
   getEngineId,
+  includeDiceType,
   isNumber,
   levenshteinDistance,
   randomInt,
   replaceExpByRandom,
   replaceFormulaInDice,
   replaceInFormula,
+  replaceUnknown,
   roll,
   standardizeDice,
   templateSchema,
   testDiceRegistered,
   testStatCombinaison,
+  verifyStatMatcherPattern,
   verifyTemplateValue
 };
 //# sourceMappingURL=index.mjs.map