@calcit/ternary-tree 0.0.22 → 0.0.24

package/lib/list.d.mts

@@ -26,8 +26,12 @@ export declare function forceListInplaceBalancing<T>(tree: TernaryTreeList<T>):
 export declare function prepend<T>(tree: TernaryTreeList<T>, item: T, disableBalancing?: boolean): TernaryTreeList<T>;
 export declare function append<T>(tree: TernaryTreeList<T>, item: T, disableBalancing?: boolean): TernaryTreeList<T>;
 export declare function concat<T>(...xsGroups: Array<TernaryTreeList<T>>): TernaryTreeList<T>;
+export declare function concat2<T>(left: TernaryTreeList<T>, middle: TernaryTreeList<T>): TernaryTreeList<T>;
+export declare function concat3<T>(left: TernaryTreeList<T>, middle: TernaryTreeList<T>, right: TernaryTreeList<T>): TernaryTreeList<T>;
 export declare function sameListShape<T>(xs: TernaryTreeList<T>, ys: TernaryTreeList<T>): boolean;
 export declare function listEqual<T>(xs: TernaryTreeList<T>, ys: TernaryTreeList<T>): boolean;
+/** in some cases we disable for performance */
+export declare let disableListStructureCheck: () => void;
 export declare function checkListStructure<T>(tree: TernaryTreeList<T>): boolean;
 export declare function slice<T>(tree: TernaryTreeList<T>, startIdx: number, endIdx: number): TernaryTreeList<T>;
 export declare function reverse<T>(tree: TernaryTreeList<T>): TernaryTreeList<T>;

package/lib/list.mjs

