@dicelette/core 1.25.1 → 1.26.0

package/dist/index.mjs

@@ -93,11 +93,11 @@ var NoStatisticsError = class extends Error {
 };
 
 // src/interfaces/index.ts
-var SortOrder = /* @__PURE__ */ ((SortOrder3) => {
-  SortOrder3["Ascending"] = "sa";
-  SortOrder3["Descending"] = "sd";
-  SortOrder3["None"] = "none";
-  return SortOrder3;
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["Ascending"] = "sa";
+  SortOrder2["Descending"] = "sd";
+  SortOrder2["None"] = "none";
+  return SortOrder2;
 })(SortOrder || {});
 
 // src/interfaces/constant.ts
@@ -181,6 +181,79 @@ import { evaluate } from "mathjs";
 import "uniformize";
 import { NumberGenerator as NumberGenerator2 } from "@dice-roller/rpg-dice-roller";
 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;
+  if (longer.length === 0) return 1;
+  const distance = levenshteinDistance(longer, shorter);
+  return (longer.length - distance) / longer.length;
+}
+function levenshteinDistance(str1, str2) {
+  const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+  for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
+  for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
+  for (let j = 1; j <= str2.length; j++) {
+    for (let i = 1; i <= str1.length; i++) {
+      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+      matrix[j][i] = Math.min(
+        matrix[j][i - 1] + 1,
+        // insertion
+        matrix[j - 1][i] + 1,
+        // deletion
+        matrix[j - 1][i - 1] + cost
+        // substitution
+      );
+    }
+  }
+  return matrix[str2.length][str1.length];
+}
+function findBestStatMatch(searchTerm, normalizedStats, similarityThreshold = MIN_THRESHOLD_MATCH, partialSearch = true) {
+  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];
+    }
+  }
+  let bestMatch;
+  let bestSimilarity = 0;
+  for (const [normalizedKey, original] of normalizedStats) {
+    const similarity = calculateSimilarity(searchTerm, normalizedKey);
+    if (similarity === 1) return original;
+    if (similarity > bestSimilarity && similarity >= similarityThreshold) {
+      bestSimilarity = similarity;
+      bestMatch = original;
+    }
+  }
+  return bestMatch;
+}
+function findBestRecord(record, searchTerm, similarityThreshold = MIN_THRESHOLD_MATCH) {
+  const normalizeRecord = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(record)) {
+    normalizeRecord.set(key.standardize(), key);
+  }
+  return findBestStatMatch(
+    searchTerm.standardize(),
+    normalizeRecord,
+    similarityThreshold,
+    false
+  ) || null;
+}
+
+// src/utils.ts
 function escapeRegex(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -190,10 +263,34 @@ function standardizeDice(dice) {
     (_match, insideBrackets, outsideText) => insideBrackets ? insideBrackets : outsideText.standardize().replaceAll("df", "dF")
   );
 }
