@bablr/btree 0.4.0 → 0.4.1

package/lib/enhanceable.js

@@ -16,6 +16,18 @@ export const buildModule = (
     return nodes.map(getSize).reduce((a, b) => a + b, 0);
   };
 
+  const getHeight = (tree) => {
+    let height = 0;
+    let node = tree;
+
+    while (Array.isArray(node)) {
+      height++;
+      node = getValues(node)[0];
+    }
+
+    return height;
+  };
+
   const treeFrom = (...values) => {
     if (!statsReducer && values.length <= NODE_SIZE) {
       return freeze(values);
@@ -30,11 +42,12 @@ export const buildModule = (
 
   const buildStats = (values) => {
     let sums = values.reduce(statsReducer, getSumsInitial());
-    finalizeSums(sums);
+    sums = finalizeSums(sums);
     return sums;
   };
 
   const treeFromValues = (values) => {
+    if (values.includes(undefined)) throw new Error();
     if (!statsReducer && values.length <= NODE_SIZE) {
       return isArray(values[0]) ? freeze([sumNodes(values), freeze(values)]) : freeze(values);
     } else {
@@ -91,32 +104,94 @@ export const buildModule = (
   };
 
   const setValuesAt = (idx, node, value) => {
-    const isLeaf = isLeafNode(node);
     const values = getValues(node);
 
     if (!Number.isFinite(idx)) throw new Error();
 
-    if (!isLeaf && !isArray(value)) {
+    if (!value == null) {
       throw new Error();
     }
 
-    if (isLeaf && isArray(value) && node.length) throw new Error();
-
     const newValues = values.slice();
     newValues[idx] = value;
     return treeFromValues(newValues);
   };
 
+  const concat = (first, second) => {
+    if (!isArray(first) || !isArray(second)) throw new Error();
+
+    let firstHeight = getHeight(first);
+    let secondHeight = getHeight(second);
+    let firstValues = getValues(first);
+    let secondValues = getValues(second);
+
+    if (firstHeight === secondHeight) {
+      if (firstValues.length + secondValues.length < NODE_SIZE) {
+        return treeFromValues([...firstValues, ...secondValues]);
+      } else {
+        return treeFromValues([first, second]);
+      }
+    } else {
+      let targetDepth = Math.abs(firstHeight - secondHeight);
+      let path =
+        firstHeight > secondHeight
+          ? findPath(Infinity, first, targetDepth)
+          : findPath(0, second, targetDepth);
+
+      let { node, index } = path.value;
+
+      let pushout = firstHeight > secondHeight ? second : first;
+
+      let values = getValues(node);
+
+      for (;;) {
+        if (pushout) {
+          values = values.slice();
+
+          let finiteIndex = index === Infinity ? values.length : index;
+
+          if (!isFinite(finiteIndex)) throw new Error();
+          if (values.length + getValues(pushout).length > NODE_SIZE) {
+            values.splice(finiteIndex, 0, pushout);
+            const { leftValues, rightValues } = splitValues(values);
+
+            pushout = treeFromValues(leftValues);
+            node = treeFromValues(rightValues);
+          } else {
+            values.splice(finiteIndex, 0, pushout);
+            node = setValues(node, values);
+            pushout = null;
+          }
+        }
+
+        if (path.size === 1) {
+          if (pushout) {
+            return treeFromValues([pushout, node]);
+          } else {
+            return node;
+          }
+        }
+
+        const poppedNode = node;
+        path = path.pop();
+        ({ node, index } = path.value);
+
+        node = setValuesAt(index, node, poppedNode);
+        values = getValues(node);
+        path = path.replace({ node, index });
+      }
+    }
+  };
+
   const addAt = (idx, tree, value) => {
     if (idx < 0 || !Number.isFinite(idx)) throw new Error('invalid argument');
     if (!isArray(tree)) throw new Error();
-    if (isArray(value)) throw new Error('cannot add arrays to btrees');
+    if (!value) throw new Error();
 
     let path = findPath(idx, tree);
 
     let { node, index } = path.value;
 
-    // left pushout vs right pushout?
     let pushout = value;
 
     let values = getValues(node);
@@ -160,7 +235,8 @@ export const buildModule = (
   };
 
   const push = (tree, value) => {
-    return addAt(getSize(tree), tree, value);
+    let size = getSize(tree);
+    return size ? addAt(size, tree, value) : treeFromValues([value]);
   };
 
   const collapses = (size) => {
@@ -175,15 +251,16 @@ export const buildModule = (
     return collapses(getValues(node).length - 1);
   };
 
-  const pop = (tree) => {
-    let path = findPath(-1, tree);
+  const removeAt = (idx, tree) => {
+    let path = findPath(idx, tree);
 
     let { node, index } = path.value;
 
-    const initialValues = freeze(getValues(node).slice(0, -1));
-    let returnValue = isLeafNode(node)
-      ? initialValues
-      : freeze([sumNodes(initialValues), initialValues]);
+    const initialValues = [...getValues(node)];
+
+    initialValues.splice(index, 1);
+
+    let returnValue = !isFinite(node[0]) ? initialValues : treeFromValues(initialValues);
 
     for (;;) {
       let values = getValues(returnValue);
@@ -221,8 +298,8 @@ export const buildModule = (
       }
 
       if (path.size === 1) {
-        if (isFinite(returnValue[0]) && getSize(returnValue) <= NODE_SIZE) {
-          returnValue = returnValue[1].flat();
+        if (getSize(returnValue) <= NODE_SIZE) {
+          returnValue = setValues(returnValue, getValues(returnValue).flat());
         }
         return returnValue;
       }
@@ -247,10 +324,16 @@ export const buildModule = (
     }
   };
 
+  const pop = (tree) => {
+    return removeAt(-1, tree);
+  };
+
   const isValidNode = (node) => {
     if (!isArray(node)) return false;
     const values = getValues(node);
-    return isArray(values); //  && values.length <= NODE_SIZE;
+    if (!isArray(values) || values.length > NODE_SIZE) return false; //  ;
+
+    return !node[0] || isFinite(node[0]) || ['object', 'string'].includes(typeof node[0]);
   };
 
   const assertValidNode = (node) => {
@@ -273,10 +356,6 @@ export const buildModule = (
     return isFinite(node[0]) || statsReducer ? treeFromValues(values) : freeze(values);
   };
 
-  const isLeafNode = (node) => {
-    return !isArray(getValues(node)[0]);
-  };
-
   function* traverse(tree) {
     let states = emptyStack.push({ node: tree, i: 0 });
 
@@ -285,23 +364,23 @@ export const buildModule = (
     stack: while (states.size) {
       const s = states.value;
       const { node } = s;
-      const isLeaf = isLeafNode(node);
 
       const values = getValues(node);
 
-      if (isLeaf) {
-        for (let i = 0; i < values.length; i++) {
-          yield values[i];
-        }
-      } else {
-        for (let { i } = s; s.i < values.length; ) {
-          const node = values[i];
+      for (let { i } = s; s.i < values.length; ) {
+        const value = values[i];
+        if (isArray(value)) {
+          let node = value;
           assertValidNode(node);
           states = states.push({ node, i: 0 });
           i = ++s.i;
           continue stack;
+        } else {
+          yield value;
+          i = ++s.i;
         }
       }
+
       states = states.pop();
     }
   }
@@ -318,13 +397,13 @@ export const buildModule = (
     }
   };
 
-  const findPath = (idx, tree) => {
+  const findPath = (idx, tree, depth = Infinity) => {
     if (idx == null) throw new Error();
 
     let path = emptyStack;
 
     let treeSum = getSize(tree);
-    let currentIdx = idx < 0 ? treeSum : 0;
+    let currentIdx = idx < 0 ? treeSum - 1 : 0;
     let direction = idx < 0 ? -1 : 1;
     let targetIdx = idx < 0 ? treeSum + idx : idx;
 
@@ -332,39 +411,52 @@ export const buildModule = (
     stack: while (node) {
       assertValidNode(node);
 
-      if (isLeafNode(node)) {
-        const startIdx = idx < 0 ? currentIdx - getSize(node) : currentIdx;
-        let index = isFinite(currentIdx) ? targetIdx - startIdx : currentIdx;
-        if (index < 0) {
-          index = -Infinity;
-        } else if (index >= getSize(node)) {
-          index = Infinity;
-        }
-        return path.push({ index, node });
-      } else {
-        const values = node[1];
-        let candidateNode;
-        let i;
-
-        let backwards = idx < 0;
-        const increment = backwards ? -1 : 1;
-        for (
-          let i = backwards ? values.length - 1 : 0;
-          backwards ? i >= 0 : i < values.length;
-          i += increment
-        ) {
-          candidateNode = values[i];
+      const values = getValues(node);
+      let candidateNode;
+
+      let backwards = idx < 0;
+      const increment = backwards ? -1 : 1;
+      for (
+        let i = backwards ? values.length - 1 : 0;
+        backwards ? i >= 0 : i < values.length;
+        i += increment
+      ) {
+        let value = values[i];
+        if (isArray(value) && path.size < depth - 1) {
+          candidateNode = value;
+
           const sum = getSize(candidateNode);
+
           const nextCount = currentIdx + sum * direction;
-          if (backwards ? nextCount <= targetIdx : nextCount > targetIdx || nextCount >= treeSum) {
+          if (
+            (backwards ? nextCount <= targetIdx : nextCount > targetIdx) ||
+            (backwards ? nextCount < 0 : nextCount >= treeSum)
+          ) {
             path = path.push({ index: i, node });
             node = candidateNode;
             continue stack;
           } else {
             currentIdx += sum * direction;
           }
+        } else {
+          const sum = getSize(value);
+          const nextCount = currentIdx + sum * direction;
+          if (!isFinite(targetIdx)) {
+            return path.push({ index: targetIdx, node });
+          } else if (currentIdx === targetIdx) {
+            return path.push({ index: i, node });
+          } else if (
+            backwards
+              ? nextCount < targetIdx || nextCount < 0
+              : nextCount > targetIdx || nextCount >= treeSum
+          ) {
+            break;
+          } else {
+            currentIdx += direction;
+          }
         }
       }
+      return path.push({ index: backwards ? -Infinity : Infinity, node });
     }
 
     return null;
@@ -414,14 +506,15 @@ export const buildModule = (
     nodeCollapses,
     nodeCanDonate,
     pop,
+    removeAt,
     push,
     addAt,
+    concat,
     isValidNode,
     assertValidNode,
     getValues,
     getSums,
     setValues,
-    isLeafNode,
     traverse,
     getSize,
     findPath,

package/lib/index.js

@@ -20,7 +20,6 @@ export const {
   getValues,
   getSums,
   setValues,
-  isLeafNode,
   traverse,
   getSize,
   findPath,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/btree",
   "description": "Functional utilities for working with btrees such as those used in agAST",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -16,7 +16,7 @@
     "test": "mocha test/*.test.js"
   },
   "dependencies": {
-    "@iter-tools/imm-stack": "1.1.0"
+    "@iter-tools/imm-stack": "1.2.0"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#c97bfa4b3663f8378e9b3e42bb5a41e685406cf9",