@calcit/ternary-tree 0.0.23 → 0.0.25

package/lib/test-map.mjs

@@ -1,215 +1,208 @@
 import { hashGenerator } from "./types.mjs";
 import { cmp, deepEqual } from "./utils.mjs";
-import { test, check, justDisplay } from "./test-utils.mjs";
+import { describe, test, check, justDisplay } from "./test-utils.mjs";
 import { initTernaryTreeMap, initTernaryTreeMapFromArray, toHashSortedPairs, merge, mergeSkip, formatMapInline, assocMap, dissocMap, contains, toPairs, initEmptyTernaryTreeMap, sameMapShape, checkMapStructure, mapLen, mapEqual, toKeys, toPairsArray, mapMapValues, mapGetDefault, } from "./map.mjs";
 export let runMapTests = () => {
-    test("init map", () => {
-        var dict = new Map();
-        var inList = [];
-        for (let idx = 0; idx < 10; idx++) {
-            dict.set(`${idx}`, idx + 10);
-            inList.push([`${idx}`, idx + 10]);
-        }
-        // TODO
-        inList.sort((x, y) => {
-            let hx = hashGenerator(x[0]);
-            let hy = hashGenerator(y[0]);
-            return cmp(hx, hy);
+    describe("TernaryTreeMap Tests", () => {
+        test("should initialize map correctly", () => {
+            var dict = new Map();
+            var inList = [];
+            for (let idx = 0; idx < 10; idx++) {
+                dict.set(`${idx}`, idx + 10);
+                inList.push([`${idx}`, idx + 10]);
+            }
+            inList.sort((x, y) => {
+                let hx = hashGenerator(x[0]);
+                let hy = hashGenerator(y[0]);
+                return cmp(hx, hy);
+            });
+            let data10 = initTernaryTreeMap(dict);
+            let data11 = initTernaryTreeMapFromArray(inList);
+            check(checkMapStructure(data10));
+            check(checkMapStructure(data11));
+            justDisplay(formatMapInline(data10, true), " ((0:10 1:11 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19))");
+            check(deepEqual(toHashSortedPairs(data10), inList));
+            check(deepEqual(toHashSortedPairs(data11), inList));
+            check(contains(data10, "1") === true);
+            check(contains(data10, "11") === false);
+            check(deepEqual(mapGetDefault(data10, "1", null), 11));
+            check(deepEqual(mapGetDefault(data10, "111", 0), 0));
+            let emptyData = new Map();
+            check(mapEqual(initEmptyTernaryTreeMap(), initTernaryTreeMap(emptyData)));
+        });
+        test("should handle assoc and contains correctly", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 100; idx++) {
+                dict.set(`${idx * 2}`, idx);
+            }
+            let data = initTernaryTreeMap(dict);
+            for (let idx = 0; idx < 100; idx++) {
+                dict.set(`${idx * 2 + 1}`, idx);
+                let data2 = assocMap(data, `${idx * 2 + 1}`, idx);
+                check(contains(data2, `${idx * 2 + 1}`));
+            }
+            var dict2 = new Map();
+            data = initTernaryTreeMap(dict2);
+            for (let idx = 0; idx < 1000; idx++) {
+                let p = 100 - idx / 10;
+                data = assocMap(data, `${p}`, idx);
+                check(contains(data, `${p}`));
+            }
+        });
+        test("should maintain structure integrity", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 100; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            check(checkMapStructure(data));
+        });
+        test("should handle map association correctly", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 10; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            check(contains(data, "1") === true);
+            check(contains(data, "12") === false);
+            check(checkMapStructure(data));
+            justDisplay(formatMapInline(assocMap(data, "1", 2222), true), "((0:10 1:2222 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19))");
+            justDisplay(formatMapInline(assocMap(data, "23", 2222), true), "(((0:10 1:11 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19)) 23:2222 _)");
+        });
+        test("should handle dissociation correctly", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 10; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            check(checkMapStructure(data));
+            for (let idx = 0; idx < 10; idx++) {
+                let v = dissocMap(data, `${idx}`);
+                check(contains(v, `${idx}`) === false);
+                check(contains(data, `${idx}`) === true);
+                check(mapLen(v) === mapLen(data) - 1);
+            }
+            for (let idx = 10; idx < 12; idx++) {
+                let v = dissocMap(data, `${idx}`);
+                check(contains(v, `${idx}`) === false);
+                check(mapLen(v) === mapLen(data));
+            }
+        });
+        test("should convert to array correctly", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 10; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            check(checkMapStructure(data));
+            justDisplay([...toKeys(data)], ["2", "3", "7", "9", "6", "5", "1", "8", "0", "4"]);
+            check(deepEqual(toPairsArray(data), [...toPairs(data)]));
+        });
+        test("should check equality correctly", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 10; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            let b = dissocMap(data, "3");
+            check(checkMapStructure(data));
+            check(checkMapStructure(b));
+            check(mapEqual(data, data));
+            check(!mapEqual(data, b));
+            let c = assocMap(data, "3", 15);
+            check(sameMapShape(data, data));
+            check(sameMapShape(data, b) === false);
+            check(sameMapShape(data, c) === false);
+            let d = assocMap(c, "3", 13);
+            check(mapEqual(data, d));
+            check(data !== d); // not identical
+        });
+        test("should merge maps correctly", () => {
+            var dict = new Map();
+            var dictBoth = new Map();
+            for (let idx = 0; idx < 4; idx++) {
+                dict.set(`${idx}`, idx + 10);
+                dictBoth.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            check(checkMapStructure(data));
+            var dictB = new Map();
+            for (let idx = 10; idx < 14; idx++) {
+                dictB.set(`${idx}`, idx + 23);
+                dictBoth.set(`${idx}`, idx + 23);
+            }
+            let b = initTernaryTreeMap(dictB);
+            let merged = merge(data, b);
+            let both = initTernaryTreeMap(dictBoth);
+            check(mapEqual(merged, both));
+        });
+        test("should merge with skip correctly", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 4; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let a = initTernaryTreeMap(dict);
+            check(checkMapStructure(a));
+            var dict2 = new Map();
+            for (let idx = 0; idx < 4; idx++) {
+                dict2.set(`${idx}`, idx + 11);
+            }
+            let b = initTernaryTreeMap(dict2);
+            check(checkMapStructure(b));
+            let c = mergeSkip(a, b, 11);
+            check(deepEqual(mapGetDefault(c, "0", null), 10));
+            check(deepEqual(mapGetDefault(c, "1", null), 12));
+            check(deepEqual(mapGetDefault(c, "2", null), 13));
+            check(deepEqual(mapGetDefault(c, "3", null), 14));
+        });
+        test("should handle iteration correctly", () => {
+            var dict = new Map();
+            var dictBoth = new Map();
+            for (let idx = 0; idx < 4; idx++) {
+                dict.set(`${idx}`, idx + 10);
+                dictBoth.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            check(checkMapStructure(data));
+            var count = 0;
+            for (let [k, v] of toPairs(data)) {
+                count = count + 1;
+            }
+            check(count === 4);
+            count = 0;
+            for (let key of toPairs(data)) {
+                count = count + 1;
+            }
+            check(count === 4);
+        });
+        test("should iterate through large maps", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 100; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            check(checkMapStructure(data));
+            var count = 0;
+            for (let [k, v] of toPairs(data)) {
+                count = count + 1;
+            }
+            check(count === 100);
+        });
+        test("should map values correctly", () => {
+            var dict = new Map();
+            for (let idx = 0; idx < 4; idx++) {
+                dict.set(`${idx}`, idx + 10);
+            }
+            let data = initTernaryTreeMap(dict);
+            var dict2 = new Map();
+            for (let idx = 0; idx < 4; idx++) {
+                dict2.set(`${idx}`, idx + 20);
+            }
+            let data2 = initTernaryTreeMap(dict2);
+            let data3 = mapMapValues(data, (x) => x + 10);
+            check(checkMapStructure(data3));
+            check(mapEqual(data2, data3));
+            check(formatMapInline(data2) === formatMapInline(data3));
         });
