@bablr/agast-helpers 0.9.0 → 0.10.0

package/lib/tags.js

@@ -1,6 +1,18 @@
 import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
-import { CloseNodeTag, LiteralTag, OpenNodeTag, PropertyWrapper, ReferenceTag } from './symbols.js';
+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;
@@ -35,61 +47,89 @@ export const getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.
 
 export const compareNames = (a, b) => (a > b ? 1 : b > a ? -1 : 0);
 
-const module_ = buildModule(
-  defaultNodeSize,
-  (acc, val) => {
-    const { references, specialTypes } = acc;
-    if (isArray(val)) {
-      acc.lineBreaks += getSums(val).lineBreaks;
+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;
 
-      for (const { 0: key, 1: value } of getSums(val).references) {
-        references.set(key, (references.get(key) ?? 0) + value);
-      }
+        let arrs = [
+          [getSums(val).references, references],
+          [getSums(val).specialTypes, specialTypes],
+        ];
 
-      for (const { 0: key, 1: value } of getSums(val).specialTypes) {
-        specialTypes.set(key, (specialTypes.get(key) ?? 0) + value);
-      }
-    } else if (val) {
-      if (val.type === LiteralTag) {
-        let text = val.value;
-        let idx = 0;
-        while ((idx = text.indexOf('\n', idx + 1)) >= 0) {
-          acc.lineBreaks++;
+        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.type === PropertyWrapper) {
-        let { tags } = val.value;
-        let refOrShiftTag = tags[0];
-
-        if (refOrShiftTag.type === ReferenceTag) {
-          const { type, name } = refOrShiftTag.value;
-          if (name) {
-            references.set(name, (references.get(name) ?? 0) + 1);
-          } else {
-            specialTypes.set(type, (specialTypes.get(type) ?? 0) + 1);
+      } 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;
-  },
-  () => ({
-    lineBreaks: 0,
-    references: new Map(),
-    specialTypes: new Map(),
-  }),
-  (mapStats) => {
-    let { lineBreaks } = mapStats;
-    let stats = {
-      lineBreaks,
-      references: [...mapStats.references].sort((a, b) => compareNames(a[0], b[0])),
-      specialTypes: [...mapStats.specialTypes].sort((a, b) => compareNames(a[0], b[0])),
-    };
-    freeze(stats);
-    freeze(stats.references);
-    freeze(stats.specialTypes);
-    return stats;
-  },
-);
+      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,
@@ -105,15 +145,24 @@ const {
   findPath,
 } = module_;
 
-const getAt = (idx, tags, wrapperIndex) => {
-  let result = module_.getAt(idx, tags);
-  return wrapperIndex == null || result?.type !== PropertyWrapper
-    ? result
-    : result.value.tags[wrapperIndex];
+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);
@@ -208,8 +257,8 @@ const removeAt = (idx, tree) => {
 
 function* traverseInner(tree) {
   for (let tag of module_.traverse(tree)) {
-    if (tag.type === PropertyWrapper) {
-      yield* tag.value.tags;
+    if (tag.type === Property) {
+      yield* module_.traverse(tag.value.tags);
     } else {
       yield tag;
     }

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 { getTags, isMultiFragment, Path } from './path.js';
+import { OpenNodeTag, CloseNodeTag, DoctypeTag, Property, GapNode } from './symbols.js';
 import * as Tags from './tags.js';
-import { getOpenTag, isFragmentNode } from './tree.js';
+import { getOpenTag, isNull } from './tree.js';
 
 const { freeze } = Object;
 
@@ -18,67 +11,76 @@ export const buildFilledGapFunction = (expressions) => (value) => {
   return t.buildGapTag();
 };
 
+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 Tags.traverseInner(node.tags)) {
+  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 ref;
           } else {
-            yield currentRef;
+            yield tags[0];
           }
 
-          yield currentBinding;
+          yield* tags[1];
 
-          yield gap(tag.value.node);
+          yield gap(node);
 
           break;
         }