howlongtobeat-core 0.1.0

package/script/src/utils/similarity.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * String similarity algorithms for HowLongToBeat
+ *
+ * Provides both Gestalt pattern matching (like Python's difflib.SequenceMatcher)
+ * and Levenshtein distance-based similarity.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSimilarity = calculateSimilarity;
+exports.gestaltSimilarity = gestaltSimilarity;
+exports.levenshteinSimilarity = levenshteinSimilarity;
+exports.createSimilarityCalculator = createSimilarityCalculator;
+/**
+ * Calculate similarity using the specified algorithm
+ */
+function calculateSimilarity(a, b, algorithm = "gestalt") {
+    if (algorithm === "levenshtein") {
+        return levenshteinSimilarity(a, b);
+    }
+    return gestaltSimilarity(a, b);
+}
+/**
+ * Gestalt Pattern Matching similarity (like Python's difflib.SequenceMatcher)
+ *
+ * This implements the Ratcliff/Obershelp algorithm which finds the longest
+ * common substring and recursively processes the remaining parts.
+ */
+function gestaltSimilarity(a, b) {
+    if (a === b)
+        return 1.0;
+    if (a.length === 0 || b.length === 0)
+        return 0.0;
+    const matches = countMatchingCharacters(a, b);
+    return (2.0 * matches) / (a.length + b.length);
+}
+/**
+ * Count matching characters using Ratcliff/Obershelp algorithm
+ */
+function countMatchingCharacters(a, b) {
+    const [lcs, aStart, aEnd, bStart, bEnd] = findLongestCommonSubstring(a, b);
+    if (lcs === 0) {
+        return 0;
+    }
+    let count = lcs;
+    // Recursively process left parts
+    if (aStart > 0 && bStart > 0) {
+        count += countMatchingCharacters(a.substring(0, aStart), b.substring(0, bStart));
+    }
+    // Recursively process right parts
+    if (aEnd < a.length && bEnd < b.length) {
+        count += countMatchingCharacters(a.substring(aEnd), b.substring(bEnd));
+    }
+    return count;
+}
+/**
+ * Find the longest common substring between two strings
+ * Returns [length, aStart, aEnd, bStart, bEnd]
+ */
+function findLongestCommonSubstring(a, b) {
+    let longestLength = 0;
+    let aStart = 0;
+    let bStart = 0;
+    // Build a table of matching positions
+    const table = Array(a.length + 1)
+        .fill(null)
+        .map(() => Array(b.length + 1).fill(0));
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            if (a[i - 1] === b[j - 1]) {
+                table[i][j] = table[i - 1][j - 1] + 1;
+                if (table[i][j] > longestLength) {
+                    longestLength = table[i][j];
+                    aStart = i - longestLength;
+                    bStart = j - longestLength;
+                }
+            }
+        }
+    }
+    return [
+        longestLength,
+        aStart,
+        aStart + longestLength,
+        bStart,
+        bStart + longestLength,
+    ];
+}
+/**
+ * Calculate Levenshtein distance between two strings
+ */
+function levenshteinDistance(a, b) {
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const matrix = [];
+    // Initialize first column
+    for (let i = 0; i <= a.length; i++) {
+        matrix[i] = [i];
+    }
+    // Initialize first row
+    for (let j = 0; j <= b.length; j++) {
+        matrix[0][j] = j;
+    }
+    // Fill in the rest of the matrix
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, // deletion
+            matrix[i][j - 1] + 1, // insertion
+            matrix[i - 1][j - 1] + cost);
+        }
+    }
+    return matrix[a.length][b.length];
+}
+/**
+ * Calculate similarity based on Levenshtein distance
+ * Returns a value between 0 and 1, where 1 means identical strings
+ */
+function levenshteinSimilarity(a, b) {
+    if (a === b)
+        return 1.0;
+    if (a.length === 0 || b.length === 0)
+        return 0.0;
+    const distance = levenshteinDistance(a, b);
+    const maxLength = Math.max(a.length, b.length);
+    return 1 - distance / maxLength;
+}
+/**
+ * Create a similarity calculator function with a specific algorithm
+ */
+function createSimilarityCalculator(algorithm = "gestalt") {
+    return (a, b) => calculateSimilarity(a, b, algorithm);
+}