@@ -736,8 +736,8 @@ export function forceListInplaceBalancing(tree) {
 // TODO, need better strategy for detecting
 function maybeReblance(tree) {
     let currentDepth = getDepth(tree);
-    if (currentDepth > 50) {
-        if (roughIntPow(3, currentDepth - 50) > tree.size) {
+    if (currentDepth > 10) {
+        if (roughIntPow(3, currentDepth - 10) > tree.size) {
             forceListInplaceBalancing(tree);
         }
     }
@@ -764,11 +764,70 @@ export function append(tree, item, disableBalancing = false) {
 }
 export function concat(...xsGroups) {
     xsGroups = xsGroups.filter((xs) => listLen(xs) > 0);
+    if (xsGroups.length === 1) {
+        return xsGroups[0];
+    }
+    if (xsGroups.length === 2) {
+        return concat2(xsGroups[0], xsGroups[1]);
+    }
+    if (xsGroups.length === 3) {
+        return concat3(xsGroups[0], xsGroups[1], xsGroups[2]);
+    }
     let result = makeTernaryTreeList(xsGroups.length, 0, xsGroups);
     maybeReblance(result);
     checkListStructure(result);
     return result;
 }
+export function concat2(left, middle) {
+    if (left.kind === TernaryTreeKind.ternaryTreeBranch) {
+        if (left.left != null && left.middle != null && left.right == null) {
+            let ret = {
+                size: left.size + middle.size,
+                kind: TernaryTreeKind.ternaryTreeBranch,
+                depth: decideParentDepth(left.left, left.middle, middle),
+                left: left.left,
+                middle: left.middle,
+                right: middle,
+            };
+            return ret;
+        }
+    }
+    if (middle.kind === TernaryTreeKind.ternaryTreeBranch) {
+        if (middle.left != null && middle.middle != null && middle.right == null) {
+            let ret = {
+                size: left.size + middle.size,
+                kind: TernaryTreeKind.ternaryTreeBranch,
+                depth: decideParentDepth(left, middle.left, middle.middle),
+                left: left,
+                middle: middle.left,
+                right: middle.middle,
+            };
+            return ret;
+        }
+    }
+    let ret = {
+        size: left.size + middle.size,
+        kind: TernaryTreeKind.ternaryTreeBranch,
+        depth: decideParentDepth(left, middle),
+        left: left,
+        middle: middle,
+        right: emptyBranch,
+    };
+    checkListStructure(ret);
+    return ret;
+}
+export function concat3(left, middle, right) {
+    let ret = {
+        size: left.size + middle.size + right.size,
+        kind: TernaryTreeKind.ternaryTreeBranch,
+        depth: decideParentDepth(left, middle, right),
+        left,
+        middle,
+        right,
+    };
+    checkListStructure(ret);
+    return ret;
+}
 export function sameListShape(xs, ys) {
     if (xs == null) {
         if (ys == null) {
@@ -820,7 +879,15 @@ export function listEqual(xs, ys) {
     }
     return true;
 }
+var skipListStructureCheck = false;
+/** in some cases we disable for performance */
+export let disableListStructureCheck = () => {
+    skipListStructureCheck = true;
+};
 export function checkListStructure(tree) {
+    if (skipListStructureCheck) {
+        return true;
+    }
     if (tree == null || listLen(tree) === 0) {
         return true;
     }

package/lib/main.mjs

@@ -4,6 +4,8 @@ import "./test-map.mjs";
 import { runListTests } from "./test-list.mjs";
 import { runMapTests } from "./test-map.mjs";
 import { mergeValueHash, overwriteHashGenerator, valueHash } from "./types.mjs";
+// import { disableListStructureCheck } from "./list.mjs";
+// disableListStructureCheck();
 overwriteComparator((x, y) => {
     // console.log("comparing", x, y);
     return deepEqual(x, y);

package/lib/test-list.mjs

@@ -1,5 +1,5 @@
-import { listToString, initTernaryTreeList, initTernaryTreeListFromRange, indexOf, findIndex, reverse, checkListStructure, slice, listToPairs, listToItems, formatListInline, sameListShape, assocBefore, concat, assocAfter, prepend, append, rest, butlast, first, assocList, dissocList, listGet, insert, initEmptyTernaryTreeList, last, listLen, forceListInplaceBalancing, listEqual, indexToItems, listMapValues, } from "./list.mjs";
-import { test, check, arrayEqual, checkEqual } from "./utils.mjs";
+import { listToString, initTernaryTreeList, initTernaryTreeListFromRange, indexOf, findIndex, reverse, checkListStructure, slice, listToPairs, listToItems, formatListInline, sameListShape, assocBefore, concat, assocAfter, prepend, append, rest, butlast, first, assocList, dissocList, listGet, insert, initEmptyTernaryTreeList, last, listLen, forceListInplaceBalancing, listEqual, indexToItems, listMapValues, concat2, } from "./list.mjs";
+import { test, check, arrayEqual, checkEqual } from "./test-utils.mjs";
 export let runListTests = () => {
     test("init list", () => {
         check(listToString(initTernaryTreeList([1, 2, 3, 4])) === "TernaryTreeList[4, ...]");
@@ -75,7 +75,7 @@ export let runListTests = () => {
         let data2 = initTernaryTreeList([3, 4]);
         let data3 = initTernaryTreeList([5, 6]);
         let data4 = initTernaryTreeList([7, 8]);
-        check(formatListInline(concat(data1, data2)) === "((1 2 _) (3 4 _) _)");
+        check(formatListInline(concat(data1, data2)) === "(1 2 (3 4 _))");
         check(formatListInline(concat(initTernaryTreeList([]), data1)) === "(1 2 _)");
         check(formatListInline(concat(data1, data2, data3)) === "((1 2 _) (3 4 _) (5 6 _))");
         check(formatListInline(concat(data1, data2, data3, data4)) === "((1 2 _) ((3 4 _) (5 6 _) _) (7 8 _))");
@@ -197,4 +197,12 @@ export let runListTests = () => {
         checkListStructure(data1);
         checkListStructure(data2);
     });
+    test("concat loop", () => {
+        let data1 = initTernaryTreeList([3, 4]);
+        let data2 = initTernaryTreeList([5]);
+        for (let i = 0; i < 100; i++) {
+            data1 = concat2(data1, data2);
+        }
+        console.log("concat into depth", formatListInline(data1));
+    });
 };

package/lib/test-map.mjs

@@ -1,5 +1,6 @@
 import { hashGenerator } from "./types.mjs";
-import { test, check, cmp, deepEqual, justDisplay } from "./utils.mjs";
+import { cmp, deepEqual } from "./utils.mjs";
+import { 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", () => {

package/lib/test-utils.d.mts

@@ -0,0 +1,6 @@
+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 arrayEqual<T>(xs: Array<T>, ys: Array<T>): boolean;
+export declare let justDisplay: (x: any, y: any) => void;

package/lib/test-utils.mjs

@@ -0,0 +1,37 @@
+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);
+        cb();
+    }
+};
+export let check = (x) => {
+    if (!x) {
+        throw new Error("Test failed");
+    }
+};
+/** compare by reference */
+export let checkEqual = (x, y) => {
+    if (x !== y) {
+        console.log("Left:  ", x);
+        console.log("Right: ", y);
+        throw new Error("Test failed");
+    }
+};
+export function arrayEqual(xs, ys) {
+    if (xs.length != ys.length) {
+        return false;
+    }
+    for (let idx = 0; idx < xs.length; idx++) {
+        if (xs[idx] !== ys[idx]) {
+            return false;
+        }
+    }
+    return true;
+}
+export let justDisplay = (x, y) => {
+    console.group("Compare:");
+    console.log(x);
+    console.log(y);
+    console.groupEnd();
+};

package/lib/utils.d.mts

@@ -10,11 +10,5 @@ export declare let divideTernarySizes: (size: number) => {
     right: number;
 };
 export declare function shallowCloneArray<T>(xs: Array<T>): Array<T>;
-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 let justDisplay: (x: any, y: any) => void;
 export declare let cmp: (x: any, y: any) => 0 | 1 | -1;
 export declare let deepEqual: (x: any, y: any) => boolean;
-export declare function arrayEqual<T>(xs: Array<T>, ys: Array<T>): boolean;

package/lib/utils.mjs

@@ -48,29 +48,6 @@ export function shallowCloneArray(xs) {
     }
     return ys;
 }
-export let test = (name, cb) => {
-    console.log("Test:", name);
-    cb();
-};
-export let check = (x) => {
-    if (!x) {
-        throw new Error("Test failed");
-    }
-};
-/** compare by reference */
-export let checkEqual = (x, y) => {
-    if (x !== y) {
-        console.log("Left:  ", x);
-        console.log("Right: ", y);
-        throw new Error("Test failed");
-    }
-};
-export let justDisplay = (x, y) => {
-    console.group("Compare:");
-    console.log(x);
-    console.log(y);
-    console.groupEnd();
-};
 export let cmp = (x, y) => {
     if (x < y) {
         return -1;
@@ -101,14 +78,3 @@ export let deepEqual = function (x, y) {
     else
         return false;
 };
-export function arrayEqual(xs, ys) {
-    if (xs.length != ys.length) {
-        return false;
-    }
-    for (let idx = 0; idx < xs.length; idx++) {
-        if (xs[idx] !== ys[idx]) {
-            return false;
-        }
-    }
-    return true;
-}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@calcit/ternary-tree",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "main": "./lib/index.mjs",
   "scripts": {},
   "devDependencies": {
-    "prettier": "^3.0.0",
-    "typescript": "^5.1.6"
+    "@types/node": "^20.12.5",
+    "prettier": "^3.2.5",
+    "typescript": "^5.4.4"
   }
 }