@calcit/ternary-tree 0.0.25 → 0.0.26

package/.yarnrc.yml

@@ -0,0 +1,6 @@
+approvedGitRepositories:
+  - "**"
+
+enableScripts: true
+
+nodeLinker: node-modules

package/lib/bench.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Micro-benchmark for ts-ternary-tree hot paths.
+ *
+ * Usage:
+ *   yarn bench
+ *
+ * Each bench() call runs the task for ~1 second and reports ops/sec.
+ * A higher number is better. Compare before/after code changes to judge
+ * whether an optimisation has real impact.
+ */
+export {};

package/lib/bench.mjs

@@ -0,0 +1,99 @@
+/**
+ * Micro-benchmark for ts-ternary-tree hot paths.
+ *
+ * Usage:
+ *   yarn bench
+ *
+ * Each bench() call runs the task for ~1 second and reports ops/sec.
+ * A higher number is better. Compare before/after code changes to judge
+ * whether an optimisation has real impact.
+ */
+import { initTernaryTreeList, listGet, assocList, dissocList, listToItems, concat, } from "./list.mjs";
+import { initTernaryTreeMapFromArray, assocMap, dissocMap, mapGetDefault, } from "./map.mjs";
+import { deepEqual, overwriteComparator } from "./utils.mjs";
+import { mergeValueHash, overwriteHashGenerator, valueHash } from "./types.mjs";
+overwriteComparator(deepEqual);
+overwriteHashGenerator((x) => mergeValueHash(10, valueHash(x)));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function bench(label, fn, durationMs = 1000) {
+    // Warmup
+    for (let i = 0; i < 100; i++)
+        fn();
+    let ops = 0;
+    const start = Date.now();
+    while (Date.now() - start < durationMs) {
+        fn();
+        ops++;
+    }
+    const elapsed = Date.now() - start;
+    const opsPerSec = Math.round((ops / elapsed) * 1000);
+    console.log(`  ${label.padEnd(40)} ${opsPerSec.toLocaleString()} ops/sec`);
+}
+function section(title) {
+    console.log(`\n--- ${title} ---`);
+}
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+const SIZE_SMALL = 100;
+const SIZE_MEDIUM = 1000;
+const SIZE_LARGE = 10000;
+const arrSmall = Array.from({ length: SIZE_SMALL }, (_, i) => i);
+const arrMedium = Array.from({ length: SIZE_MEDIUM }, (_, i) => i);
+const arrLarge = Array.from({ length: SIZE_LARGE }, (_, i) => i);
+const listSmall = initTernaryTreeList(arrSmall);
+const listMedium = initTernaryTreeList(arrMedium);
+const listLarge = initTernaryTreeList(arrLarge);
+const mapMediumPairs = arrMedium.map((i) => [`k${i}`, i]);
+const mapMedium = initTernaryTreeMapFromArray(mapMediumPairs);
+// ---------------------------------------------------------------------------
+// List benchmarks
+// ---------------------------------------------------------------------------
+section("listGet (random access)");
+bench("listGet small  (n=100)   middle idx", () => listGet(listSmall, 50));
+bench("listGet medium (n=1k)   middle idx", () => listGet(listMedium, 500));
+bench("listGet large  (n=10k)  middle idx", () => listGet(listLarge, 5000));
+section("listToItems (full iteration)");
+bench("listToItems small  (n=100)", () => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const _ of listToItems(listSmall)) { /* consume */ }
+});
+bench("listToItems medium (n=1k)", () => {
+    for (const _ of listToItems(listMedium)) { /* consume */ }
+});
+bench("listToItems large  (n=10k)", () => {
+    for (const _ of listToItems(listLarge)) { /* consume */ }
+});
+section("assocList (element update)");
+bench("assocList small  (n=100)  idx=50", () => assocList(listSmall, 50, 999));
+bench("assocList medium (n=1k)   idx=500", () => assocList(listMedium, 500, 999));
+bench("assocList large  (n=10k)  idx=5000", () => assocList(listLarge, 5000, 999));
+section("dissocList (element remove)");
+bench("dissocList small  (n=100)  idx=50", () => dissocList(listSmall, 50));
+bench("dissocList medium (n=1k)   idx=500", () => dissocList(listMedium, 500));
+bench("dissocList large  (n=10k)  idx=5000", () => dissocList(listLarge, 5000));
+section("initTernaryTreeList (construction)");
+bench("init list small  (n=100)", () => initTernaryTreeList(arrSmall));
+bench("init list medium (n=1k)", () => initTernaryTreeList(arrMedium));
+bench("init list large  (n=10k)", () => initTernaryTreeList(arrLarge));
+section("concat");
+const half1 = initTernaryTreeList(arrMedium.slice(0, 500));
+const half2 = initTernaryTreeList(arrMedium.slice(500));
+bench("concat two halves (n=500 each)", () => concat(half1, half2));
+// ---------------------------------------------------------------------------
+// Map benchmarks
+// ---------------------------------------------------------------------------
+section("assocMap (key update/insert)");
+bench("assocMap medium (n=1k) existing key", () => assocMap(mapMedium, "k500", 9999));
+bench("assocMap medium (n=1k) new key", () => assocMap(mapMedium, "new-key", 9999));
+section("dissocMap (key remove)");
+bench("dissocMap medium (n=1k)", () => dissocMap(mapMedium, "k500"));
+section("mapGetDefault (lookup)");
+bench("mapGetDefault medium (n=1k) hit", () => mapGetDefault(mapMedium, "k500", -1));
+bench("mapGetDefault medium (n=1k) miss", () => mapGetDefault(mapMedium, "no-such-key", -1));
+section("initTernaryTreeMap (construction)");
+bench("init map small  (n=100)", () => initTernaryTreeMapFromArray(mapMediumPairs.slice(0, 100)));
+bench("init map medium (n=1k)", () => initTernaryTreeMapFromArray(mapMediumPairs));
+console.log("\nDone.");

