@bablr/agast-helpers 0.10.10 → 0.11.0

package/lib/symbols.js

@@ -5,6 +5,7 @@ export const ReferenceTag = Symbol.for('ReferenceTag');
 export const ShiftTag = Symbol.for('ShiftTag');
 export const GapTag = Symbol.for('GapTag');
 export const BindingTag = Symbol.for('BindingTag');
+export const StreamTag = Symbol.for('StreamTag');
 export const NullTag = Symbol.for('NullTag');
 export const AttributeDefinition = Symbol.for('AttributeDefinition');
 export const LiteralTag = Symbol.for('LiteralTag');

package/lib/tags.js

@@ -1,5 +1,6 @@
 import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
 import {
+  ReferenceTag,
   AttributeDefinition,
   CloseNodeTag,
   GapTag,
@@ -7,22 +8,59 @@ import {
   OpenNodeTag,
   Property,
   ShiftTag,
+  TreeNode,
+  GapNode,
+  NullNode,
+  BindingTag,
+  Document,
 } from './symbols.js';
-import { isObject } from './object.js';
-import { referenceIsSingular } from './path.js';
-import { buildReference } from './builders.js';
+import { freezeRecord, isArray, isObject, isString } from './object.js';
+import { buildReference, parseTag, parseTagType } from './builders.js';
+import { printTag } from './print.js';
+import { arrayValues } from './iterable.js';
 
-const { isArray } = Array;
-const { freeze } = Object;
+let { reduce } = Array.prototype;
 
 export { defaultNodeSize };
 
-const __getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.length - 1) => {
+export const referenceIsSingular = (ref) => {
+  return !ref.flags.array && !['#', '@', '.'].includes(ref.type);
+};
+
+export const referencesAreEqual = (a, b) => {
+  return (
+    a === b ||
+    (a.type === b.type &&
+      a.name === b.name &&
+      a.flags.array === b.flags.array &&
+      a.flags.intrinsic === b.flags.intrinsic &&
+      a.flags.hasGap === b.flags.hasGap &&
+      a.flags.expression === b.flags.expression)
+  );
+};
+
+export const getTags = (node) => {
+  switch (node.type) {
+    case TreeNode:
+      return node.value.tags;
+    case NullNode:
+      return node.value.tags;
+    case GapNode:
+      return node.value.tags;
+    case Document:
+      return getTags(node.value.tree);
+    default:
+      throw new Error();
+  }
+};
+
+const __findStats = (name, sortedArray, startIdx, endIdx) => {
   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 skipIdx = idx * 3;
+  let key = sortedArray[skipIdx];
+  let value = sortedArray[skipIdx + 1];
 
   let direction = compareNames(name, key);
 
@@ -32,21 +70,127 @@ const __getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.lengt
     if (startIdx === endIdx) return null;
 
     if (direction > 0) {
-      return __getAtName(name, sortedArray, idx + 1, endIdx);
+      return __findStats(name, sortedArray, idx + 1, endIdx);
+    } else {
+      return __findStats(name, sortedArray, startIdx, idx - 1);
+    }
+  }
+};
+
+export const findStats = (name, sortedArray, startIdx = 0, endIdx = sortedArray.length / 3 - 1) => {
+  return __findStats(name, sortedArray, startIdx, endIdx);
+};
+
+export const getIndex = (pathSegment, tags) => {
+  let { type, name, index, shiftIndex } = pathSegment;
+  let firstPropsIndex = __getPropertyTagsIndex(tags, type, name, 0);
+  let prop = firstPropsIndex == null ? null : getAt(firstPropsIndex, tags);
+  let ref = prop?.value.reference;
+  let sums = getSums(tags);
+  let counts = name ? sums.names : sums.types;
+
+  if (ref?.flags.array) {
+    if (index < 0) {
+      index = findStats(type, counts) + index;
+    } else if (index == null) {
+      index = findStats(name, counts) - 1;
+
+      if (index < 0) return null;
+    }
+  }
+
+  let parentIndex = __getPropertyTagsIndex(tags, type, name, index ?? 0);
+
+  if (parentIndex != null && ref?.flags.expression) {
+    let shiftIndex_ = shiftIndex == null ? -1 : shiftIndex;
+    if (shiftIndex_ < 0) {
+      let shifts = 0;
+      // TODO speed this up for deeply nested shifts
+      // algorithm: make big jump forward, then look at shift index to see if we overshot completely
+      // works because we know the size of the thing and a bigger thing doesn't fit in a smaller one
+      while (getAt(parentIndex + shifts, getValues(tags)[1])?.value.shift) {
+        shifts++;
+      }
+
+      if (-shiftIndex_ > shifts + 1) return null;
+
+      return parentIndex + shifts + shiftIndex_ + 1;
     } else {
-      return __getAtName(name, sortedArray, startIdx, idx - 1);
+      if (parentIndex + shiftIndex_ >= getSize(tags)) {
+        return null;
+      }
+
+      return parentIndex + shiftIndex_;
     }
   }
+
+  return parentIndex;
 };
 
