@bablr/agast-helpers 0.7.0 → 0.8.0

package/lib/print.js

@@ -8,8 +8,10 @@ import {
   NullTag,
   InitializerTag,
   LiteralTag,
+  AttributeDefinition,
+  BindingTag,
 } from './symbols.js';
-import { isEmptyReference, isGapNode, isNullNode, printSource, referenceFlags } from './tree.js';
+import { referenceFlags } from './tree.js';
 
 let { isInteger, isFinite } = Number;
 let { isArray } = Array;
@@ -30,39 +32,6 @@ export const printObject = (obj) => {
     : '{}';
 };
 
-export const printPropertyMatcher = (matcher) => {
-  let { refMatcher, nodeMatcher } = matcher;
-  let ref = { type: ReferenceTag, value: refMatcher };
-  let refPart = refMatcher && !isEmptyReference(ref) ? `${printReferenceTag(ref)} ` : '';
-  let nodePart;
-
-  if (isArray(nodeMatcher)) {
-    if (nodeMatcher.length) throw new Error();
-    nodePart = '[]';
-  } else if (isGapNode(nodeMatcher)) {
-    nodePart = '<//>';
-  } else if (isNullNode(nodeMatcher)) {
-    nodePart = 'null';
-  } else {
-    nodePart = printOpenNodeMatcher(nodeMatcher);
-  }
-  return `${refPart}${nodePart}`;
-};
-
-export const printOpenNodeMatcher = (matcher) => {
-  let { flags, language: tagLanguage, type, attributes, intrinsicValue } = matcher;
-
-  let printedAttributes = printAttributes(attributes);
-  let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
-
-  let intrinsicFrag = intrinsicValue
-    ? ` ${isString(intrinsicValue) ? printExpression(intrinsicValue) : printSource(intrinsicValue)}`
-    : '';
-  let typeFrag = type !== Symbol.for('@bablr/fragment') ? printTagPath(tagLanguage, type) : ' ';
-
-  return `<${printNodeFlags(flags)}${typeFrag}${intrinsicFrag}${attributesFrag}/>`;
-};
-
 export const printExpression = (expr) => {
   if (isString(expr)) {
     return printString(expr);
@@ -91,19 +60,8 @@ export const printAttributes = (attributes) => {
   return !printed || printed === '{}' ? '' : printed;
 };
 
-export const printLanguage = (language) => {
-  if (isString(language)) {
-    return printSingleString(language);
-  } else {
-    return language.join('.');
-  }
-};
-
-export const printTagPath = (language, type) => {
-  return [
-    ...when(type && language?.length, () => [printLanguage(language)]),
-    ...when(type, [printType(type)]),
-  ].join(':');
+export const printIdentifierPath = (path) => {
+  return path.map(printIdentifier).join('.');
 };
 
 let escapeReplacer = (esc) => {
@@ -122,6 +80,14 @@ let escapeReplacer = (esc) => {
   }
 };
 
+export const printIdentifier = (id) => {
+  return /^[a-zA-Z\u{80}-\u{10ffff}][a-zA-Z\u{80}-\u{10ffff}0-9_-]+$/u.test(id)
+    ? id
+    : `\`${id
+        .replace(/[`\\]/g, '\\`')
+        .replace(/[\x00-\x20\x7f]/g, (value) => `\\u00${value.toString(16)}`)}\``;
+};
+
 export const printSingleString = (str) => {
   return `'${str.replace(/['\\\0\r\n\t\u0000-\u001A]/g, escapeReplacer)}'`;
 };
