Various tweaks including new failing tests

I added new tests that use the new `getPairOrNextLower` method
from PR #23 (and the new `getPairOrNextHigher` method in this commit)
but the tests are failing.

- Add public `getPairOrNextHigher` method
- Add `as any` in places to avoid red squiggly errors
- Change the second argument of `getPairOrNextHigher` and
  `getPairOrNextLower` to eliminate unnecessary indirection
- Other tweaks

Author: qwertie

b+tree.d.ts

@@ -333,7 +333,9 @@ export default class BTree<K = any, V = any> implements ISortedMapF<K, V>, ISort
      * avoid creating a new array on every iteration.
      */
     nextHigherPair(key: K | undefined, reusedArray?: [K, V]): [K, V] | undefined;
-    /** Returns the next key larger than the specified key (or undefined if there is none) */
+    /** Returns the next key larger than the specified key, or undefined if there is none.
+     *  Also, nextHigherKey(undefined) returns the lowest key.
+     */
     nextHigherKey(key: K | undefined): K | undefined;
     /** Returns the next pair whose key is smaller than the specified key (or undefined if there is none).
      *  If key === undefined, this function returns the highest pair.
@@ -342,15 +344,26 @@ export default class BTree<K = any, V = any> implements ISortedMapF<K, V>, ISort
      *        avoid creating a new array each time you call this method.
      */
     nextLowerPair(key: K | undefined, reusedArray?: [K, V]): [K, V] | undefined;
-    /** Returns the next key smaller than the specified key (or undefined if there is none) */
+    /** Returns the next key smaller than the specified key, or undefined if there is none.
+     *  Also, nextLowerKey(undefined) returns the highest key.
+     */
     nextLowerKey(key: K | undefined): K | undefined;
     /** Returns the key-value pair associated with the supplied key if it exists
-     * and the next lower pair otherwise (or undefined if there is none)
+     *  or the pair associated with the next lower pair otherwise. If there is no
+     *  next lower pair, undefined is returned.
      * @param key The key to search for.
      * @param reusedArray Optional array used repeatedly to store key-value pairs, to
      *        avoid creating a new array each time you call this method.
      * */
     getPairOrNextLower(key: K, reusedArray?: [K, V]): [K, V] | undefined;
+    /** Returns the key-value pair associated with the supplied key if it exists
+     *  or the pair associated with the next lower pair otherwise. If there is no
+     *  next lower pair, undefined is returned.
+     * @param key The key to search for.
+     * @param reusedArray Optional array used repeatedly to store key-value pairs, to
+     *        avoid creating a new array each time you call this method.
+     * */
+    getPairOrNextHigher(key: K, reusedArray?: [K, V]): [K, V] | undefined;
     /** Edits the value associated with a key in the tree, if it already exists.
      * @returns true if the key existed, false if not.
     */

b+tree.js

