@bablr/agast-helpers 0.5.2 → 0.6.0

package/lib/print.js

@@ -2,45 +2,77 @@ import {
   DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
-  OpenFragmentTag,
-  CloseFragmentTag,
   ReferenceTag,
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   LiteralTag,
   EmbeddedNode,
   EmbeddedTag,
-  EmbeddedExpression,
+  EmbeddedObject,
+  EmbeddedMatcher,
+  EmbeddedRegex,
 } from './symbols.js';
+import { isEmptyReference, isGapNode, isNullNode, printSource, referenceFlags } from './tree.js';
 
-const { isInteger, isFinite } = Number;
-const { isArray } = Array;
-const isString = (val) => typeof val === 'string';
-const isNumber = (val) => typeof val === 'number';
-const isObject = (val) => val && typeof val === 'object' && !isArray(val);
-const isFunction = (val) => typeof val === 'function';
+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';
 
-const when = (condition, value) =>
+let when = (condition, value) =>
   condition ? (isFunction(value) ? value() : value) : { *[Symbol.iterator]() {} };
 
 export const printCall = (call) => {
-  const { verb, arguments: args } = call;
-  return `${verb}${printTuple(args)}`;
+  let { verb, arguments: args } = call;
+  return `${verb}${`(${args.map((v) => printExpression(v)).join(' ')})`}`;
 };
 
-export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(' ')}]`;
-
-export const printTuple = (tup) => `(${tup.map((v) => printExpression(v)).join(' ')})`;
+export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(', ')}]`;
 
 export const printObject = (obj) => {
-  const entries = Object.entries(obj);
+  let entries = Object.entries(obj);
   return entries.length
-    ? `{ ${entries.map(([k, v]) => `${k}: ${printExpression(v)}`).join(' ')} }`
+    ? `{ ${entries.map(([k, v]) => `${k}: ${printExpression(v)}`).join(', ')} }`
     : '{}';
 };
 