package/lib/list.d.mts

@@ -1,4 +1,5 @@
 import { TernaryTreeList } from "./types.mjs";
+export declare function enableStructureCheck(enabled?: boolean): void;
 export declare function getDepth<T>(tree: TernaryTreeList<T>): number;
 export declare function makeTernaryTreeList<T>(size: number, offset: number, xs: Array<TernaryTreeList<T>>): TernaryTreeList<T>;
 export declare function initTernaryTreeList<T>(xs: Array<T>): TernaryTreeList<T>;

package/lib/list.mjs

@@ -1,5 +1,11 @@
 import { TernaryTreeKind } from "./types.mjs";
-import { dataEqual, divideTernarySizes, roughIntPow } from "./utils.mjs";
+import { dataEqual, roughIntPow } from "./utils.mjs";
+// When false (default), internal structure checks are skipped for performance.
+// Set to true in development/testing to catch structural bugs early.
+let _devMode = false;
+export function enableStructureCheck(enabled = true) {
+    _devMode = enabled;
+}
 // just get, will not compute recursively
 export function getDepth(tree) {
     if (tree == null)
@@ -18,16 +24,18 @@ let isEmptyBranch = (x) => {
     }
     return x.size == 0;
 };
-function decideParentDepth(...xs) {
-    let depth = 0;
-    for (let i = 0; i < xs.length; i++) {
-        let x = xs[i];
-        let y = getDepth(x);
-        if (y > depth) {
-            depth = y;
-        }
-    }
-    return depth + 1;
+// Explicit 2/3-arg versions avoid rest-parameter array allocation on every call.
+// Inlining getDepth avoids indirect function calls in V8's lower JIT tiers.
+function decideParentDepth(a, b, c) {
+    let da = a == null ? 0 : a.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : a.depth;
+    let db = b == null ? 0 : b.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : b.depth;
+    let d = da > db ? da : db;
+    if (c != null) {
+        let dc = c.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : c.depth;
+        if (dc > d)
+            d = dc;
+    }
+    return d + 1;
 }
 export function makeTernaryTreeList(size, offset, xs) {
     switch (size) {
@@ -47,7 +55,8 @@ export function makeTernaryTreeList(size, offset, xs) {
                 right: emptyBranch,
                 depth: decideParentDepth(left, middle),
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         case 3: {
@@ -62,14 +71,20 @@ export function makeTernaryTreeList(size, offset, xs) {
                 right: right,
                 depth: decideParentDepth(left, middle, right),
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         default: {
-            let divided = divideTernarySizes(size);
-            let left = makeTernaryTreeList(divided.left, offset, xs);
-            let middle = makeTernaryTreeList(divided.middle, offset + divided.left, xs);
-            let right = makeTernaryTreeList(divided.right, offset + divided.left + divided.middle, xs);
+            // Inline divideTernarySizes to avoid heap object allocation per recursive call
+            let extra = size % 3;
+            let groupSize = (size / 3) | 0;
+            let leftSize = groupSize + (extra === 2 ? 1 : 0);
+            let middleSize = groupSize + (extra === 1 ? 1 : 0);
+            let rightSize = groupSize + (extra === 2 ? 1 : 0);
+            let left = makeTernaryTreeList(leftSize, offset, xs);
+            let middle = makeTernaryTreeList(middleSize, offset + leftSize, xs);
+            let right = makeTernaryTreeList(rightSize, offset + leftSize + middleSize, xs);
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: left.size + middle.size + right.size,
@@ -78,7 +93,8 @@ export function makeTernaryTreeList(size, offset, xs) {
                 middle: middle,
                 right: right,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
@@ -134,34 +150,26 @@ export function formatListInline(tree) {
     }
 }
 export function* listToItems(tree) {
-    if (tree != null) {
-        switch (tree.kind) {
-            case TernaryTreeKind.ternaryTreeLeaf: {
-                yield tree.value;
-                break;
-            }
-            case TernaryTreeKind.ternaryTreeBranch: {
-                // Cache children to avoid repeated property access
-                const left = tree.left;
-                const middle = tree.middle;
-                const right = tree.right;
-                if (left != null) {
-                    for (let x of listToItems(left)) {
-                        yield x;
-                    }
-                }
-                if (middle != null) {
-                    for (let x of listToItems(middle)) {
-                        yield x;
-                    }
-                }
-                if (right != null) {
-                    for (let x of listToItems(right)) {
-                        yield x;
-                    }
-                }
-                break;
-            }
+    if (tree == null)
+        return;
+    // Iterative pre-order traversal using an explicit stack — avoids
+    // O(n) nested generator delegation overhead of the recursive version.
+    let stack = [tree];
+    while (stack.length > 0) {
+        let node = stack.pop();
+        if (node == null || node.size === 0)
+            continue;
+        if (node.kind === TernaryTreeKind.ternaryTreeLeaf) {
+            yield node.value;
+        }
+        else {
+            // Push right first so left is popped (processed) first (LIFO order).
+            if (node.right != null && node.right.size > 0)
+                stack.push(node.right);
+            if (node.middle != null && node.middle.size > 0)
+                stack.push(node.middle);
+            if (node.left != null && node.left.size > 0)
+                stack.push(node.left);
         }
     }
 }
@@ -307,7 +315,7 @@ export function listGet(originalTree, originalIdx) {
         const leftSize = left == null ? 0 : left.size;
         const middleSize = middle == null ? 0 : middle.size;
         const rightSize = right == null ? 0 : right.size;
-        if (leftSize + middleSize + rightSize !== tree.size) {
+        if (_devMode && leftSize + middleSize + rightSize !== tree.size) {
             throw new Error("tree.size does not match sum case branch sizes");
         }
         if (idx <= leftSize - 1) {
@@ -362,7 +370,7 @@ export function assocList(tree, idx, item) {
     const leftSize = left == null ? 0 : left.size;
     const middleSize = middle == null ? 0 : middle.size;
     const rightSize = right == null ? 0 : right.size;
-    if (leftSize + middleSize + rightSize !== tree.size)
+    if (_devMode && leftSize + middleSize + rightSize !== tree.size)
         throw new Error("tree.size does not match sum case branch sizes");
     if (idx <= leftSize - 1) {
         let changedBranch = assocList(left, idx, item);
@@ -374,7 +382,8 @@ export function assocList(tree, idx, item) {
             middle: middle,
             right: right,
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
     else if (idx <= leftSize + middleSize - 1) {
@@ -387,7 +396,8 @@ export function assocList(tree, idx, item) {
             middle: changedBranch,
             right: right,
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
     else {
@@ -400,7 +410,8 @@ export function assocList(tree, idx, item) {
             middle: middle,
             right: changedBranch,
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
 }
@@ -430,7 +441,7 @@ export function dissocList(tree, idx) {
     const leftSize = left == null ? 0 : left.size;
     const middleSize = middle == null ? 0 : middle.size;
     const rightSize = right == null ? 0 : right.size;
-    if (leftSize + middleSize + rightSize !== tree.size) {
+    if (_devMode && leftSize + middleSize + rightSize !== tree.size) {
         throw new Error("tree.size does not match sum from branch sizes");
     }
     let result = emptyBranch;
@@ -463,7 +474,7 @@ export function dissocList(tree, idx) {
             result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 size: tree.size - 1,
-                depth: decideParentDepth(left, changedBranch, right),
+                depth: decideParentDepth(left, right, emptyBranch),
                 left: left,
                 middle: right,
                 right: emptyBranch,
@@ -497,7 +508,8 @@ export function dissocList(tree, idx) {
     if (result.middle == null) {
         return result.left;
     }
-    checkListStructure(result);
+    if (_devMode)
+        checkListStructure(result);
     return result;
 }
 export function rest(tree) {
@@ -535,7 +547,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         else {
@@ -547,11 +560,13 @@ export function insert(tree, idx, item, after = false) {
                 middle: tree,
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
-    checkListStructure(tree);
+    if (_devMode)
+        checkListStructure(tree);
     if (listLen(tree) === 1) {
         if (after) {
             // in compact mode, values placed at left
@@ -563,7 +578,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
         else {
@@ -575,7 +591,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: tree.left,
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
@@ -590,7 +607,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                     right: tree.middle,
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             if (idx === 1) {
@@ -602,7 +620,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: tree.middle,
                     right: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             else {
@@ -619,7 +638,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: tree.left,
                     right: tree.middle,
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             else if (idx === 1) {
@@ -631,7 +651,8 @@ export function insert(tree, idx, item, after = false) {
                     middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                     right: tree.middle,
                 };
-                checkListStructure(result);
+                if (_devMode)
+                    checkListStructure(result);
                 return result;
             }
             else {
@@ -646,7 +667,7 @@ export function insert(tree, idx, item, after = false) {
     const leftSize = left == null ? 0 : left.size;
     const middleSize = middle == null ? 0 : middle.size;
     const rightSize = right == null ? 0 : right.size;
-    if (leftSize + middleSize + rightSize !== tree.size) {
+    if (_devMode && leftSize + middleSize + rightSize !== tree.size) {
         throw new Error("tree.size does not match sum case branch sizes");
     }
     // echo "picking: ", idx, " ", leftSize, " ", middleSize, " ", rightSize
@@ -660,7 +681,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: tree,
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
@@ -674,7 +696,8 @@ export function insert(tree, idx, item, after = false) {
                 middle: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
                 right: emptyBranch,
             };
-            checkListStructure(result);
+            if (_devMode)
+                checkListStructure(result);
             return result;
         }
     }
@@ -687,10 +710,11 @@ export function insert(tree, idx, item, after = false) {
             middle: tree.middle,
             right: { kind: TernaryTreeKind.ternaryTreeLeaf, size: 1, value: item },
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
-    if (!after && idx === 0 && rightSize === 0 && middleSize >= rightSize) {
+    if (!after && idx === 0 && rightSize === 0 && middleSize >= leftSize) {
         let result = {
             kind: TernaryTreeKind.ternaryTreeBranch,
             size: tree.size + 1,
@@ -699,7 +723,8 @@ export function insert(tree, idx, item, after = false) {
             middle: left,
             right: middle,
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
     if (idx <= leftSize - 1) {
@@ -712,7 +737,8 @@ export function insert(tree, idx, item, after = false) {
             middle: middle,
             right: right,
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
     else if (idx <= leftSize + middleSize - 1) {
@@ -725,7 +751,8 @@ export function insert(tree, idx, item, after = false) {
             middle: changedBranch,
             right: right,
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
     else {
@@ -738,7 +765,8 @@ export function insert(tree, idx, item, after = false) {
             middle: middle,
             right: changedBranch,
         };
-        checkListStructure(result);
+        if (_devMode)
+            checkListStructure(result);
         return result;
     }
 }
@@ -806,7 +834,8 @@ export function concat(...xsGroups) {
     }
     let result = makeTernaryTreeList(xsGroups.length, 0, xsGroups);
     maybeReblance(result);
-    checkListStructure(result);
+    if (_devMode)
+        checkListStructure(result);
     return result;
 }
 export function concat2(left, middle) {
@@ -844,7 +873,8 @@ export function concat2(left, middle) {
         middle: middle,
         right: emptyBranch,
     };
-    checkListStructure(ret);
+    if (_devMode)
+        checkListStructure(ret);
     return ret;
 }
 export function concat3(left, middle, right) {
@@ -856,7 +886,8 @@ export function concat3(left, middle, right) {
         middle,
         right,
     };
-    checkListStructure(ret);
+    if (_devMode)
+        checkListStructure(ret);
     return ret;
 }
 export function sameListShape(xs, ys) {

package/lib/map.mjs

@@ -1,5 +1,5 @@
 import { TernaryTreeKind, hashGenerator, } from "./types.mjs";
-import { divideTernarySizes, cmp, dataEqual } from "./utils.mjs";
+import { cmp, dataEqual } from "./utils.mjs";
 let emptyBranch = null;
 let nilResult = null;
 function getMax(tree) {
@@ -29,7 +29,6 @@ function getMin(tree) {
     }
 }
 export function getMapDepth(tree) {
-    // console.log( "calling...", tree)
     if (tree == null) {
         return 0;
     }
@@ -37,11 +36,21 @@ export function getMapDepth(tree) {
         case TernaryTreeKind.ternaryTreeLeaf:
             return 1;
         case TernaryTreeKind.ternaryTreeBranch:
-            return Math.max(getMapDepth(tree.left), getMapDepth(tree.middle), getMapDepth(tree.right)) + 1;
+            return tree.depth; // use cached depth — O(1)
         default:
             throw new Error("Unknown");
     }
 }
+function decideMapBranchDepth(left, middle, right) {
+    // Inline getMapDepth to avoid 3 indirect function calls per invocation
+    let dl = left == null ? 0 : left.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : left.depth;
+    let dm = middle == null ? 0 : middle.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : middle.depth;
+    let dr = right == null ? 0 : right.kind === TernaryTreeKind.ternaryTreeLeaf ? 1 : right.depth;
+    let d = dl > dm ? dl : dm;
+    if (dr > d)
+        d = dr;
+    return d + 1;
+}
 function createLeaf(k, v) {
     let result = {
         kind: TernaryTreeKind.ternaryTreeLeaf,
@@ -81,7 +90,8 @@ function makeTernaryTreeMap(size, offset, xs) {
                 left: createLeafFromHashEntry(leftPair),
                 middle: createLeafFromHashEntry(middlePair),
                 right: emptyBranch,
-                depth: 1,
+                depth: 2,
+                size: leftPair.pairs.length + middlePair.pairs.length,
             };
             return result;
         }
@@ -96,15 +106,21 @@ function makeTernaryTreeMap(size, offset, xs) {
                 left: createLeafFromHashEntry(leftPair),
                 middle: createLeafFromHashEntry(middlePair),
                 right: createLeafFromHashEntry(rightPair),
-                depth: 1,
+                depth: 2,
+                size: leftPair.pairs.length + middlePair.pairs.length + rightPair.pairs.length,
             };
             return result;
         }
         default: {
-            let divided = divideTernarySizes(size);
-            let left = makeTernaryTreeMap(divided.left, offset, xs);
-            let middle = makeTernaryTreeMap(divided.middle, offset + divided.left, xs);
-            let right = makeTernaryTreeMap(divided.right, offset + divided.left + divided.middle, xs);
+            // Inline divideTernarySizes to avoid heap object allocation per recursive call
+            let extra = size % 3;
+            let groupSize = (size / 3) | 0;
+            let leftSize = groupSize + (extra === 2 ? 1 : 0);
+            let middleSize = groupSize + (extra === 1 ? 1 : 0);
+            let rightSize = groupSize + (extra === 2 ? 1 : 0);
+            let left = makeTernaryTreeMap(leftSize, offset, xs);
+            let middle = makeTernaryTreeMap(middleSize, offset + leftSize, xs);
+            let right = makeTernaryTreeMap(rightSize, offset + leftSize + middleSize, xs);
             let result = {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 maxHash: getMax(right),
@@ -112,7 +128,8 @@ function makeTernaryTreeMap(size, offset, xs) {
                 left: left,
                 middle: middle,
                 right: right,
-                depth: Math.max(getMapDepth(left), getMapDepth(middle), getMapDepth(right)) + 1,
+                depth: decideMapBranchDepth(left, middle, right),
+                size: mapLen(left) + mapLen(middle) + mapLen(right),
             };
             return result;
         }
@@ -202,7 +219,7 @@ export function mapLen(tree) {
         case TernaryTreeKind.ternaryTreeLeaf:
             return tree.elements.length;
         case TernaryTreeKind.ternaryTreeBranch:
-            return mapLen(tree.left) + mapLen(tree.middle) + mapLen(tree.right); // TODO
+            return tree.size; // O(1) via cached size field
         default:
             throw new Error("Unknown");
     }
@@ -264,13 +281,13 @@ export function isMapEmpty(tree) {
 }
 export function isMapOfOne(tree, counted = 0) {
     if (tree == null) {
-        return true;
+        return false;
     }
     switch (tree.kind) {
         case TernaryTreeKind.ternaryTreeLeaf:
-            return false;
+            return tree.elements.length === 1;
         case TernaryTreeKind.ternaryTreeBranch:
-            return tree.left == null && tree.middle == null && tree.right == null;
+            return mapLenBound(tree, 2) === 1;
         default:
             throw new Error("Unknown");
     }
@@ -534,7 +551,7 @@ export function checkMapStructure(tree) {
                 throw new Error(`Bad hash at leaf node ${tree}`);
             }
         }
-        if (mapLenBound(tree, 2) !== 1) {
+        if (mapLenBound(tree, 2) < 1) {
             throw new Error(`Bad len at leaf node ${tree}`);
         }
     }
@@ -629,46 +646,49 @@ function assocExisted(tree, key, item, thisHash = null) {
         throw new Error("Unexpected missing hash in assoc, found not branch");
     }
     if (rangeContainsHash(tree.left, thisHash)) {
-        let result = {
+        let newLeft = assocExisted(tree.left, key, item, thisHash);
+        return {
             kind: TernaryTreeKind.ternaryTreeBranch,
             maxHash: tree.maxHash,
             minHash: tree.minHash,
-            left: assocExisted(tree.left, key, item, thisHash),
+            left: newLeft,
             middle: tree.middle,
             right: tree.right,
-            depth: 0, // TODO
+            depth: decideMapBranchDepth(newLeft, tree.middle, tree.right),
+            size: tree.size,
         };
-        return result;
     }
     if (tree.middle == null) {
         throw new Error("Unexpected missing hash in assoc, found not branch");
     }
     if (rangeContainsHash(tree.middle, thisHash)) {
-        let result = {
+        let newMiddle = assocExisted(tree.middle, key, item, thisHash);
+        return {
             kind: TernaryTreeKind.ternaryTreeBranch,
             maxHash: tree.maxHash,
             minHash: tree.minHash,
             left: tree.left,
-            middle: assocExisted(tree.middle, key, item, thisHash),
+            middle: newMiddle,
             right: tree.right,
-            depth: 0, // TODO
+            depth: decideMapBranchDepth(tree.left, newMiddle, tree.right),
+            size: tree.size,
         };
-        return result;
     }
     if (tree.right == null) {
         throw new Error("Unexpected missing hash in assoc, found not branch");
     }
     if (rangeContainsHash(tree.right, thisHash)) {
-        let result = {
+        let newRight = assocExisted(tree.right, key, item, thisHash);
+        return {
             kind: TernaryTreeKind.ternaryTreeBranch,
             maxHash: tree.maxHash,
             minHash: tree.minHash,
             left: tree.left,
             middle: tree.middle,
-            right: assocExisted(tree.right, key, item, thisHash),
-            depth: 0, // TODO
+            right: newRight,
+            depth: decideMapBranchDepth(tree.left, tree.middle, newRight),
+            size: tree.size,
         };
-        return result;
     }
     throw new Error("Unexpected missing hash in assoc, found not branch");
 }
@@ -692,7 +712,8 @@ function assocNew(tree, key, item, thisHash = null) {
                 left: tree,
                 middle: childBranch,
                 right: emptyBranch,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(tree, childBranch, emptyBranch),
+                size: mapLen(tree) + 1,
             };
             return result;
         }
@@ -709,7 +730,8 @@ function assocNew(tree, key, item, thisHash = null) {
                 left: childBranch,
                 middle: tree,
                 right: emptyBranch,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(childBranch, tree, emptyBranch),
+                size: mapLen(tree) + 1,
             };
             return result;
         }
@@ -750,7 +772,8 @@ function assocNew(tree, key, item, thisHash = null) {
                     left: childBranch,
                     middle: tree.left,
                     right: tree.middle,
-                    depth: 0, // TODO
+                    depth: decideMapBranchDepth(childBranch, tree.left, tree.middle),
+                    size: tree.size + 1,
                 };
                 return result;
             }
@@ -767,7 +790,8 @@ function assocNew(tree, key, item, thisHash = null) {
                     left: childBranch,
                     middle: tree,
                     right: emptyBranch,
-                    depth: 0, // TODO
+                    depth: decideMapBranchDepth(childBranch, tree, emptyBranch),
+                    size: tree.size + 1,
                 };
                 return result;
             }
@@ -787,7 +811,8 @@ function assocNew(tree, key, item, thisHash = null) {
                     left: tree.left,
                     middle: childBranch,
                     right: emptyBranch,
-                    depth: 0, // TODO
+                    depth: decideMapBranchDepth(tree.left, childBranch, emptyBranch),
+                    size: tree.size + 1,
                 };
                 return result;
             }
@@ -804,7 +829,8 @@ function assocNew(tree, key, item, thisHash = null) {
                     left: tree.left,
                     middle: tree.middle,
                     right: childBranch,
-                    depth: 0, // TODO
+                    depth: decideMapBranchDepth(tree.left, tree.middle, childBranch),
+                    size: tree.size + 1,
                 };
                 return result;
             }
@@ -821,73 +847,79 @@ function assocNew(tree, key, item, thisHash = null) {
                     left: tree,
                     middle: childBranch,
                     right: emptyBranch,
-                    depth: 0, // TODO
+                    depth: decideMapBranchDepth(tree, childBranch, emptyBranch),
+                    size: tree.size + 1,
                 };
                 return result;
             }
         }
         if (rangeContainsHash(tree.left, thisHash)) {
-            let result = {
+            let newLeft = assocNew(tree.left, key, item, thisHash);
+            return {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 maxHash: tree.maxHash,
                 minHash: tree.minHash,
-                left: assocNew(tree.left, key, item, thisHash),
+                left: newLeft,
                 middle: tree.middle,
                 right: tree.right,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(newLeft, tree.middle, tree.right),
+                size: tree.size + 1,
             };
-            return result;
         }
         if (rangeContainsHash(tree.middle, thisHash)) {
-            let result = {
+            let newMiddle = assocNew(tree.middle, key, item, thisHash);
+            return {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 maxHash: tree.maxHash,
                 minHash: tree.minHash,
                 left: tree.left,
-                middle: assocNew(tree.middle, key, item, thisHash),
+                middle: newMiddle,
                 right: tree.right,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(tree.left, newMiddle, tree.right),
+                size: tree.size + 1,
             };
-            return result;
         }
         if (rangeContainsHash(tree.right, thisHash)) {
-            let result = {
+            let newRight = assocNew(tree.right, key, item, thisHash);
+            return {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 maxHash: tree.maxHash,
                 minHash: tree.minHash,
                 left: tree.left,
                 middle: tree.middle,
-                right: assocNew(tree.right, key, item, thisHash),
-                depth: 0, // TODO
+                right: newRight,
+                depth: decideMapBranchDepth(tree.left, tree.middle, newRight),
+                size: tree.size + 1,
             };
-            return result;
         }
         if (tree.middle == null) {
             throw new Error("unreachable. if inside range, then middle should be here");
         }
         if (thisHash < getMin(tree.middle)) {
-            let result = {
+            let newLeft = assocNew(tree.left, key, item, thisHash);
+            return {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 maxHash: tree.maxHash,
                 minHash: tree.minHash,
-                left: assocNew(tree.left, key, item, thisHash),
+                left: newLeft,
                 middle: tree.middle,
                 right: tree.right,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(newLeft, tree.middle, tree.right),
+                size: tree.size + 1,
             };
-            return result;
         }
         else {
-            let result = {
+            let newRight = assocNew(tree.right, key, item, thisHash);
+            return {
                 kind: TernaryTreeKind.ternaryTreeBranch,
                 maxHash: tree.maxHash,
                 minHash: tree.minHash,
                 left: tree.left,
                 middle: tree.middle,
-                right: assocNew(tree.right, key, item, thisHash),
-                depth: 0, // TODO
+                right: newRight,
+                depth: decideMapBranchDepth(tree.left, tree.middle, newRight),
+                size: tree.size + 1,
             };
-            return result;
         }
     }
 }
@@ -948,7 +980,8 @@ function dissocExisted(tree, key) {
                 left: tree.middle,
                 middle: tree.right,
                 right: emptyBranch,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(tree.middle, tree.right, emptyBranch),
+                size: tree.size - 1,
             };
             return result;
         }
@@ -960,7 +993,8 @@ function dissocExisted(tree, key) {
                 left: changedBranch,
                 middle: tree.middle,
                 right: tree.right,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(changedBranch, tree.middle, tree.right),
+                size: tree.size - 1,
             };
             return result;
         }
@@ -978,7 +1012,8 @@ function dissocExisted(tree, key) {
                 left: tree.left,
                 middle: tree.right,
                 right: emptyBranch,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(tree.left, tree.right, emptyBranch),
+                size: tree.size - 1,
             };
             return result;
         }
@@ -990,7 +1025,8 @@ function dissocExisted(tree, key) {
                 left: tree.left,
                 middle: changedBranch,
                 right: tree.right,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(tree.left, changedBranch, tree.right),
+                size: tree.size - 1,
             };
             return result;
         }
@@ -1005,7 +1041,8 @@ function dissocExisted(tree, key) {
                 left: tree.left,
                 middle: tree.middle,
                 right: emptyBranch,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(tree.left, tree.middle, emptyBranch),
+                size: tree.size - 1,
             };
             return result;
         }
@@ -1017,7 +1054,8 @@ function dissocExisted(tree, key) {
                 left: tree.left,
                 middle: tree.middle,
                 right: changedBranch,
-                depth: 0, // TODO
+                depth: decideMapBranchDepth(tree.left, tree.middle, changedBranch),
+                size: tree.size - 1,
             };
             return result;
         }
@@ -1298,6 +1336,7 @@ export function mapMapValues(tree, f) {
                 left: mapMapValues(tree.left, f),
                 middle: mapMapValues(tree.middle, f),
                 right: mapMapValues(tree.right, f),
+                size: tree.size,
             };
             return result;
         }

package/lib/types.d.mts

@@ -22,6 +22,7 @@ export type TernaryTreeMapHashEntry<K, V> = {
 };
 export type TernaryTreeMapTheBranch<K, T> = {
     kind: TernaryTreeKind.ternaryTreeBranch;
+    size: number;
     depth: number;
     maxHash: number;
     minHash: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/ternary-tree",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "main": "./lib/index.mjs",
   "scripts": {
     "build": "tsc",
@@ -9,11 +9,12 @@
     "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"
+    "test:list-detailed-perf": "yarn build && node lib/test-list-detailed-perf.mjs",
+    "bench": "tsc && node lib/bench.mjs"
   },
   "devDependencies": {
-    "@types/node": "^20.12.5",
-    "prettier": "^3.2.5",
-    "typescript": "^5.4.4"
+    "@types/node": "*",
+    "prettier": "*",
+    "typescript": "*"
   }
 }