@woosh/meep-engine 2.95.1 → 2.96.0

package/src/core/primitives/strings/string_jaro_winkler.js

@@ -0,0 +1,153 @@
+import { BitSet } from "../../binary/BitSet.js";
+import { max2 } from "../../math/max2.js";
+import { min2 } from "../../math/min2.js";
+import { min3 } from "../../math/min3.js";
+
+/**
+ * Calculate the Jaro-Winkler distance between two strings
+ * @param {string} first The string to compare
+ * @param {string} second The string to compare with
+ * @returns {number} similarity score, higher value means strings are more similar
+ */
+export function string_jaro_winkler(first, second) {
+    const l1 = first.length;
+    const l2 = second.length;
+
+    if (l1 === 0 && l2 === 0) {
+        // special case for empty string
+        return 1;
+    }
+
+    const matches1 = BitSet.fixedSize(l1);
+    const matches2 = BitSet.fixedSize(l2);
+
+    const matches = getMatching(first, second, matches1, matches2);
+
+    if (matches <= 0) {
+        return 0;
+    }
+
+    // Calculate the Jaro distance:
+    const transpositions = getTranspositions(first, second, matches1, matches2);
+    const similarity = (matches / l1 + matches / l2 + (matches - transpositions) / matches) / 3;
+
+    // Transform to Jaro-Winkler:
+    // Prefix scale gives more favorable ratings to strings that share common prefixes:
+    const prefix_scale = 0.1;
+    const prefix = getPrefix(first, second, min3(l1, l2, 4));
+    return similarity + prefix * prefix_scale * (1 - similarity);
+}
+
+/**
+ * Find matching characters in both strings according to Jaro algorithm
+ * @param {string} a1
+ * @param {string} a2
+ * @param {BitSet} matches1
+ * @param {BitSet} matches2
+ * @return {number}
+ */
+function getMatching(a1, a2, matches1, matches2) {
+    const a1_length = a1.length;
+    const a2_length = a2.length;
+
+    // Window is modified to work with string of length 1
+    const matchWindow = max2(
+        0,
+        Math.floor(max2(a1_length, a2_length) * 0.5) - 1
+    );
+
+    let matches = 0;
+
+    // Loop to find matched characters:
+    for (let index1 = 0; index1 < a1_length; index1++) {
+
+        // Use the highest of the window diff and the min of the window and string 2 length:
+        const start = max2(0, index1 - matchWindow);
+        const end = min2(index1 + matchWindow + 1, a2_length);
+
+        // Iterate second string index:
+        for (let index2 = start; index2 < end; index2++) {
+
+            // If second string character already matched, skip:
+            if (matches2.get(index2)) {
+                continue;
+            }
+
+            // If the characters don't match, skip:
+            if (a1.charAt(index1) !== a2.charAt(index2)) {
+                continue;
+            }
+
+            // Assume match if the above 2 checks don't continue:
+            matches1.set(index1, true);
+            matches2.set(index2, true);
+
+            // Add matches by 1, break inner loop:
+            ++matches;
+            break;
+        }
+    }
+
+    return matches;
+}
+
+/**
+ * Calculate the number of transpositions between the two words
+ * @param {string} a1 The first string to compare
+ * @param {string} a2 The second string to compare
+ * @param {BitSet} matches1
+ * @param {BitSet} matches2
+ */
+function getTranspositions(a1, a2, matches1, matches2) {
+    let transpositions = 0;
+
+    // Loop to find transpositions:
+    const a1_length = a1.length;
+    const a2_length = a2.length;
+
+    for (let i1 = 0, i2 = 0; i1 < a1_length; i1++) {
+        // If a non-matching character was found, skip:
+        if (matches1.get(i1) === false) {
+            continue;
+        }
+
+        // Move i2 index to the next match:
+        while (
+            i2 < a2_length
+            && matches2.get(i2) === false
+            ) {
+            i2++;
+        }
+
+        // If the characters don't match, increase transposition:
+        if (a1.charAt(i1) !== a2.charAt(i2)) {
+            transpositions++;
+        }
+
+        // Iterate i2 index normally:
+        i2++;
+    }
+
+    return Math.floor(transpositions * 0.5);
+}
+
+/**
+ * Counts the number of common characters at the beginning
+ * of each word up to a maximum of 4
+ * @param {string} a1 The first string to compare
+ * @param {string} a2 The second string to compare
+ * @param {number} character_limit
+ * @returns {number}
+ */
+function getPrefix(a1, a2, character_limit) {
+
+    let p = 0;
+
+    for (; p < character_limit; p++) {
+        if (a1.charAt(p) !== a2.charAt(p)) {
+            return p;
+        }
+    }
+
+    return ++p;
+}

package/src/core/primitives/strings/string_jaro_winkler.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=string_jaro_winkler.spec.d.ts.map

package/src/core/primitives/strings/string_jaro_winkler.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_jaro_winkler.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_winkler.spec.js"],"names":[],"mappings":""}

package/src/core/primitives/strings/string_jaro_winkler.spec.js

