@bablr/agast-helpers 0.3.1 → 0.4.0

package/lib/tree.js

@@ -1,12 +1,25 @@
-import emptyStack from '@iter-tools/imm-stack';
 import { Coroutine } from '@bablr/coroutine';
-import { buildNull, nodeFlags, buildDoctypeTag, buildEmbeddedNode } from './builders.js';
+import emptyStack from '@iter-tools/imm-stack';
+import { nodeFlags, buildDoctypeTag, buildEmbeddedNode } from './builders.js';
 import {
   printPrettyCSTML as printPrettyCSTMLFromStream,
   printCSTML as printCSTMLFromStream,
   getStreamIterator,
   StreamIterable,
 } from './stream.js';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  EmbeddedNode,
+} from './symbols.js';
+import * as btree from './btree.js';
 import * as sym from './symbols.js';
 export * from './builders.js';
 export * from './print.js';
@@ -17,11 +30,6 @@ const isString = (str) => typeof str === 'string';
 
 const { isArray } = Array;
 
-const buildFrame = (node) => {
-  if (!node) throw new Error();
-  return { node, childrenIdx: -1, resolver: new Resolver(node) };
-};
-
 const { hasOwn, freeze } = Object;
 
 export const get = (node, path) => {
@@ -33,7 +41,7 @@ export const get = (node, path) => {
   }
 
   if (index != null) {
-    return properties[name]?.[parseInt(index, 10)];
+    return btree.getAt(parseInt(index, 10), properties[name]);
   } else {
     return properties[name];
   }
@@ -46,18 +54,18 @@ export const add = (node, ref, value) => {
     if (!hasOwn(node.properties, name)) {
       node.properties[name] = [];
     }
-    const array = node.properties[name];
 
-    array.push(value);
+    node.properties[name] = btree.push(node.properties[name], value);
   } else {
     node.properties[name] = value;
   }
 };
 
 function* __treeFromStream(tokens) {
-  let nodes = emptyStack;
-  let rootNode;
+  let path = null;
+  let rootPath = null;
   let held = null;
+  let doctype = null;
   const co = new Coroutine(getStreamIterator(tokens));
 
   for (;;) {
@@ -69,65 +77,47 @@ function* __treeFromStream(tokens) {
 
     if (co.done) break;
 
-    const token = co.value;
+    const tag = co.value;
 
-    if (token.type === 'Effect') {
+    if (tag.type === 'Effect') {
       continue;
     }
 
-    if (token.type === 'DoctypeTag') {
-      const { attributes } = token.value;
-
-      rootNode = freeze({
-        flags: nodeFlags,
-        language: attributes['bablr-language'],
-        type: null,
-        children: [],
-        properties: {},
-        attributes: freeze(attributes),
-      });
-      nodes = nodes.push(rootNode);
+    if (tag.type === DoctypeTag) {
+      doctype = tag;
       continue;
     }
 
-    if (!nodes.size) {
-      throw new Error('imbalanced tag stack');
+    if (held && tag.type !== 'StartNodeTag' && tag.type !== GapTag) {
+      throw new Error('cannot eat this type of tag while holding');
     }
 
-    switch (token.type) {
-      case 'Null': {
-        const node = nodes.value;
-        const ref = arrayLast(node.children);
-
-        if (ref.type !== 'Reference') throw new Error();
-
-        add(node, ref, null);
-
+    switch (tag.type) {
+      case LiteralTag:
+      case ReferenceTag:
+      case CloseNodeTag: {
         break;
       }
 
-      case 'Literal':
-      case 'Reference': {
-        nodes.value.children.push(token);
-        break;
-      }
+      case NullTag:
+      case GapTag: {
+        const parentNode = path.parent.node;
+        const ref = arrayLast(parentNode.children);
+        const isGap = tag.type === GapTag;
 
-      case 'Gap': {
-        if (held) {
-          const node = nodes.value;
-          const ref = arrayLast(node.children);
+        if (ref.type !== ReferenceTag) throw new Error();
 
-          if (ref.type !== 'Reference') throw new Error();
+        const node = (isGap && held) || createNode(nodeFlags, null, sym.null);
 
-          add(node, ref, held);
+        held = isGap ? null : held;
+        path = { parent: path, node, depth: (path.depth || -1) + 1 };
 
-          held = null;
-        }
+        add(parentNode, ref, node);
         break;
       }
 
-      case 'Shift': {
-        const { children, properties } = nodes.value;
+      case ShiftTag: {
+        const { children, properties } = path.node;
 
         const ref = arrayLast(children);
         let node = properties[ref.value.name];
@@ -143,68 +133,67 @@ function* __treeFromStream(tokens) {
         break;
       }
 
-      case 'OpenNodeTag': {
-        const { flags, language, type, attributes } = token.value;
-        const node = nodes.value;
+      case OpenNodeTag: {
+        const { flags, type } = tag.value;
 
-        if (!type) {
-          break;
-        }
+        const language = type ? tag.value.language : doctype.value.attributes['bablr-language'];
+        const attributes = type ? tag.value.attributes : doctype.value.attributes;
 
-        const newNode = freeze({
-          flags,
-          language,
-          type,
-          children: [],
-          properties: {},
-          attributes: freeze(attributes),
-        });
-
-        if (node && !(flags.escape || flags.trivia)) {
-          if (!node.children.length) {
-            throw new Error('Nodes must follow references');
-          }
+        const node = createNode(flags, language, type, [], {}, attributes);
+
+        const parentPath = path;
 
-          const ref = arrayLast(node.children);
+        path = { parent: path, node, depth: (path.depth || -1) + 1 };
 
-          add(node, ref, newNode);
+        if (parentPath) {
+          const { node: parentNode } = path;
+          if (!(flags.escape || flags.trivia)) {
+            if (!parentNode.children.length) {
+              throw new Error('Nodes must follow references');
+            }
+
+            const ref = arrayLast(parentNode.children);
+
+            add(parentNode, ref, node);
+          } else {
+            parentNode.children.push(buildEmbeddedNode(node));
+          }
+        } else {
+          rootPath = path;
         }
 
-        nodes = nodes.push(newNode);
         break;
       }
 
-      case 'CloseNodeTag': {
-        const completedNode = nodes.value;
-        const { flags } = completedNode;
+      default: {
+        throw new Error();
+      }
+    }
 
-        if (flags.escape || flags.trivia) {
-          const parentChildren = nodes.prev.value.children;
+    path.node.children.push(tag);
 
-          parentChildren.push(buildEmbeddedNode(completedNode));
-        }
+    switch (tag.type) {
+      case NullTag:
+      case GapTag:
+      case CloseNodeTag: {
+        const completedNode = path.node;
 
-        freeze(completedNode.properties);
-        freeze(completedNode.children);
+        finalizeNode(completedNode);
 
-        if (!completedNode.type && nodes.size !== 1) {
+        if (!completedNode.type && path.depth !== 1) {
           throw new Error('imbalanced tag stack');
         }
 
-        nodes = nodes.pop();
+        path = path.parent;
         break;
       }
-
-      default: {
-        throw new Error();
-      }
     }
   }
 
-  return rootNode;
+  return rootPath.node;
 }
 
-export const treeFromStream = (terminals) => new StreamIterable(__treeFromStream(terminals));
+export const treeFromStream = (tags) => new StreamIterable(__treeFromStream(tags));
 
 export const treeFromStreamSync = (tokens) => {
   return evaluateReturnSync(treeFromStream(tokens));
@@ -235,67 +224,73 @@ export const evaluateReturnAsync = async (generator) => {
 export const streamFromTree = (rootNode) => __streamFromTree(rootNode);
 
 function* __streamFromTree(rootNode) {
-  if (!rootNode || rootNode.type === 'Gap') {
+  if (!rootNode || rootNode.type === GapTag) {
     return rootNode;
   }
 
   yield buildDoctypeTag(rootNode.attributes);
 
-  let stack = emptyStack.push(buildFrame(rootNode));
+  let stack = emptyStack.push(rootNode);
+  const resolver = new Resolver();
 
   stack: while (stack.size) {
-    const frame = stack.value;
-    const { node, resolver } = frame;
+    const node = stack.value;
     const { children } = node;
 
-    while (++frame.childrenIdx < children.length) {
-      const terminal = children[frame.childrenIdx];
+    while (true) {
+      const tag = btree.getAt(resolver.idx, children);
 
-      switch (terminal.type) {
-        case 'EmbeddedNode': {
-          stack = stack.push(buildFrame(terminal.value));
+      if (isArray(tag)) {
+        throw new Error();
+      }
 
-          break;
+      switch (tag.type) {
+        case EmbeddedNode: {
+          stack = stack.push(tag.value);
+
+          resolver.advance(tag);
+
+          continue stack;
         }
 
-        case 'Reference': {
-          const resolved = resolver.consume(terminal).get(terminal);
+        case ReferenceTag: {
+          const resolvedPath = resolver.resolve(tag);
+          const resolved = get(stack.value, resolvedPath);
+          const { isArray: refIsArray } = tag.value;
 
-          yield terminal;
+          if (!resolved) throw new Error();
 
-          if (terminal.value.isArray && !resolved) {
-            // TODO evaluate if this is still smart
-            yield buildNull();
-          } else {
-            if (!resolved) throw new Error();
+          yield tag;
 
-            stack = stack.push(buildFrame(resolved));
-          }
+          resolver.advance(tag);
 
-          break;
+          if (!refIsArray || !isArray(resolved)) {
+            if (isArray(resolved)) throw new Error();
+            stack = stack.push(resolved);
+          }
+          continue stack;
         }
 
-        case 'Null': {
-          yield terminal;
-
-          break;
+        case GapTag:
+        case NullTag:
+        case CloseNodeTag: {
+          stack = stack.pop();
+          resolver.advance(tag);
+          yield tag;
+          continue stack;
         }
 
         default:
-          yield terminal;
-      }
-
-      if (terminal.type === 'EmbeddedNode' || terminal.type === 'Reference') {
-        continue stack;
+          resolver.advance(tag);
+          yield tag;
+          break;
       }
     }
-
-    stack = stack.pop();
   }
 }
 
 export const getCooked = (cookable) => {
-  if (!cookable || cookable.type === 'Gap') {
+  if (!cookable || cookable.type === GapTag) {
     return '';
   }
 
@@ -303,14 +298,17 @@ export const getCooked = (cookable) => {
 
   let cooked = '';
 
-  for (const terminal of children) {
-    switch (terminal.type) {
-      case 'Reference': {
+  const openTag = getOpenTag(cookable);
+  const closeTag = getCloseTag(cookable);
+
+  for (const tag of btree.traverse(children)) {
+    switch (tag.type) {
+      case ReferenceTag: {
         throw new Error('cookable nodes must not contain other nodes');
       }
 
-      case 'EmbeddedNode': {
-        const { flags, attributes } = terminal.value;
+      case EmbeddedNode: {
+        const { flags, attributes } = tag.value;
 
         if (!(flags.trivia || (flags.escape && attributes.cooked))) {
           throw new Error('cookable nodes must not contain other nodes');
@@ -328,8 +326,16 @@ export const getCooked = (cookable) => {
         break;
       }
 
-      case 'Literal': {
-        cooked += terminal.value;
+      case LiteralTag: {
+        cooked += tag.value;
+        break;
+      }
+
+      case OpenNodeTag: {
+        break;
+      }
+
+      case CloseNodeTag: {
         break;
       }
 
@@ -350,26 +356,35 @@ export const printPrettyCSTML = (rootNode, options = {}) => {
   return printPrettyCSTMLFromStream(streamFromTree(rootNode), options);
 };
 
-export const printSource = (node) => {
-  const resolver = new Resolver(node);
+const __printSource = (rootNode, resolver = new Resolver()) => {
   let printed = '';
 
-  if (!node) return '';
+  if (!rootNode) return '';
+
+  let node = rootNode;
 
   if (node instanceof Promise) {
     printed += '$Promise';
   } else {
-    for (const child of node.children) {
-      if (child.type === 'Literal') {
+    for (const child of btree.traverse(node.children)) {
+      if (child.type === LiteralTag) {
         printed += child.value;
-      } else if (child.type === 'EmbeddedNode') {
-        printed += printSource(child.value);
-      } else if (child.type === 'Reference') {
-        const node_ = resolver.consume(child).get(child);
-
-        if (node_) {
-          printed += printSource(node_);
+        resolver.advance(child);
+      } else if (child.type === EmbeddedNode) {
+        resolver.advance(child);
+        printed += __printSource(child.value, resolver);
+      } else if (child.type === ReferenceTag) {
+        const resolvedPath = resolver.resolve(child);
+        const resolvedNode = get(node, resolvedPath);
+
+        resolver.advance(child);
+        if (resolvedNode) {
+          if (!isArray(resolvedNode)) {
+            printed += __printSource(resolvedNode, resolver);
+          }
         }
+      } else {
+        resolver.advance(child);
       }
     }
   }
@@ -377,24 +392,26 @@ export const printSource = (node) => {
   return printed;
 };
 
+export const printSource = (rootNode) => __printSource(rootNode);
+
 export const sourceTextFor = printSource;
 
 export const getOpenTag = (node) => {
-  const tag = node.children[0];
-  if (tag && tag.type !== 'OpenNodeTag') throw new Error();
+  const tag = btree.getAt(0, node.children);
+  if (tag && tag.type !== OpenNodeTag) throw new Error();
   return tag;
 };
 
 export const getCloseTag = (node) => {
   const { children } = node;
-  const tag = children[children.length - 1];
-  if (tag.type !== 'CloseNodeTag') return null;
+  const tag = btree.getAt(-1, children);
+  if (tag.type !== CloseNodeTag) return null;
   return tag;
 };
 
 export const getRange = (node) => {
   const { children } = node;
-  return children.length ? [children[0], children[children.length - 1]] : null;
+  return children.length ? [children[1], children[children.length - 1]] : null;
 };
 
 export const createNode = (openTag) => {
@@ -403,8 +420,14 @@ export const createNode = (openTag) => {
 };
 
 export const finalizeNode = (node) => {
+  for (const propertyValue of Object.values(node.properties)) {
+    if (isArray(propertyValue)) {
+      btree.freeze(propertyValue);
+    }
+  }
+
   freeze(node);
-  freeze(node.children);
+  btree.freeze(node.children);
   freeze(node.properties);
   freeze(node.attributes);
   return node;
@@ -453,33 +476,145 @@ export const acceptNode = (node, accepted) => {
 export const getRoot = (fragmentNode) => {
   if (!fragmentNode) return null;
 
-  for (const terminal of fragmentNode.children) {
-    if (terminal.type === 'Reference') {
-      if (terminal.value.isArray) throw new Error();
-      return fragmentNode.properties[terminal.value.name];
+  for (const tag of btree.traverse(fragmentNode.children)) {
+    if (tag.type === ReferenceTag) {
+      return fragmentNode.properties[tag.value.name];
     }
   }
 };
 
 export class Resolver {
-  constructor(node, counters = new Map()) {
-    this.node = node;
-    this.counters = counters;
+  constructor(
+    states = emptyStack.push({ properties: new Map(), idx: 0 }),
+    reference = null,
+    popped = false,
+    held = null,
+  ) {
+    this.states = states;
+    this.reference = reference;
+    this.popped = popped;
+    this.held = held;
   }
 
-  consume(reference) {
-    const { name, isArray } = reference.value;
-    const { counters } = this;
+  get idx() {
+    return this.states.value.idx;
+  }
 
-    if (isArray) {
-      const count = counters.get(name) + 1 || 0;
+  get properties() {
+    return this.states.value.properties;
+  }
+
+  advance(tag) {
+    const { states } = this;
+
+    ++states.value.idx;
+
+    this.popped = false;
+
+    switch (tag.type) {
+      case ReferenceTag: {
+        const { name, isArray } = tag.value;
+        const { properties } = states.value;
+
+        if (this.reference) throw new Error();
+
+        this.reference = tag;
+
+        let state = properties.get(name);
+
+        if (isArray) {
+          if (state && !state.isArray) throw new Error();
+
+          const { count = -1 } = state || {};
+
+          state = { count: count + 1, isArray };
+        } else if (state) {
+          throw new Error(`attempted to consume property {name: ${name}} twice`);
+        } else {
+          state = { count: 1, isArray: false };
+        }
+
+        properties.set(name, state);
+
+        if (!isArray || state.count > 0) {
+          this.states = states.push({ properties: new Map(), idx: 0 });
+        }
+
+        break;
+      }
+
+      case EmbeddedNode: {
+        if (this.reference) throw new Error();
+
+        this.reference = tag;
+
+        this.states = states.push({ properties: new Map(), idx: 0 });
+        break;
+      }
+
+      case OpenNodeTag: {
+        const { flags } = tag.value;
+        const isRootNode = states.size === 1;
+
+        if (!isRootNode && !this.reference && !(flags.trivia || flags.escape)) {
+          throw new Error();
+        }
+
+        if (this.reference?.type !== EmbeddedNode && (flags.trivia || flags.escape)) {
+          this.states = states.push({ properties: new Map(), idx: 0 });
+        }
+
+        this.reference = null;
+        break;
+      }
 
-      counters.set(name, count);
-    } else {
-      if (counters.has(name))
-        throw new Error(`attempted to consume property {name: ${name}} twice`);
+      case ArrayTag: {
+        if (!this.reference) throw new Error();
 
-      counters.set(name, 1);
+        const { name } = this.reference.value;
+        const { properties } = states.value;
+        const state = properties.get(name);
+
+        if (!state || !state.isArray || state.count !== 0) throw new Error();
+
+        properties.set(name, { count: 0, isArray: true });
+
+        this.reference = null;
+        break;
+      }
+
+      case ShiftTag: {
+        this.held = this.states.value;
+        this.states = this.states.push({ properties: new Map(), idx: 0 });
+        this.reference = tag;
+
+        break;
+      }
+
+      case NullTag: {
+        this.states = states.pop();
+        this.popped = true;
+        this.reference = null;
+        break;
+      }
+
+      case GapTag: {
+        this.states = states.pop();
+
+        if (this.held) {
+          // this.states = this.states.push(this.held);
+          this.held = null;
+        }
+
+        this.popped = true;
+        this.reference = null;
+        break;
+      }
+
+      case CloseNodeTag: {
+        this.states = states.pop();
+        this.popped = true;
+      }
     }
 
     return this;
@@ -487,30 +622,37 @@ export class Resolver {
 
   resolve(reference) {
     let { name, isArray } = reference.value;
-    const { counters } = this;
+    const { states } = this;
+    const state = states.value.properties.get(name);
     let path = name;
 
     if (isArray) {
-      const count = counters.get(name) || 0;
-
-      path += '.' + count;
+      if (state) {
+        const count = state?.count || 0;
+        path += '.' + count;
+      }
     }
 
     return path;
   }
 
-  get(reference) {
-    if (!this.node) throw new Error('Cannot get from a resolver with no node');
-
-    return get(this.node, this.resolve(reference));
-  }
-
   branch() {
-    return new Resolver(this.node, new Map(this.counters));
+    const { states, reference, popped, held } = this;
+    const { properties, idx } = states.value;
+
+    return new Resolver(
+      states.replace({ properties: new Map(properties), idx }),
+      reference,
+      popped,
+      held,
+    );
   }
 
   accept(resolver) {
-    this.counters = resolver.counters;
+    this.states = resolver.states;
+    this.reference = resolver.reference;
+    this.popped = resolver.popped;
+    this.held = resolver.held;
 
     return this;
   }