@bablr/agast-helpers 0.6.1 → 0.7.1

package/lib/print.js

@@ -6,13 +6,8 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayInitializerTag,
+  InitializerTag,
   LiteralTag,
-  EmbeddedNode,
-  EmbeddedTag,
-  EmbeddedObject,
-  EmbeddedMatcher,
-  EmbeddedRegex,
 } from './symbols.js';
 import { isEmptyReference, isGapNode, isNullNode, printSource, referenceFlags } from './tree.js';
 
@@ -26,11 +21,6 @@ let isFunction = (val) => typeof val === 'function';
 let when = (condition, value) =>
   condition ? (isFunction(value) ? value() : value) : { *[Symbol.iterator]() {} };
 
-export const printCall = (call) => {
-  let { verb, arguments: args } = call;
-  return `${verb}${`(${args.map((v) => printExpression(v)).join(' ')})`}`;
-};
-
 export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(', ')}]`;
 
 export const printObject = (obj) => {
@@ -76,6 +66,8 @@ export const printOpenNodeMatcher = (matcher) => {
 export const printExpression = (expr) => {
   if (isString(expr)) {
     return printString(expr);
+  } else if (typeof expr === 'symbol') {
+    return printString(expr.description);
   } else if (expr == null || typeof expr === 'boolean') {
     return String(expr);
   } else if (isNumber(expr)) {
@@ -89,37 +81,11 @@ export const printExpression = (expr) => {
     }
   } else if (isArray(expr)) {
     return printArray(expr);
-  } else if (typeof expr === 'object') {
-    return printEmbedded(expr);
   } else {
     throw new Error();
   }
 };
 
-export const printEmbedded = (value) => {
-  switch (value.type) {
-    case EmbeddedTag:
-      return `t\`${printTag(value.value)}\``;
-
-    case EmbeddedMatcher:
-      return `m\`${printSource(value.value)}\``;
-
-    case EmbeddedRegex:
-      return `re\`${printSource(value.value)}\``;
-
-    case EmbeddedObject: {
-      return printObject(value.value);
-    }
-
-    case EmbeddedNode: {
-      return printSource(value.value);
-    }
-
-    default:
-      throw new Error();
-  }
-};
-
 export const printAttributes = (attributes) => {
   const printed = attributes && printObject(attributes);
   return !printed || printed === '{}' ? '' : printed;
@@ -174,10 +140,14 @@ export const printGapTag = (tag) => {
   return `<//>`;
 };
 
-export const printArrayInitializerTag = (tag) => {
-  if (tag?.type !== ArrayInitializerTag) throw new Error();
+export const printInitializerTag = (tag) => {
+  if (tag?.type !== InitializerTag) throw new Error();
 
-  return `[]`;
+  if (tag.value.isArray) {
+    return `[]`;
+  } else {
+    return 'undefined';
+  }
 };
 
 export const printShiftTag = (tag) => {
@@ -236,6 +206,7 @@ export const printReferenceFlags = (flags = referenceFlags) => {
 };
 
 export const printNodeFlags = (flags) => {
+  if (flags.cover && !flags.fragment) throw new Error();
   let star = flags.token ? '*' : '';
   let dollar = flags.hasGap ? '$' : '';
 
@@ -248,7 +219,7 @@ export const printOpenNodeTag = (tag) => {
   let { flags, language: tagLanguage, type, attributes } = tag.value;
 
   if (!type) {
-    return `<${printNodeFlags(flags)}>`;
+    return `<${printNodeFlags(flags)}_>`;
   }
 
   let printedAttributes = printAttributes(attributes);
@@ -288,8 +259,8 @@ export const printTag = (tag) => {
     case GapTag:
       return printGapTag(tag);
 
-    case ArrayInitializerTag:
-      return printArrayInitializerTag(tag);
+    case InitializerTag:
+      return printInitializerTag(tag);
 
     case ShiftTag:
       return printShiftTag(tag);

package/lib/shorthand.js

@@ -4,7 +4,7 @@ import {
   buildOpenNodeTag,
   buildCloseNodeTag,
   buildLiteralTag,
-  buildArrayInitializerTag,
+  buildInitializerTag,
 } from './builders.js';
 import { parseReference, treeFromStreamSync } from './tree.js';
 
@@ -31,7 +31,7 @@ export const lit = (str) => buildLiteralTag(stripArray(str));
 
 export const doctype = buildDoctypeTag;
 export const gap = buildGapTag;
-export const arr = buildArrayInitializerTag;
+export const arr = () => buildInitializerTag(true);
 export const nodeOpen = buildOpenNodeTag;
 export const nodeClose = buildCloseNodeTag;
 export const tree = (...tags) => treeFromStreamSync(tags);

package/lib/stream.js

@@ -1,7 +1,7 @@
 import { Coroutine } from '@bablr/coroutine';
 import emptyStack from '@iter-tools/imm-stack';
 import { printSelfClosingNodeTag, printTag } from './print.js';
-import { buildTokenGroup, buildWriteEffect } from './builders.js';
+import { buildTokenGroup } from './builders.js';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -10,19 +10,13 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayInitializerTag,
+  InitializerTag,
   LiteralTag,
-  EmbeddedObject,
   TokenGroup,
 } from './symbols.js';
 
 export * from './print.js';
 
-const getEmbeddedObject = (obj) => {
-  if (obj.type !== EmbeddedObject) throw new Error();
-  return obj.value;
-};
-
 export const getStreamIterator = (obj) => {
   return obj[Symbol.for('@@streamIterator')]?.() || obj[Symbol.iterator]?.();
 };
@@ -203,71 +197,8 @@ function* __isEmpty(tags) {
 export const isEmpty = (tags) =>
   new StreamIterable(__isEmpty(tags))[Symbol.iterator]().next().value;
 
-function* __generateStandardOutput(tags) {
-  const co = new Coroutine(getStreamIterator(tags));
-
-  for (;;) {
-    co.advance();
-
-    if (co.current instanceof Promise) {
-      co.current = yield co.current;
-    }
-    if (co.done) break;
-
-    const tag = co.value;
-
-    if (tag.type === 'Effect') {
-      const effect = tag.value;
-      if (effect.verb === 'write') {
-        const writeEffect = getEmbeddedObject(effect.value);
-        if (writeEffect.stream == null || writeEffect.stream === 1) {
-          yield* writeEffect.text;
-        }
-      }
-    }
-  }
-}
-
-export const generateStandardOutput = (tags) => new StreamIterable(__generateStandardOutput(tags));
-
-function* __generateAllOutput(tags) {
-  const co = new Coroutine(getStreamIterator(tags));
-
-  let currentStream = null;
-
-  for (;;) {
-    co.advance();
-
-    if (co.current instanceof Promise) {
-      co.current = yield co.current;
-    }
-    if (co.done) break;
-
-    const tag = co.value;
-
-    if (tag.type === 'Effect') {
-      const effect = tag.value;
-      if (effect.verb === 'write') {
-        const writeEffect = getEmbeddedObject(effect.value);
-        const prevStream = currentStream;
-        currentStream = getEmbeddedObject(writeEffect.options).stream || 1;
-        if (
-          prevStream &&
-          (prevStream !== currentStream || currentStream === 2) &&
-          !writeEffect.text.startsWith('\n')
-        ) {
-          yield* '\n';
-        }
-        yield* writeEffect.text;
-      }
-    }
-  }
-}
-
-export const generateAllOutput = (tags) => new StreamIterable(__generateAllOutput(tags));
-
 export const printCSTML = (tags) => {
-  return stringFromStream(generateStandardOutput(generateCSTML(tags)));
+  return stringFromStream(generateCSTML(tags));
 };
 
 function* __emptyStreamIterator() {}
@@ -388,9 +319,7 @@ function* __prettyGroupTags(tags) {
 
     if (
       (tag.type === 'Effect' && tag.value.verb === 'write') ||
-      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayInitializerTag, ShiftTag].includes(
-        tag.type,
-      ) ||
+      [ReferenceTag, DoctypeTag, GapTag, NullTag, InitializerTag, ShiftTag].includes(tag.type) ||
       (tag.type === OpenNodeTag && (!tag.value.type || ref?.value.name === '@'))
     ) {
       state.broken = true;
@@ -470,7 +399,7 @@ function* __generatePrettyCSTML(tags, options) {
       ref &&
       (tag.type === NullTag ||
         tag.type === GapTag ||
-        tag.type === ArrayInitializerTag ||
+        tag.type === InitializerTag ||
         tag.type === TokenGroup);
 
     if (!first && !inline) {
@@ -520,151 +449,8 @@ export const generatePrettyCSTML = (tags, options = {}) => {
   return new StreamIterable(__generatePrettyCSTML(tags, options));
 };
 
-function* __writeCSTMLStrategy(tags) {
-  if (!tags) {
-    yield buildWriteEffect('<//>');
-    return;
-  }
-
-  let prevTag = null;
-
-  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
-
-  for (;;) {
-    co.advance();
-
-    if (co.current instanceof Promise) {
-      co.current = yield co.current;
-    }
-    if (co.done) break;
-
-    const tag = co.value;
-
-    if (tag.type === ReferenceTag && prevTag.type === NullTag) {
-      yield buildWriteEffect(' ');
-    }
-
-    if (tag.type === 'Effect') {
-      yield tag;
-
-      continue;
-    }
-
-    if (tag.type === TokenGroup) {
-      const intrinsicValue = getCooked(tag.value);
-      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
-    } else {
-      yield buildWriteEffect(printTag(tag));
-    }
-
-    prevTag = tag;
-  }
-
-  yield buildWriteEffect('\n');
-}
-
-export const writeCSTMLStrategy = (tags, options = {}) =>
-  new StreamIterable(__writeCSTMLStrategy(tags, options));
-
-function* __writePrettyCSTMLStrategy(tags, options) {
-  let { indent = '  ', emitEffects = false, inline: inlineOption = true } = options;
-
-  if (!tags) {
-    yield buildWriteEffect('<//>');
-    return;
-  }
-
-  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
-  let indentLevel = 0;
-  let first = true;
-  let inline = false;
-  let ref = null;
-
-  for (;;) {
-    co.advance();
-
-    if (co.done) break;
-
-    if (co.current instanceof Promise) {
-      co.current = yield co.current;
-    }
-
-    const tag = co.value;
-
-    if (tag.type === 'Effect') {
-      const effect = tag.value;
-      if (emitEffects && effect.verb === 'write') {
-        const writeEffect = getEmbeddedObject(effect.value);
-        yield buildWriteEffect(
-          (first ? '' : '\n') + writeEffect.text,
-          getEmbeddedObject(writeEffect.options),
-        );
-
-        inline = false;
-        first = false;
-      } else {
-        yield tag;
-      }
-      continue;
-    }
-
-    inline =
-      inlineOption &&
-      inline &&
-      ref &&
-      (tag.type === NullTag ||
-        tag.type === GapTag ||
-        tag.type === ArrayInitializerTag ||
-        tag.type === TokenGroup);
-
-    if (!first && !inline) {
-      yield buildWriteEffect('\n');
-    }
-
-    if (tag.type === CloseNodeTag) {
-      ref = null;
-      if (indentLevel === 0) {
-        throw new Error('imbalanced tag stack');
-      }
-
-      indentLevel--;
-    }
-
-    if (!inline) {
-      yield buildWriteEffect(indent.repeat(indentLevel));
-    } else {
-      yield buildWriteEffect(' ');
-    }
-
-    if (tag.type === TokenGroup) {
-      ref = null;
-      const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
-      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
-    } else {
-      yield buildWriteEffect(printTag(tag));
-    }
-
-    if (tag.type === ReferenceTag) {
-      inline = true;
-      ref = tag;
-    }
-
-    if (tag.type === OpenNodeTag) {
-      indentLevel++;
-    }
-
-    first = false;
-  }
-
-  yield buildWriteEffect('\n');
-}
-
-export const writePrettyCSTMLStrategy = (tags, options = {}) => {
-  return new StreamIterable(__writePrettyCSTMLStrategy(tags, options));
-};
-
 export const printPrettyCSTML = (tags, options = {}) => {
-  return stringFromStream(generateStandardOutput(generatePrettyCSTML(tags, options)));
+  return stringFromStream(generatePrettyCSTML(tags, options));
 };
 
 export const getCooked = (tags) => {

package/lib/sumtree.js

@@ -0,0 +1,62 @@
+import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
+import { LiteralTag, ReferenceTag } from './symbols.js';
+
+const { isArray } = Array;
+const { freeze } = Object;
+
+export { defaultNodeSize };
+
+export const {
+  treeFrom,
+  treeFromValues,
+  findBalancePoint,
+  splitValues,
+  collapses,
+  nodeCollapses,
+  nodeCanDonate,
+  pop,
+  push,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getValues,
+  getSums,
+  setValues,
+  isLeafNode,
+  traverse,
+  getSize,
+  findPath,
+  getAt,
+  replaceAt,
+} = buildModule(
+  defaultNodeSize,
+  (acc, val) => {
+    const { references } = acc;
+    if (isArray(val)) {
+      acc.lineBreaks += val[2].lineBreaks;
+      for (const { 0: key, 1: value } of Object.entries(val[2].references)) {
+        references[key] = (references[key] ?? 0) + value;
+      }
+    } else {
+      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 === ReferenceTag) {
+        const { name } = val.value;
+        references[name] = (references[name] ?? 0) + 1;
+      }
+    }
+    return acc;
+  },
+  () => ({
+    lineBreaks: 0,
+    references: {},
+  }),
+  (stats) => {
+    freeze(stats);
+    freeze(stats.references);
+  },
+);

package/lib/symbols.js

@@ -1,6 +1,3 @@
-export const node = Symbol.for('@bablr/node');
-export const fragment = Symbol.for('@bablr/fragment');
-
 export const DoctypeTag = Symbol.for('DoctypeTag');
 export const OpenNodeTag = Symbol.for('OpenNodeTag');
 export const CloseNodeTag = Symbol.for('CloseNodeTag');
@@ -8,13 +5,9 @@ export const ReferenceTag = Symbol.for('ReferenceTag');
 export const ShiftTag = Symbol.for('ShiftTag');
 export const GapTag = Symbol.for('GapTag');
 export const NullTag = Symbol.for('NullTag');
-export const ArrayInitializerTag = Symbol.for('ArrayInitializerTag');
+export const InitializerTag = Symbol.for('InitializerTag');
 export const LiteralTag = Symbol.for('LiteralTag');
 
-export const EmbeddedNode = Symbol.for('EmbeddedNode');
-export const EmbeddedMatcher = Symbol.for('EmbeddedMatcher');
-export const EmbeddedRegex = Symbol.for('EmbeddedRegex');
-export const EmbeddedTag = Symbol.for('EmbeddedTag');
-export const EmbeddedObject = Symbol.for('EmbeddedObject');
-
 export const TokenGroup = Symbol.for('TokenGroup');
+
+export const EmbeddedNode = Symbol.for('EmbeddedNode');

package/lib/template.js

@@ -1,14 +1,14 @@
 import * as t from './builders.js';
 import {
   ReferenceTag,
-  ArrayInitializerTag,
+  InitializerTag,
   OpenNodeTag,
   CloseNodeTag,
   DoctypeTag,
   EmbeddedNode,
   GapTag,
 } from './symbols.js';
-import * as btree from './btree.js';
+import * as sumtree from './sumtree.js';
 import { getOpenTag, get, isFragmentNode } from './tree.js';
 
 const { freeze } = Object;
@@ -30,7 +30,7 @@ export function* interpolateFragment(node, ref, expressions) {
   if (!open.value.type) {
     let currentRef = null;
     let isFragment = isFragmentNode(node);
-    for (let tag of btree.traverse(node.children)) {
+    for (let tag of sumtree.traverse(node.children)) {
       switch (tag.type) {
         case DoctypeTag: {
           break;
@@ -48,7 +48,7 @@ export function* interpolateFragment(node, ref, expressions) {
           break;
         }
 
-        case ArrayInitializerTag: {
+        case InitializerTag: {
           const { name } = currentRef.value;
           counters.set(name, -1);
           if (name === '.') {