@bablr/agast-helpers 0.9.0 → 0.10.0

package/lib/print.js

@@ -6,16 +6,15 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  InitializerTag,
   LiteralTag,
   AttributeDefinition,
   BindingTag,
-  Document,
 } from './symbols.js';
 import { referenceFlags } from './builders.js';
 
 let { isInteger, isFinite } = Number;
 let { isArray } = Array;
+let { freeze } = Object;
 let isString = (val) => typeof val === 'string';
 let isNumber = (val) => typeof val === 'number';
 let isObject = (val) => val && typeof val === 'object' && !isArray(val);
@@ -58,7 +57,20 @@ export const printAttributes = (attributes) => {
 };
 
 export const printIdentifierPath = (path) => {
-  return path.map(printIdentifier).join('.');
+  return path
+    .map((segment) => {
+      let { name, type } = segment;
+      if (name) {
+        return printIdentifier(name);
+      }
+      if (type) {
+        if (type !== '..') throw new Error();
+        return type;
+      } else {
+        throw new Error();
+      }
+    })
+    .join('.');
 };
 
 let escapeReplacer = (esc) => {
@@ -78,7 +90,7 @@ 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)
+  return /^[a-zA-Z\u{80}-\u{10ffff}][a-zA-Z\u{80}-\u{10ffff}0-9_-]*$/u.test(id)
     ? id
     : `\`${id
         .replace(/[`\\]/g, '\\`')
@@ -103,16 +115,6 @@ export const printGapTag = (tag) => {
   return `<//>`;
 };
 
