@bablr/agast-helpers 0.8.0 → 0.10.0

package/lib/symbols.js

@@ -6,10 +6,13 @@ export const ShiftTag = Symbol.for('ShiftTag');
 export const GapTag = Symbol.for('GapTag');
 export const BindingTag = Symbol.for('BindingTag');
 export const NullTag = Symbol.for('NullTag');
-export const InitializerTag = Symbol.for('InitializerTag');
 export const AttributeDefinition = Symbol.for('AttributeDefinition');
 export const LiteralTag = Symbol.for('LiteralTag');
 
-export const TokenGroup = Symbol.for('TokenGroup');
+export const Document = Symbol.for('Document');
+export const TreeNode = Symbol.for('TreeNode');
+export const NullNode = Symbol.for('NullNode');
+export const GapNode = Symbol.for('GapNode');
+export const Node = Symbol.for('Node');
 
 export const Property = Symbol.for('Property');

package/lib/tags.js

@@ -0,0 +1,285 @@
+import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
+import {
+  AttributeDefinition,
+  CloseNodeTag,
+  GapNode,
+  GapTag,
+  LiteralTag,
+  OpenNodeTag,
+  Property,
+  ReferenceTag,
+  ShiftTag,
+} from './symbols.js';
+import { isObject } from './object.js';
+import { referenceIsSingular } from './path.js';
+import { buildReference } from './builders.js';
+
+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 { references, specialTypes } = acc;
+      if (isArray(val)) {
+        acc.lineBreaks += getSums(val).lineBreaks;
+        acc.gaps += getSums(val).gaps;
+
+        let arrs = [
+          [getSums(val).references, references],
+          [getSums(val).specialTypes, specialTypes],
+        ];
+
+        for (let { 0: arr, 1: map } of arrs) {
+          for (const { 0: key, 1: value, 2: reference } of arr) {
+            let count = map.get(key)?.[1] ?? 0;
+
+            if (!reference.flags.array && referenceIsSingular(reference) && count > 0)
+              throw new Error();
+
+            map.set(key, freeze([key, count + value, reference]));
+          }
+        }
+      } else if (val) {
+        if (val.type === LiteralTag) {
+          let text = val.value;
+          let idx = 0;
+          while ((idx = text.indexOf('\n', idx + 1)) >= 0) {
+            acc.lineBreaks++;
+          }
+        } else if (val.type === GapTag) {
+          acc.gaps++;
+        } else if (val.type === Property) {
+          let { tags } = val.value;
+          let refOrShiftTag = tags[0];
+
+          if (tags[2]) {
+            acc.gaps += tags[2].value.tags[2].gaps;
+          }
+          if (refOrShiftTag?.type !== ShiftTag) {
+            let ref = refOrShiftTag?.value || buildReference();
+            const { type, name } = ref;
+
+            if (name) {
+              let count = references.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;
+
+              if (!ref.flags.array && referenceIsSingular(ref) && count > 0) throw new Error();
+
+              specialTypes.set(type, freeze([type, count + 1, ref]));
+            }
+          }
+        }
+      }
+      return acc;
+    },
+    {
+      gaps: 0,
+      lineBreaks: 0,
+      references: new Map(),
+      specialTypes: new Map(),
+    },
+  );
+
+  let { lineBreaks, gaps } = mapStats;
+  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])),
+  };
+  freeze(stats);
+  freeze(stats.references);
+  freeze(stats.specialTypes);
+  return stats;
+};
+
+const module_ = buildModule(defaultNodeSize, sumValues);
+
+const {
+  from,
+  fromValues,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getValues,
+  getSums,
+  setValues,
+  traverse,
+  getSize,
+  findPath,
+} = module_;
+
+const getAt = (idx, tags, propertyIndex) => {
+  if (propertyIndex !== undefined) {
+    throw new Error('propertyIndex');
+  }
+  return module_.getAt(idx, tags);
+};
+
+const push = (tags, tag) => {
+  let firstTag = getAt(0, tags);
+
+  if (
+    !Array.isArray(tag) &&
+    ![OpenNodeTag, Property, CloseNodeTag, AttributeDefinition, LiteralTag, GapTag].includes(
+      tag.type,
+    )
+  )
+    throw new Error();
+
+  if (isArray(tag)) {
+    if (!firstTag || firstTag.type !== OpenNodeTag) {
+      return module_.concat(tags, tag);
+    }
+    let children = getValues(tags)[1] ?? module_.fromValues([]);
+
+    let { 0: open } = getValues(tags);
+
+    children = module_.concat(children, tag);
+
+    return module_.fromValues([open, children]);
+  } else {
+    if (tag.type === OpenNodeTag) {
+      if (getSize(tags) !== 0) throw new Error();
+      return module_.push(tags, tag);
+    } else {
+      if (!firstTag || firstTag.type !== OpenNodeTag) {
+        return module_.push(tags, tag);
+      }
+
+      let children = getValues(tags)[1] ?? [];
+
+      // sometimes this is the top level
+      if (firstTag) {
+        if (tag.type === CloseNodeTag) {
+          let { 0: open, 1: children = module_.fromValues([]) } = getValues(tags);
+
+          return module_.fromValues([open, children, tag]);
+        } else {
+          let { 0: open } = getValues(tags);
+
+          children = module_.push(children, tag);
+
+          return module_.fromValues([open, children]);
+        }
+      } else {
+        return module_.push(tags, tag);
+      }
+    }
+  }
+};
+
+const replaceAt = (idx, tree, value) => {
+  let idx_ = idx < 0 ? getSize(tree) + idx : idx;
+
+  if (value.type !== getAt(idx_, tree).type) throw new Error();
+  let firstTag = getAt(0, tree);
+
+  if (firstTag && firstTag.type === OpenNodeTag) {
+    let newTags = [...getValues(tree)];
+    if (idx_ === 0) {
+      newTags[0] = value;
+    } else if (isObject(value) && value.type === CloseNodeTag) {
+      if (idx_ !== getSize(tree) - 1) throw new Error();
+      newTags[2] = value;
+    } else {
+      let children = getValues(tree)[1];
+
+      children = module_.replaceAt(idx_ - 1, children, value);
+
+      newTags[1] = children;
+    }
+    return module_.fromValues(newTags);
+  } else {
+    return module_.replaceAt(idx_, tree, value);
+  }
+};
+
+const removeAt = (idx, tree) => {
+  let idx_ = idx < 0 ? getSize(tree) + idx : idx;
+
+  let firstTag = getAt(0, tree);
+
+  if (firstTag && firstTag.type === OpenNodeTag) {
+    let newTags = [...getValues(tree)];
+    if (idx_ === 0) {
+      newTags.splice(0, 1);
+    } else if (idx_ === getSize(tree - 1)) {
+      newTags.splice(2, 1);
+    } else {
+      let children = getValues(tree)[1];
+
+      children = module_.removeAt(idx_ - 1, children);
+
+      newTags[1] = children;
+    }
+    return module_.fromValues(newTags);
+  } else {
+    return module_.removeAt(idx_, tree);
+  }
+};
+
+function* traverseInner(tree) {
+  for (let tag of module_.traverse(tree)) {
+    if (tag.type === Property) {
+      yield* module_.traverse(tag.value.tags);
+    } else {
+      yield tag;
+    }
+  }
+}
+
+export {
+  from,
+  fromValues,
+  push,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getSize,
+  getValues,
+  getSums,
+  setValues,
+  traverse,
+  traverseInner,
+  findPath,
+  getAt,
+  replaceAt,
+  removeAt,
+};

