flo-mat 3.0.10 → 3.0.11

package/__tests__/jsog/check-jsog-eql-calc.spec.ts

@@ -0,0 +1,81 @@
+import type { Mat } from '../../src/mat/mat.js';
+import { expect, test } from '@jest/globals';
+import { squares4 } from 'squares-rng';
+import { mats1_, getMats1 } from './mat-dummys.js';
+import { CpNode, getAllOnLoop } from '../../src/index.js';
+
+
+test('Check MAT objects equal (JSOG)', function() {
+    const mats1 = getMats1();
+
+    // too hard for Jest due to circular references
+    // expect(mats_obj1).toEqual(mats_calc1);
+    
+    // Fast path: check root array structure and length
+    expect(Array.isArray(mats1_)).toBe(true);
+    expect(Array.isArray(mats1)).toBe(true);
+    expect(mats1_.length).toBe(mats1.length);
+    
+    // Verify key properties of the MAT objects instead of deep comparison
+    const mats1_0_ = mats1_[0];
+    const mats1_0 = mats1[0];
+    
+    // Check critical structure exists
+    expect(mats1_0_).toHaveProperty('cpNode');
+    expect(mats1_0).toHaveProperty('cpNode');
+    
+    // Verify circular reference integrity
+    if (mats1_0_.cpNode && mats1_0_.cpNode.nextOnCircle) {
+        expect(mats1_0_.cpNode.nextOnCircle).toBeDefined();
+    }
+
+    getAllOnLoop(mats1_0_.cpNode).length; //?
+
+    // Perform a random walk on the calculated MAT to ensure it behaves as expected
+    let testCpNode = mats1_0.cpNode;
+    let testCpNode_ = mats1_0_.cpNode;
+
+    const N = 10;
+    let reachCpNodes = new Set<CpNode>();
+    for (let i=0; i<N; i++) {
+        testCpNode = randomWalk(testCpNode, i*N, N);
+        testCpNode_ = randomWalk(testCpNode_, i*N, N);
+
+        // testCpNode.cp.pointOnShape.p; //?
+        // testCpNode_.cp.pointOnShape.p;//?
+
+        reachCpNodes.add(testCpNode);
+
+        expect(testCpNode.cp.pointOnShape).toEqual(testCpNode_.cp.pointOnShape);
+    }
+
+    reachCpNodes.size; //?
+});
+
+
+const NEXT = 0;
+const PREV = 1;
+const NEXT_ON_CIRCLE = 2;
+const PREV_ON_CIRCLE = 3;
+
+function randomWalk(
+        cpNode: CpNode,
+        seed: number,
+        steps: number) {
+
+    for (let i=0; i<steps; i++) {
+        const direction = squares4(seed + i) % 4;
+
+        if (direction === NEXT) {
+            cpNode = cpNode.next;
+        } else if (direction === PREV) {
+            cpNode = cpNode.prev;
+        } else if (direction === NEXT_ON_CIRCLE) {
+            cpNode = cpNode.nextOnCircle;
+        } else if (direction === PREV_ON_CIRCLE) {
+            cpNode = cpNode.prevOnCircle;
+        }
+    }
+
+    return cpNode;
+}

package/__tests__/jsog/decode-jsog.ts

@@ -0,0 +1,85 @@
+
+/**
+ * Decodes a JSOG-encoded object back into a live circular graph.
+ */
+function decodeJSOG(jsog: any) {
+    const idMap = new Map<string, any>();
+
+    // Pass 1: catalog all objects that have an @id.
+    function findIds(obj: any) {
+        if (!obj || typeof obj !== 'object') return;
+
+        if (Array.isArray(obj)) {
+            obj.forEach(findIds);
+            return;
+        }
+
+        if (obj['@id'] !== undefined) {
+            const id = String(obj['@id']);
+            if (!idMap.has(id)) {
+                if (obj['@type'] === 'Map') {
+                    idMap.set(id, new Map());
+                } else if (obj['@type'] === 'Set') {
+                    idMap.set(id, new Set());
+                } else {
+                    idMap.set(id, {});
+                }
+            }
+        }
+
+        Object.entries(obj).forEach(([key, val]) => {
+            if (key !== '@ref') {
+                findIds(val);
+            }
+        });
+    }
+
+    // Pass 2: reconstruct the graph by swapping @ref for the actual object.
+    function resolve(obj: any): any {
+        if (!obj || typeof obj !== 'object') return obj;
+
+        if (Array.isArray(obj)) {
+            return obj.map(resolve);
+        }
+
+        if (obj['@ref'] !== undefined) {
+            const refId = String(obj['@ref']);
+            if (!idMap.has(refId)) {
+                throw new Error(`Invalid JSOG: missing @id for @ref "${refId}".`);
+            }
+            return idMap.get(refId);
+        }
+
+        const result = obj['@id'] !== undefined
+            ? idMap.get(String(obj['@id']))
+            : {};
+
+        if (obj['@type'] === 'Map') {
+            for (const pair of obj.entries ?? []) {
+                if (!Array.isArray(pair) || pair.length !== 2) continue;
+                result.set(resolve(pair[0]), resolve(pair[1]));
+            }
+            return result;
+        }
+
+        if (obj['@type'] === 'Set') {
+            for (const value of obj.values ?? []) {
+                result.add(resolve(value));
+            }
+            return result;
+        }
+
+        for (const key in obj) {
+            if (key === '@id' || key === '@type') continue;
+            result[key] = resolve(obj[key]);
+        }
+
+        return result;
+    }
+
+    findIds(jsog);
+    return resolve(jsog);
+}
+
+
+export { decodeJSOG }

package/__tests__/jsog/get-mats1.ts

@@ -0,0 +1,41 @@
+import type { Mat } from "../../src/mat/mat.js";
+import { findMats } from "../../src/find-mat/find-mats.js";
+
+
+/** mat-demo: "achispado" font, "comma" glyph */
+const loops1 = [
+    [
+        [[139, 8], [82, -101]],
+        [[82, -101], [24, 8]],
+        [[24, 8], [46, 8]],
+        [[46, 8], [46, 54]],
+        [[46, 54], [117, 54]],
+        [[117, 54], [117, 8]],
+        [[117, 8], [139, 8]],
+        [[139, 8], [139, 8]]
+    ]
+];
+
+
+// Cache
+let mats1: Mat[] | undefined = undefined;
+function getMats1() {
+    if (mats1) { return mats1; }
+
+    mats1 = findMats(loops1, {
+        applySat: false,
+        simplify: true,
+        satScale: 1.675,
+        maxCurviness: 0.05,
+        maxLength: 40,
+        // maxCurviness: 5,
+        // maxLength: 4000,
+        angleIncrement: 15,
+        simplifyTolerance: 2**-1
+    });
+
+    return mats1;
+}
+
+
+export { getMats1 }