-        let data10 = initTernaryTreeMap(dict);
-        let data11 = initTernaryTreeMapFromArray(inList);
-        checkMapStructure(data10);
-        checkMapStructure(data11);
-        // echo data10
-        justDisplay(formatMapInline(data10, true), " ((0:10 1:11 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19))");
-        check(deepEqual(toHashSortedPairs(data10), inList));
-        check(deepEqual(toHashSortedPairs(data11), inList));
-        check(contains(data10, "1") === true);
-        check(contains(data10, "11") === false);
-        check(deepEqual(mapGetDefault(data10, "1", null), 11));
-        check(deepEqual(mapGetDefault(data10, "111", 0), 0));
-        // check(deepEqual(mapGetDefault(data10, "11", {} as any), null)); // should throws error
-        let emptyData = new Map();
-        check(mapEqual(initEmptyTernaryTreeMap(), initTernaryTreeMap(emptyData)));
-    });
-    test("assoc and contains", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 100; idx++) {
-            dict.set(`${idx * 2}`, idx);
-        }
-        let data = initTernaryTreeMap(dict);
-        for (let idx = 0; idx < 100; idx++) {
-            dict.set(`${idx * 2 + 1}`, idx);
-            let data2 = assocMap(data, `${idx * 2 + 1}`, idx);
-            check(contains(data2, `${idx * 2 + 1}`));
-        }
-        var dict = new Map();
-        data = initTernaryTreeMap(dict);
-        for (let idx = 0; idx < 1000; idx++) {
-            let p = 100 - idx / 10;
-            data = assocMap(data, `${p}`, idx);
-            check(contains(data, `${p}`));
-        }
-    });
-    test("check structure", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 100; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        check(checkMapStructure(data));
-    });
-    test("assoc map", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 10; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        // echo data.formatInline
-        check(contains(data, "1") === true);
-        check(contains(data, "12") === false);
-        checkMapStructure(data);
-        justDisplay(formatMapInline(assocMap(data, "1", 2222), true), "((0:10 1:2222 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19))");
-        justDisplay(formatMapInline(assocMap(data, "23", 2222), true), "(((0:10 1:11 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19)) 23:2222 _)");
-    });
-    test("dissoc", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 10; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        checkMapStructure(data);
-        // echo data.formatInline
-        for (let idx = 0; idx < 10; idx++) {
-            let v = dissocMap(data, `${idx}`);
-            check(contains(v, `${idx}`) === false);
-            check(contains(data, `${idx}`) === true);
-            check(mapLen(v) === mapLen(data) - 1);
-        }
-        for (let idx = 10; idx < 12; idx++) {
-            let v = dissocMap(data, `${idx}`);
-            check(contains(v, `${idx}`) === false);
-            check(mapLen(v) === mapLen(data));
-        }
-    });
-    test("to array", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 10; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        checkMapStructure(data);
-        // TODO
-        // justDisplay((mapToString(toPairs(data))) , "@[2:12, 3:13, 7:17, 9:19, 6:16, 5:15, 1:11, 8:18, 0:10, 4:14]")
-        justDisplay([...toKeys(data)], ["2", "3", "7", "9", "6", "5", "1", "8", "0", "4"]);
-        check(deepEqual(toPairsArray(data), [...toPairs(data)]));
-    });
-    test("Equality", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 10; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        let b = dissocMap(data, "3");
-        checkMapStructure(data);
-        checkMapStructure(b);
-        check(mapEqual(data, data));
-        check(!mapEqual(data, b));
-        let c = assocMap(data, "3", 15);
-        check(sameMapShape(data, data));
-        check(sameMapShape(data, b) === false);
-        check(sameMapShape(data, c) === false);
-        let d = assocMap(c, "3", 13);
-        check(mapEqual(data, d));
-        check(data !== d); // not identical
-    });
-    test("Merge", () => {
-        var dict = new Map();
-        var dictBoth = new Map();
-        for (let idx = 0; idx < 4; idx++) {
-            dict.set(`${idx}`, idx + 10);
-            dictBoth.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        checkMapStructure(data);
-        var dictB = new Map();
-        for (let idx = 10; idx < 14; idx++) {
-            dictB.set(`${idx}`, idx + 23);
-            dictBoth.set(`${idx}`, idx + 23);
-        }
-        let b = initTernaryTreeMap(dictB);
-        let merged = merge(data, b);
-        let both = initTernaryTreeMap(dictBoth);
-        check(mapEqual(merged, both));
-    });
-    test("Merge skip", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 4; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let a = initTernaryTreeMap(dict);
-        checkMapStructure(a);
-        var dict2 = new Map();
-        for (let idx = 0; idx < 4; idx++) {
-            dict2.set(`${idx}`, idx + 11);
-        }
-        let b = initTernaryTreeMap(dict2);
-        checkMapStructure(b);
-        let c = mergeSkip(a, b, 11);
-        check(deepEqual(mapGetDefault(c, "0", null), 10));
-        check(deepEqual(mapGetDefault(c, "1", null), 12));
-        check(deepEqual(mapGetDefault(c, "2", null), 13));
-        check(deepEqual(mapGetDefault(c, "3", null), 14));
-    });
-    test("iterator", () => {
-        var dict = new Map();
-        var dictBoth = new Map();
-        for (let idx = 0; idx < 4; idx++) {
-            dict.set(`${idx}`, idx + 10);
-            dictBoth.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        checkMapStructure(data);
-        var i = 0;
-        for (let [k, v] of toPairs(data)) {
-            i = i + 1;
-        }
-        check(i === 4);
-        i = 0;
-        for (let key of toPairs(data)) {
-            i = i + 1;
-        }
-        check(i === 4);
-    });
-    test("each map", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 100; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        checkMapStructure(data);
-        var i = 0;
-        for (let [k, v] of toPairs(data)) {
-            // echo "..{k}-{v}.."
-            i = i + 1;
-        }
-        check(i === 100);
-    });
-    test("map values", () => {
-        var dict = new Map();
-        for (let idx = 0; idx < 4; idx++) {
-            dict.set(`${idx}`, idx + 10);
-        }
-        let data = initTernaryTreeMap(dict);
-        var dict2 = new Map();
-        for (let idx = 0; idx < 4; idx++) {
-            dict2.set(`${idx}`, idx + 20);
-        }
-        let data2 = initTernaryTreeMap(dict2);
-        let data3 = mapMapValues(data, (x) => x + 10);
-        checkMapStructure(data3);
-        checkMapStructure(data3);
-        check(mapEqual(data2, data3));
-        check(formatMapInline(data2) === formatMapInline(data3));
     });
 };