package/lib/template.js

@@ -1,15 +1,8 @@
 import * as t from './builders.js';
-import {
-  ReferenceTag,
-  InitializerTag,
-  OpenNodeTag,
-  CloseNodeTag,
-  DoctypeTag,
-  Property,
-  BindingTag,
-} from './symbols.js';
-import * as Children from './children.js';
-import { getOpenTag, get, isFragmentNode } from './tree.js';
+import { 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';
 
 const { freeze } = Object;
 
@@ -18,63 +11,76 @@ export const buildFilledGapFunction = (expressions) => (value) => {
   return t.buildGapTag();
 };
 
-export function* interpolateFragment(node, ref, expressions) {
+export const interpolate = (node, expressions) => {
+  let path = Path.from(node);
+
+  outer: for (let expression of expressions) {
+    let i = 0;
+    do {
+      path = path.atDepth(0);
+      let tag;
+      while ((tag = Tags.getAt(i, getTags(path.node)))) {
+        if (path.node.type === GapNode) {
+          path = path.replaceWith(expression);
+          continue outer;
+        } else if (tag.type === Property && tag.value.tags[2]) {
+          let tags = getTags(tag.value.tags[2]);
+          if (tags[2].gaps) {
+            path = path.push(i);
+            i = 0;
+            continue;
+          }
+        }
+        i++;
+      }
+      i = path.parent?.tagsIndex + 1;
+      path = path.parent;
+    } while (path.depth);
+  }
+
+  return path.atDepth(0).node;
+};
+
+export const interpolateFragment = (node, ref, expressions) => {
+  return __interpolateFragment(node, ref, expressions);
+};
+
+function* __interpolateFragment(node, ref, expressions) {
+  if (isNull(node)) return;
+
   const open = getOpenTag(node);
 
   const gap = buildFilledGapFunction(expressions);
 
-  if (!open.value.type) {
-    let currentRef = null;
-    let currentBinding = null;
-    let isFragment = isFragmentNode(node);
-    for (let tag of Children.traverse(node.children)) {
+  if (!open.value.name) {
+    let isMultiFragment_ = isMultiFragment(node);
+    for (let tag of Tags.traverse(getTags(node))) {
       switch (tag.type) {
         case DoctypeTag: {
           break;
         }
         case OpenNodeTag:
         case CloseNodeTag: {
-          if (!isFragment) {
+          if (!isMultiFragment_) {
             yield tag;
           }
           break;
         }
 
-        case ReferenceTag: {
-          currentRef = tag;
-          break;
-        }
-
-        case BindingTag: {
-          currentBinding = tag;
-          break;
-        }
-
-        case InitializerTag: {
-          const { type } = currentRef.value;
-          if (type === '.') {
-            yield freeze(ref);
-          } else {
-            yield currentRef;
-          }
-          yield tag;
-          break;
-        }
-
         case Property: {
-          let { reference } = tag.value;
+          let { reference, node, tags } = tag.value;
           const { type } = reference;
 
-          if (type === '.') {
+          if (type === '_') {
             // TODO check/combine flags
-            yield freeze(ref);
-            yield currentBinding;
+            yield ref;
           } else {
-            yield currentRef;
-            yield currentBinding;
+            yield tags[0];
           }
 
-          yield gap(tag.value.node);
+          yield* tags[1];
+
+          yield gap(node);
 
           break;
         }