@bablr/agast-helpers 0.3.1 → 0.4.0

package/lib/stream.js

@@ -1,11 +1,25 @@
 import { Coroutine } from '@bablr/coroutine';
 import emptyStack from '@iter-tools/imm-stack';
-import { printSelfClosingNodeTag, printTerminal } from './print.js';
+import { printSelfClosingNodeTag, printTag } from './print.js';
 import { buildWriteEffect, buildTokenGroup } from './builders.js';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  EmbeddedExpression,
+  TokenGroup,
+} from './symbols.js';
+
 export * from './print.js';
 
 const getEmbeddedExpression = (obj) => {
-  if (obj.type !== 'EmbeddedExpression') throw new Error();
+  if (obj.type !== EmbeddedExpression) throw new Error();
   return obj.value;
 };
 
@@ -89,10 +103,8 @@ export class AsyncGenerator {
   }
 }
 
-export const isIntrinsicToken = (terminal) => {
-  return (
-    terminal.type === 'OpenNodeTag' && terminal.value.flags.intrinsic && terminal.value.flags.token
-  );
+export const isIntrinsicToken = (tag) => {
+  return tag.type === OpenNodeTag && tag.value.flags.intrinsic && tag.value.flags.token;
 };
 
 export class StreamGenerator {
@@ -149,8 +161,8 @@ export const maybeWait = (maybePromise, callback) => {
   }
 };
 
-function* __generateStandardOutput(terminals) {
-  const co = new Coroutine(getStreamIterator(terminals));
+function* __generateStandardOutput(tags) {
+  const co = new Coroutine(getStreamIterator(tags));
 
   for (;;) {
     co.advance();
@@ -160,10 +172,10 @@ function* __generateStandardOutput(terminals) {
     }
     if (co.done) break;
 
-    const terminal = co.value;
+    const tag = co.value;
 
-    if (terminal.type === 'Effect') {
-      const effect = getEmbeddedExpression(terminal.value);
+    if (tag.type === 'Effect') {
+      const effect = getEmbeddedExpression(tag.value);
       if (effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         if (writeEffect.stream == null || writeEffect.stream === 1) {
@@ -174,11 +186,10 @@ function* __generateStandardOutput(terminals) {
   }
 }
 
-export const generateStandardOutput = (terminals) =>
-  new StreamIterable(__generateStandardOutput(terminals));
+export const generateStandardOutput = (tags) => new StreamIterable(__generateStandardOutput(tags));
 
-function* __generateAllOutput(terminals) {
-  const co = new Coroutine(getStreamIterator(terminals));
+function* __generateAllOutput(tags) {
+  const co = new Coroutine(getStreamIterator(tags));
 
   let currentStream = null;
 
@@ -190,10 +201,10 @@ function* __generateAllOutput(terminals) {
     }
     if (co.done) break;
 
-    const terminal = co.value;
+    const tag = co.value;
 
-    if (terminal.type === 'Effect') {
-      const effect = getEmbeddedExpression(terminal.value);
+    if (tag.type === 'Effect') {
+      const effect = getEmbeddedExpression(tag.value);
       if (effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         const prevStream = currentStream;
@@ -207,10 +218,10 @@ function* __generateAllOutput(terminals) {
   }
 }
 
-export const generateAllOutput = (terminals) => new StreamIterable(__generateAllOutput(terminals));
+export const generateAllOutput = (tags) => new StreamIterable(__generateAllOutput(tags));
 
-export const printCSTML = (terminals) => {
-  return stringFromStream(generateStandardOutput(generateCSTMLStrategy(terminals)));
+export const printCSTML = (tags) => {
+  return stringFromStream(generateStandardOutput(generateCSTMLStrategy(tags)));
 };
 
 function* __emptyStreamIterator() {}
@@ -230,9 +241,9 @@ export const asyncStringFromStream = async (stream) => {
 
     if (co.done) break;
 
-    const terminal = co.value;
+    const tag = co.value;
 
-    str += printTerminal(terminal);
+    str += printTag(tag);
   }
 
   return str;
@@ -255,21 +266,17 @@ export const stringFromStream = (stream) => {
   return str;
 };
 
-function* __generateCSTMLStrategy(terminals, options) {
+function* __generateCSTMLStrategy(tags, options) {
   let { emitEffects = false, inline: inlineOption = true } = options;
 
-  if (emitEffects) {
-    throw new Error('You must use generatePrettyCSTML with emitEffects');
-  }
-
-  if (!terminals) {
+  if (!tags) {
     yield buildWriteEffect('<//>');
     return;
   }
 
-  let prevTerminal = null;
+  let prevTag = null;
 
-  const co = new Coroutine(getStreamIterator(prettyGroupTokens(terminals)));
+  const co = new Coroutine(getStreamIterator(prettyGroupTokens(tags)));
 
   for (;;) {
     co.advance();
@@ -279,40 +286,43 @@ function* __generateCSTMLStrategy(terminals, options) {
     }
     if (co.done) break;
 
-    const terminal = co.value;
+    const tag = co.value;
 
-    if (terminal.type === 'Reference' && prevTerminal.type === 'Null') {
+    if (tag.type === ReferenceTag && prevTag.type === NullTag) {
       yield buildWriteEffect(' ');
     }
 
-    if (terminal.type === 'Effect') {
-      const effect = terminal.value;
+    if (tag.type === 'Effect') {
+      const effect = tag.value;
       if (emitEffects && effect.verb === 'write') {
         yield buildWriteEffect(effect.value.text, effect.value.options);
       }
       continue;
     }
 
-    if (terminal.type === 'TokenGroup') {
-      const intrinsicValue = getCooked(terminal.value.slice(1, -1));
-      yield buildWriteEffect(printSelfClosingNodeTag(terminal.value[0], intrinsicValue));
+    if (tag.type === TokenGroup) {
+      const intrinsicValue = getCooked(tag.value);
+      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
     } else {
-      yield buildWriteEffect(printTerminal(terminal));
+      yield buildWriteEffect(printTag(tag));
     }
 
-    prevTerminal = terminal;
+    prevTag = tag;
   }
 
   yield buildWriteEffect('\n');
 }
 
-export const prettyGroupTokens = (terminals) => new StreamIterable(__prettyGroupTokens(terminals));
+export const generateCSTMLStrategy = (tags, options = {}) =>
+  new StreamIterable(__generateCSTMLStrategy(tags, options));
 
-function* __prettyGroupTokens(terminals) {
+export const prettyGroupTokens = (tags) => new StreamIterable(__prettyGroupTokens(tags));
+
+function* __prettyGroupTokens(tags) {
   let states = emptyStack.push({ holding: [], broken: false, open: null });
   let state = states.value;
 
-  const co = new Coroutine(getStreamIterator(terminals));
+  const co = new Coroutine(getStreamIterator(tags));
 
   for (;;) {
     co.advance();
@@ -323,18 +333,16 @@ function* __prettyGroupTokens(terminals) {
       co.current = yield co.current;
     }
 
-    const terminal = co.value;
-    const isOpenClose =
-      terminal.type === 'CloseNodeTag' || (terminal.type === 'OpenNodeTag' && terminal.value.type);
+    const tag = co.value;
+    const isOpenClose = tag.type === CloseNodeTag || (tag.type === OpenNodeTag && tag.value.type);
 
     if (
-      (terminal.type === 'Effect' && terminal.value.verb === 'write') ||
-      ['Reference', 'DoctypeTag', 'Gap', 'Null'].includes(terminal.type) ||
-      (terminal.type === 'OpenNodeTag' && !terminal.value.type) ||
+      (tag.type === 'Effect' && tag.value.verb === 'write') ||
+      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayTag, ShiftTag].includes(tag.type) ||
+      (tag.type === OpenNodeTag && !tag.value.type) ||
       (state.open &&
         !isIntrinsicToken(state.open) &&
-        (terminal.type === 'Literal' ||
-          (terminal.type === 'OpenNodeTag' && terminal.value.flags.escape)))
+        (tag.type === LiteralTag || (tag.type === OpenNodeTag && tag.value.flags.escape)))
     ) {
       state.broken = true;
 
@@ -343,51 +351,48 @@ function* __prettyGroupTokens(terminals) {
         state.holding = [];
       }
 
-      if (!isOpenClose && terminal.type !== 'Effect') {
-        yield terminal;
+      if (!isOpenClose && tag.type !== 'Effect') {
+        yield tag;
       }
-    } else if (!isOpenClose && terminal.type !== 'Effect') {
-      state.holding.push(terminal);
+    } else if (!isOpenClose && tag.type !== 'Effect') {
+      state.holding.push(tag);
     }
 
-    if (terminal.type === 'Effect') {
-      yield terminal;
+    if (tag.type === 'Effect') {
+      yield tag;
     }
 
-    if (terminal.type === 'CloseNodeTag') {
+    if (tag.type === CloseNodeTag) {
       if (!state.broken && (isIntrinsicToken(state.open) || state.holding.length === 1)) {
-        state.holding.push(terminal);
+        state.holding.push(tag);
         yield buildTokenGroup(state.holding);
       } else {
         if (state.holding.length) {
           yield* state.holding;
         }
-        yield terminal;
+        yield tag;
       }
 
       states = states.pop();
       state = states.value;
     }
 
-    if (terminal.type === 'OpenNodeTag' && terminal.value.type) {
-      states = states.push({ holding: [terminal], broken: false, open: terminal });
+    if (tag.type === OpenNodeTag && tag.value.type) {
+      states = states.push({ holding: [tag], broken: false, open: tag });
       state = states.value;
     }
   }
 }
 
-export const generateCSTMLStrategy = (terminals, options = {}) =>
-  new StreamIterable(__generateCSTMLStrategy(terminals, options));
-
-function* __generatePrettyCSTMLStrategy(terminals, options) {
+function* __generatePrettyCSTMLStrategy(tags, options) {
   let { indent = '  ', emitEffects = false, inline: inlineOption = true } = options;
 
-  if (!terminals) {
+  if (!tags) {
     yield buildWriteEffect('<//>');
     return;
   }
 
-  const co = new Coroutine(getStreamIterator(prettyGroupTokens(terminals)));
+  const co = new Coroutine(getStreamIterator(prettyGroupTokens(tags)));
   let indentLevel = 0;
   let first = true;
   let inline = false;
@@ -401,10 +406,10 @@ function* __generatePrettyCSTMLStrategy(terminals, options) {
       co.current = yield co.current;
     }
 
-    const terminal = co.value;
+    const tag = co.value;
 
-    if (terminal.type === 'Effect') {
-      const effect = getEmbeddedExpression(terminal.value);
+    if (tag.type === 'Effect') {
+      const effect = getEmbeddedExpression(tag.value);
       if (emitEffects && effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         yield buildWriteEffect(
@@ -421,13 +426,16 @@ function* __generatePrettyCSTMLStrategy(terminals, options) {
     inline =
       inlineOption &&
       inline &&
-      (terminal.type === 'Null' || terminal.type === 'Gap' || terminal.type === 'TokenGroup');
+      (tag.type === NullTag ||
+        tag.type === GapTag ||
+        tag.type === ArrayTag ||
+        tag.type === TokenGroup);
 
     if (!first && !inline) {
       yield buildWriteEffect('\n');
     }
 
-    if (terminal.type === 'CloseNodeTag') {
+    if (tag.type === CloseNodeTag) {
       if (indentLevel === 0) {
         throw new Error('imbalanced tag stack');
       }
@@ -441,18 +449,18 @@ function* __generatePrettyCSTMLStrategy(terminals, options) {
       yield buildWriteEffect(' ');
     }
 
-    if (terminal.type === 'TokenGroup') {
-      const intrinsicValue = getCooked(terminal.value.slice(1, -1));
-      yield buildWriteEffect(printSelfClosingNodeTag(terminal.value[0], intrinsicValue));
+    if (tag.type === TokenGroup) {
+      const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
+      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
     } else {
-      yield buildWriteEffect(printTerminal(terminal));
+      yield buildWriteEffect(printTag(tag));
     }
 
-    if (terminal.type === 'Reference') {
+    if (tag.type === ReferenceTag) {
       inline = true;
     }
 
-    if (terminal.type === 'OpenNodeTag') {
+    if (tag.type === OpenNodeTag) {
       indentLevel++;
     }
 
@@ -462,32 +470,51 @@ function* __generatePrettyCSTMLStrategy(terminals, options) {
   yield buildWriteEffect('\n');
 }
 
-export const generatePrettyCSTMLStrategy = (terminals, options = {}) => {
-  return new StreamIterable(__generatePrettyCSTMLStrategy(terminals, options));
+export const generatePrettyCSTMLStrategy = (tags, options = {}) => {
+  return new StreamIterable(__generatePrettyCSTMLStrategy(tags, options));
 };
 
-export const printPrettyCSTML = (terminals, options = {}) => {
-  return stringFromStream(generateStandardOutput(generatePrettyCSTMLStrategy(terminals, options)));
+export const printPrettyCSTML = (tags, options = {}) => {
+  return stringFromStream(generateStandardOutput(generatePrettyCSTMLStrategy(tags, options)));
 };
 
-export const getCooked = (terminals) => {
+export const getCooked = (tags) => {
   let cooked = '';
 
-  for (const terminal of terminals) {
-    switch (terminal.type) {
-      case 'Reference': {
-        throw new Error('cookable nodes must not contain other nodes');
+  let first = true;
+  let foundLast = false;
+  let depth = 0;
+
+  for (const tag of tags) {
+    if (foundLast) throw new Error();
+
+    switch (tag.type) {
+      case ReferenceTag: {
+        if (depth === 1) {
+          throw new Error('cookable nodes must not contain other nodes');
+        }
+        break;
       }
 
-      case 'OpenNodeTag': {
-        const { flags, attributes } = terminal.value;
+      case OpenNodeTag: {
+        const { flags, attributes } = tag.value;
+
+        depth++;
+
+        if (first) {
+          if (flags.token) {
+            break;
+          } else {
+            throw new Error(JSON.stringify(flags));
+          }
+        }
 
         if (!(flags.trivia || (flags.escape && attributes.cooked))) {
           throw new Error('cookable nodes must not contain other nodes');
         }
 
         if (flags.escape) {
-          const { cooked: cookedValue } = terminal.value.attributes;
+          const { cooked: cookedValue } = tag.value.attributes;
 
           if (!cookedValue) throw new Error('cannot cook string: it contains uncooked escapes');
 
@@ -497,8 +524,18 @@ export const getCooked = (terminals) => {
         break;
       }
 
-      case 'Literal': {
-        cooked += terminal.value;
+      case CloseNodeTag: {
+        if (depth === 1) {
+          foundLast = true;
+        }
+        depth--;
+        break;
+      }
+
+      case LiteralTag: {
+        if (depth === 1) {
+          cooked += tag.value;
+        }
         break;
       }
 
@@ -506,29 +543,31 @@ export const getCooked = (terminals) => {
         throw new Error();
       }
     }
+
+    first = false;
   }
 
   return cooked;
 };
 
-export const printSource = (terminals) => {
+export const printSource = (tags) => {
   let printed = '';
 
-  if (!terminals) return printed;
+  if (!tags) return printed;
 
-  for (const terminal of terminals) {
-    if (terminal.type === 'Literal') {
-      printed += terminal.value;
+  for (const tag of tags) {
+    if (tag.type === LiteralTag) {
+      printed += tag.value;
     }
   }
 
   return printed;
 };
 
-export function* generateSourceTextFor(terminals) {
-  for (const terminal of terminals) {
-    if (terminal.type === 'Literal') {
-      yield* terminal.value;
+export function* generateSourceTextFor(tags) {
+  for (const tag of tags) {
+    if (tag.type === LiteralTag) {
+      yield* tag.value;
     }
   }
 }

package/lib/symbols.js

@@ -6,4 +6,20 @@ 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 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 LiteralTag = Symbol.for('LiteralTag');
+
+export const EmbeddedNode = Symbol.for('EmbeddedNode');
+export const EmbeddedTag = Symbol.for('EmbeddedTag');
+export const EmbeddedExpression = Symbol.for('EmbeddedExpression');
+
+export const TokenGroup = Symbol.for('TokenGroup');
+
 export { null_ as null };

package/lib/template.js

@@ -1,11 +1,18 @@
 import * as t from './builders.js';
+import { LiteralTag, EmbeddedNode } from './symbols.js';
+import * as btree from './btree.js';
 
 const { isArray } = Array;
 const { freeze } = Object;
+const { isFinite } = Number;
 
 export const interpolateArray = (value) => {
   if (isArray(value)) {
-    return value;
+    if (isFinite(value[0])) {
+      return [...btree.traverse(value)];
+    } else {
+      return value;
+    }
   } else {
     return [value];
   }
@@ -27,28 +34,28 @@ export const interpolateArrayChildren = (value, ref, sep) => {
   }
 };
 
-const validateTerminal = (term) => {
-  if (!term || (term.type !== 'Literal' && term.type !== 'EmbeddedNode')) {
-    throw new Error('Invalid terminal');
+const validateTag = (tag) => {
+  if (!tag || (tag.type !== LiteralTag && tag.type !== EmbeddedNode)) {
+    throw new Error('Invalid tag');
   }
-  if (term.type === 'EmbeddedNode' && !term.value.flags.escape) {
+  if (tag.type === EmbeddedNode && !tag.value.flags.escape) {
     throw new Error();
   }
 };
 
 export const interpolateString = (value) => {
-  const terminals = [];
+  const tags = [];
   if (isArray(value)) {
     for (const element of value) {
-      validateTerminal(element);
+      validateTag(element);
 
-      terminals.push(element);
+      tags.push(element);
     }
   } else {
     // we can't safely interpolate strings here, though I wish we could
-    validateTerminal(value);
-    terminals.push(value);
+    validateTag(value);
+    tags.push(value);
   }
 
-  return t.buildNode('String', 'Content', terminals);
+  return t.buildNode('String', 'Content', tags);
 };