-function generateStatsDice(originalDice, stats, dollarValue) {
+function handleDiceAfterD(tokenStd, normalizedStats) {
+  const diceMatch = /^(\d*)d(.+)$/i.exec(tokenStd);
+  if (!diceMatch) return null;
+  const diceCount = diceMatch[1] || "";
+  const afterD = diceMatch[2];
+  const bestMatch = findBestStatMatch(afterD, normalizedStats, 1, false);
+  if (bestMatch) {
+    const [, value] = bestMatch;
+    return `${diceCount}d${value.toString()}`;
+  }
+  return null;
+}
+function handleSimpleToken(tokenStd, token, normalizedStats, minThreshold) {
+  const bestMatch = findBestStatMatch(tokenStd, normalizedStats, minThreshold, false);
+  if (bestMatch) {
+    const [, value] = bestMatch;
+    return value.toString();
+  }
+  return token;
+}
+function generateStatsDice(originalDice, stats, minThreshold = 0.6, dollarValue) {
   let dice = originalDice.standardize();
   if (stats && Object.keys(stats).length > 0) {
-    const statKeys = Object.keys(stats);
+    const normalizedStats = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(stats)) {
+      const normalized = key.standardize();
+      normalizedStats.set(normalized, [key, value]);
+    }
     const partsRegex = /(\[[^\]]+])|([^[]+)/g;
     let result = "";
     let match;
@@ -207,7 +304,7 @@ function generateStatsDice(originalDice, stats, dollarValue) {
       if (!outsideText) {
         continue;
       }
-      const tokenRegex = /(\$?[\p{L}\p{N}_]+)/gu;
+      const tokenRegex = /(\$?[\p{L}\p{N}_.]+)/gu;
       let lastIndex = 0;
       let tokenMatch;
       while ((tokenMatch = tokenRegex.exec(outsideText)) !== null) {
@@ -216,45 +313,13 @@ function generateStatsDice(originalDice, stats, dollarValue) {
         const tokenHasDollar = token.startsWith("$");
         const tokenForCompare = tokenHasDollar ? token.slice(1) : token;
         const tokenStd = tokenForCompare.standardize();
-        const diceMatch = /^(\d*)d(.+)$/i.exec(tokenStd);
-        if (diceMatch) {
-          const diceCount = diceMatch[1] || "";
-          const afterD = diceMatch[2];
-          let foundStatAfterD = false;
-          for (const key of statKeys) {
-            const keyStd = key.standardize();
-            if (afterD === keyStd) {
-              result += `${diceCount}d${stats[key].toString()}`;
-              foundStatAfterD = true;
-              break;
-            }
-          }
-          if (foundStatAfterD) {
-            lastIndex = tokenRegex.lastIndex;
-            continue;
-          }
-        }
-        let bestKey = null;
-        let bestScore = 0;
-        for (const key of statKeys) {
-          const keyStd = key.standardize();
-          if (tokenStd === keyStd) {
-            bestKey = key;
-            bestScore = 1;
-            break;
-          }
-          const score = similarityScore(tokenStd, keyStd);
-          if (score > bestScore) {
-            bestScore = score;
-            bestKey = key;
-          }
-        }
-        if (bestKey && bestScore >= 0.6) {
-          const statValue = stats[bestKey];
-          result += statValue.toString();
-        } else {
-          result += token;
+        const diceReplacement = handleDiceAfterD(tokenStd, normalizedStats);
+        if (diceReplacement) {
+          result += diceReplacement;
+          lastIndex = tokenRegex.lastIndex;
+          continue;
         }
+        result += handleSimpleToken(tokenStd, token, normalizedStats, minThreshold);
         lastIndex = tokenRegex.lastIndex;
       }
       result += outsideText.slice(lastIndex);
@@ -298,33 +363,6 @@ function randomInt(min, max, engine = NumberGenerator2.engines.nodeCrypto, rng)
   if (!rng) rng = new Random(engine || void 0);
   return rng.integer(min, max);
 }
-function levenshteinDistance(a, b) {
-  if (a === b) return 0;
-  const al = a.length;
-  const bl = b.length;
-  if (al === 0) return bl;
-  if (bl === 0) return al;
-  const v0 = new Array(bl + 1);
-  const v1 = new Array(bl + 1);
-  for (let i = 0; i <= bl; i++) v0[i] = i;
-  for (let i = 0; i < al; i++) {
-    v1[0] = i + 1;
-    for (let j = 0; j < bl; j++) {
-      const cost = a[i] === b[j] ? 0 : 1;
-      v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
-    }
-    for (let j = 0; j <= bl; j++) v0[j] = v1[j];
-  }
-  return v1[bl];
-}
-function similarityScore(a, b) {
-  const la = a.length;
-  const lb = b.length;
-  if (la === 0 && lb === 0) return 1;
-  const dist = levenshteinDistance(a, b);
-  const max = Math.max(la, lb);
-  return 1 - dist / max;
-}
 function createCriticalCustom(dice, customCritical, template, engine = NumberGenerator2.engines.nodeCrypto) {
   const compareRegex = dice.match(SIGN_REGEX_SPACE);
   let customDice = dice;
@@ -1443,6 +1481,7 @@ export {
   SortOrder,
   TooManyDice,
   TooManyStats,
+  calculateSimilarity,
   createCriticalCustom,
   diceRandomParse,
   diceTypeRandomParse,
@@ -1450,11 +1489,14 @@ export {
   evalCombinaison,
   evalOneCombinaison,
   evalStatsDice,
+  findBestRecord,
+  findBestStatMatch,
   generateRandomStat,
   generateStatsDice,
   getEngine,
   getEngineId,
   isNumber,
+  levenshteinDistance,
   randomInt,
   replaceExpByRandom,
   replaceFormulaInDice,