@bablr/agast-helpers 0.8.0 → 0.9.0

package/lib/tree.js

@@ -13,6 +13,10 @@ import {
   buildChild,
   buildShiftTag,
   buildGapTag,
+  buildBinding,
+  buildReference,
+  multiFragmentFlags,
+  buildPropertyWrapper,
 } from './builders.js';
 import {
   printPrettyCSTML as printPrettyCSTMLFromStream,
@@ -33,13 +37,17 @@ import {
   BindingTag,
   Property,
   ShiftTag,
+  PropertyWrapper,
 } from './symbols.js';
-import * as btree from './btree.js';
-import * as Children from './children.js';
+import * as BTree from './btree.js';
+import * as Tags from './tags.js';
 export * from './builders.js';
 export * from './print.js';
 import {
   get,
+  getOr,
+  has,
+  list,
   TagPath,
   Path,
   isFragmentNode,
@@ -49,12 +57,16 @@ import {
   getCloseTag,
   getRoot,
   getRootArray,
-  getFirstNodeShiftStack,
+  isStubTag,
+  wrapperIsFull,
 } from './path.js';
 import { isPlainObject } from './object.js';
 
 export {
   get,
+  getOr,
+  has,
+  list,
   isFragmentNode,
   isNullNode,
   isGapNode,
@@ -82,7 +94,7 @@ export const mergeReferences = (outer, inner) => {
 
   if (
     (name != null && inner.name != null && name !== inner.name) ||
-    (type != null && inner.type != null && type !== inner.type)
+    (type != null && inner.type != null && type !== inner.type && inner.type !== '.')
   ) {
     return inner;
   }
@@ -145,7 +157,11 @@ function* __treeFromStream(tags, options) {
 
     switch (tag.type) {
       case LiteralTag:
+        break;
+
       case CloseNodeTag: {
+        let { node } = path;
+        if (!node.tags[1]) throw new Error();
         break;
       }
 
@@ -180,11 +196,12 @@ function* __treeFromStream(tags, options) {
 
         let node = createNode(tag);
 
+        suppressTag = true;
+
         if (isGap) {
           if (held) {
             node = held;
             add(path.node, referenceTag, node, bindingTag);
-            suppressTag = true;
           } else if (!expressionsCo.done) {
             expressionsCo.advance();
 
@@ -197,7 +214,6 @@ function* __treeFromStream(tags, options) {
                   : expressionsCo.value == null
                   ? buildStubNode(buildNullTag())
                   : expressionsCo.value;
-              suppressTag = true;
 
               if (isFragmentNode(node)) {
                 const parentNode = path.node;
@@ -205,7 +221,7 @@ function* __treeFromStream(tags, options) {
                 let referenceTag;
                 let bindingTag;
 
-                for (const tag of Children.traverse(node.children)) {
+                for (const tag of Tags.traverse(node.tags)) {
                   switch (tag.type) {
                     case DoctypeTag: {
                       break;
@@ -275,7 +291,7 @@ function* __treeFromStream(tags, options) {
       }
 
       // case ShiftTag: {
-      //   const { children, properties } = path.node;
+      //   const { tags, properties } = path.node;
 
       //   let property = properties[ref.value.name];
       //   let node;
@@ -293,9 +309,8 @@ function* __treeFromStream(tags, options) {
       // }
 
       case OpenNodeTag: {
+        const node = createNode(tag);
         if (path) {
-          const node = createNode(tag);
-
           if (path) {
             add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
             referenceTag = null;
@@ -303,23 +318,12 @@ function* __treeFromStream(tags, options) {
 
           path = { parent: path, node, depth: (path ? path.depth : -1) + 1, arrays: new Set() };
         } else {
-          const { type, flags, attributes } = tag.value;
-
-          const attributes_ = doctype?.value.attributes ?? attributes;
-
-          const node = {
-            flags,
-            type,
-            children: [],
-            properties: {},
-            attributes: attributes_,
-          };
-
           path = { parent: null, node, depth: 0, arrays: new Set() };
 
           rootPath = path;
         }
 
+        suppressTag = true;
         break;
       }
 
@@ -329,7 +333,7 @@ function* __treeFromStream(tags, options) {
     }
 
     if (!suppressTag) {
-      path.node.children = Children.push(path.node.children, tag);
+      path.node.tags = Tags.push(path.node.tags, tag);
     }
 
     switch (tag.type) {
@@ -394,34 +398,17 @@ export const evaluateReturnAsync = async (generator) => {
 };
 
 export const isEmpty = (node) => {
-  const { properties } = node;
-
-  let ref = null;
-
-  for (const tag of Children.traverse(node.children)) {
+  for (const tag of Tags.traverseInner(node.tags)) {
     switch (tag.type) {
-      case ReferenceTag: {
-        const { name } = tag.value;
-
-        ref = tag;
-
-        if (properties[name]) {
-          const property = properties[name];
-
-          if (
-            property != null ||
-            (isArray(property) && property.length) ||
-            !isNullNode(property.node)
-          ) {
-            return false;
-          }
-        }
-        break;
-      }
-
       case Property: {
         if (tag.value.reference.type === '@') {
           return false;
+        } else {
+          const property = tag.value;
+
+          if (!isNullNode(property.node)) {
+            return false;
+          }
         }
         break;
       }
@@ -434,32 +421,47 @@ export const isEmpty = (node) => {
   return true;
 };
 
+let buildGapProperty = () =>
+  buildProperty(buildReference('.'), buildBinding(), buildStubNode(buildGapTag()));
+
+export const buildBounds = (
+  openBoundary = BTree.fromValues([buildGapProperty()]),
+  closeBoundary = openBoundary,
+) => {
+  return freeze([openBoundary, closeBoundary]);
+};
+
 export const buildStubNode = (tag) => {
+  if (!isStubTag(tag)) throw new Error();
   return freeze({
     flags: nodeFlags,
     type: null,
-    children: freeze([tag]),
-    properties: freeze({}),
+    bounds: buildBounds(null, null),
+    tags: Tags.from(tag),
     attributes: freeze({}),
   });
 };
 
-export const streamFromTree = (rootNode, options = {}) => {
-  let rootNode_ = isPlainObject(rootNode) ? rootNode : rootNode.node;
+export const streamFromTree = (tree, options = {}) => {
+  let rootNode = isPlainObject(tree) ? tree : tree.node;
 
-  return __streamFromTree(rootNode_, options);
+  return __streamFromTree(null, rootNode, options);
 };
 
-function* __streamFromTree(rootNode, options) {
+function* __streamFromTree(doctypeTag, rootNode, options) {
   const { unshift = false } = options;
-  if (!rootNode || !Children.getSize(rootNode.children)) return;
+  if (!rootNode || !Tags.getSize(rootNode.tags)) return;
 
   let tagPath = TagPath.fromNode(rootNode, 0);
 
   let count = 0;
 
+  if (doctypeTag) {
+    yield doctypeTag;
+  }
+
   do {
-    if (tagPath.tag.type === OpenNodeTag) count++;
+    if (tagPath.tag.type === OpenNodeTag && !tagPath.tag.value.literalValue) count++;
     if (tagPath.tag.type === CloseNodeTag) count--;
 
     if (
@@ -475,12 +477,107 @@ function* __streamFromTree(rootNode, options) {
   if (count !== 0) throw new Error();
 }
 
+export const vcsStreamFromTree = (rootNode) => {
+  let rootNode_ = isPlainObject(rootNode) ? rootNode : rootNode.node;
+
+  return __vcsStreamFromTree(rootNode_);
+};
+
+function* __vcsStreamFromTree(rootNode) {
+  let stack = null;
+  let agastNode = rootNode;
+  let depth = 0;
+  let nodeShifted = false;
+  let i = 0;
+  let seenFirstProperty = false;
+  let node = Tags.getValues(rootNode.tags);
+
+  outer: while (node) {
+    while (i >= node.length) {
+      if (stack) {
+        let oldAgastNode = agastNode;
+        let hadSeenFirst = seenFirstProperty;
+        ({ stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty } = stack);
+        if (oldAgastNode === agastNode) {
+          seenFirstProperty = hadSeenFirst;
+          yield buildCloseNodeTag();
+        }
+
+        i++;
+      } else {
+        return;
+      }
+    }
+
+    let child = node[i];
+
+    if (isArray(child)) {
+      stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty };
+
+      yield buildOpenNodeTag(multiFragmentFlags);
+
+      node = Tags.getValues(child);
+      depth++;
+      i = 0;
+    } else {
+      let wrappedTag = child;
+
+      if (wrappedTag.type === PropertyWrapper) {
+        for (let tag of wrappedTag.value.tags) {
+          switch (tag.type) {
+            case Property: {
+              let replaceWithGap = nodeShifted && !seenFirstProperty;
+
+              if (replaceWithGap) {
+                yield buildGapTag();
+
+                seenFirstProperty = true;
+
+                break;
+              } else {
+                stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty: true };
+                node = Tags.getValues(tag.value.node.tags);
+
+                depth++;
+                i = 0;
+                agastNode = tag.value.node;
+                nodeShifted = wrappedTag.value.tags[0].type === ShiftTag;
+                seenFirstProperty = false;
+                continue outer;
+              }
+            }
+
+            default: {
+              yield tag;
+
+              if (tag.type === OpenNodeTag && tag.value.literalValue) {
+                ({ stack, agastNode, node, depth, i, nodeShifted } = stack);
+                seenFirstProperty = true;
+              }
+
+              break;
+            }
+          }
+        }
+      } else {
+        yield wrappedTag;
+
+        if (wrappedTag.type === OpenNodeTag && wrappedTag.value.literalValue) {
+          ({ stack, agastNode, node, depth, i, nodeShifted } = stack);
+          seenFirstProperty = true;
+        }
+      }
+      i++;
+    }
+  }
+}
+
 export const getCooked = (cookable) => {
   if (!cookable || isGapNode(cookable.type)) {
     return '';
   }
 
-  const children = cookable.children || cookable;
+  const tags = cookable.tags || cookable;
 
   let cooked = '';
 
@@ -489,7 +586,7 @@ export const getCooked = (cookable) => {
 
   let referenceTag = null;
 
-  for (let tag of Children.traverse(children)) {
+  for (let tag of Tags.traverse(tags)) {
     switch (tag.type) {
       case ReferenceTag: {
         let { type } = tag.value;
@@ -505,8 +602,8 @@ export const getCooked = (cookable) => {
       case BindingTag:
         break;
 
-      case Property: {
-        let { node, reference } = tag.value;
+      case PropertyWrapper: {
+        let { node, reference } = tag.value.property;
         let { attributes } = node;
 
         if (reference.type === '@') {
@@ -543,50 +640,44 @@ export const getCooked = (cookable) => {
   return cooked;
 };
 
-export const printCSTML = (rootNode) => {
-  return printCSTMLFromStream(streamFromTree(rootNode));
+export const printCSTML = (tree) => {
+  return printCSTMLFromStream(streamFromTree(tree));
 };
 
-export const printPrettyCSTML = (rootNode, options = {}) => {
-  return printPrettyCSTMLFromStream(streamFromTree(rootNode), options);
+export const printPrettyCSTML = (tree, options = {}) => {
+  return printPrettyCSTMLFromStream(streamFromTree(tree), options);
 };
 
-export const printSource = (rootNode) => {
-  return printSourceFromStream(streamFromTree(rootNode, { unshift: true }));
+export const printSource = (tree) => {
+  return printSourceFromStream(streamFromTree(tree, { unshift: true }));
 };
 
 export const sourceTextFor = printSource;
 
 export const getRange = (node) => {
-  const { children } = node;
+  const { tags } = node;
   let path = Path.from(node);
-  return Children.getSize(children) ? [TagPath.from(path, 0), TagPath.from(path, -1)] : null;
+  return Tags.getSize(tags) ? [TagPath.from(path, 0), TagPath.from(path, -1)] : null;
 };
 
 export const createNode = (openTag) => {
+  let bounds = buildBounds();
+  let literalTags = [];
+  let tags = openTag ? Tags.fromValues([openTag, ...literalTags]) : Tags.fromValues(literalTags);
+  let flags, type, attributes;
+
   if (!openTag || openTag.type === GapTag || openTag.type === NullTag) {
-    return {
-      flags: nodeFlags,
-      type: openTag && ([NullTag, GapTag].includes(openTag.type) ? null : openTag.type),
-      children: [],
-      properties: {},
-      attributes: openTag?.attributes || {},
-    };
+    flags = nodeFlags;
+    type = openTag && ([NullTag, GapTag].includes(openTag.type) ? null : openTag.type);
+    attributes = openTag?.attributes || {};
   } else {
-    const { flags, type, attributes = {} } = openTag.value || {};
-    return {
-      flags,
-      type,
-      children: [],
-      properties: {},
-      attributes,
-    };
+    ({ flags, type, attributes = {} } = openTag.value || {});
   }
+  return { flags, type, bounds, tags, attributes };
 };
 
 export const finalizeNode = (node) => {
   freeze(node);
-  freeze(node.properties);
   freeze(node.attributes);
   return node;
 };
@@ -599,145 +690,17 @@ export const isNull = (node) => {
   return node == null || isNullNode(node);
 };
 
-export const branchProperties = (properties) => {
-  const copy = { ...properties };
-
-  for (const { 0: key, 1: value } of Object.entries(copy)) {
-    if (isArray(value)) {
-      copy[key] = btree.fromValues(value);
-    }
-  }
-
-  return copy;
-};
-
-export const branchNode = (node) => {
-  const { flags, type, children, properties, attributes } = node;
-  return {
-    flags,
-    type,
-    children,
-    properties: branchProperties(properties),
-    attributes: { ...attributes },
-  };
-};
-
-export const acceptNode = (node, accepted) => {
-  const { children, properties, attributes } = accepted;
-  node.children = children;
-  node.properties = properties;
-  node.attributes = attributes;
-  return node;
-};
-
-export function* traverseProperties(properties) {
-  for (const value of Object.values(properties)) {
-    if (isArray(value)) {
-      for (let item of btree.traverse(value)) {
-        if (isArray(item.node)) {
-          yield btree.getAt(-1, item.node);
-        } else {
-          yield item.node;
-        }
-      }
-    } else {
-      yield value.node;
-    }
-  }
-}
-
-export const addToProperties = (properties, property) => {
-  let { reference, node: value } = property;
-  let { flags, name, isArray } = reference;
-
-  if (!name) throw new Error();
-  if (value === null) throw new Error();
-  if (!hasOwn(property, 'binding')) throw new Error();
-
-  if (Object.isFrozen(properties)) {
-    throw new Error('not implemented');
-  }
-
-  let isInitializer = value === undefined || Array.isArray(value);
-
-  let outerProperty = property;
-
-  if (flags.expression && !isInitializer) {
-    let shiftStack =
-      getFirstNodeShiftStack(value) ||
-      btree.fromValues([buildProperty(reference, null, buildStubNode(buildGapTag()))]);
-
-    shiftStack = btree.push(shiftStack, property);
-    outerProperty = buildProperty(reference, null, shiftStack);
-  }
-
-  if (isArray && !isInitializer) {
-    properties[name] = buildProperty(
-      reference,
-      null,
-      btree.push(properties[name]?.node || btree.fromValues([]), outerProperty),
-    );
-  } else {
-    properties[name] = outerProperty;
-  }
-
-  return properties;
-};
-
-export const shiftToProperties = (properties, property) => {
-  let { reference, node: value } = property;
-  let { flags, name, isArray } = reference;
-
-  if (!name) throw new Error();
-
-  if (Object.isFrozen(properties)) {
-    throw new Error('not implemented');
-  }
-
-  if (!flags.expression) {
-    return addToProperties(properties, property);
-  }
-  let isInitializer = value === undefined || Array.isArray(value);
-
-  let outerProperty;
-  if (flags.expression && !isInitializer) {
-    let shiftStack =
-      getFirstNodeShiftStack(value) ||
-      btree.fromValues([buildProperty(reference, null, buildStubNode(buildGapTag()))]);
-
-    shiftStack = btree.push(shiftStack, property);
-    outerProperty = buildProperty(reference, null, shiftStack);
-  }
-
-  if (isArray) {
-    properties[name] = buildProperty(
-      reference,
-      null,
-      btree.replaceAt(-1, properties[name].node, outerProperty),
-    );
-  } else {
-    properties[name] = outerProperty;
-  }
-  return properties;
-};
-
 export const addProperty = (node, property) => {
   if (!node || !property) throw new Error();
   if (!Object.isFrozen(property)) throw new Error();
 
-  let back1 = Children.getAt(-1, node.children);
-  let back2 = Children.getAt(-2, node.children);
-
-  let referenceTag;
-  let bindingTag = null;
-
   if (property.node === null) {
     throw new Error();
   }
 
-  let { node: value } = property;
+  let { node: value, binding, reference } = property;
 
-  let isArrayInitializer = isArray(value);
+  let isArrayInitializer = reference.type !== '_' && isArray(value);
   let isInitializer = value === undefined || isArrayInitializer;
 
   if (isArrayInitializer && value.length) throw new Error();
@@ -746,47 +709,39 @@ export const addProperty = (node, property) => {
     throw new Error();
   }
 
-  let foundShift = false;
-  let foundBinding = false;
-  if (back1.type === BindingTag) {
-    bindingTag = property.binding && back1;
-    referenceTag = back2;
-    foundShift = foundBinding = true;
-  } else if (back1.type === ReferenceTag) {
-    bindingTag = property.binding && buildChild(BindingTag, property.binding);
-    referenceTag = back1;
-    foundShift = true;
-  } else {
-    bindingTag = property.binding && buildChild(BindingTag, property.binding);
-    referenceTag = buildChild(ReferenceTag, property.reference);
+  if (reference.type === '_') {
+    node.tags = Tags.push(node.tags, value);
+    return node;
   }
 
-  if (!referenceTag) throw new Error();
+  let referenceTag = buildChild(ReferenceTag, reference);
+  let propertyWrapper;
 
   if (isInitializer) {
-    if (property.reference.name) {
-      addToProperties(node.properties, property);
-    }
+    let tags = freeze([referenceTag, buildInitializerTag(isArrayInitializer)]);
 
-    if (!foundShift) {
-      node.children = Children.push(node.children, referenceTag);
-    }
-    node.children = Children.push(node.children, buildInitializerTag(isArrayInitializer));
+    propertyWrapper = buildPropertyWrapper(
+      tags,
+      buildProperty(reference, null, isArrayInitializer ? [] : null),
+    );
+  } else {
+    let tags = freeze([
+      referenceTag,
+      buildChild(BindingTag, binding),
+      buildChild(Property, property),
+    ]);
 
-    return;
+    propertyWrapper = buildPropertyWrapper(tags, property);
   }
 
-  if (property.reference.name) {
-    addToProperties(node.properties, property);
-  }
+  let lastTag = Tags.getAt(-1, node.tags);
+  let unboundProperty = lastTag.type === PropertyWrapper && lastTag.value.tags.length < 3;
 
-  if (!foundShift) {
-    node.children = Children.push(node.children, referenceTag);
-  }
-  if (!foundBinding && bindingTag) {
-    node.children = Children.push(node.children, bindingTag);
+  if (unboundProperty) {
+    node.tags = Tags.replaceAt(-1, node.tags, buildChild(PropertyWrapper, propertyWrapper));
+  } else {
+    node.tags = Tags.push(node.tags, buildChild(PropertyWrapper, propertyWrapper));
   }
-  node.children = Children.push(node.children, buildChild(Property, property));
 
   return node;
 };
@@ -796,12 +751,6 @@ export const shiftProperty = (node, property) => {
   if (!property.reference) throw new Error();
   if (!Object.isFrozen(property)) throw new Error();
 
-  let back1 = Children.getAt(-1, node.children);
-  let back2 = Children.getAt(-2, node.children);
-
-  let shiftTag;
-  let bindingTag = null;
-
   if (property.node === null) {
     property.node = buildNullNode();
   }
@@ -811,79 +760,62 @@ export const shiftProperty = (node, property) => {
   let isArrayInitializer = isArray(value);
   let isInitializer = value === undefined || isArrayInitializer;
 
-  if (!isInitializer && !property.binding) {
+  if (isInitializer || !property.binding) {
     throw new Error();
   }
 
-  let foundShift = false;
-  let foundBinding = false;
-  if (back1.type === BindingTag) {
-    bindingTag = back1;
-    shiftTag = back2;
-    foundShift = foundBinding = true;
-
-    if (bindingTag.value !== property.binding) throw new Error();
-  } else if ([ShiftTag, ReferenceTag].includes(back1.type)) {
-    bindingTag = buildChild(BindingTag, property.binding);
-    shiftTag = back1;
-    foundShift = true;
-  } else {
-    bindingTag = buildChild(BindingTag, property.binding);
-    shiftTag = buildChild(ReferenceTag, property.reference);
+  let existingProperty = Tags.getAt(-1, node.tags);
+
+  if (!wrapperIsFull(existingProperty)) {
+    existingProperty = Tags.getAt(-2, node.tags);
   }
 
-  if (!shiftTag) throw new Error();
+  let existingRef = existingProperty?.value.tags[0];
 
-  if (isInitializer) {
-    shiftToProperties(node.properties, property);
+  let bindingTag = buildChild(BindingTag, property.binding);
 
-    if (!foundShift) {
-      node.children = Children.push(node.children, shiftTag);
-    }
-    node.children = Children.push(node.children, buildInitializerTag(isArrayInitializer));
+  let shiftStack = existingProperty?.value.property.node.bounds[0] || BTree.fromValues([]);
+  let stackSize = shiftStack && property.reference.flags.expression ? BTree.getSize(shiftStack) : 0;
 
-    return;
-  }
+  let index = existingRef.type === ReferenceTag ? 1 : existingRef.value.index + 1;
+  let height = BTree.getSize(shiftStack) + 1;
 
-  let shiftStack = node.properties[property.reference.name]?.node || btree.fromValues([]);
-  let stackSize = shiftStack && property.reference.flags.expression ? btree.getSize(shiftStack) : 0;
+  let shiftTag = stackSize ? buildShiftTag(index, height) : existingRef;
 
-  shiftToProperties(node.properties, property);
+  let tags = freeze([shiftTag, bindingTag, buildChild(Property, property)]);
 
-  let index = shiftTag.type === ReferenceTag ? 1 : shiftTag.value.index + 1;
-  let height = btree.getSize(shiftStack) + 1;
+  let lastTag = Tags.getAt(-1, node.tags);
+  let unboundProperty = lastTag.type === PropertyWrapper && lastTag.value.tags.length < 3;
 
-  let newShiftTag = stackSize ? buildShiftTag(index, height) : shiftTag;
+  let propertyWrapper = buildPropertyWrapper(tags, property);
 
-  if (!foundShift) {
-    node.children = Children.push(node.children, newShiftTag);
-  }
-  if (!foundBinding) {
-    node.children = Children.push(node.children, bindingTag);
+  if (unboundProperty) {
+    node.tags = Tags.replaceAt(-1, node.tags, buildChild(PropertyWrapper, propertyWrapper));
+  } else {
+    node.tags = Tags.push(node.tags, buildChild(PropertyWrapper, propertyWrapper));
   }
-  node.children = Children.push(node.children, buildChild(Property, property));
 
   return node;
 };
 
 export const add = (node, referenceTag, value, bindingTag) => {
-  let lastChild = Children.getAt(-1, node.children);
+  let lastChild = Tags.getAt(-1, node.tags);
   let reference = referenceTag.value;
   let binding = bindingTag
     ? bindingTag.value
-    : lastChild.type === BindingTag
+    : lastChild?.type === BindingTag
     ? lastChild.value
-    : buildBindingTag().value;
+    : buildBinding();
   return addProperty(node, buildProperty(reference, binding, value));
 };
 
 export const shift = (node, referenceTag, value, bindingTag) => {
-  let lastChild = Children.getAt(-1, node.children);
+  let lastChild = Tags.getAt(-1, node.tags);
   let reference = referenceTag.value;
   let binding = bindingTag
     ? bindingTag.value
     : lastChild.type === BindingTag
     ? lastChild.value
-    : buildBindingTag().value;
+    : buildBinding();
   return shiftProperty(node, buildProperty(reference, binding, value));
 };