@bablr/agast-helpers 0.3.2 → 0.5.0

package/lib/stream.js

@@ -1,11 +1,27 @@
 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,
+  OpenFragmentTag,
+  CloseFragmentTag,
+} 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,12 +105,6 @@ export class AsyncGenerator {
   }
 }
 
-export const isIntrinsicToken = (terminal) => {
-  return (
-    terminal.type === 'OpenNodeTag' && terminal.value.flags.intrinsic && terminal.value.flags.token
-  );
-};
-
 export class StreamGenerator {
   constructor(embeddedGenerator) {
     this.generator = embeddedGenerator;
@@ -149,8 +159,8 @@ export const maybeWait = (maybePromise, callback) => {
   }
 };
 
-function* __generateStandardOutput(terminals) {
-  const co = new Coroutine(getStreamIterator(terminals));
+function* __isEmpty(tags) {
+  const co = new Coroutine(getStreamIterator(tags));
 
   for (;;) {
     co.advance();
@@ -160,10 +170,55 @@ function* __generateStandardOutput(terminals) {
     }
     if (co.done) break;
 
-    const terminal = co.value;
+    let depth = 0;
+
+    const tag = co.value;
+
+    switch (tag.type) {
+      case OpenFragmentTag:
+      case OpenNodeTag:
+        if (tag.value.flags.trivia) {
+          ++depth;
+        }
+
+        if (depth === 0 && tag.value.flags.escape) {
+          return false;
+        }
+
+        break;
+
+      case CloseFragmentTag:
+      case CloseNodeTag:
+        --depth;
+        break;
+
+      case LiteralTag:
+      case GapTag:
+        return false;
+    }
+  }
+
+  return true;
+}
 
-    if (terminal.type === 'Effect') {
-      const effect = getEmbeddedExpression(terminal.value);
+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 = getEmbeddedExpression(effect.value);
         if (writeEffect.stream == null || writeEffect.stream === 1) {
@@ -174,11 +229,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 +244,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 = tag.value;
       if (effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         const prevStream = currentStream;
@@ -207,10 +261,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 +284,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,17 +309,17 @@ export const stringFromStream = (stream) => {
   return str;
 };
 
-function* __generateCSTMLStrategy(terminals, options) {
+function* __generateCSTMLStrategy(tags, options) {
   let { emitEffects = false, inline: inlineOption = true } = options;
 
-  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();
@@ -275,43 +329,47 @@ 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 generateCSTMLStrategy = (terminals, options = {}) =>
-  new StreamIterable(__generateCSTMLStrategy(terminals, options));
+export const generateCSTMLStrategy = (tags, options = {}) =>
+  new StreamIterable(__generateCSTMLStrategy(tags, options));
+
+const isToken = (tag) => {
+  return tag.value.flags.token;
+};
 
-export const prettyGroupTokens = (terminals) => new StreamIterable(__prettyGroupTokens(terminals));
+export const prettyGroupTokens = (tags) => new StreamIterable(__prettyGroupTokens(tags));
 
-function* __prettyGroupTokens(terminals) {
+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();
@@ -322,18 +380,19 @@ function* __prettyGroupTokens(terminals) {
       co.current = yield co.current;
     }
 
-    const terminal = co.value;
+    const tag = co.value;
     const isOpenClose =
-      terminal.type === 'CloseNodeTag' || (terminal.type === 'OpenNodeTag' && terminal.value.type);
+      tag.type === CloseNodeTag ||
+      tag.type === OpenNodeTag ||
+      tag.type === CloseFragmentTag ||
+      tag.type === OpenFragmentTag;
 
     if (
-      (terminal.type === 'Effect' && terminal.value.verb === 'write') ||
-      ['Reference', 'DoctypeTag', 'Gap', 'Null'].includes(terminal.type) ||
-      (terminal.type === 'OpenNodeTag' && !terminal.value.type) ||
-      (state.open &&
-        !isIntrinsicToken(state.open) &&
-        (terminal.type === 'Literal' ||
-          (terminal.type === 'OpenNodeTag' && terminal.value.flags.escape)))
+      (tag.type === 'Effect' && tag.value.verb === 'write') ||
+      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayTag, ShiftTag, OpenFragmentTag].includes(
+        tag.type,
+      ) ||
+      (tag.type === OpenNodeTag && tag.value.flags.escape)
     ) {
       state.broken = true;
 
@@ -341,52 +400,55 @@ function* __prettyGroupTokens(terminals) {
         yield* state.holding;
         state.holding = [];
       }
-
-      if (!isOpenClose && terminal.type !== 'Effect') {
-        yield terminal;
-      }
-    } else if (!isOpenClose && terminal.type !== 'Effect') {
-      state.holding.push(terminal);
+    } else if (tag.type === LiteralTag) {
+      state.holding.push(tag);
     }
 
-    if (terminal.type === 'Effect') {
-      yield terminal;
+    if (!state.holding.length && !isOpenClose) {
+      yield tag;
     }
 
-    if (terminal.type === 'CloseNodeTag') {
-      if (!state.broken && (isIntrinsicToken(state.open) || state.holding.length === 1)) {
-        state.holding.push(terminal);
+    if (tag.type === CloseNodeTag || tag.type === CloseFragmentTag) {
+      if (!state.broken && (isToken(state.open) || state.holding.length === 1)) {
+        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.type === OpenFragmentTag) {
+      if (tag.type === OpenFragmentTag) {
+        states = states.push({ holding: [], broken: false, open: tag });
+        yield tag;
+      } else {
+        states = states.push({ holding: [tag], broken: false, open: tag });
+      }
+
       state = states.value;
     }
   }
 }
 
-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;
+  let ref = null;
 
   for (;;) {
     co.advance();
@@ -397,10 +459,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 = tag.value;
       if (emitEffects && effect.verb === 'write') {
         const writeEffect = getEmbeddedExpression(effect.value);
         yield buildWriteEffect(
@@ -417,13 +479,18 @@ function* __generatePrettyCSTMLStrategy(terminals, options) {
     inline =
       inlineOption &&
       inline &&
-      (terminal.type === 'Null' || terminal.type === 'Gap' || terminal.type === 'TokenGroup');
+      ref &&
+      (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 || tag.type === CloseFragmentTag) {
+      ref = null;
       if (indentLevel === 0) {
         throw new Error('imbalanced tag stack');
       }
@@ -437,18 +504,20 @@ 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) {
+      ref = null;
+      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;
+      ref = tag;
     }
 
-    if (terminal.type === 'OpenNodeTag') {
+    if (tag.type === OpenNodeTag || tag.type === OpenFragmentTag) {
       indentLevel++;
     }
 
@@ -458,32 +527,52 @@ 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 OpenFragmentTag:
+      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');
 
@@ -493,8 +582,19 @@ export const getCooked = (terminals) => {
         break;
       }
 
-      case 'Literal': {
-        cooked += terminal.value;
+      case CloseFragmentTag:
+      case CloseNodeTag: {
+        if (depth === 1) {
+          foundLast = true;
+        }
+        depth--;
+        break;
+      }
+
+      case LiteralTag: {
+        if (depth === 1) {
+          cooked += tag.value;
+        }
         break;
       }
 
@@ -502,29 +602,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,22 @@ 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 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,54 +1,93 @@
 import * as t from './builders.js';
+import {
+  LiteralTag,
+  EmbeddedNode,
+  ReferenceTag,
+  ArrayTag,
+  OpenFragmentTag,
+  OpenNodeTag,
+  DoctypeTag,
+  CloseFragmentTag,
+} from './symbols.js';
+import * as btree from './btree.js';
+import { getOpenTag, getRoot } from './tree.js';
 
 const { isArray } = Array;
 const { freeze } = Object;
+const { isFinite } = Number;
+
+export const interpolateArray = (fragment) => {
+  const value = getRoot(fragment);
 
-export const interpolateArray = (value) => {
   if (isArray(value)) {
-    return value;
+    if (isFinite(value[0])) {
+      return [...btree.traverse(value)];
+    } else {
+      return value;
+    }
   } else {
     return [value];
   }
 };
 
-export const interpolateArrayChildren = (value, ref, sep) => {
-  if (isArray(value)) {
-    const values = value;
-    const children = [];
-    let first = true;
-    for (const _ of values) {
-      if (!first) children.push(freeze({ ...sep }));
-      children.push(freeze({ ...ref }));
-      first = false;
+export function* interpolateFragmentChildren(value, ref) {
+  const open = getOpenTag(value);
+
+  if (open.type === OpenFragmentTag) {
+    let currentRef = null;
+    for (let child of btree.traverse(value.children)) {
+      if (
+        child.type === DoctypeTag ||
+        child.type === OpenFragmentTag ||
+        child.type === CloseFragmentTag
+      ) {
+        continue;
+      }
+
+      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;
+        }
+      } else {
+        yield child;
+      }
     }
-    return children;
+  } else if (open.type === OpenNodeTag) {
+    yield freeze({ ...ref });
   } else {
-    return [freeze({ ...ref })];
+    throw new Error();
   }
-};
+}
 
-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);
 };