@bablr/agast-helpers 0.6.1 → 0.7.0

package/lib/tree.js

@@ -1,5 +1,4 @@
 import { Coroutine } from '@bablr/coroutine';
-import emptyStack from '@iter-tools/imm-stack';
 import {
   nodeFlags,
   buildReferenceTag,
@@ -20,14 +19,14 @@ import {
   OpenNodeTag,
   CloseNodeTag,
   ReferenceTag,
-  ShiftTag,
   GapTag,
   NullTag,
-  ArrayInitializerTag,
+  InitializerTag,
   LiteralTag,
   EmbeddedNode,
 } from './symbols.js';
 import * as btree from './btree.js';
+import * as sumtree from './sumtree.js';
 export * from './builders.js';
 export * from './print.js';
 import {
@@ -40,6 +39,7 @@ import {
   isGapNode,
   getOpenTag,
   getCloseTag,
+  getShifted,
 } from './path.js';
 
 export { add, get, isFragmentNode, isNullNode, isGapNode, getOpenTag, getCloseTag };
@@ -92,8 +92,9 @@ export const mergeReferences = (outer, inner) => {
     inner.value.name != null &&
     inner.value.name !== '.' &&
     name !== inner.value.name
-  )
-    throw new Error();
+  ) {
+    return inner;
+  }
 
   isArray = isArray || inner.value.isArray;
   expression = !!(expression || inner.value.flags.expression);
@@ -108,6 +109,20 @@ export const isEmptyReference = (ref) => {
   return name === '.' && !isArray && !(flags.expression || flags.hasGap);
 };
 
+export const defineAttribute = (node, key, value) => {
+  const openTag = getOpenTag(node);
+
+  if (value != null) {
+    const { flags, language, type } = openTag.value;
+    const attributes = { ...openTag.value.attributes, [key]: value };
+    const newOpenTag = buildOpenNodeTag(flags, language, type, attributes);
+
+    node.attributes = attributes;
+
+    node.children = sumtree.replaceAt(0, node.children, newOpenTag);
+  }
+};
+
 function* __treeFromStream(tags, options) {
   let path = null;
   let rootPath = null;
@@ -155,7 +170,7 @@ function* __treeFromStream(tags, options) {
         break;
       }
 
-      case ArrayInitializerTag: {
+      case InitializerTag: {
         add(path.node, reference, []);
         suppressTag = true;
         reference = null;
@@ -198,7 +213,7 @@ function* __treeFromStream(tags, options) {
 
                 let reference;
 
-                for (const tag of btree.traverse(node.children)) {
+                for (const tag of sumtree.traverse(node.children)) {
                   switch (tag.type) {
                     case DoctypeTag: {
                       break;
@@ -218,7 +233,7 @@ function* __treeFromStream(tags, options) {
                       reference = tag;
                       break;
 
-                    case ArrayInitializerTag: {
+                    case InitializerTag: {
                       add(parentNode, mergeReferences(outerReference, reference), []);
                       break;
                     }
@@ -229,7 +244,7 @@ function* __treeFromStream(tags, options) {
                     }
 
                     case GapTag: {
-                      const resolvedNode = get(reference, node);
+                      const resolvedNode = getShifted(shift, reference, node);
                       add(parentNode, mergeReferences(outerReference, reference), resolvedNode);
                       break;
                     }
@@ -324,7 +339,7 @@ function* __treeFromStream(tags, options) {
     }
 
     if (!suppressTag) {
-      path.node.children = btree.push(path.node.children, tag);
+      path.node.children = sumtree.push(path.node.children, tag);
     }
 
     switch (tag.type) {
@@ -395,7 +410,7 @@ export const isEmpty = (node) => {
 
   let ref = null;
 
-  for (const tag of btree.traverse(node.children)) {
+  for (const tag of sumtree.traverse(node.children)) {
     switch (tag.type) {
       case ReferenceTag: {
         const { name } = tag.value;
@@ -444,9 +459,9 @@ export const buildStubNode = (tag) => {
 
 function* __streamFromTree(rootNode, options) {
   const { unshift = false } = options;
-  if (!rootNode || !btree.getSum(rootNode.children)) return;
+  if (!rootNode || !sumtree.getSize(rootNode.children)) return;
 
-  let tagPath = TagPath.from(Path.from(rootNode), 0);
+  let tagPath = TagPath.fromNode(rootNode, 0);
 
   let count = 0;
 
@@ -474,7 +489,7 @@ export const getCooked = (cookable) => {
 
   let reference = null;
 
-  for (const tag of btree.traverse(children)) {
+  for (const tag of sumtree.traverse(children)) {
     switch (tag.type) {
       case ReferenceTag: {
         const { name } = tag.value;
@@ -540,7 +555,8 @@ export const sourceTextFor = printSource;
 
 export const getRange = (node) => {
   const { children } = node;
-  return btree.getSum(children) ? [btree.getAt(0, children), btree.getAt(-1, children)] : null;
+  let path = Path.from(node);
+  return sumtree.getSize(children) ? [TagPath.from(path, 0), TagPath.from(path, -1)] : null;
 };
 
 export const createNode = (openTag) => {
@@ -560,26 +576,7 @@ export const createNode = (openTag) => {
 };
 
 export const finalizeNode = (node) => {
-  for (const property of Object.values(node.properties)) {
-    if (isArray(property)) {
-      btree.freeze(property);
-      for (const childProperty of btree.traverse(property)) {
-        freeze(childProperty);
-        if (childProperty.reference.value.flags.expression) {
-          btree.freeze(childProperty.node);
-        }
-      }
-    } else {
-      freeze(property);
-
-      if (property.reference.value.flags.expression) {
-        btree.freeze(property.node);
-      }
-    }
-  }
-
   freeze(node);
-  btree.freeze(node.children);
   freeze(node.properties);
   freeze(node.attributes);
   return node;
@@ -598,7 +595,7 @@ export const branchProperties = (properties) => {
 
   for (const { 0: key, 1: value } of Object.entries(copy)) {
     if (isArray(value)) {
-      copy[key] = btree.fromValues(value);
+      copy[key] = btree.treeFromValues(value);
     }
   }
 
@@ -611,8 +608,7 @@ export const branchNode = (node) => {
     flags,
     language,
     type,
-    // if we always use immutable trees we won't need to do this
-    children: btree.fromValues(btree.traverse(children)),
+    children,
     properties: branchProperties(properties),
     attributes: { ...attributes },
   };
@@ -645,208 +641,3 @@ export function* traverseProperties(properties) {
     }
   }
 }
-
-export class Resolver {
-  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;
-    this.doctype = null;
-  }
-
-  get idx() {
-    return this.states.value.idx;
-  }
-
-  get properties() {
-    return this.states.value.properties;
-  }
-
-  advance(tag) {
-    const { states } = this;
-
-    ++states.value.idx;
-
-    this.popped = false;
-
-    let hadReference = this.reference;
-
-    switch (tag.type) {
-      case ReferenceTag: {
-        const { name, isArray } = tag.value;
-        const { properties } = states.value;
-
-        if (this.reference) throw new Error();
-
-        this.reference = tag;
-
-        if (name && name !== '#' && name !== '@') {
-          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);
-        }
-
-        break;
-      }
-
-      case EmbeddedNode: {
-        if (!this.reference || !['#', '@'].includes(this.reference.value.name)) throw new Error();
-
-        // this.states = states.push({ properties: new Map(), idx: 0 });
-        break;
-      }
-
-      case OpenNodeTag: {
-        const { reference } = this;
-        const { flags } = tag.value;
-        const isRootNode = states.size === 1;
-
-        if (tag.value.type) {
-          this.states = states.push({ properties: new Map(), idx: 0 });
-        }
-
-        if (!tag.value.type && (!isRootNode || this.reference)) throw new Error();
-
-        if (
-          tag.type === OpenNodeTag &&
-          ((!reference && !isRootNode) ||
-            (reference &&
-              reference.type !== ReferenceTag &&
-              reference.type !== ShiftTag &&
-              reference.type !== OpenNodeTag))
-        ) {
-          throw new Error('Invalid location for OpenNodeTag');
-        }
-
-        if (!isRootNode && !reference) {
-          throw new Error();
-        }
-
-        this.reference = null;
-        break;
-      }
-
-      case ArrayInitializerTag: {
-        if (!this.reference) throw new Error();
-
-        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: {
-        if (!this.reference) throw new Error();
-
-        this.popped = true;
-        this.reference = null;
-        break;
-      }
-
-      case GapTag: {
-        // if (!this.reference) throw new Error();
-
-        if (this.held) {
-          // this.states = this.states.push(this.held);
-          this.held = null;
-        }
-
-        this.popped = true;
-        this.reference = null;
-        break;
-      }
-
-      case CloseNodeTag: {
-        if (this.reference) throw new Error();
-
-        this.states = states.pop();
-        this.popped = true;
-        break;
-      }
-
-      case DoctypeTag:
-        this.doctype = tag;
-        break;
-
-      case LiteralTag:
-        break;
-
-      default:
-        throw new Error();
-    }
-
-    if (hadReference && this.reference) throw new Error();
-
-    return this;
-  }
-
-  resolve(reference) {
-    let { name, isArray, flags } = reference.value;
-    const { states } = this;
-    const state = states.value.properties.get(name);
-    let index = null;
-
-    if (name === '@' || name === '#') return reference;
-
-    if (isArray && state) {
-      index = state?.count || 0;
-    }
-
-    return buildReferenceTag(name, isArray, flags, index);
-  }
-
-  branch() {
-    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.states = resolver.states;
-    this.reference = resolver.reference;
-    this.popped = resolver.popped;
-    this.held = resolver.held;
-
-    return this;
-  }
-}
-
-freeze(Resolver.prototype);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-helpers",
   "description": "Helper functions for working with agAST trees",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -14,6 +14,7 @@
     "./print": "./lib/print.js",
     "./shorthand": "./lib/shorthand.js",
     "./stream": "./lib/stream.js",
+    "./sumtree": "./lib/sumtree.js",
     "./symbols": "./lib/symbols.js",
     "./template": "./lib/template.js",
     "./tree": "./lib/tree.js"