@bablr/btree 0.4.1 → 0.4.2

package/README.md

@@ -1,18 +1,19 @@
 # @bablr/btree
 
-Functional utilities for working with btrees such as those used in agAST.
+This library offers a set of functional utilities for working with immutable btrees such as those used in agAST.
 
 ```js
-expect(push(['a', 'b'], 'c')).toEqual([
-  3,
-  [['a'], ['b', 'c']],
-]);
+import * as btree from '@bablr/btree';
 
-expect(addAt(0, [3, [['x'], ['y', 'z']]], 'w')).toEqual([
-  4,
-  [
-    ['w', 'x'],
-    ['y', 'z'],
-  ],
-]);
+let tree = btree.fromValues([]);
+tree = btree.push('a');
+tree = btree.push('b');
+tree = btree.push('c');
+let tree3 = tree;
+tree = btree.concat(tree, tree);
+tree = btree.concat(tree3, tree);
+
+btree.getSize(tree); // 9
+btree.getAt(-2, tree); // 'b'
+[...btree.traverse(tree)]; // ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
 ```

package/lib/enhanceable.js

@@ -1,17 +1,31 @@
-import emptyStack from '@iter-tools/imm-stack';
-
 const { isArray } = Array;
 const { freeze } = Object;
 const { isFinite } = Number;
 
 export const defaultNodeSize = 8;
 