-export const printInitializerTag = (tag) => {
-  if (tag?.type !== InitializerTag) throw new Error();
-
-  if (tag.value.isArray) {
-    return `[]`;
-  } else {
-    return 'undefined';
-  }
-};
-
 export const printShiftTag = (tag) => {
   if (tag?.type !== ShiftTag) throw new Error();
 
@@ -120,18 +122,31 @@ export const printShiftTag = (tag) => {
 };
 
 export const printReference = (ref) => {
-  let { type, name, isArray, flags } = ref;
-  let pathBraces = isArray ? `[]` : '';
+  let { type, name, flags } = ref;
 
   if (type && type !== '#' && name) throw new Error();
-  if (type && !['.', '#', '@', '_'].includes(type)) throw new Error();
+  if (type && !['_', '.', '#', '@'].includes(type)) throw new Error();
 
-  return `${type || ''}${printIdentifier(name) || ''}${pathBraces}${printReferenceFlags(flags)}:`;
+  return `${type || ''}${printIdentifier(name) || ''}${printReferenceFlags(flags)}:`;
 };
 
 export const printBinding = (binding) => {
-  let { languagePath } = binding;
-  return `:${languagePath ? printIdentifierPath(languagePath) : ''}:`;
+  let { segments } = binding;
+  return `:${
+    segments.length ? segments.map((segment) => printBindingSegment(segment)).join('/') : ''
+  }:`;
+};
+
+export const printBindingSegment = (segment) => {
+  let { type, name } = segment;
+  if (type) {
+    if (type !== '..') throw new Error();
+    return type;
+  } else if (name) {
+    return printIdentifier(name);
+  } else {
+    throw new Error();
+  }
 };
 
 export const printReferenceTag = (tag) => {
@@ -150,7 +165,7 @@ export const printNullTag = (tag) => {
   return 'null';
 };
 
-export const printType = (type) => {
+export const printName = (type) => {
   return typeof type === 'string'
     ? type
     : typeof type === 'symbol'
@@ -158,6 +173,10 @@ export const printType = (type) => {
     : String(type);
 };
 
+export const printType = (type) => {
+  return typeof type === 'symbol' ? type.description : String(type);
+};
+
 export const printDoctypeTag = (tag) => {
   if (tag?.type !== DoctypeTag) throw new Error();
 
@@ -176,55 +195,58 @@ export const printLiteralTag = (tag) => {
 };
 
 export const printReferenceFlags = (flags = referenceFlags) => {
+  let array = flags.array ? `[]` : '';
   let plus = flags.expression ? '+' : '';
+  let star = flags.intrinsic ? '*' : '';
   let dollar = flags.hasGap ? '$' : '';
 
-  return `${plus}${dollar}`;
+  return `${array}${plus}${star}${dollar}`;
 };
 
 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}${fragment}${multiFragment}`;
+  return `${star}${dollar}`;
+};
+
+export const printNodeType = (type) => {
+  if (![Symbol.for('_'), Symbol.for('__')].includes(type)) throw new Error();
+
+  return type.description;
 };
 
 export const printOpenNodeTag = (tag) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
-  let { flags, type, literalValue, attributes, selfClosing } = tag.value;
+  let { flags, type, name, literalValue, attributes, selfClosing } = tag.value;
 
-  if (!type && !flags.fragment) throw new Error();
   if (literalValue && !selfClosing) throw new Error();
-
-  if (!type) {
-    return `<${printNodeFlags(flags)}>`;
-  }
+  let selfClosingFrag = selfClosing ? ' /' : '';
+  let literalFrag = literalValue ? ` ${printString(literalValue)}` : '';
 
   let printedAttributes = printAttributes(attributes);
   let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
-  let literalFrag = literalValue ? ` ${printString(literalValue)}` : '';
-  let selfClosingFrag = selfClosing ? ' /' : '';
+  let typeFrag = type ? printNodeType(type) : '';
+  let nameFrag = name ? printType(name) : '';
 
-  return `<${printNodeFlags(flags)}${printType(
-    type,
-  )}${literalFrag}${attributesFrag}${selfClosingFrag}>`;
+  return `<${printNodeFlags(
+    flags,
+  )}${typeFrag}${nameFrag}${literalFrag}${attributesFrag}${selfClosingFrag}>`;
 };
 
 export const printSelfClosingNodeTag = (tag, literalValue) => {
   if (tag?.type !== OpenNodeTag) throw new Error();
 
-  let { flags, type, attributes } = tag.value;
+  let { flags, type, name, attributes } = tag.value;
 
   let printedAttributes = printAttributes(attributes);
   let attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
-  let intrinsicFrag = literalValue ? ` ${printString(literalValue)}` : '';
+  let literalFrag = literalValue ? ` ${printString(literalValue)}` : '';
+  let typeFrag = type ? printNodeType(type) : '';
+  let nameFrag = name ? printType(name) : '';
 
-  return `<${printNodeFlags(flags)}${printType(type)}${intrinsicFrag}${attributesFrag} />`;
+  return `<${printNodeFlags(flags)}${typeFrag}${nameFrag}${literalFrag}${attributesFrag} />`;
 };
 
 export const printCloseNodeTag = (tag) => {
@@ -238,14 +260,15 @@ export const printAttributeDefinition = (tag) => {
   if (!tag.value.path?.length) throw new Error();
   let { path, value } = tag.value;
 
-  return `{ ${printIdentifierPath(path)}: ${printExpression(value)} }`;
+  return `{ ${printIdentifierPath(
+    path.map((name) => freeze({ type: null, name })),
+  )}: ${printExpression(value)} }`;
 };
 
 const printers = {
   [NullTag]: printNullTag,
   [GapTag]: printGapTag,
   [BindingTag]: printBindingTag,
-  [InitializerTag]: printInitializerTag,
   [ShiftTag]: printShiftTag,
   [LiteralTag]: printLiteralTag,
   [DoctypeTag]: printDoctypeTag,

package/lib/shorthand.js

@@ -4,8 +4,10 @@ import {
   buildOpenNodeTag,
   buildCloseNodeTag,
   buildLiteralTag,
-  buildInitializerTag,
+  buildOpenFragmentTag,
+  buildOpenCoverTag,
 } from './builders.js';
+import { freeze } from './object.js';
 import { buildReferenceTag, treeFromStreamSync } from './tree.js';
 
 export * from './builders.js';
@@ -26,26 +28,27 @@ const stripArray = (val) => {
 export const parseReference = (str) => {
   let {
     1: type,
-    2: name,
-    3: isArray,
-    4: index,
+    2: namedType,
+    3: name,
+    4: array,
     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(
+    6: intrinsicToken,
+    7: hasGapToken,
+  } = /^\s*(?:([.#@_])|(#)?([a-zA-Z\u{80}-\u{10ffff}][a-zA-Z0-9_\u{80}-\u{10ffff}-]*))\s*(\[\])?\s*(\+)?(\*)?(\$)?\s*$/u.exec(
     str,
   );
 
-  let flags = {
+  let flags = freeze({
+    array: !!array,
     expression: !!expressionToken,
+    intrinsic: !!intrinsicToken,
     hasGap: !!hasGapToken,
-  };
+  });
 
-  index = index ? parseInt(index, 10) : null;
-  isArray = !!isArray;
-  type = type || null;
+  type = type || namedType || null;
   name = name || null;
 
-  return buildReferenceTag(type, name, isArray, flags, index);
+  return buildReferenceTag(type, name, flags);
 };
 
 export const ref = (path) => {
@@ -56,7 +59,8 @@ export const lit = (str) => buildLiteralTag(stripArray(str));
 
 export const doctype = buildDoctypeTag;
 export const gap = buildGapTag;
-export const arr = () => buildInitializerTag(true);
 export const nodeOpen = buildOpenNodeTag;
+export const fragOpen = buildOpenFragmentTag;
+export const coverOpen = buildOpenCoverTag;
 export const nodeClose = buildCloseNodeTag;
 export const tree = (...tags) => treeFromStreamSync(tags);