@bablr/agast-helpers 0.10.10 → 0.11.0

package/lib/print.js

@@ -1,3 +1,4 @@
+import { freezeRecord } from '@bablr/record';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -9,8 +10,9 @@ import {
   LiteralTag,
   AttributeDefinition,
   BindingTag,
+  StreamTag,
 } from './symbols.js';
-import { referenceFlags } from './builders.js';
+import { parseObject } from './builders.js';
 
 let { isInteger, isFinite } = Number;
 let { isArray } = Array;
@@ -46,19 +48,22 @@ export const printExpression = (expr) => {
     }
   } else if (isArray(expr)) {
     return printArray(expr);
+  } else if (isObject(expr)) {
+    return printObject(expr);
   } else {
     throw new Error();
   }
 };
 
 export const printAttributes = (attributes) => {
-  const printed = attributes && printObject(attributes);
+  const printed =
+    attributes && printObject(isString(attributes) ? parseObject(attributes) : attributes);
   return !printed || printed === '{}' ? '' : printed;
 };
 
 export const printIdentifierPath = (path) => {
-  return path
-    .map((segment) => {
+  return Array.prototype.map
+    .call(path, (segment) => {
       let { name, type } = segment;
       if (name) {
         return printIdentifier(name);
@@ -131,19 +136,12 @@ export const printReference = (ref) => {
 };
 
 export const printBinding = (binding) => {
-  let { segments } = binding;
-  return `:${
-    segments.length ? segments.map((segment) => printBindingSegment(segment)).join('/') : ''
-  }:`;
-};
-
-export const printBindingSegment = (segment) => {
-  let { type, name } = segment;
+  let { type, name } = binding;
   if (type) {
     if (type !== '..') throw new Error();
-    return type;
+    return `:${type}:`;
   } else if (name) {
-    return printIdentifier(name);
+    return `:${printIdentifier(name.description)}:`;
   } else {
     throw new Error();
   }
@@ -158,9 +156,7 @@ export const printBindingTag = (tag) => {
 };
 
 export const printNullTag = (tag) => {
-  if (tag && tag.type !== NullTag) {
-    throw new Error();
-  }
+  if (tag && tag.type !== NullTag && tag !== 'null') throw new Error();
 
   return 'null';
 };
@@ -174,7 +170,7 @@ export const printName = (type) => {
 };
 
 export const printType = (type) => {
-  return typeof type === 'symbol' ? type.description : String(type);
+  return type == null ? '' : typeof type === 'symbol' ? type.description : String(type);
 };
 
 export const printDoctypeTag = (tag) => {
@@ -194,7 +190,14 @@ export const printLiteralTag = (tag) => {
   return printString(tag.value);
 };
 
-export const printReferenceFlags = (flags = referenceFlags) => {
+let defaultFlags = freezeRecord({
+  array: false,
+  expression: false,
+  intrinsic: false,
+  hasGap: false,
+});
+
+export const printReferenceFlags = (flags = defaultFlags) => {
   let array = flags.array ? `[]` : '';
   let plus = flags.expression ? '+' : '';
   let star = flags.intrinsic ? '*' : '';
@@ -249,6 +252,14 @@ export const printSelfClosingNodeTag = (tag, literalValue) => {
   return `<${printNodeFlags(flags)}${typeFrag}${nameFrag}${literalFrag}${attributesFrag} />`;
 };
 
+export const printStreamTag = (tag) => {
+  if (tag?.type !== StreamTag) throw new Error();
+
+  let { processPath, stream } = tag.value;
+
+  return `<${Array.prototype.join.call(processPath, '.')}-${stream}>`;
+};
+
 export const printCloseNodeTag = (tag) => {
   if (tag?.type !== CloseNodeTag) throw new Error();
 
@@ -261,7 +272,7 @@ export const printAttributeDefinition = (tag) => {
   let { path, value } = tag.value;
 
   return `{ ${printIdentifierPath(
-    path.map((name) => freeze({ type: null, name })),
+    Array.prototype.map.call(path, (name) => freeze({ type: null, name })),
   )}: ${printExpression(value)} }`;
 };
 
@@ -275,13 +286,25 @@ const printers = {
   [ReferenceTag]: printReferenceTag,
   [OpenNodeTag]: printOpenNodeTag,
   [CloseNodeTag]: printCloseNodeTag,
+  [StreamTag]: printStreamTag,
   [AttributeDefinition]: printAttributeDefinition,
 };
 
 export const printTag = (tag) => {
+  if (tag == null || isString(tag)) return tag;
   if (!isObject(tag)) throw new Error();
 
-  let printer = printers[tag?.type];
+  let printer = printers[tag.type];
+
+  return printer ? printer(tag) : tag;
+};
 
-  return printer(tag);
+export const printIOTag = (tag) => {
+  if (tag == null || isString(tag)) return tag;
+  if (!isObject(tag)) throw new Error();
+
+  if (tag.type === StreamTag) {
+    return printStreamTag(tag);
+  }
+  return printTag(tag);
 };

package/lib/shorthand.js

@@ -6,9 +6,9 @@ import {
   buildLiteralTag,
   buildOpenFragmentTag,
   buildOpenCoverTag,
+  parseReferenceTag,
 } from './builders.js';
-import { freeze } from './object.js';
-import { buildReferenceTag, treeFromStreamSync } from './tree.js';
+import { treeFromStream } from './tree.js';
 
 export * from './builders.js';
 
@@ -25,34 +25,8 @@ const stripArray = (val) => {
   }
 };
 
-export const parseReference = (str) => {
-  let {
-    1: type,
-    2: namedType,
-    3: name,
-    4: array,
-    5: expressionToken,
-    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 = freeze({
-    array: !!array,
-    expression: !!expressionToken,
-    intrinsic: !!intrinsicToken,
-    hasGap: !!hasGapToken,
-  });
-
-  type = type || namedType || null;
-  name = name || null;
-
-  return buildReferenceTag(type, name, flags);
-};
-
 export const ref = (path) => {
-  return parseReference(isArray(path) ? path[0] : path);
+  return parseReferenceTag(isArray(path) ? path[0] : path);
 };
 
 export const lit = (str) => buildLiteralTag(stripArray(str));
@@ -63,4 +37,4 @@ export const nodeOpen = buildOpenNodeTag;
 export const fragOpen = buildOpenFragmentTag;
 export const coverOpen = buildOpenCoverTag;
 export const nodeClose = buildCloseNodeTag;
-export const tree = (...tags) => treeFromStreamSync(tags);
+export const tree = (...tags) => treeFromStream(tags);

package/lib/spans.js

@@ -1,163 +0,0 @@
-import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
-
-const { isArray } = Array;
-const { freeze } = Object;
-
-export { defaultNodeSize };
-
-const __getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.length - 1) => {
-  if (!sortedArray.length || endIdx < startIdx) return null;
-
-  let idx = startIdx + Math.floor((endIdx - startIdx) / 2 + 0.1);
-  let entry = sortedArray[idx];
-  let { 0: key, 1: value } = entry;
-
-  let direction = compareNames(name, key);
-
-  if (direction === 0) {
-    return value;
-  } else {
-    if (startIdx === endIdx) return null;
-
-    if (direction > 0) {
-      return __getAtName(name, sortedArray, idx + 1, endIdx);
-    } else {
-      return __getAtName(name, sortedArray, startIdx, idx - 1);
-    }
-  }
-};
-
-export const getAtName = (name, sortedArray, startIdx = 0, endIdx = sortedArray.length - 1) => {
-  return __getAtName(name, sortedArray, startIdx, endIdx);
-};
-
-export const compareNames = (a, b) => (a > b ? 1 : b > a ? -1 : 0);
-
-export const sumValues = (values) => {
-  let mapStats = values.reduce(
-    (acc, val) => {
-      const { names } = acc;
-      if (isArray(val)) {
-        let arr = getSums(val).names;
-        let map = names;
-
-        for (const { 0: key, 1: value } of arr) {
-          let count = map.get(key)?.[1] ?? 0;
-
-          map.set(key, freeze([key, count + value]));
-        }
-      } else if (val) {
-        let span = val;
-
-        const { name } = span;
-
-        if (name) {
-          let count = names.get(name)?.[1] ?? 0;
-
-          names.set(name, freeze([name, count + 1]));
-        }
-      }
-      return acc;
-    },
-    {
-      names: new Map(),
-    },
-  );
-
-  let stats = {
-    names: [...mapStats.names.values()].sort((a, b) => compareNames(a[0], b[0])),
-  };
-  freeze(stats);
-  freeze(stats.names);
-  return stats;
-};
-
-const module_ = buildModule(defaultNodeSize, sumValues);
-
-const {
-  from,
-  fromValues,
-  push,
-  pop,
-  addAt,
-  isValidNode,
-  assertValidNode,
-  getSize,
-  getValues,
-  getSums,
-  setValues,
-  traverse,
-  traverseInner,
-  findPath,
-  getAt,
-  replaceAt,
-  removeAt,
-} = module_;
-
-const getSpan = (name, spans) => {
-  let nameCount = 0;
-  let node = spans;
-  let idx = -1;
-  let index = getAtName(name, getSums(spans).names);
-
-  // drill into subtrees, passing over subtrees with too few references of the desired name
-  outer: while (node) {
-    let sums = getSums(node);
-
-    if (!sums) return null;
-
-    let valueNameCount = getAtName(name, sums.names);
-
-    if (nameCount + valueNameCount < index) {
-      return null;
-    }
-
-    for (const value of getValues(node)) {
-      if (!isArray(value)) {
-        idx++;
-        let span = value;
-
-        if (name != null && span.name === name) {
-          nameCount += 1;
-          if (nameCount === index) {
-            return getAt(idx, spans);
-          }
-        }
-      } else {
-        let valueSums = getSums(value);
-        if (nameCount + getAtName(name, valueSums.names) > index) {
-          node = value;
-          continue outer;
-        } else {
-          nameCount += getAtName(name, valueSums.names) ?? 0;
-          idx += getSize(value);
-        }
-      }
-    }
-
-    return null;
-  }
-
-  return null;
-};
-
-export {
-  from,
-  fromValues,
-  push,
-  pop,
-  addAt,
-  isValidNode,
-  assertValidNode,
-  getSize,
-  getValues,
-  getSums,
-  setValues,
-  traverse,
-  traverseInner,
-  findPath,
-  getAt,
-  replaceAt,
-  removeAt,
-  getSpan,
-};