-export const getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.length - 1) => {
-  return __getAtName(name, sortedArray, startIdx, endIdx);
+const __getPropertyTagsIndex = (tags, type, name, index) => {
+  let nameCount = 0;
+  let node = getValues(tags)[1];
+  let idx = -1;
+
+  // drill into subtrees, passing over subtrees with too few references of the desired name
+  outer: while (node) {
+    let sums = getSums(node);
+
+    if (!sums) throw new Error();
+
+    let valueNameCount = name != null ? findStats(name, sums.names) : findStats(type, sums.types);
+
+    if (nameCount + valueNameCount < index) {
+      return null;
+    }
+
+    for (const value of arrayValues(getValues(node))) {
+      if (!isNode(value)) {
+        idx++;
+        let tag = value;
+        if (isObject(tag) && tag.type === Property) {
+          let { tags, reference } = tag.value;
+          if (parseTagType(tags[1][0]) === ReferenceTag) {
+            if (
+              (name != null && reference.name === name) ||
+              (type != null && reference.type === type)
+            ) {
+              nameCount += 1;
+              if (nameCount > index) {
+                return idx + 1;
+              }
+            }
+          }
+        }
+      } else {
+        let valueSums = getSums(value);
+        if (
+          nameCount +
+            (name != null ? findStats(name, valueSums.names) : findStats(type, valueSums.types)) >
+          index
+        ) {
+          node = value;
+          continue outer;
+        } else {
+          nameCount +=
+            (name != null ? findStats(name, valueSums.names) : findStats(type, valueSums.types)) ??
+            0;
+          idx += getSize(value);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  return null;
 };
 
 export const compareNames = (a, b) => (a > b ? 1 : b > a ? -1 : 0);
 
-export const sumValues = (values) => {
-  let mapStats = values.reduce(
+export const sumValues = (values, depth) => {
+  let mapStats = reduce.call(
+    values,
     (acc, val) => {
       const { names, types } = acc;
       if (isArray(val)) {
@@ -59,30 +203,35 @@ export const sumValues = (values) => {
         ];
 
         for (let { 0: arr, 1: map } of arrs) {
-          for (const { 0: key, 1: value, 2: reference } of arr) {
+          for (let i = 0; i < arr.length; i++) {
+            let key = arr[i];
+            let value = arr[++i];
+            let reference = arr[++i];
+
             let count = map.get(key)?.[1] ?? 0;
 
-            if (!reference.flags.array && referenceIsSingular(reference) && count > 0)
-              throw new Error();
+            if (referenceIsSingular(reference) && count > 0) throw new Error();
 
-            map.set(key, freeze([key, count + value, reference]));
+            map.set(key, [key, count + value, reference]);
           }
         }
       } else if (val) {
-        if (val.type === LiteralTag) {
-          let text = val.value;
+        let tag = parseTag(val);
+        if (tag.type === LiteralTag) {
+          let text = tag.value;
           let idx = 0;
           while ((idx = text.indexOf('\n', idx + 1)) >= 0) {
             acc.lineBreaks++;
           }
-        } else if (val.type === GapTag) {
+        } else if (tag.type === GapTag) {
           acc.gaps++;
-        } else if (val.type === Property) {
-          let { tags } = val.value;
-          let refOrShiftTag = tags[0];
+        } else if (tag.type === Property) {
+          let { tags } = tag.value;
+          if (!isArray(tags[1][0]) && !isString(tags[1][0])) throw new Error();
+          let refOrShiftTag = isArray(tags[1][0]) ? buildReference() : parseTag(tags[1][0]);
 
-          if (tags[2]) {
-            acc.gaps += tags[2].value.tags[2].gaps;
+          if (tags[1][2]) {
+            acc.gaps += tags[1][2].value.tags[2].gaps;
           }
           if (refOrShiftTag?.type !== ShiftTag) {
             let ref = refOrShiftTag?.value || buildReference();
@@ -91,17 +240,17 @@ export const sumValues = (values) => {
             if (name) {
               let count = names.get(name)?.[1] ?? 0;
 
-              if (!ref.flags.array && referenceIsSingular(ref) && count > 0) throw new Error();
+              if (referenceIsSingular(ref) && count > 0) throw new Error();
 
-              names.set(name, freeze([name, count + 1, ref]));
+              names.set(name, [name, count + 1, ref]);
             }
 
             if (type) {
               let count = types.get(type)?.[1] ?? 0;
 
-              if (!ref.flags.array && referenceIsSingular(ref) && count > 0) throw new Error();
+              if (referenceIsSingular(ref) && count > 0) throw new Error();
 
-              types.set(type, freeze([type, count + 1, ref]));
+              types.set(type, [type, count + 1, ref]);
             }
           }
         }
@@ -117,130 +266,146 @@ export const sumValues = (values) => {
   );
 
   let { lineBreaks, gaps } = mapStats;
-  let stats = {
+  let stats = freezeRecord({
     gaps,
     lineBreaks,
-    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.names);
-  freeze(stats.types);
+    names: freezeRecord(
+      [...mapStats.names.values()].sort((a, b) => compareNames(a[0], b[0])).flatMap((_) => _),
+    ),
+    types: freezeRecord(
+      [...mapStats.types.values()].sort((a, b) => compareNames(a[0], b[0])).flatMap((_) => _),
+    ),
+  });
   return stats;
 };
 
-const module_ = buildModule(defaultNodeSize, sumValues);
+const module_ = buildModule(defaultNodeSize, sumValues, Symbol.for('Tags'));
 
 const {
   from,
   fromValues,
+  create,
   addAt,
   isValidNode,
+  isNode,
   assertValidNode,
   getValues,
   getSums,
-  setValues,
+  getDepth,
+  getType,
   traverse,
   getSize,
   findPath,
 } = module_;
 
-const getAt = (idx, tags, propertyIndex) => {
-  if (propertyIndex !== undefined) {
-    throw new Error('propertyIndex');
+let { slice } = Array.prototype;
+
+const getAt = (idx, tags) => {
+  if (isArray(idx) && idx.length > 1) {
+    return module_.getAt(slice.call(idx, 1), module_.getAt(slice.call(idx, 0, 1), tags));
+  } else {
+    return module_.getAt(idx, tags);
   }
-  return module_.getAt(idx, tags);
 };
 
-const push = (tags, tag) => {
-  let firstTag = getAt(0, tags);
+const push = (tag, tags) => {
+  let tag_ = parseTag(tag);
+  let firstTag = parseTag(getAt(0, tags));
 
   if (
-    !Array.isArray(tag) &&
-    ![OpenNodeTag, Property, CloseNodeTag, AttributeDefinition, LiteralTag, GapTag].includes(
-      tag.type,
-    )
+    !isNode(tag_) &&
+    ![
+      OpenNodeTag,
+      Property,
+      CloseNodeTag,
+      AttributeDefinition,
+      BindingTag,
+      LiteralTag,
+      GapTag,
+    ].includes(tag_.type)
   )
     throw new Error();
 
-  if (isArray(tag)) {
+  if (isNode(tag_)) {
     if (!firstTag || firstTag.type !== OpenNodeTag) {
-      return module_.concat(tags, tag);
+      return module_.concat(tags, tag_);
     }
     let children = getValues(tags)[1] ?? module_.fromValues([]);
 
     let { 0: open } = getValues(tags);
 
-    children = module_.concat(children, tag);
+    children = module_.concat(children, tag_);
 
     return module_.fromValues([open, children]);
   } else {
-    if (tag.type === OpenNodeTag) {
+    if (tag_.type === OpenNodeTag) {
       if (getSize(tags) !== 0) throw new Error();
-      return module_.push(tags, tag);
+      return module_.push(printTag(tag_), tags);
     } else {
       if (!firstTag || firstTag.type !== OpenNodeTag) {
-        return module_.push(tags, tag);
+        return module_.push(printTag(tag_), tags);
       }
 
-      let children = getValues(tags)[1] ?? [];
+      let children = getValues(tags)[1] ?? module_.fromValues([]);
 
       // sometimes this is the top level
       if (firstTag) {
-        if (tag.type === CloseNodeTag) {
+        if (tag_.type === CloseNodeTag) {
           let { 0: open, 1: children = module_.fromValues([]) } = getValues(tags);
 
-          return module_.fromValues([open, children, tag]);
+          return module_.fromValues([open, children, printTag(tag_)]);
         } else {
           let { 0: open } = getValues(tags);
 
-          children = module_.push(children, tag);
+          children = module_.push(printTag(tag_), children);
 
-          return module_.fromValues([open, children]);
+          return module_.fromValues([open, children], 1);
         }
       } else {
-        return module_.push(tags, tag);
+        return module_.push(tag_, tags);
       }
     }
   }
 };
 
-const replaceAt = (idx, tree, value) => {
+const replaceAt = (idx, tag, tree) => {
   let idx_ = idx < 0 ? getSize(tree) + idx : idx;
+  let tagObj = parseTag(tag);
+  let tag_ = printTag(tag);
 
-  if (value.type !== getAt(idx_, tree).type) throw new Error();
-  let firstTag = getAt(0, tree);
+  if (tagObj.type !== parseTagType(getAt(idx_, tree))) throw new Error();
+  let firstTag = parseTag(getAt(0, tree));
 
   if (firstTag && firstTag.type === OpenNodeTag) {
-    let newTags = [...getValues(tree)];
+    let newTags = [...arrayValues(getValues(tree))];
     if (idx_ === 0) {
-      newTags[0] = value;
-    } else if (isObject(value) && value.type === CloseNodeTag) {
+      newTags[0] = tag_;
+    } else if (tagObj.type === CloseNodeTag) {
       if (idx_ !== getSize(tree) - 1) throw new Error();
-      newTags[2] = value;
+      newTags[2] = tag_;
     } else {
       let children = getValues(tree)[1];
 
-      children = module_.replaceAt(idx_ - 1, children, value);
+      children = module_.replaceAt(idx_ - 1, tag_, children);
 
       newTags[1] = children;
     }
     return module_.fromValues(newTags);
   } else {
-    return module_.replaceAt(idx_, tree, value);
+    return module_.replaceAt(idx_, tag_, tree);
   }
 };
 
 const removeAt = (idx, tree) => {
   let idx_ = idx < 0 ? getSize(tree) + idx : idx;
 
-  let firstTag = getAt(0, tree);
+  let firstTag = parseTag(getAt(0, tree));
 
   if (firstTag && firstTag.type === OpenNodeTag) {
-    let newTags = [...getValues(tree)];
+    let newTags = [...arrayValues(getValues(tree))];
     if (idx_ === 0) {
       newTags.splice(0, 1);
-    } else if (idx_ === getSize(tree - 1)) {
+    } else if (idx_ === getSize(tree) - 1) {
       newTags.splice(2, 1);
     } else {
       let children = getValues(tree)[1];
@@ -256,27 +421,41 @@ const removeAt = (idx, tree) => {
 };
 
 function* traverseInner(tree) {
-  for (let tag of module_.traverse(tree)) {
-    if (tag.type === Property) {
-      yield* module_.traverse(tag.value.tags);
+  for (let tag of traverse(tree)) {
+    if (isObject(tag) && tag.type === Property) {
+      yield* traverse(tag.value.tags);
     } else {
       yield tag;
     }
   }
 }
 
+const map = (fn, tree) => {
+  let { 0: open, 1: children, 2: close } = getValues(tree);
+
+  let newValues = [fn(open)];
+  if (children) newValues.push(module_.map(fn, children));
+  if (close) newValues.push(fn(close));
+
+  return module_.fromValues(newValues);
+};
+
 export {
   from,
   fromValues,
+  create,
   push,
   addAt,
   isValidNode,
+  isNode,
   assertValidNode,
   getSize,
   getValues,
   getSums,
-  setValues,
+  getDepth,
+  getType,
   traverse,
+  map,
   traverseInner,
   findPath,
   getAt,

package/lib/template.js

@@ -1,5 +1,7 @@
 import * as t from './builders.js';
-import { buildNullNode, getTags, isMultiFragment, Path } from './path.js';
+import { isObject } from './object.js';
+import { parseTagType } from './builders.js';
+import { buildNullNode, isMultiFragment, isNode, 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';
@@ -12,6 +14,8 @@ export const buildFilledGapFunction = (expressions) => (value) => {
 };
 
 export const interpolate = (expressions, node) => {
+  if (!isNode(node)) throw new Error();
+
   let path = Path.from(node);
 
   outer: for (let expression of expressions) {
@@ -19,12 +23,12 @@ export const interpolate = (expressions, node) => {
     do {
       path = path.atDepth(0);
       let tag;
-      while ((tag = Tags.getAt(i, getTags(path.node)))) {
+      while ((tag = Tags.getAt(i, Tags.getTags(path.node)))) {
         if (path.node.type === GapNode) {
           path = path.replaceWith(expression ?? buildNullNode());
           continue outer;
-        } else if (tag.type === Property && tag.value.tags[2]) {
-          let tags = getTags(tag.value.tags[2]);
+        } else if (isObject(tag) && tag.type === Property && tag.value.tags[1][2]) {
+          let tags = Tags.getTags(tag.value.tags[1][2]);
           if (tags[2].gaps) {
             path = path.push(i);
             i = 0;
@@ -41,21 +45,19 @@ export const interpolate = (expressions, node) => {
   return path.atDepth(0).node;
 };
 
-export const interpolateFragment = (node, ref, expressions) => {
-  return __interpolateFragment(node, ref, expressions);
+export const interpolateFragment = (node, ref) => {
+  return __interpolateFragment(node, ref);
 };
 
-function* __interpolateFragment(node, ref, expressions) {
+function* __interpolateFragment(node, ref) {
   if (isNull(node)) return;
 
-  const open = getOpenTag(node);
-
-  const gap = buildFilledGapFunction(expressions);
+  const open = t.parseTag(getOpenTag(node));
 
   if (!open.value.name) {
     let isMultiFragment_ = isMultiFragment(node);
-    for (let tag of Tags.traverse(getTags(node))) {
-      switch (tag.type) {
+    for (let tag of Tags.traverse(Tags.getTags(node))) {
+      switch (parseTagType(tag)) {
         case DoctypeTag: {
           break;
         }
@@ -71,16 +73,17 @@ function* __interpolateFragment(node, ref, expressions) {
           let { reference, node, tags } = tag.value;
           const { type } = reference;
 
+          // don't I elsewhere forbid this?
           if (type === '_') {
             // TODO check/combine flags
             yield ref;
           } else {
-            yield tags[0];
+            yield tags[1][0];
           }
 
-          yield* tags[1];
+          yield* Tags.traverse(tags[1][1]);
 
-          yield gap(node);
+          yield node;
 
           break;
         }
@@ -93,7 +96,7 @@ function* __interpolateFragment(node, ref, expressions) {
     }
   } else if (open.type === OpenNodeTag) {
     yield freeze(ref);
-    yield gap(node);
+    yield node;
   } else {
     throw new Error();
   }