@truto/truto-jsonata 1.0.47 → 1.0.48

package/README.md

@@ -2116,6 +2116,53 @@ expression.evaluate({ input, possibleValues, threshold }).then(result => { conso
 
 </details>
 
+<details>
+<summary>diceCoefficient(value1, value2)</summary>
+
+Calculates the Dice Coefficient similarity score between two strings. The Dice Coefficient measures the similarity of two strings based on their bigrams (pairs of adjacent characters). The function normalizes both strings (converts to lowercase and removes non-alphanumeric characters) before comparison.
+
+**Parameters:**
+
+- **value1**: The first string to compare.
+- **value2**: The second string to compare.
+
+**Returns:**
+
+A number between `0.0` (completely different) and `1.0` (identical), representing the similarity score.
+
+**Example Usage:**
+
+```javascript
+import trutoJsonata from '@truto/truto-jsonata';
+
+// Example 1: Identical strings return 1.0
+const expression1 = trutoJsonata("$diceCoefficient('hello', 'hello')");
+expression1.evaluate({}).then(result => { console.log(result); });
+// Output: 1.0
+
+// Example 2: Similar strings return a score between 0 and 1
+const expression2 = trutoJsonata("$diceCoefficient('apple', 'appl')");
+expression2.evaluate({}).then(result => { console.log(result); });
+// Output: 0.8 (or similar value depending on similarity)
+
+// Example 3: Case-insensitive comparison
+const expression3 = trutoJsonata("$diceCoefficient('Hello', 'HELLO')");
+expression3.evaluate({}).then(result => { console.log(result); });
+// Output: 1.0
+
+// Example 4: Non-alphanumeric characters are ignored
+const expression4 = trutoJsonata("$diceCoefficient('hello-world', 'hello world')");
+expression4.evaluate({}).then(result => { console.log(result); });
+// Output: 1.0
+
+// Example 5: Completely different strings return 0.0
+const expression5 = trutoJsonata("$diceCoefficient('hello', 'xyz')");
+expression5.evaluate({}).then(result => { console.log(result); });
+// Output: 0.0
+```
+
+</details>
+
 <details>
 <summary>sortNodes(array,   idKey = 'id',
   parentIdKey = 'parent_id',

package/dist/browser/index.js

@@ -50641,6 +50641,76 @@ var digest = async (text, algorithm = "SHA-256", stringType = "hex") => {
 };
 var digest_default = digest;
 
+// node_modules/n-gram/index.js
+var bigram = nGram(2);
+var trigram = nGram(3);
+function nGram(n2) {
+  if (typeof n2 !== "number" || Number.isNaN(n2) || n2 < 1 || n2 === Number.POSITIVE_INFINITY) {
+    throw new Error("`" + n2 + "` is not a valid argument for `n-gram`");
+  }
+  return grams;
+  function grams(value) {
+    const nGrams = [];
+    if (value === null || value === undefined) {
+      return nGrams;
+    }
+    const source = typeof value.slice === "function" ? value : String(value);
+    let index = source.length - n2 + 1;
+    if (index < 1) {
+      return nGrams;
+    }
+    while (index--) {
+      nGrams[index] = source.slice(index, index + n2);
+    }
+    return nGrams;
+  }
+}
+
+// node_modules/dice-coefficient/index.js
+function diceCoefficient(value, other2) {
+  const left = toPairs(value);
+  const right = toPairs(other2);
+  let index = -1;
+  let intersections = 0;
+  while (++index < left.length) {
+    const leftPair = left[index];
+    let offset2 = -1;
+    while (++offset2 < right.length) {
+      const rightPair = right[offset2];
+      if (leftPair === rightPair) {
+        intersections++;
+        right[offset2] = "";
+        break;
+      }
+    }
+  }
+  return 2 * intersections / (left.length + right.length);
+}
+function toPairs(value) {
+  if (Array.isArray(value)) {
+    return value.map((bigram2) => normalize(bigram2));
+  }
+  const normal = normalize(value);
+  return normal.length === 1 ? [normal] : bigram(normal);
+}
+function normalize(value) {
+  return String(value).toLowerCase();
+}
+
+// src/functions/diceCoefficient.ts
+function getNormalizedString(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function _diceCoefficient(value, value2) {
+  if (value === value2) {
+    return 1;
+  }
+  const normalizedValue = getNormalizedString(value);
+  const normalizedValue2 = getNormalizedString(value2);
+  return diceCoefficient(normalizedValue, normalizedValue2);
+}
+var diceCoefficient_default = _diceCoefficient;
+
 // src/functions/dtFromFormat.ts
 function dtFromFormat(date, format, options3) {
   if (format === "RFC2822") {
@@ -51448,70 +51518,14 @@ function jsToXml_default(json, options3 = { compact: true, spaces: 4 }) {
   return import_xml_js.js2xml(json, options3);
 }
 
-// node_modules/n-gram/index.js
-var bigram = nGram(2);
-var trigram = nGram(3);
-function nGram(n2) {
-  if (typeof n2 !== "number" || Number.isNaN(n2) || n2 < 1 || n2 === Number.POSITIVE_INFINITY) {
-    throw new Error("`" + n2 + "` is not a valid argument for `n-gram`");
-  }
-  return grams;
-  function grams(value) {
-    const nGrams = [];
-    if (value === null || value === undefined) {
-      return nGrams;
-    }
-    const source = typeof value.slice === "function" ? value : String(value);
-    let index = source.length - n2 + 1;
-    if (index < 1) {
-      return nGrams;
-    }
-    while (index--) {
-      nGrams[index] = source.slice(index, index + n2);
-    }
-    return nGrams;
-  }
-}
-
-// node_modules/dice-coefficient/index.js
-function diceCoefficient(value, other2) {
-  const left = toPairs(value);
-  const right = toPairs(other2);
-  let index = -1;
-  let intersections = 0;
-  while (++index < left.length) {
-    const leftPair = left[index];
-    let offset2 = -1;
-    while (++offset2 < right.length) {
-      const rightPair = right[offset2];
-      if (leftPair === rightPair) {
-        intersections++;
-        right[offset2] = "";
-        break;
-      }
-    }
-  }
-  return 2 * intersections / (left.length + right.length);
-}
-function toPairs(value) {
-  if (Array.isArray(value)) {
-    return value.map((bigram2) => normalize(bigram2));
-  }
-  const normal = normalize(value);
-  return normal.length === 1 ? [normal] : bigram(normal);
-}
-function normalize(value) {
-  return String(value).toLowerCase();
-}
-
 // src/functions/mostSimilar.ts
-function getNormalizedString(value) {
+function getNormalizedString2(value) {
   return value.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
 function mostSimilar(value, possibleValues, threshold = 0.8) {
-  const normalizedValue = getNormalizedString(value);
+  const normalizedValue = getNormalizedString2(value);
   const result = reduce_default(possibleValues, (acc, possibleValue) => {
-    const normalizedPossibleValue = getNormalizedString(possibleValue);
+    const normalizedPossibleValue = getNormalizedString2(possibleValue);
     const similarity = diceCoefficient(normalizedValue, normalizedPossibleValue);
     if (similarity > acc.similarity) {
       return { similarity, value: possibleValue };
@@ -67877,6 +67891,7 @@ function registerJsonataExtensions(expression) {
   expression.registerFunction("uuid", uuid_default);
   expression.registerFunction("getArrayBuffer", getArrayBuffer_default);
   expression.registerFunction("mostSimilar", mostSimilar_default);
+  expression.registerFunction("diceCoefficient", diceCoefficient_default);
   expression.registerFunction("sortNodes", sortNodes_default);
   expression.registerFunction("blob", blob_default);
   expression.registerFunction("convertHtmlToMarkdown", convertHtmlToMarkdown_default);
@@ -67950,4 +67965,4 @@ export {
   trutoJsonata as default
 };
 
-//# debugId=E22AACED232C3A8A64756E2164756E21
+//# debugId=19179F04099D0A3864756E2164756E21