package/lib/test-utils.d.mts

@@ -1,6 +1,10 @@
-export declare let test: (name: string, cb: () => void) => void;
-export declare let check: (x: boolean) => void;
-/** compare by reference */
-export declare let checkEqual: (x: any, y: any) => void;
+export declare function describe(suiteName: string, cb: () => void): void;
+export declare function test(testName: string, cb: () => void): void;
+export declare function check(condition: boolean, message?: string): void;
+export declare function checkEqual<T>(actual: T, expected: T, message?: string): void;
+export declare function checkDeepEqual<T>(actual: T, expected: T, message?: string): void;
+export declare function checkThrows(fn: () => void, message?: string): void;
 export declare function arrayEqual<T>(xs: Array<T>, ys: Array<T>): boolean;
-export declare let justDisplay: (x: any, y: any) => void;
+export declare function checkArrayEqual<T>(actual: Array<T>, expected: Array<T>, message?: string): void;
+export declare function justDisplay(x: any, y: any): void;
+export declare function printTestSummary(): void;

package/lib/test-utils.mjs

@@ -1,23 +1,87 @@
-export let test = (name, cb) => {
-    let target = process === null || process === void 0 ? void 0 : process.env["target"];
-    if (target == null || name.includes(target)) {
-        console.log("Test:", name);
+const stats = { total: 0, passed: 0, failed: 0, suites: 0 };
+const suites = [];
+let currentSuite = null;
+const colors = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+};
+export function describe(suiteName, cb) {
+    const target = process === null || process === void 0 ? void 0 : process.env["target"];
+    if (target != null && !suiteName.includes(target)) {
+        return;
+    }
+    console.log(`\n${colors.cyan}${colors.bright}○ ${suiteName}${colors.reset}`);
+    const suite = { name: suiteName, tests: [] };
+    suites.push(suite);
+    currentSuite = suite;
+    stats.suites++;
+    try {
         cb();
     }
-};
-export let check = (x) => {
-    if (!x) {
-        throw new Error("Test failed");
+    catch (error) {
+        console.log(`${colors.red}Suite "${suiteName}" failed to execute: ${error}${colors.reset}`);
     }
-};
-/** compare by reference */
-export let checkEqual = (x, y) => {
-    if (x !== y) {
-        console.log("Left:  ", x);
-        console.log("Right: ", y);
-        throw new Error("Test failed");
+    currentSuite = null;
+}
+export function test(testName, cb) {
+    const target = process === null || process === void 0 ? void 0 : process.env["target"];
+    if (target != null && !testName.includes(target)) {
+        return;
     }
-};
+    const testCase = { name: testName, passed: false };
+    if (currentSuite) {
+        currentSuite.tests.push(testCase);
+    }
+    stats.total++;
+    const startTime = Date.now();
+    try {
+        cb();
+        testCase.passed = true;
+        testCase.duration = Date.now() - startTime;
+        stats.passed++;
+        console.log(`  ${colors.green}✓${colors.reset} ${testName} ${colors.cyan}(${testCase.duration}ms)${colors.reset}`);
+    }
+    catch (error) {
+        testCase.passed = false;
+        testCase.error = error;
+        testCase.duration = Date.now() - startTime;
+        stats.failed++;
+        console.log(`  ${colors.red}✗${colors.reset} ${testName} ${colors.cyan}(${testCase.duration}ms)${colors.reset}`);
+        console.log(`    ${colors.red}${error.message}${colors.reset}`);
+    }
+}
+export function check(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}
+export function checkEqual(actual, expected, message) {
+    if (actual !== expected) {
+        const errorMessage = message || `Expected ${expected}, but got ${actual}`;
+        throw new Error(errorMessage);
+    }
+}
+export function checkDeepEqual(actual, expected, message) {
+    if (!deepEqual(actual, expected)) {
+        const errorMessage = message || `Deep equality check failed:\nActual: ${JSON.stringify(actual)}\nExpected: ${JSON.stringify(expected)}`;
+        throw new Error(errorMessage);
+    }
+}
+export function checkThrows(fn, message) {
+    try {
+        fn();
+        throw new Error(message || "Expected function to throw, but it didn't");
+    }
+    catch (error) {
+        // Success - function threw as expected
+    }
+}
 export function arrayEqual(xs, ys) {
     if (xs.length != ys.length) {
         return false;
@@ -29,9 +93,58 @@ export function arrayEqual(xs, ys) {
     }
     return true;
 }
-export let justDisplay = (x, y) => {
+export function checkArrayEqual(actual, expected, message) {
+    if (!arrayEqual(actual, expected)) {
+        const errorMessage = message || `Arrays are not equal:\nActual: [${actual.join(", ")}]\nExpected: [${expected.join(", ")}]`;
+        throw new Error(errorMessage);
+    }
+}
+export function justDisplay(x, y) {
     console.group("Compare:");
     console.log(x);
     console.log(y);
     console.groupEnd();
-};
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    if (typeof a === "object" && typeof b === "object") {
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (!keysB.includes(key) || !deepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+export function printTestSummary() {
+    console.log(`\n${colors.bright}Test Summary:${colors.reset}`);
+    console.log(`${colors.cyan}Suites: ${stats.suites}${colors.reset}`);
+    console.log(`${colors.cyan}Tests:  ${stats.total}${colors.reset}`);
+    console.log(`${colors.green}Passed: ${stats.passed}${colors.reset}`);
+    if (stats.failed > 0) {
+        console.log(`${colors.red}Failed: ${stats.failed}${colors.reset}`);
+        console.log(`\n${colors.red}${colors.bright}❌ ${stats.failed} test(s) failed${colors.reset}`);
+        process.exit(1);
+    }
+    else {
+        console.log(`\n${colors.green}${colors.bright}✅ All tests passed!${colors.reset}`);
+    }
+}

package/lib/{main.mjs → test.mjs}

@@ -4,6 +4,9 @@ import "./test-map.mjs";
 import { runListTests } from "./test-list.mjs";
 import { runMapTests } from "./test-map.mjs";
 import { mergeValueHash, overwriteHashGenerator, valueHash } from "./types.mjs";
+import { printTestSummary } from "./test-utils.mjs";
+// import { disableListStructureCheck } from "./list.mjs";
+// disableListStructureCheck();
 overwriteComparator((x, y) => {
     // console.log("comparing", x, y);
     return deepEqual(x, y);
@@ -13,5 +16,7 @@ overwriteHashGenerator((x) => {
     // console.log("hashing", x, ret);
     return ret;
 });
+console.log("🧪 Running TernaryTree Tests...\n");
 runListTests();
 runMapTests();
+printTestSummary();

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "@calcit/ternary-tree",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "main": "./lib/index.mjs",
-  "scripts": {},
+  "scripts": {
+    "build": "tsc",
+    "test": "yarn build && node lib/test.mjs",
+    "test:watch": "yarn build && node lib/test.mjs",
+    "test:list": "TARGET=list yarn test",
+    "test:map": "TARGET=map yarn test",
+    "test:list-perf": "yarn build && node lib/test-list-perf.mjs",
+    "test:list-detailed-perf": "yarn build && node lib/test-list-detailed-perf.mjs"
+  },
   "devDependencies": {
-    "@types/node": "^20.4.8",
-    "prettier": "^3.0.0",
-    "typescript": "^5.1.6"
+    "@types/node": "^20.12.5",
+    "prettier": "^3.2.5",
+    "typescript": "^5.4.4"
   }
 }