Optimizations for diffAgainst

Author: jenn-le

b+tree.js

@@ -640,14 +640,13 @@ var BTree = /** @class */ (function () {
      * @returns true if the step was completed and false if the step would have caused the cursor to move beyond the end of the tree.
      */
     BTree.step = function (cursor, stepToNode) {
-        if (stepToNode === void 0) { stepToNode = false; }
         var internalSpine = cursor.internalSpine, levelIndices = cursor.levelIndices, leaf = cursor.leaf;
-        if (stepToNode || leaf) {
+        if (stepToNode === true || leaf) {
             var levelsLength = levelIndices.length;
             // Step to the next node only if:
             // - We are explicitly directed to via stepToNode, or
             // - There are no key/value pairs left to step to in this leaf
-            if (stepToNode || levelIndices[levelsLength - 1] === 0) {
+            if (stepToNode === true || levelIndices[levelsLength - 1] === 0) {
                 var spineLength = internalSpine.length;
                 // Root is leaf
                 if (spineLength === 0)
@@ -656,19 +655,17 @@ var BTree = /** @class */ (function () {
                 var nodeLevelIndex = spineLength - 1;
                 var levelIndexWalkBack = nodeLevelIndex;
                 while (levelIndexWalkBack >= 0) {
-                    var childIndex = levelIndices[levelIndexWalkBack];
-                    if (childIndex > 0) {
+                    if (levelIndices[levelIndexWalkBack] > 0) {
                         if (levelIndexWalkBack < levelsLength - 1) {
                             // Remove leaf state from cursor
                             cursor.leaf = undefined;
-                            levelIndices.splice(levelIndexWalkBack + 1, levelsLength - levelIndexWalkBack);
+                            levelIndices.pop();
                         }
-                        // If we walked upwards past any internal node, splice them out
+                        // If we walked upwards past any internal node, slice them out
                         if (levelIndexWalkBack < nodeLevelIndex)
-                            internalSpine.splice(levelIndexWalkBack + 1, spineLength - levelIndexWalkBack);
+                            cursor.internalSpine = internalSpine.slice(0, levelIndexWalkBack + 1);
                         // Move to new internal node
-                        var nodeIndex = --levelIndices[levelIndexWalkBack];
-                        cursor.currentKey = internalSpine[levelIndexWalkBack][nodeIndex].maxKey();
+                        cursor.currentKey = internalSpine[levelIndexWalkBack][--levelIndices[levelIndexWalkBack]].maxKey();
                         return true;
                     }
                     levelIndexWalkBack--;

b+tree.ts

@@ -739,14 +739,14 @@ export default class BTree<K=any, V=any> implements ISortedMapF<K,V>, ISortedMap
    * @param stepToNode If true, the cursor will be advanced to the next node (skipping values)
    * @returns true if the step was completed and false if the step would have caused the cursor to move beyond the end of the tree.
    */ 
-  private static step<K, V>(cursor: DiffCursor<K, V>, stepToNode: boolean = false): boolean {
+  private static step<K, V>(cursor: DiffCursor<K, V>, stepToNode?: boolean): boolean {
     const { internalSpine, levelIndices, leaf } = cursor;
-    if (stepToNode || leaf) {
+    if (stepToNode === true || leaf) {
       const levelsLength = levelIndices.length;
       // Step to the next node only if:
       // - We are explicitly directed to via stepToNode, or
       // - There are no key/value pairs left to step to in this leaf
-      if (stepToNode || levelIndices[levelsLength - 1] === 0) {
+      if (stepToNode === true || levelIndices[levelsLength - 1] === 0) {
         const spineLength = internalSpine.length;
         // Root is leaf
         if (spineLength === 0)
@@ -755,19 +755,17 @@ export default class BTree<K=any, V=any> implements ISortedMapF<K,V>, ISortedMap
         const nodeLevelIndex = spineLength - 1;
         let levelIndexWalkBack = nodeLevelIndex;
         while (levelIndexWalkBack >= 0) {
-          const childIndex = levelIndices[levelIndexWalkBack]
-          if (childIndex > 0) {
+          if (levelIndices[levelIndexWalkBack] > 0) {
             if (levelIndexWalkBack < levelsLength - 1) {
               // Remove leaf state from cursor
               cursor.leaf = undefined;
-              levelIndices.splice(levelIndexWalkBack + 1, levelsLength - levelIndexWalkBack);
+              levelIndices.pop();
             }
-            // If we walked upwards past any internal node, splice them out
+            // If we walked upwards past any internal node, slice them out
             if (levelIndexWalkBack < nodeLevelIndex)
-              internalSpine.splice(levelIndexWalkBack + 1, spineLength - levelIndexWalkBack);
+              cursor.internalSpine = internalSpine.slice(0, levelIndexWalkBack + 1);
             // Move to new internal node
-            const nodeIndex = --levelIndices[levelIndexWalkBack];
-            cursor.currentKey = internalSpine[levelIndexWalkBack][nodeIndex].maxKey();
+            cursor.currentKey = internalSpine[levelIndexWalkBack][--levelIndices[levelIndexWalkBack]].maxKey();
             return true;
           }
           levelIndexWalkBack--;
@@ -1680,7 +1678,7 @@ class BNodeInternal<K,V> extends BNode<K,V> {
  * - Leaf is only populated if the cursor points to a KVP. If this is the case, levelIndices.length === internalSpine.length + 1
  *    and levelIndices[levelIndices.length - 1] is the index of the value.
  */
-type DiffCursor<K,V> = { height: number, internalSpine: BNode<K,V>[][], levelIndices: number[], leaf: BNode<K,V> | undefined, currentKey: K };
+type DiffCursor<K,V> = { height: number, internalSpine: BNode<K,V>[][], levelIndices: number[],  leaf: BNode<K,V> | undefined, currentKey: K };
 
 // Optimization: this array of `undefined`s is used instead of a normal
 // array of values in nodes where `undefined` is the only value.