@bablr/agast-helpers 0.10.2 → 0.10.4

package/lib/builders.js

@@ -18,7 +18,7 @@ import {
   TreeNode,
 } from './symbols.js';
 
-const { freeze } = Object;
+const { freeze, values } = Object;
 const { isArray } = Array;
 
 export const deepFreeze = (object) => {
@@ -27,16 +27,28 @@ export const deepFreeze = (object) => {
     let item = list.value;
     list = list.pop();
 
-    for (const value of Object.values(item)) {
+    for (const value of values(item)) {
       if (isObject(value)) {
         list = list.push(value);
       }
     }
 
-    Object.freeze(item);
+    freeze(item);
   }
 };
 
+export const buildSpan = (name, guard = null, props = {}) => {
+  if (!name) throw new Error();
+  deepFreeze(props);
+  return freeze({ type: 'Explicit', name, guard, props });
+};
+
+export const buildTypedSpan = (type, name, guard = null, props = {}) => {
+  if (!type || !name) throw new Error();
+  deepFreeze(props);
+  return freeze({ type, name, guard, props });
+};
+
 export const buildProperty = (tags, shift) => {
   if (shift && !shift.index) throw new Error();
   freeze(tags);
@@ -163,7 +175,7 @@ export const buildShiftTag = () => {
   return freeze({ type: ShiftTag, value });
 };
 
-export const buildDoctypeTag = (version = 0, attributes = Object.freeze({})) => {
+export const buildDoctypeTag = (version = 0, attributes = freeze({})) => {
   return freeze({
     type: DoctypeTag,
     value: freeze({ doctype: 'cstml', version, attributes }),

package/lib/path.js

@@ -377,10 +377,10 @@ export const getChildPropertyIndex = (agAstNode, tagsIndex) => {
 
       if (Array.isArray(value)) {
         let childNode = value;
-        let { references } = Tags.getSums(childNode);
+        let { names } = Tags.getSums(childNode);
 
         let res;
-        if ((res = Tags.getAtName(name, references))) {
+        if ((res = Tags.getAtName(name, names))) {
           count += res;
         }
       }
@@ -401,7 +401,7 @@ export const getPropertyTagsIndex = (agAstNode, type, name, index, shiftIndex) =
   let prop = firstPropsIndex == null ? null : Tags.getAt(firstPropsIndex, getTags(agAstNode));
   let ref = prop?.value.reference;
   let sums = Tags.getSums(agAstNode.value.tags);
-  let counts = name ? sums.references : sums.specialTypes;
+  let counts = name ? sums.names : sums.types;
 
   if (ref?.flags.array) {
     if (index < 0) {
@@ -453,9 +453,7 @@ const __getPropertyTagsIndex = (agAstNode, type, name, index) => {
     if (!sums) return null;
 
     let valueNameCount =
-      name != null
-        ? Tags.getAtName(name, sums.references)
-        : Tags.getAtName(type, sums.specialTypes);
+      name != null ? Tags.getAtName(name, sums.names) : Tags.getAtName(type, sums.types);
 
     if (nameCount + valueNameCount < index) {
       return null;
@@ -484,8 +482,8 @@ const __getPropertyTagsIndex = (agAstNode, type, name, index) => {
         if (
           nameCount +
             (name != null
-              ? Tags.getAtName(name, valueSums.references)
-              : Tags.getAtName(type, valueSums.specialTypes)) >
+              ? Tags.getAtName(name, valueSums.names)
+              : Tags.getAtName(type, valueSums.types)) >
           index
         ) {
           node = value;
@@ -493,8 +491,8 @@ const __getPropertyTagsIndex = (agAstNode, type, name, index) => {
         } else {
           nameCount +=
             (name != null
-              ? Tags.getAtName(name, valueSums.references)
-              : Tags.getAtName(type, valueSums.specialTypes)) ?? 0;
+              ? Tags.getAtName(name, valueSums.names)
+              : Tags.getAtName(type, valueSums.types)) ?? 0;
           idx += Tags.getSize(value);
         }
       }
@@ -653,7 +651,7 @@ export const countList = (name, node) => {
 
   if (name == null) throw new Error('Bad path');
 
-  return Tags.getAtName(name, Tags.getSums(getTags(node)).references);
+  return Tags.getAtName(name, Tags.getSums(getTags(node)).names);
 };
 
 export function* allTagPathsFor(range, options = {}) {
@@ -1473,7 +1471,7 @@ export const Path = class AgastPath {
             rootIdx != null &&
             !referencesAreEqual(
               tag.value,
-              Tags.getAt(rootIdx, getTags(targetPath.node)).value.property.reference,
+              Tags.getAt(rootIdx, getTags(targetPath.node)).value.reference,
             )
           ) {
             throw new Error('mismatched references');

package/lib/spans.js

@@ -0,0 +1,163 @@
+import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
+
+const { isArray } = Array;
+const { freeze } = Object;
+
+export { defaultNodeSize };
+
+const __getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.length - 1) => {
+  if (!sortedArray.length || endIdx < startIdx) return null;
+
+  let idx = startIdx + Math.floor((endIdx - startIdx) / 2 + 0.1);
+  let entry = sortedArray[idx];
+  let { 0: key, 1: value } = entry;
+
+  let direction = compareNames(name, key);
+
+  if (direction === 0) {
+    return value;
+  } else {
+    if (startIdx === endIdx) return null;
+
+    if (direction > 0) {
+      return __getAtName(name, sortedArray, idx + 1, endIdx);
+    } else {
+      return __getAtName(name, sortedArray, startIdx, idx - 1);
+    }
+  }
+};
+
+export const getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.length - 1) => {
+  return __getAtName(name, sortedArray, startIdx, endIdx);
+};
+
+export const compareNames = (a, b) => (a > b ? 1 : b > a ? -1 : 0);
+
+export const sumValues = (values) => {
+  let mapStats = values.reduce(
+    (acc, val) => {
+      const { names } = acc;
+      if (isArray(val)) {
+        let arr = getSums(val).names;
+        let map = names;
+
+        for (const { 0: key, 1: value } of arr) {
+          let count = map.get(key)?.[1] ?? 0;
+
+          map.set(key, freeze([key, count + value]));
+        }
+      } else if (val) {
+        let span = val;
+
+        const { name } = span;
+
+        if (name) {
+          let count = names.get(name)?.[1] ?? 0;
+
+          names.set(name, freeze([name, count + 1]));
+        }
+      }
+      return acc;
+    },
+    {
+      names: new Map(),
+    },
+  );
+
+  let stats = {
+    names: [...mapStats.names.values()].sort((a, b) => compareNames(a[0], b[0])),
+  };
+  freeze(stats);
+  freeze(stats.names);
+  return stats;
+};
+
+const module_ = buildModule(defaultNodeSize, sumValues);
+
+const {
+  from,
+  fromValues,
+  push,
+  pop,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getSize,
+  getValues,
+  getSums,
+  setValues,
+  traverse,
+  traverseInner,
+  findPath,
+  getAt,
+  replaceAt,
+  removeAt,
+} = module_;
+
+const getSpan = (name, spans) => {
+  let nameCount = 0;
+  let node = spans;
+  let idx = -1;
+  let index = getAtName(name, getSums(spans).names);
+
+  // drill into subtrees, passing over subtrees with too few references of the desired name
+  outer: while (node) {
+    let sums = getSums(node);
+
+    if (!sums) return null;
+
+    let valueNameCount = getAtName(name, sums.names);
+
+    if (nameCount + valueNameCount < index) {
+      return null;
+    }
+
+    for (const value of getValues(node)) {
+      if (!isArray(value)) {
+        idx++;
+        let span = value;
+
+        if (name != null && span.name === name) {
+          nameCount += 1;
+          if (nameCount === index) {
+            return getAt(idx, spans);
+          }
+        }
+      } else {
+        let valueSums = getSums(value);
+        if (nameCount + getAtName(name, valueSums.names) > index) {
+          node = value;
+          continue outer;
+        } else {
+          nameCount += getAtName(name, valueSums.names) ?? 0;
+          idx += getSize(value);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  return null;
+};
+
+export {
+  from,
+  fromValues,
+  push,
+  pop,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getSize,
+  getValues,
+  getSums,
+  setValues,
+  traverse,
+  traverseInner,
+  findPath,
+  getAt,
+  replaceAt,
+  removeAt,
+  getSpan,
+};

package/lib/tags.js

@@ -48,14 +48,14 @@ export const compareNames = (a, b) => (a > b ? 1 : b > a ? -1 : 0);
 export const sumValues = (values) => {
   let mapStats = values.reduce(
     (acc, val) => {
-      const { references, specialTypes } = acc;
+      const { names, types } = acc;
       if (isArray(val)) {
         acc.lineBreaks += getSums(val).lineBreaks;
         acc.gaps += getSums(val).gaps;
 
         let arrs = [
-          [getSums(val).references, references],
-          [getSums(val).specialTypes, specialTypes],
+          [getSums(val).names, names],
+          [getSums(val).types, types],
         ];
 
         for (let { 0: arr, 1: map } of arrs) {
@@ -89,17 +89,19 @@ export const sumValues = (values) => {
             const { type, name } = ref;
 
             if (name) {
-              let count = references.get(name)?.[1] ?? 0;
+              let count = names.get(name)?.[1] ?? 0;
 
               if (!ref.flags.array && referenceIsSingular(ref) && count > 0) throw new Error();
 
-              references.set(name, freeze([name, count + 1, ref]));
-            } else {
-              let count = specialTypes.get(type)?.[1] ?? 0;
+              names.set(name, freeze([name, count + 1, ref]));
+            }
+
+            if (type) {
+              let count = types.get(type)?.[1] ?? 0;
 
               if (!ref.flags.array && referenceIsSingular(ref) && count > 0) throw new Error();
 
-              specialTypes.set(type, freeze([type, count + 1, ref]));
+              types.set(type, freeze([type, count + 1, ref]));
             }
           }
         }
@@ -109,8 +111,8 @@ export const sumValues = (values) => {
     {
       gaps: 0,
       lineBreaks: 0,
-      references: new Map(),
-      specialTypes: new Map(),
+      names: new Map(),
+      types: new Map(),
     },
   );
 
@@ -118,12 +120,12 @@ export const sumValues = (values) => {
   let stats = {
     gaps,
     lineBreaks,
-    references: [...mapStats.references.values()].sort((a, b) => compareNames(a[0], b[0])),
-    specialTypes: [...mapStats.specialTypes.values()].sort((a, b) => compareNames(a[0], b[0])),
+    names: [...mapStats.names.values()].sort((a, b) => compareNames(a[0], b[0])),
+    types: [...mapStats.types.values()].sort((a, b) => compareNames(a[0], b[0])),
   };
   freeze(stats);
-  freeze(stats.references);
-  freeze(stats.specialTypes);
+  freeze(stats.names);
+  freeze(stats.types);
   return stats;
 };
 

package/lib/template.js

@@ -1,5 +1,5 @@
 import * as t from './builders.js';
-import { getTags, isMultiFragment, Path } from './path.js';
+import { buildNullNode, getTags, isMultiFragment, Path } from './path.js';
 import { OpenNodeTag, CloseNodeTag, DoctypeTag, Property, GapNode } from './symbols.js';
 import * as Tags from './tags.js';
 import { getOpenTag, isNull } from './tree.js';
@@ -21,7 +21,7 @@ export const interpolate = (node, expressions) => {
       let tag;
       while ((tag = Tags.getAt(i, getTags(path.node)))) {
         if (path.node.type === GapNode) {
-          path = path.replaceWith(expression);
+          path = path.replaceWith(expression ?? buildNullNode());
           continue outer;
         } else if (tag.type === Property && tag.value.tags[2]) {
           let tags = getTags(tag.value.tags[2]);

package/lib/tree.js

@@ -167,8 +167,8 @@ function* __streamFromTree(doctypeTag, rootNode, options) {
       if (tagPath.tag.type === CloseNodeTag) count--;
 
       let gapNode;
-      if (getGapNode && tagPath.tag.type === GapTag && (gapNode = getGapNode(tagPath.tag))) {
-        stack.push({ tagPath, count });
+      if (getGapNode && tagPath.tag.type === GapTag && (gapNode = getGapNode(tagPath.path.node))) {
+        stack.push({ tagPath: unshift ? tagPath.nextUnshifted : tagPath.next, count });
         tagPath = TagPath.fromNode(gapNode, 0);
         count = 0;
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-helpers",
   "description": "Helper functions for working with agAST trees",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -15,6 +15,7 @@
     "./path": "./lib/path.js",
     "./print": "./lib/print.js",
     "./shorthand": "./lib/shorthand.js",
+    "./spans": "./lib/spans.js",
     "./stream": "./lib/stream.js",
     "./symbols": "./lib/symbols.js",
     "./tags": "./lib/tags.js",
@@ -26,7 +27,7 @@
     "test": "mocha test/*.test.js"
   },
   "dependencies": {
-    "@bablr/btree": "0.4.3",
+    "@bablr/btree": "0.4.4",
     "@bablr/coroutine": "0.1.0",
     "@bablr/stream-iterator": "2.0.0",
     "@iter-tools/imm-stack": "1.2.0"