@bablr/agast-helpers 0.5.3 → 0.6.1

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 { buildWriteEffect, buildTokenGroup } from './builders.js';
+import { buildTokenGroup, buildWriteEffect } from './builders.js';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -10,18 +10,16 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   LiteralTag,
-  EmbeddedExpression,
+  EmbeddedObject,
   TokenGroup,
-  OpenFragmentTag,
-  CloseFragmentTag,
 } from './symbols.js';
 
 export * from './print.js';
 
-const getEmbeddedExpression = (obj) => {
-  if (obj.type !== EmbeddedExpression) throw new Error();
+const getEmbeddedObject = (obj) => {
+  if (obj.type !== EmbeddedObject) throw new Error();
   return obj.value;
 };
 
@@ -171,23 +169,24 @@ function* __isEmpty(tags) {
     if (co.done) break;
 
     let depth = 0;
+    let ref = null;
 
     const tag = co.value;
 
     switch (tag.type) {
-      case OpenFragmentTag:
+      case ReferenceTag:
+        ref = tag;
+        break;
+
       case OpenNodeTag:
-        if (tag.value.flags.trivia) {
-          ++depth;
-        }
+        ++depth;
 
-        if (depth === 0 && tag.value.flags.escape) {
+        if (depth === 0 && ref.value.name === '@') {
           return false;
         }
 
         break;
 
-      case CloseFragmentTag:
       case CloseNodeTag:
         --depth;
         break;
@@ -220,7 +219,7 @@ function* __generateStandardOutput(tags) {
     if (tag.type === 'Effect') {
       const effect = tag.value;
       if (effect.verb === 'write') {
-        const writeEffect = getEmbeddedExpression(effect.value);
+        const writeEffect = getEmbeddedObject(effect.value);
         if (writeEffect.stream == null || writeEffect.stream === 1) {
           yield* writeEffect.text;
         }
@@ -249,10 +248,14 @@ function* __generateAllOutput(tags) {
     if (tag.type === 'Effect') {
       const effect = tag.value;
       if (effect.verb === 'write') {
-        const writeEffect = getEmbeddedExpression(effect.value);
+        const writeEffect = getEmbeddedObject(effect.value);
         const prevStream = currentStream;
-        currentStream = getEmbeddedExpression(writeEffect.options).stream || 1;
-        if (prevStream && prevStream !== currentStream && !writeEffect.text.startsWith('\n')) {
+        currentStream = getEmbeddedObject(writeEffect.options).stream || 1;
+        if (
+          prevStream &&
+          (prevStream !== currentStream || currentStream === 2) &&
+          !writeEffect.text.startsWith('\n')
+        ) {
           yield* '\n';
         }
         yield* writeEffect.text;
@@ -264,7 +267,7 @@ function* __generateAllOutput(tags) {
 export const generateAllOutput = (tags) => new StreamIterable(__generateAllOutput(tags));
 
 export const printCSTML = (tags) => {
-  return stringFromStream(generateCSTML(tags));
+  return stringFromStream(generateStandardOutput(generateCSTML(tags)));
 };
 
 function* __emptyStreamIterator() {}
@@ -310,16 +313,14 @@ export const stringFromStream = (stream) => {
 };
 
 function* __generateCSTML(tags, options) {
-  let { emitEffects = false, inline: inlineOption = true } = options;
-
   if (!tags) {
-    yield '<//>';
+    yield* '<//>';
     return;
   }
 
   let prevTag = null;
 
-  const co = new Coroutine(getStreamIterator(prettyGroupTokens(tags)));
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
 
   for (;;) {
     co.advance();
@@ -332,28 +333,24 @@ function* __generateCSTML(tags, options) {
     const tag = co.value;
 
     if (tag.type === ReferenceTag && prevTag.type === NullTag) {
-      yield ' ';
+      yield* ' ';
     }
 
     if (tag.type === 'Effect') {
-      const effect = tag.value;
-      if (emitEffects && effect.verb === 'write') {
-        yield effect.value.text, effect.value.options;
-      }
       continue;
     }
 
     if (tag.type === TokenGroup) {
       const intrinsicValue = getCooked(tag.value);
-      yield printSelfClosingNodeTag(tag.value[0], intrinsicValue);
+      yield* printSelfClosingNodeTag(tag.value[0], intrinsicValue);
     } else {
-      yield printTag(tag);
+      yield* printTag(tag);
     }
 
     prevTag = tag;
   }
 
-  yield '\n';
+  yield* '\n';
 }
 
 export const generateCSTML = (tags, options = {}) =>
@@ -363,14 +360,16 @@ const isToken = (tag) => {
   return tag.value.flags.token;
 };
 
-export const prettyGroupTokens = (tags) => new StreamIterable(__prettyGroupTokens(tags));
+export const prettyGroupTags = (tags) => new StreamIterable(__prettyGroupTags(tags));
 
-function* __prettyGroupTokens(tags) {
+function* __prettyGroupTags(tags) {
   let states = emptyStack.push({ holding: [], broken: false, open: null });
   let state = states.value;
 
   const co = new Coroutine(getStreamIterator(tags));
 
+  let ref = null;
+
   for (;;) {
     co.advance();
 
@@ -381,18 +380,18 @@ function* __prettyGroupTokens(tags) {
     }
 
     const tag = co.value;
-    const isOpenClose =
-      tag.type === CloseNodeTag ||
-      tag.type === OpenNodeTag ||
-      tag.type === CloseFragmentTag ||
-      tag.type === OpenFragmentTag;
+    const isOpenClose = tag.type === CloseNodeTag || tag.type === OpenNodeTag;
+
+    if (tag.type === ReferenceTag) {
+      ref = tag;
+    }
 
     if (
       (tag.type === 'Effect' && tag.value.verb === 'write') ||
-      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayTag, ShiftTag, OpenFragmentTag].includes(
+      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayInitializerTag, ShiftTag].includes(
         tag.type,
       ) ||
-      (tag.type === OpenNodeTag && tag.value.flags.escape)
+      (tag.type === OpenNodeTag && (!tag.value.type || ref?.value.name === '@'))
     ) {
       state.broken = true;
 
@@ -408,7 +407,7 @@ function* __prettyGroupTokens(tags) {
       yield tag;
     }
 
-    if (tag.type === CloseNodeTag || tag.type === CloseFragmentTag) {
+    if (tag.type === CloseNodeTag) {
       if (!state.broken && (isToken(state.open) || state.holding.length === 1)) {
         state.holding.push(tag);
         yield buildTokenGroup(state.holding);
@@ -423,8 +422,8 @@ function* __prettyGroupTokens(tags) {
       state = states.value;
     }
 
-    if (tag.type === OpenNodeTag || tag.type === OpenFragmentTag) {
-      if (tag.type === OpenFragmentTag) {
+    if (tag.type === OpenNodeTag) {
+      if (!tag.value.type) {
         states = states.push({ holding: [], broken: false, open: tag });
         yield tag;
       } else {
@@ -437,14 +436,145 @@ function* __prettyGroupTokens(tags) {
 }
 
 function* __generatePrettyCSTML(tags, options) {
+  let { indent = '  ', inline: inlineOption = true } = options;
+
+  if (!tags) {
+    yield* '<//>';
+    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') {
+      continue;
+    }
+
+    inline =
+      inlineOption &&
+      inline &&
+      ref &&
+      (tag.type === NullTag ||
+        tag.type === GapTag ||
+        tag.type === ArrayInitializerTag ||
+        tag.type === TokenGroup);
+
+    if (!first && !inline) {
+      yield* '\n';
+    }
+
+    if (tag.type === CloseNodeTag) {
+      ref = null;
+
+      indentLevel--;
+    }
+
+    if (!inline) {
+      yield* indent.repeat(indentLevel);
+    } else {
+      yield* ' ';
+    }
+
+    if (tag.type === TokenGroup) {
+      ref = null;
+      const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
+      yield* printSelfClosingNodeTag(tag.value[0], intrinsicValue);
+    } else {
+      yield* printTag(tag);
+    }
+
+    if (tag.type === ReferenceTag) {
+      inline = true;
+      ref = tag;
+    }
+
+    if (tag.type === OpenNodeTag) {
+      indentLevel++;
+    }
+
+    first = false;
+  }
+
+  if (indentLevel !== 0) {
+    throw new Error('imbalanced tags');
+  }
+
+  yield* '\n';
+}
+
+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 '<//>';
+    yield buildWriteEffect('<//>');
     return;
   }
 
-  const co = new Coroutine(getStreamIterator(prettyGroupTokens(tags)));
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
   let indentLevel = 0;
   let first = true;
   let inline = false;
@@ -464,11 +594,16 @@ function* __generatePrettyCSTML(tags, options) {
     if (tag.type === 'Effect') {
       const effect = tag.value;
       if (emitEffects && effect.verb === 'write') {
-        const writeEffect = getEmbeddedExpression(effect.value);
-        yield (first ? '' : '\n') + writeEffect.text, getEmbeddedExpression(writeEffect.options);
+        const writeEffect = getEmbeddedObject(effect.value);
+        yield buildWriteEffect(
+          (first ? '' : '\n') + writeEffect.text,
+          getEmbeddedObject(writeEffect.options),
+        );
 
         inline = false;
         first = false;
+      } else {
+        yield tag;
       }
       continue;
     }
@@ -479,14 +614,14 @@ function* __generatePrettyCSTML(tags, options) {
       ref &&
       (tag.type === NullTag ||
         tag.type === GapTag ||
-        tag.type === ArrayTag ||
+        tag.type === ArrayInitializerTag ||
         tag.type === TokenGroup);
 
     if (!first && !inline) {
-      yield '\n';
+      yield buildWriteEffect('\n');
     }
 
-    if (tag.type === CloseNodeTag || tag.type === CloseFragmentTag) {
+    if (tag.type === CloseNodeTag) {
       ref = null;
       if (indentLevel === 0) {
         throw new Error('imbalanced tag stack');
@@ -496,17 +631,17 @@ function* __generatePrettyCSTML(tags, options) {
     }
 
     if (!inline) {
-      yield indent.repeat(indentLevel);
+      yield buildWriteEffect(indent.repeat(indentLevel));
     } else {
-      yield ' ';
+      yield buildWriteEffect(' ');
     }
 
     if (tag.type === TokenGroup) {
       ref = null;
       const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
-      yield printSelfClosingNodeTag(tag.value[0], intrinsicValue);
+      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
     } else {
-      yield printTag(tag);
+      yield buildWriteEffect(printTag(tag));
     }
 
     if (tag.type === ReferenceTag) {
@@ -514,22 +649,22 @@ function* __generatePrettyCSTML(tags, options) {
       ref = tag;
     }
 
-    if (tag.type === OpenNodeTag || tag.type === OpenFragmentTag) {
+    if (tag.type === OpenNodeTag) {
       indentLevel++;
     }
 
     first = false;
   }
 
-  yield '\n';
+  yield buildWriteEffect('\n');
 }
 
-export const generatePrettyCSTML = (tags, options = {}) => {
-  return new StreamIterable(__generatePrettyCSTML(tags, options));
+export const writePrettyCSTMLStrategy = (tags, options = {}) => {
+  return new StreamIterable(__writePrettyCSTMLStrategy(tags, options));
 };
 
 export const printPrettyCSTML = (tags, options = {}) => {
-  return stringFromStream(generatePrettyCSTML(tags, options));
+  return stringFromStream(generateStandardOutput(generatePrettyCSTML(tags, options)));
 };
 
 export const getCooked = (tags) => {
@@ -538,19 +673,20 @@ export const getCooked = (tags) => {
   let first = true;
   let foundLast = false;
   let depth = 0;
+  let ref = null;
 
   for (const tag of tags) {
     if (foundLast) throw new Error();
 
     switch (tag.type) {
       case ReferenceTag: {
+        ref = tag;
         if (depth === 1) {
           throw new Error('cookable nodes must not contain other nodes');
         }
         break;
       }
 
-      case OpenFragmentTag:
       case OpenNodeTag: {
         const { flags, attributes } = tag.value;
 
@@ -564,11 +700,11 @@ export const getCooked = (tags) => {
           }
         }
 
-        if (!(flags.trivia || (flags.escape && attributes.cooked))) {
+        if (!(ref.value.name === '#' || (ref.value.name === '@' && attributes.cooked))) {
           throw new Error('cookable nodes must not contain other nodes');
         }
 
-        if (flags.escape) {
+        if (ref.value.name === '@') {
           const { cooked: cookedValue } = tag.value.attributes;
 
           if (!cookedValue) throw new Error('cannot cook string: it contains uncooked escapes');
@@ -579,7 +715,6 @@ export const getCooked = (tags) => {
         break;
       }
 
-      case CloseFragmentTag:
       case CloseNodeTag: {
         if (depth === 1) {
           foundLast = true;
@@ -614,6 +749,8 @@ export const printSource = (tags) => {
   for (const tag of tags) {
     if (tag.type === LiteralTag) {
       printed += tag.value;
+    } else if (tag.type === GapTag) {
+      throw new Error('use generateSourceTextFor');
     }
   }
 
@@ -624,6 +761,8 @@ export function* generateSourceTextFor(tags) {
   for (const tag of tags) {
     if (tag.type === LiteralTag) {
       yield* tag.value;
+    } else if (tag.type === GapTag) {
+      yield null;
     }
   }
 }

package/lib/symbols.js

@@ -1,27 +1,20 @@
 export const node = Symbol.for('@bablr/node');
-
-export const gap = Symbol.for('@bablr/gap');
-
 export const fragment = Symbol.for('@bablr/fragment');
 
-export const null_ = Symbol.for('@bablr/null');
-
 export const DoctypeTag = Symbol.for('DoctypeTag');
 export const OpenNodeTag = Symbol.for('OpenNodeTag');
 export const CloseNodeTag = Symbol.for('CloseNodeTag');
-export const OpenFragmentTag = Symbol.for('OpenFragmentTag');
-export const CloseFragmentTag = Symbol.for('CloseFragmentTag');
 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 ArrayTag = Symbol.for('ArrayTag');
+export const ArrayInitializerTag = Symbol.for('ArrayInitializerTag');
 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 EmbeddedExpression = Symbol.for('EmbeddedExpression');
+export const EmbeddedObject = Symbol.for('EmbeddedObject');
 
 export const TokenGroup = Symbol.for('TokenGroup');
-
-export { null_ as null };