@bablr/agast-helpers 0.7.1 → 0.9.0

package/lib/print.js

@@ -8,18 +8,17 @@ import {
   NullTag,
   InitializerTag,
   LiteralTag,
+  AttributeDefinition,
+  BindingTag,
+  Document,
 } from './symbols.js';
-import { isEmptyReference, isGapNode, isNullNode, printSource, referenceFlags } from './tree.js';
+import { referenceFlags } from './builders.js';
 
 let { isInteger, isFinite } = Number;
 let { isArray } = Array;
 let isString = (val) => typeof val === 'string';
 let isNumber = (val) => typeof val === 'number';
 let isObject = (val) => val && typeof val === 'object' && !isArray(val);
-let isFunction = (val) => typeof val === 'function';
-
-let when = (condition, value) =>
-  condition ? (isFunction(value) ? value() : value) : { *[Symbol.iterator]() {} };
 
 export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(', ')}]`;
 
@@ -30,39 +29,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 +57,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 +77,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)}'`;
 };
@@ -156,13 +119,27 @@ export const printShiftTag = (tag) => {
   return `^^^`;
 };
 
-export const printReferenceTag = (tag) => {
-  if (tag?.type !== ReferenceTag) throw new Error();
+export const printReference = (ref) => {
+  let { type, name, isArray, flags } = ref;
+  let pathBraces = isArray ? `[]` : '';
 
-  let { name, isArray, flags, index } = tag.value;
-  let pathBraces = isArray ? `[${index || ''}]` : '';
+  if (type && type !== '#' && name) throw new Error();
+  if (type && !['.', '#', '@', '_'].includes(type)) throw new Error();
 
-  return `${name || ''}${pathBraces}${printReferenceFlags(flags)}:`;
+  return `${type || ''}${printIdentifier(name) || ''}${pathBraces}${printReferenceFlags(flags)}:`;
+};
+
+export const printBinding = (binding) => {
+  let { languagePath } = binding;
+  return `:${languagePath ? printIdentifierPath(languagePath) : ''}:`;
+};
+
+export const printReferenceTag = (tag) => {
+  return printReference(tag.value);
+};
+
+export const printBindingTag = (tag) => {
+  return printBinding(tag.value);
 };
 
 export const printNullTag = (tag) => {
@@ -177,7 +154,7 @@ export const printType = (type) => {
   return typeof type === 'string'
     ? type
     : typeof type === 'symbol'
-    ? type.description.replace('@bablr/', '')
+    ? printIdentifier(type.description)
     : String(type);
 };
 
@@ -207,40 +184,47 @@ 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 ? '$' : '';
+  let fragment = flags.fragment ? '_' : '';
+  let multiFragment = fragment && !flags.cover ? '_' : '';
 
-  return `${star}${dollar}`;
+  return `${star}${dollar}${fragment}${multiFragment}`;
 };
 
 export const printOpenNodeTag = (tag) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
-  let { flags, language: tagLanguage, type, attributes } = tag.value;
+  let { flags, type, literalValue, attributes, selfClosing } = tag.value;
+
+  if (!type && !flags.fragment) throw new Error();
+  if (literalValue && !selfClosing) throw new Error();
 
   if (!type) {
-    return `<${printNodeFlags(flags)}_>`;
+    return `<${printNodeFlags(flags)}>`;
   }
 
   let printedAttributes = printAttributes(attributes);
   let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
+  let literalFrag = literalValue ? ` ${printString(literalValue)}` : '';
+  let selfClosingFrag = selfClosing ? ' /' : '';
 
-  return `<${printNodeFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
+  return `<${printNodeFlags(flags)}${printType(
+    type,
+  )}${literalFrag}${attributesFrag}${selfClosingFrag}>`;
 };
 
-export const printSelfClosingNodeTag = (tag, intrinsicValue) => {
+export const printSelfClosingNodeTag = (tag, literalValue) => {
   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)}` : '';
+  let intrinsicFrag = literalValue ? ` ${printString(literalValue)}` : '';
 
-  return `<${printNodeFlags(flags)}${printTagPath(
-    tagLanguage,
-    type,
-  )}${intrinsicFrag}${attributesFrag} />`;
+  return `<${printNodeFlags(flags)}${printType(type)}${intrinsicFrag}${attributesFrag} />`;
 };
 
 export const printCloseNodeTag = (tag) => {
@@ -249,38 +233,32 @@ export const printCloseNodeTag = (tag) => {
   return `</>`;
 };
 
-export const printTag = (tag) => {
-  if (!isObject(tag)) throw new Error();
-
-  switch (tag?.type || NullTag) {
-    case NullTag:
-      return printNullTag(tag);
+export const printAttributeDefinition = (tag) => {
+  if (tag?.type !== AttributeDefinition) throw new Error();
+  if (!tag.value.path?.length) throw new Error();
+  let { path, value } = tag.value;
 
-    case GapTag:
-      return printGapTag(tag);
-
-    case InitializerTag:
-      return printInitializerTag(tag);
-
-    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,147 +1,25 @@
 import { Coroutine } from '@bablr/coroutine';
 import emptyStack from '@iter-tools/imm-stack';
-import { printSelfClosingNodeTag, printTag } from './print.js';
-import { buildTokenGroup } from './builders.js';
+import { getStreamIterator, StreamIterable, StreamGenerator } from '@bablr/stream-iterator';
+import { printTag } from './print.js';
+import { buildOpenNodeTag } from './builders.js';
 import {
-  DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
   ReferenceTag,
-  ShiftTag,
   GapTag,
   NullTag,
   InitializerTag,
   LiteralTag,
-  TokenGroup,
+  BindingTag,
+  DoctypeTag,
+  ShiftTag,
+  AttributeDefinition,
 } from './symbols.js';
 
-export * from './print.js';
-
-export const getStreamIterator = (obj) => {
-  return obj[Symbol.for('@@streamIterator')]?.() || obj[Symbol.iterator]?.();
-};
-
-export class SyncGenerator {
-  constructor(embeddedGenerator) {
-    if (!embeddedGenerator.next) throw new Error();
-
-    this.generator = embeddedGenerator;
-  }
-
-  next(value) {
-    const step = this.generator.next(value);
-
-    if (step instanceof Promise) {
-      throw new Error('invalid embedded generator');
-    }
-
-    if (step.done) {
-      return step;
-    } else if (step.value instanceof Promise) {
-      throw new Error('sync generators cannot resolve promises');
-    } else {
-      return step;
-    }
-  }
-
-  return(value) {
-    const step = this.generator.return(value);
-    if (step instanceof Promise) {
-      throw new Error('invalid embedded generator');
-    }
-
-    if (step.value instanceof Promise) {
-      throw new Error('sync generators cannot resolve promises');
-    }
-    return step;
-  }
-
-  [Symbol.iterator]() {
-    return this;
-  }
-}
-
-export class AsyncGenerator {
-  constructor(embeddedGenerator) {
-    this.generator = embeddedGenerator;
-  }
-
-  next(value) {
-    const step = this.generator.next(value);
-
-    if (step instanceof Promise) {
-      throw new Error('invalid embedded generator');
-    }
-
-    if (step.done) {
-      return Promise.resolve(step);
-    } else if (step.value instanceof Promise) {
-      return step.value.then((value) => {
-        return this.next(value);
-      });
-    } else {
-      return Promise.resolve(step);
-    }
-  }
-
-  return(value) {
-    const result = this.generator.return(value);
-    if (result instanceof Promise) {
-      throw new Error('sync generators cannot resolve promises');
-    }
-    return result;
-  }
-
-  [Symbol.asyncIterator]() {
-    return this;
-  }
-}
-
-export class StreamGenerator {
-  constructor(embeddedGenerator) {
-    this.generator = embeddedGenerator;
-  }
-
-  next(value) {
-    const step = this.generator.next(value);
-
-    if (step.done) {
-      return step;
-    } else if (step.value instanceof Promise) {
-      return step.value.then((value) => {
-        return this.next(value);
-      });
-    } else {
-      return step;
-    }
-  }
-
-  return(value) {
-    return this.generator.return(value);
-  }
-
-  [Symbol.for('@@streamIterator')]() {
-    return this;
-  }
-}
-
-export class StreamIterable {
-  constructor(embeddedStreamIterable) {
-    this.iterable = embeddedStreamIterable;
-  }
-
-  [Symbol.iterator]() {
-    return new SyncGenerator(this.iterable);
-  }
-
-  [Symbol.asyncIterator]() {
-    return new AsyncGenerator(this.iterable);
-  }
+export { getStreamIterator, StreamIterable, StreamGenerator };
 
-  [Symbol.for('@@streamIterator')]() {
-    return new StreamGenerator(this.iterable);
-  }
-}
+export * from './print.js';
 
 export const maybeWait = (maybePromise, callback) => {
   if (maybePromise instanceof Promise) {
@@ -175,7 +53,9 @@ function* __isEmpty(tags) {
       case OpenNodeTag:
         ++depth;
 
-        if (depth === 0 && ref.value.name === '@') {
+        if (tag.value.literalValue) return false;
+
+        if (depth === 0 && ref.value.type === '@') {
           return false;
         }
 
@@ -218,9 +98,9 @@ export const asyncStringFromStream = async (stream) => {
 
     if (co.done) break;
 
-    const tag = co.value;
+    const chr = co.value;
 
-    str += printTag(tag);
+    str += chr;
   }
 
   return str;
@@ -271,12 +151,7 @@ function* __generateCSTML(tags, options) {
       continue;
     }
 
-    if (tag.type === TokenGroup) {
-      const intrinsicValue = getCooked(tag.value);
-      yield* printSelfClosingNodeTag(tag.value[0], intrinsicValue);
-    } else {
-      yield* printTag(tag);
-    }
+    yield* printTag(tag);
 
     prevTag = tag;
   }
@@ -319,8 +194,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;
 
@@ -338,8 +222,14 @@ function* __prettyGroupTags(tags) {
 
     if (tag.type === CloseNodeTag) {
       if (!state.broken && (isToken(state.open) || state.holding.length === 1)) {
-        state.holding.push(tag);
-        yield buildTokenGroup(state.holding);
+        let { flags, type, attributes } = state.holding[0].value;
+
+        let literal = state.holding
+          .slice(1)
+          .map((lit) => lit.value)
+          .join('');
+
+        yield buildOpenNodeTag(flags, type, attributes, literal, true);
       } else {
         if (state.holding.length) {
           yield* state.holding;
@@ -352,14 +242,13 @@ function* __prettyGroupTags(tags) {
     }
 
     if (tag.type === OpenNodeTag) {
-      if (!tag.value.type) {
-        states = states.push({ holding: [], broken: false, open: tag });
+      if (tag.value.literalValue) {
         yield tag;
       } else {
         states = states.push({ holding: [tag], broken: false, open: tag });
-      }
 
-      state = states.value;
+        state = states.value;
+      }
     }
   }
 }
@@ -393,14 +282,19 @@ 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);
+        (tag.type === OpenNodeTag && tag.value.selfClosing));
 
     if (!first && !inline) {
       yield* '\n';
@@ -413,18 +307,12 @@ function* __generatePrettyCSTML(tags, options) {
     }
 
     if (!inline) {
-      yield* indent.repeat(indentLevel);
+      yield* indent.repeat(Math.max(0, 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);
-    }
+    yield* printTag(tag);
 
     if (tag.type === ReferenceTag) {
       inline = true;
@@ -432,7 +320,7 @@ function* __generatePrettyCSTML(tags, options) {
     }
 
     if (tag.type === OpenNodeTag) {
-      indentLevel++;
+      indentLevel += tag.value.selfClosing ? 0 : 1;
     }
 
     first = false;
@@ -474,9 +362,9 @@ export const getCooked = (tags) => {
       }
 
       case OpenNodeTag: {
-        const { flags, attributes } = tag.value;
+        const { flags, attributes, literalValue, selfClosing } = tag.value;
 
-        depth++;
+        depth += selfClosing ? 0 : 1;
 
         if (first) {
           if (flags.token) {
@@ -486,16 +374,18 @@ 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');
 
           cooked += cookedValue;
+        } else if (literalValue) {
+          cooked += literalValue;
         }
 
         break;
@@ -533,7 +423,9 @@ export const printSource = (tags) => {
   if (!tags) return printed;
 
   for (const tag of tags) {
-    if (tag.type === LiteralTag) {
+    if (tag.type === OpenNodeTag && tag.value.literalValue) {
+      printed += tag.value.literalValue;
+    } else if (tag.type === LiteralTag) {
       printed += tag.value;
     } else if (tag.type === GapTag) {
       throw new Error('use generateSourceTextFor');

package/lib/symbols.js

@@ -4,10 +4,14 @@ 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 Document = Symbol.for('Document');
+export const Node = Symbol.for('Node');
 
-export const EmbeddedNode = Symbol.for('EmbeddedNode');
+export const Property = Symbol.for('Property');
+export const PropertyWrapper = Symbol.for('PropertyWrapper');