@bablr/agast-helpers 0.5.3 → 0.6.0

package/lib/template.js

@@ -1,93 +1,107 @@
 import * as t from './builders.js';
 import {
-  LiteralTag,
-  EmbeddedNode,
   ReferenceTag,
-  ArrayTag,
-  OpenFragmentTag,
+  ArrayInitializerTag,
   OpenNodeTag,
+  CloseNodeTag,
   DoctypeTag,
-  CloseFragmentTag,
+  EmbeddedNode,
+  GapTag,
 } from './symbols.js';
 import * as btree from './btree.js';
-import { getOpenTag, getRoot } from './tree.js';
+import { getOpenTag, get, isFragmentNode } from './tree.js';
 
-const { isArray } = Array;
 const { freeze } = Object;
-const { isFinite } = Number;
-
-export const interpolateArray = (fragment) => {
-  const value = getRoot(fragment);
 
-  if (isArray(value)) {
-    if (isFinite(value[0])) {
-      return [...btree.traverse(value)];
-    } else {
-      return value;
-    }
-  } else {
-    return [value];
-  }
+export const buildFilledGapFunction = (expressions) => (value) => {
+  expressions.push(value);
+  return t.buildGapTag();
 };
 
-export function* interpolateFragmentChildren(value, ref) {
-  const open = getOpenTag(value);
+export function* interpolateFragment(node, ref, expressions) {
+  const open = getOpenTag(node);
+
+  if (node.type !== null) throw new Error();
+
+  const gap = buildFilledGapFunction(expressions);
 
-  if (open.type === OpenFragmentTag) {
+  const counters = new Map();
+
+  if (!open.value.type) {
     let currentRef = null;
-    for (let child of btree.traverse(value.children)) {
-      if (
-        child.type === DoctypeTag ||
-        child.type === OpenFragmentTag ||
-        child.type === CloseFragmentTag
-      ) {
-        continue;
-      }
+    let isFragment = isFragmentNode(node);
+    for (let tag of btree.traverse(node.children)) {
+      switch (tag.type) {
+        case DoctypeTag: {
+          break;
+        }
+        case OpenNodeTag:
+        case CloseNodeTag: {
+          if (!isFragment) {
+            yield tag;
+          }
+          break;
+        }
+
+        case ReferenceTag: {
+          currentRef = tag;
+          break;
+        }
+
+        case ArrayInitializerTag: {
+          const { name } = currentRef.value;
+          counters.set(name, -1);
+          if (name === '.') {
+            yield freeze({ ...ref });
+          } else {
+            yield currentRef;
+          }
+          yield tag;
+          break;
+        }
+
+        case GapTag: {
+          const { name, isArray, flags } = currentRef.value;
+
+          if (name === '.') {
+            // TODO check/combine flags
+            yield freeze({ ...ref });
+          } else {
+            yield currentRef;
+          }
+
+          const count = counters.get(name) + 1;
 
-      if (child.type === ArrayTag) {
-        // if (notAlreadyInitialized) {
-        yield child;
-        // }
-      } else if (child.type === ReferenceTag) {
-        currentRef = child;
-        if (child.value.name === '.') {
-          yield freeze({ ...ref });
-        } else {
-          yield child;
+          counters.set(name, count);
+
+          const resolvedRef = t.buildReferenceTag(name, isArray, flags, count);
+
+          yield gap(get(resolvedRef, node));
+
+          break;
+        }
+
+        case EmbeddedNode: {
+          const { name } = currentRef.value;
+          if (name === '.') {
+            yield freeze({ ...ref });
+          } else {
+            yield currentRef;
+          }
+          yield gap(tag.value);
+          break;
+        }
+
+        default: {
+          yield tag;
+          break;
         }
-      } else {
-        yield child;
       }
     }
   } else if (open.type === OpenNodeTag) {
     yield freeze({ ...ref });
+    yield gap(get(ref, node));
   } else {
     throw new Error();
   }
 }
-
-const validateTag = (tag) => {
-  if (!tag || (tag.type !== LiteralTag && tag.type !== EmbeddedNode)) {
-    throw new Error('Invalid tag');
-  }
-  if (tag.type === EmbeddedNode && !tag.value.flags.escape) {
-    throw new Error();
-  }
-};
-
-export const interpolateString = (value) => {
-  const tags = [];
-  if (isArray(value)) {
-    for (const element of value) {
-      validateTag(element);
-
-      tags.push(element);
-    }
-  } else {
-    // we can't safely interpolate strings here, though I wish we could
-    validateTag(value);
-    tags.push(value);
-  }
-
-  return t.buildNode('String', 'Content', tags);
-};