@@ -553,7 +553,7 @@ var BTree = /** @class */ (function () {
                             var valOther = otherLeaf.values[otherLevelIndices[otherLevelIndices.length - 1]];
                             if (!Object.is(valThis, valOther)) {
                                 var result = different(thisCursor.currentKey, valThis, valOther);
-                                if (result && (result === null || result === void 0 ? void 0 : result.break))
+                                if (result && result.break)
                                     return result.break;
                             }
                         }
@@ -828,12 +828,14 @@ var BTree = /** @class */ (function () {
         if (key === undefined) {
             return this._root.minPair(reusedArray);
         }
-        return this._root.getPairOrNextHigher(key, this, false, reusedArray);
+        return this._root.getPairOrNextHigher(key, this._compare, false, reusedArray);
     };
-    /** Returns the next key larger than the specified key (or undefined if there is none) */
+    /** Returns the next key larger than the specified key, or undefined if there is none.
+     *  Also, nextHigherKey(undefined) returns the lowest key.
+     */
     BTree.prototype.nextHigherKey = function (key) {
         var p = this.nextHigherPair(key, ReusedArray);
-        return p ? p[0] : p;
+        return p && p[0];
     };
     /** Returns the next pair whose key is smaller than the specified key (or undefined if there is none).
      *  If key === undefined, this function returns the highest pair.
@@ -846,21 +848,34 @@ var BTree = /** @class */ (function () {
         if (key === undefined) {
             return this._root.maxPair(reusedArray);
         }
-        return this._root.getPairOrNextLower(key, this, false, reusedArray);
+        return this._root.getPairOrNextLower(key, this._compare, false, reusedArray);
     };
-    /** Returns the next key smaller than the specified key (or undefined if there is none) */
+    /** Returns the next key smaller than the specified key, or undefined if there is none.
+     *  Also, nextLowerKey(undefined) returns the highest key.
+     */
     BTree.prototype.nextLowerKey = function (key) {
         var p = this.nextLowerPair(key, ReusedArray);
-        return p ? p[0] : p;
+        return p && p[0];
     };
     /** Returns the key-value pair associated with the supplied key if it exists
-     * and the next lower pair otherwise (or undefined if there is none)
+     *  or the pair associated with the next lower pair otherwise. If there is no
+     *  next lower pair, undefined is returned.
      * @param key The key to search for.
      * @param reusedArray Optional array used repeatedly to store key-value pairs, to
      *        avoid creating a new array each time you call this method.
      * */
     BTree.prototype.getPairOrNextLower = function (key, reusedArray) {
-        return this._root.getPairOrNextLower(key, this, true, reusedArray || []);
+        return this._root.getPairOrNextLower(key, this._compare, true, reusedArray || []);
+    };
+    /** Returns the key-value pair associated with the supplied key if it exists
+     *  or the pair associated with the next lower pair otherwise. If there is no
+     *  next lower pair, undefined is returned.
+     * @param key The key to search for.
+     * @param reusedArray Optional array used repeatedly to store key-value pairs, to
+     *        avoid creating a new array each time you call this method.
+     * */
+    BTree.prototype.getPairOrNextHigher = function (key, reusedArray) {
+        return this._root.getPairOrNextHigher(key, this._compare, true, reusedArray || []);
     };
     /** Edits the value associated with a key in the tree, if it already exists.
      * @returns true if the key existed, false if not.
@@ -1179,8 +1194,8 @@ var BNode = /** @class */ (function () {
         var i = this.indexOf(key, -1, tree._compare);
         return i < 0 ? defaultValue : this.values[i];
     };
-    BNode.prototype.getPairOrNextLower = function (key, tree, inclusive, reusedArray) {
-        var i = this.indexOf(key, -1, tree._compare);
+    BNode.prototype.getPairOrNextLower = function (key, compare, inclusive, reusedArray) {
+        var i = this.indexOf(key, -1, compare);
         var indexOrLower = i < 0 ? ~i - 1 : (inclusive ? i : i - 1);
         if (indexOrLower >= 0) {
             reusedArray[0] = this.keys[indexOrLower];
@@ -1189,8 +1204,8 @@ var BNode = /** @class */ (function () {
         }
         return undefined;
     };
-    BNode.prototype.getPairOrNextHigher = function (key, tree, inclusive, reusedArray) {
-        var i = this.indexOf(key, -1, tree._compare);
+    BNode.prototype.getPairOrNextHigher = function (key, compare, inclusive, reusedArray) {
+        var i = this.indexOf(key, -1, compare);
         var indexOrLower = i < 0 ? ~i : (inclusive ? i : i + 1);
         var keys = this.keys;
         if (indexOrLower < keys.length) {
@@ -1404,21 +1419,21 @@ var BNodeInternal = /** @class */ (function (_super) {
         var i = this.indexOf(key, 0, tree._compare), children = this.children;
         return i < children.length ? children[i].get(key, defaultValue, tree) : undefined;
     };
-    BNodeInternal.prototype.getPairOrNextLower = function (key, tree, inclusive, reusedArray) {
-        var i = this.indexOf(key, 0, tree._compare), children = this.children;
+    BNodeInternal.prototype.getPairOrNextLower = function (key, compare, inclusive, reusedArray) {
+        var i = this.indexOf(key, 0, compare), children = this.children;
         if (i >= children.length)
             return undefined;
-        var result = children[i].getPairOrNextLower(key, tree, inclusive, reusedArray);
+        var result = children[i].getPairOrNextLower(key, compare, inclusive, reusedArray);
         if (result === undefined && i > 0) {
             return children[i - 1].maxPair(reusedArray);
         }
         return result;
     };
-    BNodeInternal.prototype.getPairOrNextHigher = function (key, tree, inclusive, reusedArray) {
-        var i = this.indexOf(key, 0, tree._compare), children = this.children, length = children.length;
+    BNodeInternal.prototype.getPairOrNextHigher = function (key, compare, inclusive, reusedArray) {
+        var i = this.indexOf(key, 0, compare), children = this.children, length = children.length;
         if (i >= length)
             return undefined;
-        var result = children[i].getPairOrNextHigher(key, tree, inclusive, reusedArray);
+        var result = children[i].getPairOrNextHigher(key, compare, inclusive, reusedArray);
         if (result === undefined && i < length - 1) {
             return children[i + 1].minPair(reusedArray);
         }

b+tree.test.ts

@@ -421,27 +421,63 @@ function testBTree(maxNodeSize: number)
     });
   }
 
-  for (let size of [5, 10, 300]) {
-    const tree = new BTree<number,number>(undefined, undefined, maxNodeSize);
-    const pairs: [number,number][] = [];
-    for (let i = 0; i < size; i++) {
-      const value = randInt(size * 2);
-      tree.set(i, value);
-      pairs.push([i, value]);
-    }
-    test(`nextLowerPair/nextHigherPair for tree of size ${size}`, () => {
-      expect(tree.nextHigherPair(undefined)).toEqual([tree.minKey()!, tree.get(tree.minKey()!)]);
+  describe(`Next higher/lower methods`, () => {
+    test(`nextLower/nextHigher methods return undefined in an empty tree`, () => {
+      const tree = new BTree<number,number>(undefined, undefined, maxNodeSize);
+      expect(tree.nextLowerPair(undefined)).toEqual(undefined);
+      expect(tree.nextHigherPair(undefined)).toEqual(undefined);
+      expect(tree.getPairOrNextLower(1)).toEqual(undefined);
+      expect(tree.getPairOrNextHigher(2)).toEqual(undefined);
+      
+      // This shouldn't make a difference
+      tree.set(5, 55);
+      tree.delete(5);
+      
+      expect(tree.nextLowerPair(undefined)).toEqual(undefined);
+      expect(tree.nextHigherPair(undefined)).toEqual(undefined);
+      expect(tree.nextLowerPair(3)).toEqual(undefined);
+      expect(tree.nextHigherPair(4)).toEqual(undefined);
+      expect(tree.getPairOrNextLower(5)).toEqual(undefined);
+      expect(tree.getPairOrNextHigher(6)).toEqual(undefined);
+    });
+
+    for (let size of [5, 10, 300]) {
+      // Build a tree and list with pairs whose keys are even numbers: 0, 2, 4, 6, 8, 10...
+      const tree = new BTree<number,number>(undefined, undefined, maxNodeSize);
+      const pairs: [number,number][] = [];
       for (let i = 0; i < size; i++) {
-        if (i > 0) {
-          expect(tree.nextLowerPair(i)).toEqual(pairs[i - 1]);
+        const value = i;
+        tree.set(i * 2, value);
+        pairs.push([i * 2, value]);
+      }
+
+      test(`nextLowerPair/nextHigherPair for tree of size ${size}`, () => {
+        expect(tree.nextHigherPair(undefined)).toEqual([tree.minKey()!, tree.get(tree.minKey()!)]);
+        expect(tree.nextHigherPair(tree.maxKey())).toEqual(undefined);
+        for (let i = 0; i < size * 2; i++) {
+          if (i > 0) {
+            expect(tree.nextLowerPair(i)).toEqual(pairs[((i + 1) >> 1) - 1]);
+          }
+          if (i < size - 1) {
+            expect(tree.nextHigherPair(i)).toEqual(pairs[(i >> 1) + 1]);
+          }
         }
-        if (i < size - 1) {
-          expect(tree.nextHigherPair(i)).toEqual(pairs[i + 1]);
+        expect(tree.nextLowerPair(undefined)).toEqual([tree.maxKey()!, tree.get(tree.maxKey()!)]);
+        expect(tree.nextLowerPair(tree.minKey())).toEqual(undefined);
+      })
+
+      test(`getPairOrNextLower/getPairOrNextHigher for tree of size ${size}`, () => {
+        for (let i = 0; i < size * 2; i++) {
+          if (i > 0) {
+            expect(tree.getPairOrNextLower(i)).toEqual(pairs[i >> 1]);
+          }
+          if (i < size - 1) {
+            expect(tree.getPairOrNextHigher(i)).toEqual(pairs[(i + 1) >> 1]);
+          }
         }
-      }
-      expect(tree.nextLowerPair(undefined)).toEqual([tree.maxKey()!, tree.get(tree.maxKey()!)]);
-    })
-  }
+      })
+    }
+  });
 
   for (let size of [6, 36, 216]) {
     test(`setPairs & deleteRange [size ${size}]`, () => {