@bablr/agast-helpers 0.8.0 → 0.9.0

package/lib/print.js

@@ -10,18 +10,15 @@ import {
   LiteralTag,
   AttributeDefinition,
   BindingTag,
+  Document,
 } from './symbols.js';
-import { 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(', ')}]`;
 
@@ -122,23 +119,29 @@ export const printShiftTag = (tag) => {
   return `^^^`;
 };
 
-export const printReferenceTag = (tag) => {
-  if (tag?.type !== ReferenceTag) throw new Error();
-
-  let { type, name, isArray, flags } = tag.value;
+export const printReference = (ref) => {
+  let { type, name, isArray, flags } = ref;
   let pathBraces = isArray ? `[]` : '';
 
-  if (type && name) throw new Error();
-  if (type && !['.', '#', '@'].includes(type)) throw new Error();
+  if (type && type !== '#' && name) throw new Error();
+  if (type && !['.', '#', '@', '_'].includes(type)) throw new Error();
 
-  return `${type || printIdentifier(name) || ''}${pathBraces}${printReferenceFlags(flags)}:`;
+  return `${type || ''}${printIdentifier(name) || ''}${pathBraces}${printReferenceFlags(flags)}:`;
 };
 
-export const printBindingTag = (tag) => {
-  let { languagePath } = tag.value;
+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) => {
   if (tag && tag.type !== NullTag) {
     throw new Error();
@@ -181,35 +184,45 @@ 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, 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)}${printType(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, 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)}${printType(type)}${intrinsicFrag}${attributesFrag} />`;
 };