@@ -0,0 +1,39 @@
+import { string_jaro_winkler } from "./string_jaro_winkler.js";
+
+test("empty strings", () => {
+
+    expect(string_jaro_winkler("", "")).toBe(1)
+
+});
+
+test("whitespace", () => {
+    expect(string_jaro_winkler(" ", " ")).toBe(1);
+
+    expect(string_jaro_winkler("\n", "\n")).toBe(1);
+    expect(string_jaro_winkler("\t", "\t")).toBe(1);
+
+    expect(string_jaro_winkler("  ", " ")).toBeGreaterThan(0);
+});
+
+test("negative cases", () => {
+
+
+    expect(string_jaro_winkler("a", "")).toBe(0);
+    expect(string_jaro_winkler("", "a")).toBe(0);
+
+    expect(string_jaro_winkler("a", "b")).toBe(0);
+    expect(string_jaro_winkler("b", "a")).toBe(0);
+
+});
+
+test("known cases", () => {
+
+
+    expect(string_jaro_winkler("a", "a")).toBeCloseTo(1);
+    expect(string_jaro_winkler("aa", "aa")).toBeCloseTo(1);
+    expect(string_jaro_winkler("abc", "abc")).toBeCloseTo(1);
+
+    expect(string_jaro_winkler("DwAyNE", "DuANE")).toBeCloseTo(0.84);
+    expect(string_jaro_winkler("TRATE", "TRACE")).toBeCloseTo(0.906667);
+
+});

package/src/engine/graphics/ecs/mesh/SkeletonUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SkeletonUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/SkeletonUtils.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,2DAHW,MAAM,GACJ,UAAU,GAAG,IAAI,CAiD7B;AAiCD;;;;GAIG;AACH,mEAFa,WAAS,SAAS,CAgB9B;AAED;;;;;GAKG;AACH,qEAHW,yBAAuB,GACtB,IAAI,GAAC,IAAI,CAkCpB;AAED;;;;;GAKG;AACH,iEAHW,yBAAuB,GACrB,IAAI,GAAG,IAAI,CAUvB;AAGD;;;;;GAKG;AACH,0EAFa,IAAI,GAAG,IAAI,CA+BvB;AAID;;;;;GAKG;AACH,sEAFa,IAAI,GAAG,IAAI,CA8BvB;qBAlPoB,OAAO"}
+{"version":3,"file":"SkeletonUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/SkeletonUtils.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,2DAHW,MAAM,GACJ,UAAU,GAAG,IAAI,CAuC7B;AAiCD;;;;GAIG;AACH,mEAFa,WAAS,SAAS,CAgB9B;AAED;;;;;GAKG;AACH,qEAHW,yBAAuB,GACtB,IAAI,GAAC,IAAI,CAkCpB;AAED;;;;;GAKG;AACH,iEAHW,yBAAuB,GACrB,IAAI,GAAG,IAAI,CAUvB;AAGD;;;;;GAKG;AACH,0EAFa,IAAI,GAAG,IAAI,CA+BvB;AAID;;;;;GAKG;AACH,sEAFa,IAAI,GAAG,IAAI,CA8BvB;qBA1OoB,OAAO"}

package/src/engine/graphics/ecs/mesh/SkeletonUtils.js

@@ -1,7 +1,8 @@
-import { distance as levenshtein_distance } from "fastest-levenshtein";
 import { Bone } from "three";
-import { BoneMapping } from "./skeleton/BoneMapping.js";
+import { arrayPickBestElement } from "../../../../core/collection/array/arrayPickBestElement.js";
+import { string_compute_similarity } from "../../../../core/primitives/strings/string_compute_similarity.js";
 import { extractName } from "../../../../extractName.js";
+import { BoneMapping } from "./skeleton/BoneMapping.js";
 
 
 /**
@@ -42,20 +43,10 @@ export function getSkeletonBone(component, boneName) {
     //bone not found
 
     //try to find similar bones
-    const similarities = bones.map(function (bone) {
-        const distance = levenshtein_distance(bone.name, boneName);
-        return {
-            bone: bone,
-            distance: distance
-        };
+    const bestMatch = arrayPickBestElement(bones, function (bone) {
+        return string_compute_similarity(bone.name, boneName);
     });
 
-    similarities.sort(function (a, b) {
-        return a.distance - b.distance;
-    });
-
-    const bestMatch = similarities[0].bone;
-
     throw  new Error("Bone '" + boneName + "' not found, did you mean '" + bestMatch.name + "'");
 }
 

package/src/engine/graphics/ecs/mesh/skeleton/BoneMapping.js

@@ -1,7 +1,7 @@
-import { HumanoidBoneType } from "./HumanoidBoneType.js";
-import { distance as levenshtein_distance } from "fastest-levenshtein";
 import { assert } from "../../../../../core/assert.js";
 import { string_compute_common_prefix } from "../../../../../core/primitives/strings/string_compute_common_prefix.js";
+import { string_compute_similarity } from "../../../../../core/primitives/strings/string_compute_similarity.js";
+import { HumanoidBoneType } from "./HumanoidBoneType.js";
 
 
 /**
@@ -40,7 +40,7 @@ export class BoneMapping {
         boneValues.forEach(function (boneName, boneIndex) {
 
             conditionedNames.forEach(function (name, inputIndex) {
-                const distance = levenshtein_distance(name, boneName);
+                const distance = string_compute_similarity(name, boneName);
                 const match = {
                     boneIndex,
                     inputIndex,