@bablr/agast-helpers 0.7.1 → 0.9.0

package/lib/tags.js

@@ -0,0 +1,236 @@
+import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
+import { CloseNodeTag, LiteralTag, OpenNodeTag, PropertyWrapper, ReferenceTag } from './symbols.js';
+import { isObject } from './object.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);
+
+const module_ = buildModule(
+  defaultNodeSize,
+  (acc, val) => {
+    const { references, specialTypes } = acc;
+    if (isArray(val)) {
+      acc.lineBreaks += getSums(val).lineBreaks;
+
+      for (const { 0: key, 1: value } of getSums(val).references) {
+        references.set(key, (references.get(key) ?? 0) + value);
+      }
+
+      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++;
+        }
+      } 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);
+          }
+        }
+      }
+    }
+    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;
+  },
+);
+
+const {
+  from,
+  fromValues,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getValues,
+  getSums,
+  setValues,
+  traverse,
+  getSize,
+  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 push = (tags, tag) => {
+  let firstTag = getAt(0, tags);
+  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 === PropertyWrapper) {
+      yield* 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

@@ -5,11 +5,11 @@ import {
   OpenNodeTag,
   CloseNodeTag,
   DoctypeTag,
-  EmbeddedNode,
-  GapTag,
+  Property,
+  BindingTag,
 } from './symbols.js';
-import * as sumtree from './sumtree.js';
-import { getOpenTag, get, isFragmentNode } from './tree.js';
+import * as Tags from './tags.js';
+import { getOpenTag, isFragmentNode } from './tree.js';
 
 const { freeze } = Object;
 
@@ -18,19 +18,20 @@ export const buildFilledGapFunction = (expressions) => (value) => {
   return t.buildGapTag();
 };
 
-export function* interpolateFragment(node, ref, expressions) {
-  const open = getOpenTag(node);
+export const interpolateFragment = (node, ref, expressions) => {
+  return __interpolateFragment(node, ref, expressions);
+};
 
-  if (node.type !== null) throw new Error();
+function* __interpolateFragment(node, ref, expressions) {
+  const open = getOpenTag(node);
 
   const gap = buildFilledGapFunction(expressions);
 
-  const counters = new Map();
-
   if (!open.value.type) {
     let currentRef = null;
+    let currentBinding = null;
     let isFragment = isFragmentNode(node);
-    for (let tag of sumtree.traverse(node.children)) {
+    for (let tag of Tags.traverseInner(node.tags)) {
       switch (tag.type) {
         case DoctypeTag: {
           break;
@@ -48,11 +49,15 @@ export function* interpolateFragment(node, ref, expressions) {
           break;
         }
 
+        case BindingTag: {
+          currentBinding = tag;
+          break;
+        }
+
         case InitializerTag: {
-          const { name } = currentRef.value;
-          counters.set(name, -1);
-          if (name === '.') {
-            yield freeze({ ...ref });
+          const { type } = currentRef.value;
+          if (type === '.') {
+            yield freeze(ref);
           } else {
             yield currentRef;
           }
@@ -60,35 +65,21 @@ export function* interpolateFragment(node, ref, expressions) {
           break;
         }
 
-        case GapTag: {
-          const { name, isArray, flags } = currentRef.value;
+        case Property: {
+          let { reference } = tag.value;
+          const { type } = reference;
 
-          if (name === '.') {
+          if (type === '.') {
             // TODO check/combine flags
-            yield freeze({ ...ref });
+            yield ref;
           } else {
             yield currentRef;
           }
 
-          const count = counters.get(name) + 1;
-
-          counters.set(name, count);
+          yield currentBinding;
 
-          const resolvedRef = t.buildReferenceTag(name, isArray, flags, count);
+          yield gap(tag.value.node);
 
-          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;
         }
 
@@ -99,8 +90,8 @@ export function* interpolateFragment(node, ref, expressions) {
       }
     }
   } else if (open.type === OpenNodeTag) {
-    yield freeze({ ...ref });
-    yield gap(get(ref, node));
+    yield freeze(ref);
+    yield gap(node);
   } else {
     throw new Error();
   }