@@ -159,10 +125,18 @@ export const printShiftTag = (tag) => {
 export const printReferenceTag = (tag) => {
   if (tag?.type !== ReferenceTag) throw new Error();
 
-  let { name, isArray, flags, index } = tag.value;
-  let pathBraces = isArray ? `[${index || ''}]` : '';
+  let { type, name, isArray, flags } = tag.value;
+  let pathBraces = isArray ? `[]` : '';
 
-  return `${name || ''}${pathBraces}${printReferenceFlags(flags)}:`;
+  if (type && name) throw new Error();
+  if (type && !['.', '#', '@'].includes(type)) throw new Error();
+
+  return `${type || printIdentifier(name) || ''}${pathBraces}${printReferenceFlags(flags)}:`;
+};
+
+export const printBindingTag = (tag) => {
+  let { languagePath } = tag.value;
+  return `:${languagePath ? printIdentifierPath(languagePath) : ''}:`;
 };
 
 export const printNullTag = (tag) => {
@@ -177,7 +151,7 @@ export const printType = (type) => {
   return typeof type === 'string'
     ? type
     : typeof type === 'symbol'
-    ? type.description.replace('@bablr/', '')
+    ? printIdentifier(type.description)
     : String(type);
 };
 
@@ -209,40 +183,35 @@ export const printNodeFlags = (flags) => {
   if (flags.cover && !flags.fragment) throw new Error();
   let star = flags.token ? '*' : '';
   let dollar = flags.hasGap ? '$' : '';
-  let frag = flags.fragment ? '_' : '';
-  let cover = flags.cover ? '_' : '';
 
-  return `${star}${dollar}${frag}${cover}`;
+  return `${star}${dollar}`;
 };
 
 export const printOpenNodeTag = (tag) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
-  let { flags, language: tagLanguage, type, attributes } = tag.value;
+  let { flags, type, attributes } = tag.value;
 
   if (!type) {
-    return `<${printNodeFlags(flags)}>`;
+    return `<${printNodeFlags(flags)}_>`;
   }
 
   let printedAttributes = printAttributes(attributes);
   let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
 
-  return `<${printNodeFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
+  return `<${printNodeFlags(flags)}${printType(type)}${attributesFrag}>`;
 };
 
 export const printSelfClosingNodeTag = (tag, intrinsicValue) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
-  let { flags, language: tagLanguage, type, attributes } = tag.value;
+  let { flags, type, attributes } = tag.value;
 
   let printedAttributes = printAttributes(attributes);
   let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
   let intrinsicFrag = intrinsicValue ? ` ${printString(intrinsicValue)}` : '';
 
-  return `<${printNodeFlags(flags)}${printTagPath(
-    tagLanguage,
-    type,
-  )}${intrinsicFrag}${attributesFrag} />`;
+  return `<${printNodeFlags(flags)}${printType(type)}${intrinsicFrag}${attributesFrag} />`;
 };
 
 export const printCloseNodeTag = (tag) => {
@@ -251,38 +220,31 @@ export const printCloseNodeTag = (tag) => {
   return `</>`;
 };
 
-export const printTag = (tag) => {
-  if (!isObject(tag)) throw new Error();
-
-  switch (tag?.type || NullTag) {
-    case NullTag:
-      return printNullTag(tag);
-
-    case GapTag:
-      return printGapTag(tag);
-
-    case InitializerTag:
-      return printInitializerTag(tag);
+export const printAttributeDefinition = (tag) => {
+  if (tag?.type !== AttributeDefinition) throw new Error();
+  let { path, value } = tag.value;
 
-    case ShiftTag:
-      return printShiftTag(tag);
-
-    case LiteralTag:
-      return printLiteralTag(tag);
-
-    case DoctypeTag:
-      return printDoctypeTag(tag);
+  return `{ ${printIdentifierPath(path)}: ${printExpression(value)} }`;
+};
 
-    case ReferenceTag:
-      return printReferenceTag(tag);
+const printers = {
+  [NullTag]: printNullTag,
+  [GapTag]: printGapTag,
+  [BindingTag]: printBindingTag,
+  [InitializerTag]: printInitializerTag,
+  [ShiftTag]: printShiftTag,
+  [LiteralTag]: printLiteralTag,
+  [DoctypeTag]: printDoctypeTag,
+  [ReferenceTag]: printReferenceTag,
+  [OpenNodeTag]: printOpenNodeTag,
+  [CloseNodeTag]: printCloseNodeTag,
+  [AttributeDefinition]: printAttributeDefinition,
+};
 
-    case OpenNodeTag:
-      return printOpenNodeTag(tag);
+export const printTag = (tag) => {
+  if (!isObject(tag)) throw new Error();
 
-    case CloseNodeTag:
-      return printCloseNodeTag(tag);
+  let printer = printers[tag?.type];
 
-    default:
-      throw new Error();
-  }
+  return printer(tag);
 };

package/lib/shorthand.js

@@ -6,7 +6,7 @@ import {
   buildLiteralTag,
   buildInitializerTag,
 } from './builders.js';
-import { parseReference, treeFromStreamSync } from './tree.js';
+import { buildReferenceTag, treeFromStreamSync } from './tree.js';
 
 export * from './builders.js';
 
@@ -23,6 +23,31 @@ const stripArray = (val) => {
   }
 };
 
+export const parseReference = (str) => {
+  let {
+    1: type,
+    2: name,
+    3: isArray,
+    4: index,
+    5: expressionToken,
+    6: hasGapToken,
+  } = /^\s*(?:([.#@])|([a-zA-Z\u{80}-\u{10ffff}][a-zA-Z0-9_\u{80}-\u{10ffff}-]*))\s*(\[\s*(\d+\s*)?\])?\s*(\+)?(\$)?\s*$/u.exec(
+    str,
+  );
+
+  let flags = {
+    expression: !!expressionToken,
+    hasGap: !!hasGapToken,
+  };
+
+  index = index ? parseInt(index, 10) : null;
+  isArray = !!isArray;
+  type = type || null;
+  name = name || null;
+
+  return buildReferenceTag(type, name, isArray, flags, index);
+};
+
 export const ref = (path) => {
   return parseReference(isArray(path) ? path[0] : path);
 };

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 } from './builders.js';
+import { buildOpenNodeTag, buildTokenGroup } from './builders.js';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -13,6 +13,8 @@ import {
   InitializerTag,
   LiteralTag,
   TokenGroup,
+  BindingTag,
+  AttributeDefinition,
 } from './symbols.js';
 
 export * from './print.js';
@@ -120,6 +122,10 @@ export class StreamGenerator {
     return this.generator.return(value);
   }
 
+  [Symbol.iterator]() {
+    return this;
+  }
+
   [Symbol.for('@@streamIterator')]() {
     return this;
   }
@@ -175,7 +181,7 @@ function* __isEmpty(tags) {
       case OpenNodeTag:
         ++depth;
 
-        if (depth === 0 && ref.value.name === '@') {
+        if (depth === 0 && ref.value.type === '@') {
           return false;
         }
 
@@ -319,8 +325,17 @@ function* __prettyGroupTags(tags) {
 
     if (
       (tag.type === 'Effect' && tag.value.verb === 'write') ||
-      [ReferenceTag, DoctypeTag, GapTag, NullTag, InitializerTag, ShiftTag].includes(tag.type) ||
-      (tag.type === OpenNodeTag && (!tag.value.type || ref?.value.name === '@'))
+      [
+        ReferenceTag,
+        DoctypeTag,
+        BindingTag,
+        GapTag,
+        NullTag,
+        InitializerTag,
+        ShiftTag,
+        AttributeDefinition,
+      ].includes(tag.type) ||
+      (tag.type === OpenNodeTag && (!tag.value.type || ref?.value.type === '@'))
     ) {
       state.broken = true;
 
@@ -352,12 +367,7 @@ function* __prettyGroupTags(tags) {
     }
 
     if (tag.type === OpenNodeTag) {
-      if (!tag.value.type) {
-        states = states.push({ holding: [], broken: false, open: tag });
-        yield tag;
-      } else {
-        states = states.push({ holding: [tag], broken: false, open: tag });
-      }
+      states = states.push({ holding: [tag], broken: false, open: tag });
 
       state = states.value;
     }
@@ -393,12 +403,17 @@ function* __generatePrettyCSTML(tags, options) {
       continue;
     }
 
+    if (tag.type === BindingTag && !tag.value.languagePath?.length) {
+      continue;
+    }
+
     inline =
       inlineOption &&
       inline &&
       ref &&
       (tag.type === NullTag ||
         tag.type === GapTag ||
+        tag.type === BindingTag ||
         tag.type === InitializerTag ||
         tag.type === TokenGroup);
 
@@ -421,7 +436,12 @@ function* __generatePrettyCSTML(tags, options) {
     if (tag.type === TokenGroup) {
       ref = null;
       const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
-      yield* printSelfClosingNodeTag(tag.value[0], intrinsicValue);
+      let openTag = tag.value[0];
+      let { flags, type, attributes } = openTag.value;
+      yield* printSelfClosingNodeTag(buildOpenNodeTag(flags, type, attributes), intrinsicValue);
+    } else if (tag.type === OpenNodeTag) {
+      let { flags, type, attributes } = tag.value;
+      yield* printTag(buildOpenNodeTag(flags, type, attributes));
     } else {
       yield* printTag(tag);
     }
@@ -486,11 +506,11 @@ export const getCooked = (tags) => {
           }
         }
 
-        if (!(ref.value.name === '#' || (ref.value.name === '@' && attributes.cooked))) {
+        if (!(ref.value.type === '#' || (ref.value.type === '@' && attributes.cooked))) {
           throw new Error('cookable nodes must not contain other nodes');
         }
 
-        if (ref.value.name === '@') {
+        if (ref.value.type === '@') {
           const { cooked: cookedValue } = tag.value.attributes;
 
           if (!cookedValue) throw new Error('cannot cook string: it contains uncooked escapes');

package/lib/symbols.js

@@ -4,10 +4,12 @@ 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 BindingTag = Symbol.for('BindingTag');
 export const NullTag = Symbol.for('NullTag');
 export const InitializerTag = Symbol.for('InitializerTag');
+export const AttributeDefinition = Symbol.for('AttributeDefinition');
 export const LiteralTag = Symbol.for('LiteralTag');
 
 export const TokenGroup = Symbol.for('TokenGroup');
 
-export const EmbeddedNode = Symbol.for('EmbeddedNode');
+export const Property = Symbol.for('Property');

package/lib/template.js

@@ -5,10 +5,10 @@ import {
   OpenNodeTag,
   CloseNodeTag,
   DoctypeTag,
-  EmbeddedNode,
-  GapTag,
+  Property,
+  BindingTag,
 } from './symbols.js';
-import * as sumtree from './sumtree.js';
+import * as Children from './children.js';
 import { getOpenTag, get, isFragmentNode } from './tree.js';
 
 const { freeze } = Object;
@@ -21,16 +21,13 @@ export const buildFilledGapFunction = (expressions) => (value) => {
 export function* interpolateFragment(node, ref, expressions) {
   const open = getOpenTag(node);
 
-  if (node.type !== null) throw new Error();
-
   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 Children.traverse(node.children)) {
       switch (tag.type) {
         case DoctypeTag: {
           break;
@@ -48,11 +45,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 +61,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 freeze(ref);
+            yield currentBinding;
           } else {
             yield currentRef;
+            yield currentBinding;
           }
 
-          const count = counters.get(name) + 1;
-
-          counters.set(name, count);
-
-          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 +86,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();
   }