+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);
@@ -67,15 +99,20 @@ export const printExpression = (expr) => {
 export const printEmbedded = (value) => {
   switch (value.type) {
     case EmbeddedTag:
-      return printTag(value.value);
+      return `t\`${printTag(value.value)}\``;
+
+    case EmbeddedMatcher:
+      return `m\`${printSource(value.value)}\``;
+
+    case EmbeddedRegex:
+      return `re\`${printSource(value.value)}\``;
 
-    case EmbeddedExpression: {
+    case EmbeddedObject: {
       return printObject(value.value);
     }
 
     case EmbeddedNode: {
-      throw new Error('not implemented');
-      break;
+      return printSource(value.value);
     }
 
     default:
@@ -84,9 +121,8 @@ export const printEmbedded = (value) => {
 };
 
 export const printAttributes = (attributes) => {
-  return Object.entries(attributes)
-    .map(([k, v]) => (v === true ? k : v === false ? `!${k}` : `${k}=${printExpression(v)}`))
-    .join(' ');
+  const printed = attributes && printObject(attributes);
+  return !printed || printed === '{}' ? '' : printed;
 };
 
 export const printLanguage = (language) => {
@@ -104,7 +140,7 @@ export const printTagPath = (language, type) => {
   ].join(':');
 };
 
-const escapeReplacer = (esc) => {
+let escapeReplacer = (esc) => {
   if (esc === '\r') {
     return '\\r';
   } else if (esc === '\n') {
@@ -138,8 +174,8 @@ export const printGapTag = (tag) => {
   return `<//>`;
 };
 
-export const printArrayTag = (tag) => {
-  if (tag?.type !== ArrayTag) throw new Error();
+export const printArrayInitializerTag = (tag) => {
+  if (tag?.type !== ArrayInitializerTag) throw new Error();
 
   return `[]`;
 };
@@ -153,11 +189,10 @@ export const printShiftTag = (tag) => {
 export const printReferenceTag = (tag) => {
   if (tag?.type !== ReferenceTag) throw new Error();
 
-  const { name, isArray, hasGap } = tag.value;
-  const pathBraces = isArray ? '[]' : '';
-  const gapDollar = hasGap ? '$' : '';
+  let { name, isArray, flags, index } = tag.value;
+  let pathBraces = isArray ? `[${index || ''}]` : '';
 
-  return `${name}${pathBraces}${gapDollar}:`;
+  return `${name || ''}${pathBraces}${printReferenceFlags(flags)}:`;
 };
 
 export const printNullTag = (tag) => {
@@ -193,47 +228,45 @@ export const printLiteralTag = (tag) => {
   return printString(tag.value);
 };
 
-export const printFlags = (flags) => {
-  const hash = flags.trivia ? '#' : '';
-  const star = flags.token ? '*' : '';
-  const at = flags.escape ? '@' : '';
-  const plus = flags.expression ? '+' : '';
-  const dollar = flags.hasGap ? '$' : '';
+export const printReferenceFlags = (flags = referenceFlags) => {
+  let plus = flags.expression ? '+' : '';
+  let dollar = flags.hasGap ? '$' : '';
 
-  if (flags.escape && flags.trivia) throw new Error('Node cannot be escape and trivia');
+  return `${plus}${dollar}`;
+};
+
+export const printNodeFlags = (flags) => {
+  let star = flags.token ? '*' : '';
+  let dollar = flags.hasGap ? '$' : '';
 
-  return `${hash}${star}${at}${plus}${dollar}`;
+  return `${star}${dollar}`;
 };
 
 export const printOpenNodeTag = (tag) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
-  const { flags, language: tagLanguage, type, attributes } = tag.value;
-
-  const printedAttributes = attributes && printAttributes(attributes);
-  const attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
+  let { flags, language: tagLanguage, type, attributes } = tag.value;
 
-  return `<${printFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
-};
-
-export const printOpenFragmentTag = (tag) => {
-  if (tag?.type !== OpenFragmentTag) throw new Error();
+  if (!type) {
+    return `<${printNodeFlags(flags)}>`;
+  }
 
-  const { flags } = tag.value;
+  let printedAttributes = printAttributes(attributes);
+  let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
 
-  return `<${printFlags(flags)}>`;
+  return `<${printNodeFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
 };
 
 export const printSelfClosingNodeTag = (tag, intrinsicValue) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
-  const { flags, language: tagLanguage, type, attributes } = tag.value;
+  let { flags, language: tagLanguage, type, attributes } = tag.value;
 
-  const printedAttributes = attributes && printAttributes(attributes);
-  const attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
-  const intrinsicFrag = intrinsicValue ? ` ${printString(intrinsicValue)}` : '';
+  let printedAttributes = printAttributes(attributes);
+  let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
+  let intrinsicFrag = intrinsicValue ? ` ${printString(intrinsicValue)}` : '';
 
-  return `<${printFlags(flags)}${printTagPath(
+  return `<${printNodeFlags(flags)}${printTagPath(
     tagLanguage,
     type,
   )}${intrinsicFrag}${attributesFrag} />`;
@@ -245,12 +278,6 @@ export const printCloseNodeTag = (tag) => {
   return `</>`;
 };
 
-export const printCloseFragmentTag = (tag) => {
-  if (tag?.type !== CloseFragmentTag) throw new Error();
-
-  return `</>`;
-};
-
 export const printTag = (tag) => {
   if (!isObject(tag)) throw new Error();
 
@@ -261,8 +288,8 @@ export const printTag = (tag) => {
     case GapTag:
       return printGapTag(tag);
 
-    case ArrayTag:
-      return printArrayTag(tag);
+    case ArrayInitializerTag:
+      return printArrayInitializerTag(tag);
 
     case ShiftTag:
       return printShiftTag(tag);
@@ -282,12 +309,6 @@ export const printTag = (tag) => {
     case CloseNodeTag:
       return printCloseNodeTag(tag);
 
-    case OpenFragmentTag:
-      return printOpenFragmentTag(tag);
-
-    case CloseFragmentTag:
-      return printCloseFragmentTag(tag);
-
     default:
       throw new Error();
   }

package/lib/shorthand.js

@@ -1,22 +1,12 @@
 import {
-  buildReferenceTag,
+  buildDoctypeTag,
   buildGapTag,
-  buildEmbeddedNode,
-  buildNodeOpenTag,
-  buildNodeCloseTag,
+  buildOpenNodeTag,
+  buildCloseNodeTag,
   buildLiteralTag,
-  buildNullNode,
-  buildArrayTag,
-  buildNode,
-  buildFragment,
-  buildGapNode,
-  buildSyntacticNode,
-  buildEscapeNode,
-  buildSyntacticEscapeNode,
-  buildSyntacticTriviaNode,
-  buildTriviaNode,
+  buildArrayInitializerTag,
 } from './builders.js';
-import { parsePath } from './path.js';
+import { parseReference, treeFromStreamSync } from './tree.js';
 
 export * from './builders.js';
 
@@ -34,24 +24,14 @@ const stripArray = (val) => {
 };
 
 export const ref = (path) => {
-  const { name, isArray: pathIsArray } = parsePath(isArray(path) ? path[0] : path);
-
-  return buildReferenceTag(name, pathIsArray);
+  return parseReference(isArray(path) ? path[0] : path);
 };
 
 export const lit = (str) => buildLiteralTag(stripArray(str));
 
+export const doctype = buildDoctypeTag;
 export const gap = buildGapTag;
-export const arr = buildArrayTag;
-export const embedded = buildEmbeddedNode;
-export const nodeOpen = buildNodeOpenTag;
-export const nodeClose = buildNodeCloseTag;
-export const node = buildNode;
-export const frag = buildFragment;
-export const g_node = buildGapNode;
-export const s_node = buildSyntacticNode;
-export const e_node = buildEscapeNode;
-export const s_e_node = buildSyntacticEscapeNode;
-export const s_t_node = buildSyntacticTriviaNode;
-export const t_node = buildTriviaNode;
-export const null_node = buildNullNode;
+export const arr = buildArrayInitializerTag;
+export const nodeOpen = buildOpenNodeTag;
+export const nodeClose = buildCloseNodeTag;
+export const tree = (...tags) => treeFromStreamSync(tags);