@@ -222,6 +235,7 @@ export const printCloseNodeTag = (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;
 
   return `{ ${printIdentifierPath(path)}: ${printExpression(value)} }`;

package/lib/shorthand.js

@@ -31,7 +31,7 @@ export const parseReference = (str) => {
     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(
+  } = /^\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,
   );
 

package/lib/stream.js

@@ -1,153 +1,25 @@
 import { Coroutine } from '@bablr/coroutine';
 import emptyStack from '@iter-tools/imm-stack';
-import { printSelfClosingNodeTag, printTag } from './print.js';
-import { buildOpenNodeTag, 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.iterator]() {
-    return this;
-  }
-
-  [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) {
@@ -181,6 +53,8 @@ function* __isEmpty(tags) {
       case OpenNodeTag:
         ++depth;
 
+        if (tag.value.literalValue) return false;
+
         if (depth === 0 && ref.value.type === '@') {
           return false;
         }
@@ -224,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;
@@ -277,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;
   }
@@ -353,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;
@@ -367,9 +242,13 @@ function* __prettyGroupTags(tags) {
     }
 
     if (tag.type === OpenNodeTag) {
-      states = states.push({ holding: [tag], 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;
+      }
     }
   }
 }
@@ -415,7 +294,7 @@ function* __generatePrettyCSTML(tags, options) {
         tag.type === GapTag ||
         tag.type === BindingTag ||
         tag.type === InitializerTag ||
-        tag.type === TokenGroup);
+        (tag.type === OpenNodeTag && tag.value.selfClosing));
 
     if (!first && !inline) {
       yield* '\n';
@@ -428,23 +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;
-      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);
-    }
+    yield* printTag(tag);
 
     if (tag.type === ReferenceTag) {
       inline = true;
@@ -452,7 +320,7 @@ function* __generatePrettyCSTML(tags, options) {
     }
 
     if (tag.type === OpenNodeTag) {
-      indentLevel++;
+      indentLevel += tag.value.selfClosing ? 0 : 1;
     }
 
     first = false;
@@ -494,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) {
@@ -516,6 +384,8 @@ export const getCooked = (tags) => {
           if (!cookedValue) throw new Error('cannot cook string: it contains uncooked escapes');
 
           cooked += cookedValue;
+        } else if (literalValue) {
+          cooked += literalValue;
         }
 
         break;
@@ -553,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

@@ -10,6 +10,8 @@ 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 Property = Symbol.for('Property');
+export const PropertyWrapper = Symbol.for('PropertyWrapper');

package/lib/tags.js

@@ -0,0 +1,236 @@
+import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
+import { CloseNodeTag, LiteralTag, OpenNodeTag, PropertyWrapper, ReferenceTag } from './symbols.js';
+import { isObject } from './object.js';
+
+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);
+
+const module_ = buildModule(
+  defaultNodeSize,
+  (acc, val) => {
+    const { references, specialTypes } = acc;
+    if (isArray(val)) {
+      acc.lineBreaks += getSums(val).lineBreaks;
+
+      for (const { 0: key, 1: value } of getSums(val).references) {
+        references.set(key, (references.get(key) ?? 0) + value);
+      }
+
+      for (const { 0: key, 1: value } of getSums(val).specialTypes) {
+        specialTypes.set(key, (specialTypes.get(key) ?? 0) + value);
+      }
+    } else if (val) {
+      if (val.type === LiteralTag) {
+        let text = val.value;
+        let idx = 0;
+        while ((idx = text.indexOf('\n', idx + 1)) >= 0) {
+          acc.lineBreaks++;
+        }
+      } else if (val.type === PropertyWrapper) {
+        let { tags } = val.value;
+        let refOrShiftTag = tags[0];
+
+        if (refOrShiftTag.type === ReferenceTag) {
+          const { type, name } = refOrShiftTag.value;
+          if (name) {
+            references.set(name, (references.get(name) ?? 0) + 1);
+          } else {
+            specialTypes.set(type, (specialTypes.get(type) ?? 0) + 1);
+          }
+        }
+      }
+    }
+    return acc;
+  },
+  () => ({
+    lineBreaks: 0,
+    references: new Map(),
+    specialTypes: new Map(),
+  }),
+  (mapStats) => {
+    let { lineBreaks } = mapStats;
+    let stats = {
+      lineBreaks,
+      references: [...mapStats.references].sort((a, b) => compareNames(a[0], b[0])),
+      specialTypes: [...mapStats.specialTypes].sort((a, b) => compareNames(a[0], b[0])),
+    };
+    freeze(stats);
+    freeze(stats.references);
+    freeze(stats.specialTypes);
+    return stats;
+  },
+);
+
+const {
+  from,
+  fromValues,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getValues,
+  getSums,
+  setValues,
+  traverse,
+  getSize,
+  findPath,
+} = module_;
+
+const getAt = (idx, tags, wrapperIndex) => {
+  let result = module_.getAt(idx, tags);
+  return wrapperIndex == null || result?.type !== PropertyWrapper
+    ? result
+    : result.value.tags[wrapperIndex];
+};
+
+const push = (tags, tag) => {
+  let firstTag = getAt(0, tags);
+  if (isArray(tag)) {
+    if (!firstTag || firstTag.type !== OpenNodeTag) {
+      return module_.concat(tags, tag);
+    }
+    let children = getValues(tags)[1] ?? module_.fromValues([]);
+
+    let { 0: open } = getValues(tags);
+
+    children = module_.concat(children, tag);
+
+    return module_.fromValues([open, children]);
+  } else {
+    if (tag.type === OpenNodeTag) {
+      if (getSize(tags) !== 0) throw new Error();
+      return module_.push(tags, tag);
+    } else {
+      if (!firstTag || firstTag.type !== OpenNodeTag) {
+        return module_.push(tags, tag);
+      }
+
+      let children = getValues(tags)[1] ?? [];
+
+      // sometimes this is the top level
+      if (firstTag) {
+        if (tag.type === CloseNodeTag) {
+          let { 0: open, 1: children = module_.fromValues([]) } = getValues(tags);
+
+          return module_.fromValues([open, children, tag]);
+        } else {
+          let { 0: open } = getValues(tags);
+
+          children = module_.push(children, tag);
+
+          return module_.fromValues([open, children]);
+        }
+      } else {
+        return module_.push(tags, tag);
+      }
+    }
+  }
+};
+
+const replaceAt = (idx, tree, value) => {
+  let idx_ = idx < 0 ? getSize(tree) + idx : idx;
+
+  if (value.type !== getAt(idx_, tree).type) throw new Error();
+  let firstTag = getAt(0, tree);
+
+  if (firstTag && firstTag.type === OpenNodeTag) {
+    let newTags = [...getValues(tree)];
+    if (idx_ === 0) {
+      newTags[0] = value;
+    } else if (isObject(value) && value.type === CloseNodeTag) {
+      if (idx_ !== getSize(tree) - 1) throw new Error();
+      newTags[2] = value;
+    } else {
+      let children = getValues(tree)[1];
+
+      children = module_.replaceAt(idx_ - 1, children, value);
+
+      newTags[1] = children;
+    }
+    return module_.fromValues(newTags);
+  } else {
+    return module_.replaceAt(idx_, tree, value);
+  }
+};
+
+const removeAt = (idx, tree) => {
+  let idx_ = idx < 0 ? getSize(tree) + idx : idx;
+
+  let firstTag = getAt(0, tree);
+
+  if (firstTag && firstTag.type === OpenNodeTag) {
+    let newTags = [...getValues(tree)];
+    if (idx_ === 0) {
+      newTags.splice(0, 1);
+    } else if (idx_ === getSize(tree - 1)) {
+      newTags.splice(2, 1);
+    } else {
+      let children = getValues(tree)[1];
+
+      children = module_.removeAt(idx_ - 1, children);
+
+      newTags[1] = children;
+    }
+    return module_.fromValues(newTags);
+  } else {
+    return module_.removeAt(idx_, tree);
+  }
+};
+
+function* traverseInner(tree) {
+  for (let tag of module_.traverse(tree)) {
+    if (tag.type === PropertyWrapper) {
+      yield* tag.value.tags;
+    } else {
+      yield tag;
+    }
+  }
+}
+
+export {
+  from,
+  fromValues,
+  push,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getSize,
+  getValues,
+  getSums,
+  setValues,
+  traverse,
+  traverseInner,
+  findPath,
+  getAt,
+  replaceAt,
+  removeAt,
+};