-export const buildModule = (
-  NODE_SIZE = defaultNodeSize,
-  statsReducer,
-  getSumsInitial,
-  finalizeSums,
-) => {
+export const deepFreeze = (object) => {
+  let stack = [object];
+  while (stack.length) {
+    let item = stack[stack.length - 1];
+    stack.pop();
+
+    for (const value of Object.values(item)) {
+      if (value && typeof value === 'object') {
+        if (
+          !(Array.isArray(value) || [Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        )
+          throw new Error();
+        stack.push(value);
+      }
+    }
+
+    Object.freeze(item);
+  }
+  return object;
+};
+
+export const buildModule = (NODE_SIZE = defaultNodeSize, buildStats) => {
   const sumNodes = (nodes) => {
     return nodes.map(getSize).reduce((a, b) => a + b, 0);
   };
@@ -29,7 +43,8 @@ export const buildModule = (
   };
 
   const treeFrom = (...values) => {
-    if (!statsReducer && values.length <= NODE_SIZE) {
+    validateValues(values);
+    if (!buildStats && values.length <= NODE_SIZE) {
       return freeze(values);
     } else {
       let tree = [];
@@ -40,19 +55,14 @@ export const buildModule = (
     }
   };
 
-  const buildStats = (values) => {
-    let sums = values.reduce(statsReducer, getSumsInitial());
-    sums = finalizeSums(sums);
-    return sums;
-  };
-
   const treeFromValues = (values) => {
-    if (values.includes(undefined)) throw new Error();
-    if (!statsReducer && values.length <= NODE_SIZE) {
+    validateValues(values);
+
+    if (!buildStats && values.length <= NODE_SIZE) {
       return isArray(values[0]) ? freeze([sumNodes(values), freeze(values)]) : freeze(values);
     } else {
       if (values.length <= NODE_SIZE) {
-        if (statsReducer) {
+        if (buildStats) {
           return freeze([sumNodes(values), freeze(values), buildStats(values)]);
         } else {
           return freeze([sumNodes(values), freeze(values)]);
@@ -91,11 +101,11 @@ export const buildModule = (
 
     let midIndex;
 
-    if (isLeaf) {
-      midIndex = Math.floor(values.length / 2 + 0.01);
-    } else {
-      midIndex = findBalancePoint(values);
-    }
+    // if (isLeaf) {
+    midIndex = Math.floor(values.length / 2 + 0.01);
+    // } else {
+    //   midIndex = findBalancePoint(values);
+    // }
 
     let leftValues = values.slice(0, midIndex);
     let rightValues = values.slice(midIndex);
@@ -125,60 +135,46 @@ export const buildModule = (
     let firstValues = getValues(first);
     let secondValues = getValues(second);
 
+    if (!secondValues.length) return first;
+    if (!firstValues.length) return second;
+
     if (firstHeight === secondHeight) {
-      if (firstValues.length + secondValues.length < NODE_SIZE) {
+      if (firstValues.length + secondValues.length <= NODE_SIZE) {
         return treeFromValues([...firstValues, ...secondValues]);
       } else {
-        return treeFromValues([first, second]);
+        let { leftValues, rightValues } = splitValues([...firstValues, ...secondValues]);
+        return treeFromValues([treeFromValues(leftValues), treeFromValues(rightValues)]);
       }
     } 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 tree = firstHeight <= secondHeight ? second : first;
       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 (!nodeCollapses(pushout)) {
+        let targetIndex = firstHeight > secondHeight ? getSize(tree) : 0;
+        return addAt(targetIndex, tree, pushout);
+      } else {
+        let depth = Math.abs(firstHeight - secondHeight) - 1;
+        let targetIndex = firstHeight > secondHeight ? getSize(tree) - 1 : 0;
+        let targetPath = findPath(targetIndex, tree, depth);
+        let lastIndex = targetPath.length - 1;
+        let targetNode = getValues(targetPath[lastIndex].node)[targetPath[lastIndex].index];
+        let combinedValues =
+          firstHeight > secondHeight
+            ? [...getValues(targetNode), ...getValues(pushout)]
+            : [...getValues(pushout), ...getValues(targetNode)];
+        if (getValues(pushout).length + getValues(targetNode).length <= NODE_SIZE) {
+          return replaceAt(targetIndex, tree, treeFromValues(combinedValues));
+        } else {
+          let { leftValues, rightValues } = splitValues(combinedValues);
 
-        if (path.size === 1) {
-          if (pushout) {
-            return treeFromValues([pushout, node]);
+          if (firstHeight > secondHeight) {
+            return replaceAt(targetIndex, addAt(targetIndex + 1, tree, rightValues), leftValues);
+            // return addAt(targetIndex + 1, replaceAt(targetIndex, tree, leftValues), rightValues);
           } else {
-            return node;
+            // TODO change order of operations like above?
+            return addAt(targetIndex, replaceAt(targetIndex, tree, rightValues), leftValues);
           }
         }
-
-        const poppedNode = node;
-        path = path.pop();
-        ({ node, index } = path.value);
-
-        node = setValuesAt(index, node, poppedNode);
-        values = getValues(node);
-        path = path.replace({ node, index });
       }
     }
   };
@@ -188,9 +184,10 @@ export const buildModule = (
     if (!isArray(tree)) throw new Error();
     if (!value) throw new Error();
 
-    let path = findPath(idx, tree);
+    let path = findPath(idx, tree, getHeight(tree) - getHeight(value) - 1);
 
-    let { node, index } = path.value;
+    let pathIdx = path.length - 1;
+    let { node, index } = path[pathIdx];
 
     let pushout = value;
 
@@ -203,7 +200,7 @@ export const buildModule = (
         let finiteIndex = index === Infinity ? values.length : index;
 
         if (!isFinite(finiteIndex)) throw new Error();
-        if (values.length + getValues(pushout).length > NODE_SIZE) {
+        if (values.length + (pushout ? 1 : 0) > NODE_SIZE) {
           values.splice(finiteIndex, 0, pushout);
           const { leftValues, rightValues } = splitValues(values);
 
@@ -216,7 +213,7 @@ export const buildModule = (
         }
       }
 
-      if (path.size === 1) {
+      if (pathIdx === 0) {
         if (pushout) {
           return treeFromValues([pushout, node]);
         } else {
@@ -225,12 +222,11 @@ export const buildModule = (
       }
 
       const poppedNode = node;
-      path = path.pop();
-      ({ node, index } = path.value);
+      pathIdx--;
+      ({ node, index } = path[pathIdx]);
 
       node = setValuesAt(index, node, poppedNode);
       values = getValues(node);
-      path = path.replace({ node, index });
     }
   };
 
@@ -240,7 +236,7 @@ export const buildModule = (
   };
 
   const collapses = (size) => {
-    return size > NODE_SIZE / 2 + 0.01;
+    return size < NODE_SIZE / 2 - 0.01;
   };
 
   const nodeCollapses = (node) => {
@@ -248,13 +244,16 @@ export const buildModule = (
   };
 
   const nodeCanDonate = (node) => {
-    return collapses(getValues(node).length - 1);
+    return !collapses(getValues(node).length - 1);
   };
 
   const removeAt = (idx, tree) => {
+    if (idx > getSize(tree)) throw new Error('Index exceeds tree bounds');
+
     let path = findPath(idx, tree);
 
-    let { node, index } = path.value;
+    let pathIdx = path.length - 1;
+    let { node, index } = path[pathIdx];
 
     const initialValues = [...getValues(node)];
 
@@ -266,8 +265,8 @@ export const buildModule = (
       let values = getValues(returnValue);
       let adjustSibling = null;
 
-      if (path.size > 1 && nodeCollapses(returnValue)) {
-        let { node: parentNode, index: parentIndex } = path.prev.value;
+      if (pathIdx >= 1 && nodeCollapses(returnValue)) {
+        let { node: parentNode, index: parentIndex } = path[pathIdx - 1];
         const prevSibling = getValues(parentNode)[parentIndex - 1];
         const nextSibling = getValues(parentNode)[parentIndex + 1];
         let targetSibling = nodeCanDonate(prevSibling)
@@ -297,15 +296,12 @@ export const buildModule = (
         }
       }
 
-      if (path.size === 1) {
-        if (getSize(returnValue) <= NODE_SIZE) {
-          returnValue = setValues(returnValue, getValues(returnValue).flat());
-        }
+      if (pathIdx === 0) {
         return returnValue;
       }
 
-      path = path.pop();
-      ({ node, index } = path.value);
+      pathIdx--;
+      ({ node, index } = path[pathIdx]);
 
       values = getValues(node).slice();
 
@@ -328,6 +324,20 @@ export const buildModule = (
     return removeAt(-1, tree);
   };
 
+  const validateValues = (values) => {
+    if (values.length > NODE_SIZE) throw new Error();
+    if (!values.length) return;
+
+    let nodeIsLeaf = !isArray(values[0]);
+    for (let value of values) {
+      if (!nodeIsLeaf && nodeCollapses(value)) {
+        throw new Error('invalid btree: uncollapsed node');
+      } else if (!nodeIsLeaf && value == null) {
+        throw new Error('invalid btree: nil sibling');
+      }
+    }
+  };
+
   const isValidNode = (node) => {
     if (!isArray(node)) return false;
     const values = getValues(node);
@@ -347,22 +357,27 @@ export const buildModule = (
 
   const getSums = (node) => {
     if (!isValidNode(node)) throw new Error();
-    return node[2];
+    let sums = Number.isFinite(node[0]) ? node[2] : null;
+    return sums || (buildStats ? buildStats(getValues(node)) : null);
   };
 
   const setValues = (node, values) => {
-    if (values.length > NODE_SIZE) throw new Error();
+    if (isFinite(node[0]) || buildStats) {
+      return treeFromValues(values);
+    }
+
+    validateValues(values);
 
-    return isFinite(node[0]) || statsReducer ? treeFromValues(values) : freeze(values);
+    return freeze(values);
   };
 
   function* traverse(tree) {
-    let states = emptyStack.push({ node: tree, i: 0 });
+    let states = [{ node: tree, i: 0 }];
 
     assertValidNode(tree);
 
-    stack: while (states.size) {
-      const s = states.value;
+    stack: while (states.length) {
+      const s = states[states.length - 1];
       const { node } = s;
 
       const values = getValues(node);
@@ -372,7 +387,7 @@ export const buildModule = (
         if (isArray(value)) {
           let node = value;
           assertValidNode(node);
-          states = states.push({ node, i: 0 });
+          states.push({ node, i: 0 });
           i = ++s.i;
           continue stack;
         } else {
@@ -381,7 +396,7 @@ export const buildModule = (
         }
       }
 
-      states = states.pop();
+      states.pop();
     }
   }
 
@@ -399,15 +414,33 @@ export const buildModule = (
 
   const findPath = (idx, tree, depth = Infinity) => {
     if (idx == null) throw new Error();
+    if (tree && !isArray(tree)) throw new Error();
 
-    let path = emptyStack;
+    let path = [];
+    let node = tree;
+
+    if (isArray(idx)) {
+      for (let seg of idx) {
+        let index = typeof seg !== 'object' ? seg : seg.index;
+        if (typeof index === 'string') throw new Error();
+        if (!isArray(node)) return null;
+        let index_ = index < 0 ? getSize(node) + index : index;
+        path.push({ index: index_, node });
+        node = getValues(node)[index_];
+        if (node && !isArray(node)) {
+          return freeze(path);
+        }
+        if (!node) return null;
+      }
+
+      return freeze(path);
+    }
 
     let treeSum = getSize(tree);
     let currentIdx = idx < 0 ? treeSum - 1 : 0;
     let direction = idx < 0 ? -1 : 1;
     let targetIdx = idx < 0 ? treeSum + idx : idx;
 
-    let node = tree;
     stack: while (node) {
       assertValidNode(node);
 
@@ -422,17 +455,16 @@ export const buildModule = (
         i += increment
       ) {
         let value = values[i];
-        if (isArray(value) && path.size < depth - 1) {
+        if (isArray(value) && path.length < depth) {
           candidateNode = value;
 
           const sum = getSize(candidateNode);
-
-          const nextCount = currentIdx + sum * direction;
+          const nextIndex = currentIdx + sum * direction;
           if (
-            (backwards ? nextCount <= targetIdx : nextCount > targetIdx) ||
-            (backwards ? nextCount < 0 : nextCount >= treeSum)
+            (backwards ? nextIndex < targetIdx : nextIndex > targetIdx) ||
+            (backwards ? nextIndex < 0 : nextIndex >= treeSum)
           ) {
-            path = path.push({ index: i, node });
+            path.push({ index: i, node });
             node = candidateNode;
             continue stack;
           } else {
@@ -440,35 +472,43 @@ export const buildModule = (
           }
         } else {
           const sum = getSize(value);
-          const nextCount = currentIdx + sum * direction;
+          const nextIndex = currentIdx + sum * direction;
           if (!isFinite(targetIdx)) {
-            return path.push({ index: targetIdx, node });
-          } else if (currentIdx === targetIdx) {
-            return path.push({ index: i, node });
+            path.push({ index: targetIdx, node });
+
+            return freeze(path);
+          } else if (backwards ? nextIndex < targetIdx : nextIndex > targetIdx) {
+            path.push({ index: i, node });
+
+            return freeze(path);
           } else if (
             backwards
-              ? nextCount < targetIdx || nextCount < 0
-              : nextCount > targetIdx || nextCount >= treeSum
+              ? nextIndex < targetIdx || nextIndex < 0
+              : nextIndex > targetIdx || nextIndex >= treeSum
           ) {
             break;
           } else {
-            currentIdx += direction;
+            currentIdx += direction * sum;
           }
         }
       }
-      return path.push({ index: backwards ? -Infinity : Infinity, node });
+
+      path.push({ index: backwards ? -Infinity : Infinity, node });
+
+      return freeze(path);
     }
 
     return null;
   };
 
   const getAt = (idx, tree) => {
-    const v = findPath(idx, tree)?.value;
-    return v && getValues(v.node)[v.index];
+    const path = findPath(idx, tree);
+    let seg = path && path[path.length - 1];
+    return seg && getValues(seg.node)[seg.index];
   };
 
   const replaceAt = (idx, tree, value) => {
-    let path = findPath(idx, tree);
+    let path = findPath(idx, tree, getHeight(tree) - getHeight(value) - 1);
 
     if (getSize(tree) < idx) {
       throw new Error('Cannot add past the end of a list');
@@ -476,16 +516,17 @@ export const buildModule = (
       return addAt(idx, tree, value);
     }
 
-    let { node, index } = path.value;
+    let pathIndex = path.length - 1;
+    let { node, index } = path[pathIndex];
 
     let returnValue = setValuesAt(index, node, value);
 
     for (;;) {
-      ({ node, index } = path.value);
+      ({ node, index } = path[pathIndex]);
 
-      if (path.size > 1) {
-        path = path.pop();
-        ({ node, index } = path.value);
+      if (pathIndex > 0) {
+        pathIndex--;
+        ({ node, index } = path[pathIndex]);
 
         returnValue = setValuesAt(index, node, returnValue);
       } else {

package/lib/index.js

@@ -1,6 +1,6 @@
-import { defaultNodeSize, buildModule } from './enhanceable.js';
+import { defaultNodeSize, deepFreeze, buildModule } from './enhanceable.js';
 
-export { defaultNodeSize };
+export { defaultNodeSize, deepFreeze };
 
 export const {
   btreeFrom,
@@ -14,6 +14,7 @@ export const {
   nodeCanDonate,
   pop,
   push,
+  concat,
   addAt,
   isValidNode,
   assertValidNode,

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.1",
+  "version": "0.4.2",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -15,9 +15,7 @@
   "scripts": {
     "test": "mocha test/*.test.js"
   },
-  "dependencies": {
-    "@iter-tools/imm-stack": "1.2.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#c97bfa4b3663f8378e9b3e42bb5a41e685406cf9",
     "enhanced-resolve": "^5.12.0",
@@ -29,7 +27,10 @@
     "mocha": "10.7.3",
     "prettier": "^2.6.2"
   },
-  "repository": "github:bablr-lang/btree",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bablr-lang/btree.git"
+  },
   "homepage": "https://github.com/bablr-lang/btree",
   "license": "MIT"
 }