@woosh/meep-engine 2.95.0 → 2.96.0

package/src/core/math/epsilonEquals.spec.js

@@ -0,0 +1,17 @@
+import { epsilonEquals } from "./epsilonEquals.js";
+
+test("basics", () => {
+
+    expect(epsilonEquals(0, 0, 0)).toBe(true);
+    expect(epsilonEquals(0, 1, 0)).toBe(false);
+    expect(epsilonEquals(1, 0, 0)).toBe(false);
+    expect(epsilonEquals(-1, 0, 0)).toBe(false);
+    expect(epsilonEquals(-1, 1, 0)).toBe(false);
+    expect(epsilonEquals(1, -1, 0)).toBe(false);
+
+    expect(epsilonEquals(1, 1.1, 0)).toBe(false);
+    expect(epsilonEquals(1, 1, 0.1)).toBe(true);
+    expect(epsilonEquals(1, 1.09, 0.1)).toBe(true);
+    expect(epsilonEquals(1, 1.11, 0.1)).toBe(false);
+
+});

package/src/core/model/node-graph/node/NodeInstance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeInstance.js"],"names":[],"mappings":"AAcA;IAEI;;;OAGG;IACH,IAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,6BAAmB;IAEnB;;;OAGG;IACH,WAFU,yBAAyB,EAAE,CAEtB;IAEf;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,qBAAmB;IAEnB;;;OAGG;IACH,aAFU,gBAAgB,CAED;IAEzB;;;;;;OAMG;IACH,wBAFU,MAAM,CAEE;IAElB;;OAEG;IACH;QACI;;;WAGG;mCADO,OAAO,MAAM,WAAO;QAG9B;;;WAGG;iCADO,OAAO,MAAM,MAAI;QAG3B;;;WAGG;mCADO,OAAO,MAAM,MAAI;QAI3B;;;;WAIG;qCADO,wCAAwC;MAGpD;IAEF;;;;;;OAMG;IACH,yBALW,MAAM,aACN,aAAa,UACb,YAAY,GACV,MAAM,CAsBlB;IAED;;;OAGG;IACH,gDAEC;IAED;;;OAGG;IACH,+CAEC;IAGD;;;OAGG;IACH,mCAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,oBAKhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,OAKhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,KAOhB;IAED;;;;OAIG;IACH,2BAHW,MAAM,oBAmChB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAkBnB;IAED;;;OAGG;IACH,uCAQC;IAED,wBAIC;IAED;;;OAGG;IACH,mDAqCC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,yBAAyB,GAAC,SAAS,CAe/C;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAQnB;IAED,mBAEC;IAIL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CAPpC;0CArVyC,gCAAgC;iBAHzD,kCAAkC;mBAChC,kCAAkC;8BAGvB,oBAAoB"}
+{"version":3,"file":"NodeInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeInstance.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH;IAEI;;;;OAIG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,6BAAmB;IAEnB;;;OAGG;IACH,WAFU,yBAAyB,EAAE,CAEtB;IAEf;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,qBAAmB;IAEnB;;;OAGG;IACH,aAFU,gBAAgB,CAED;IAEzB;;;;;;OAMG;IACH,wBAFU,MAAM,CAEE;IAElB;;OAEG;IACH;QACI;;;WAGG;mCADO,OAAO,MAAM,WAAO;QAG9B;;;WAGG;iCADO,OAAO,MAAM,MAAI;QAG3B;;;WAGG;mCADO,OAAO,MAAM,MAAI;QAI3B;;;;WAIG;qCADO,wCAAwC;MAGpD;IAEF;;;;;;OAMG;IACH,yBALW,MAAM,aACN,aAAa,UACb,YAAY,GACV,MAAM,CAsBlB;IAED;;;OAGG;IACH,gDAEC;IAED;;;OAGG;IACH,+CAEC;IAGD;;;OAGG;IACH,mCAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,oBAKhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,OAKhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,KAOhB;IAED;;;;OAIG;IACH,2BAHW,MAAM,oBAmChB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAkBnB;IAED;;;OAGG;IACH,uCAQC;IAED,wBAIC;IAED;;;OAGG;IACH,mDAqCC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,yBAAyB,GAAC,SAAS,CAe/C;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAQnB;IAED,mBAEC;IAIL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CAPpC;0CA3VyC,gCAAgC;iBAHzD,kCAAkC;mBAChC,kCAAkC;8BAGvB,oBAAoB"}

package/src/core/model/node-graph/node/NodeInstance.js

@@ -12,10 +12,16 @@ import { PortDirection } from "./PortDirection.js";
  */
 let id_counter = 0;
 
+/**
+ * Represents a node instance in a graph, its main purpose is to provide connection medium for the graph.
+ * A useful analogy is that of a "class" and an "object", there can be multiple instances (objects) of the same class. In this analogy `NodeInstance` is the object, and `NodeDescription` is a class.
+ * There can be multiple `NodeInstance`s referencing the same `NodeDescription`.
+ */
 export class NodeInstance {
 
     /**
-     *
+     * Unique identifier
+     * @readonly
      * @type {number}
      */
     id = id_counter++;
@@ -342,7 +348,7 @@ export class NodeInstance {
     }
 
     toString() {
-        return `NodeInstance{ id = ${this.id}, description = ${this.description.id} }`
+        return `NodeInstance{ id = ${this.id}, description = ${this.description?.id} }`
     }
 }
 

package/src/core/primitives/strings/string_compute_similarity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Higher value means string are more similar
+ * @type {(function(string, string): number)}
+ */
+export const string_compute_similarity: ((arg0: string, arg1: string) => number);
+//# sourceMappingURL=string_compute_similarity.d.ts.map

package/src/core/primitives/strings/string_compute_similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_compute_similarity.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_compute_similarity.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wCAFU,QAAU,MAAM,QAAE,MAAM,KAAG,MAAM,CAAC,CAEiB"}

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

@@ -0,0 +1,7 @@
+import { string_jaro_winkler } from "./string_jaro_winkler.js";
+
+/**
+ * Higher value means string are more similar
+ * @type {(function(string, string): number)}
+ */
+export const string_compute_similarity = string_jaro_winkler;

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

@@ -0,0 +1,8 @@
+/**
+ * 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: string, second: string): number;
+//# sourceMappingURL=string_jaro_winkler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string_jaro_winkler.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_winkler.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CA6BlB"}

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,

package/src/engine/graphics/texture/sampler/HarmonicDiffusionGrid.spec.js

@@ -1,6 +1,6 @@
+import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { HarmonicDiffusionGrid } from "./HarmonicDiffusionGrid.js";
-import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new HarmonicDiffusionGrid([], 0, 0);
@@ -77,7 +77,7 @@ test("20 step 4x1, corners assigned", () => {
     expect(grid.data[3]).toBe(-7);
 });
 
-test("performance 512x512", () => {
+test.skip("performance 512x512", () => {
     const w = 139;
     const h = 139;