@bablr/agast-helpers 0.7.1 → 0.8.0

package/lib/tree.js

@@ -7,6 +7,12 @@ import {
   buildLiteralTag,
   buildCloseNodeTag,
   tokenFlags,
+  buildInitializerTag,
+  buildBindingTag,
+  buildProperty,
+  buildChild,
+  buildShiftTag,
+  buildGapTag,
 } from './builders.js';
 import {
   printPrettyCSTML as printPrettyCSTMLFromStream,
@@ -23,14 +29,16 @@ import {
   NullTag,
   InitializerTag,
   LiteralTag,
-  EmbeddedNode,
+  AttributeDefinition,
+  BindingTag,
+  Property,
+  ShiftTag,
 } from './symbols.js';
 import * as btree from './btree.js';
-import * as sumtree from './sumtree.js';
+import * as Children from './children.js';
 export * from './builders.js';
 export * from './print.js';
 import {
-  add,
   get,
   TagPath,
   Path,
@@ -39,14 +47,26 @@ import {
   isGapNode,
   getOpenTag,
   getCloseTag,
-  getShifted,
+  getRoot,
+  getRootArray,
+  getFirstNodeShiftStack,
 } from './path.js';
+import { isPlainObject } from './object.js';
 
-export { add, get, isFragmentNode, isNullNode, isGapNode, getOpenTag, getCloseTag };
+export {
+  get,
+  isFragmentNode,
+  isNullNode,
+  isGapNode,
+  getOpenTag,
+  getCloseTag,
+  getRoot,
+  getRootArray,
+};
 
-export const buildToken = (language, type, value, attributes = {}) => {
+export const buildToken = (type, value, attributes = {}) => {
   return treeFromStreamSync([
-    buildOpenNodeTag(tokenFlags, language, type, attributes),
+    buildOpenNodeTag(tokenFlags, type, attributes),
     buildLiteralTag(value),
     buildCloseNodeTag(),
   ]);
@@ -55,72 +75,36 @@ export const buildToken = (language, type, value, attributes = {}) => {
 const isString = (str) => typeof str === 'string';
 
 const { isArray } = Array;
-const { freeze } = Object;
-
-export const parseReference = (str) => {
-  let {
-    1: name,
-    2: isArray,
-    3: index,
-    4: expressionToken,
-    5: hasGapToken,
-  } = /^\s*([.#@]|[a-zA-Z]+)\s*(\[\s*(\d+\s*)?\])?\s*(\+)?(\$)?\s*$/.exec(str);
-
-  let flags = {
-    expression: !!expressionToken,
-    hasGap: !!hasGapToken,
-  };
-
-  index = index ? parseInt(index, 10) : null;
-  isArray = !!isArray;
-  name = name || null;
-
-  return buildReferenceTag(name, isArray, flags, index);
-};
+const { freeze, hasOwn } = Object;
 
 export const mergeReferences = (outer, inner) => {
-  let {
-    name,
-    isArray,
-    index,
-    flags: { expression, hasGap },
-  } = outer.value;
+  let { type, name, isArray, index, flags: { expression, hasGap } = {} } = outer;
 
   if (
-    name != null &&
-    name !== '.' &&
-    inner.value.name != null &&
-    inner.value.name !== '.' &&
-    name !== inner.value.name
+    (name != null && inner.name != null && name !== inner.name) ||
+    (type != null && inner.type != null && type !== inner.type)
   ) {
     return inner;
   }
 
-  isArray = isArray || inner.value.isArray;
-  expression = !!(expression || inner.value.flags.expression);
-  hasGap = !!(hasGap || inner.value.flags.hasGap);
-  name = name === '.' ? inner.value.name : name;
-
-  return buildReferenceTag(name, isArray, { expression, hasGap }, index);
-};
+  isArray = isArray || inner.isArray;
+  expression = !!(expression || inner.flags.expression);
+  hasGap = !!(hasGap || inner.flags.hasGap);
+  name = type === '.' ? inner.name : name;
+  type = type === '.' ? inner.type : type;
 
-export const isEmptyReference = (ref) => {
-  let { name, isArray, flags } = ref.value;
-  return name === '.' && !isArray && !(flags.expression || flags.hasGap);
+  return buildReferenceTag(type, name, isArray, { expression, hasGap }, index).value;
 };
 
-export const defineAttribute = (node, key, value) => {
-  const openTag = getOpenTag(node);
+export const mergeReferenceTags = (outer, inner) => {
+  let value = mergeReferences(outer.value, inner.value);
 
-  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;
+  return buildChild(ReferenceTag, value);
+};
 
-    node.children = sumtree.replaceAt(0, node.children, newOpenTag);
-  }
+export const isEmptyReference = (ref) => {
+  let { type, isArray, flags } = ref.value;
+  return type === '.' && !isArray && !(flags.expression || flags.hasGap);
 };
 
 function* __treeFromStream(tags, options) {
@@ -130,7 +114,8 @@ function* __treeFromStream(tags, options) {
   let doctype = null;
   const co = new Coroutine(getStreamIterator(tags));
   const expressionsCo = new Coroutine(getStreamIterator(options.expressions || []));
-  let reference = null;
+  let referenceTag = null;
+  let bindingTag = null;
 
   for (;;) {
     co.advance();
@@ -165,15 +150,21 @@ function* __treeFromStream(tags, options) {
       }
 
       case ReferenceTag: {
-        reference = tag;
+        referenceTag = tag;
+        suppressTag = true;
+        break;
+      }
+
+      case BindingTag: {
+        bindingTag = tag;
         suppressTag = true;
         break;
       }
 
       case InitializerTag: {
-        add(path.node, reference, []);
+        add(path.node, referenceTag, []);
         suppressTag = true;
-        reference = null;
+        referenceTag = null;
         break;
       }
 
@@ -185,19 +176,19 @@ function* __treeFromStream(tags, options) {
 
         const isGap = tag.type === GapTag;
 
-        if (path.parent && reference.type !== ReferenceTag) throw new Error();
+        if (path.parent && referenceTag.type !== ReferenceTag) throw new Error();
 
         let node = createNode(tag);
 
         if (isGap) {
           if (held) {
             node = held;
-            add(path.node, reference, node);
+            add(path.node, referenceTag, node, bindingTag);
             suppressTag = true;
           } else if (!expressionsCo.done) {
             expressionsCo.advance();
 
-            let outerReference = reference;
+            let outerReference = referenceTag;
 
             if (!expressionsCo.done) {
               node =
@@ -211,15 +202,17 @@ function* __treeFromStream(tags, options) {
               if (isFragmentNode(node)) {
                 const parentNode = path.node;
 
-                let reference;
+                let referenceTag;
+                let bindingTag;
 
-                for (const tag of sumtree.traverse(node.children)) {
+                for (const tag of Children.traverse(node.children)) {
                   switch (tag.type) {
                     case DoctypeTag: {
                       break;
                     }
-                    case OpenNodeTag:
-                    case CloseNodeTag: {
+
+                    case OpenNodeTag: {
+                      referenceTag = bindingTag = null;
                       if (!tag.value.type) {
                         break;
                       } else {
@@ -228,29 +221,28 @@ function* __treeFromStream(tags, options) {
                     }
 
                     case ReferenceTag:
-                      // combine tags for .
-
-                      reference = tag;
+                      referenceTag = tag;
                       break;
 
                     case InitializerTag: {
-                      add(parentNode, mergeReferences(outerReference, reference), []);
+                      add(parentNode, mergeReferenceTags(outerReference, referenceTag), []);
                       break;
                     }
 
-                    case EmbeddedNode: {
-                      add(parentNode, mergeReferences(outerReference, reference), tag.value);
-                      break;
-                    }
-
-                    case GapTag: {
-                      const resolvedNode = getShifted(shift, reference, node);
-                      add(parentNode, mergeReferences(outerReference, reference), resolvedNode);
+                    case BindingTag: {
+                      bindingTag = tag;
                       break;
                     }
 
+                    case GapTag:
                     case NullTag: {
-                      add(parentNode, mergeReferences(outerReference, reference), null);
+                      add(
+                        parentNode,
+                        mergeReferenceTags(outerReference, referenceTag),
+                        buildStubNode(tag),
+                        bindingTag,
+                      );
+                      referenceTag = bindingTag = null;
                       break;
                     }
 
@@ -262,21 +254,21 @@ function* __treeFromStream(tags, options) {
                 if (path.node.flags.token) {
                   throw new Error('not implemented');
                 }
-                add(path.node, reference, node);
+                add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
               }
             } else {
               if (!path.node.flags.token) {
-                add(path.node, reference, node);
+                add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
               }
             }
           }
         }
 
-        reference = null;
+        referenceTag = null;
         held = isGap ? null : held;
 
         if (!path.node.flags.token) {
-          path = { parent: path, node, depth: (path.depth || -1) + 1, arrays: new Set() };
+          path = { parent: path, node, depth: (path.depth ?? -1) + 1, arrays: new Set() };
         }
 
         break;
@@ -305,20 +297,18 @@ function* __treeFromStream(tags, options) {
           const node = createNode(tag);
 
           if (path) {
-            add(path.node, reference, node);
-            reference = null;
+            add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
+            referenceTag = null;
           }
 
           path = { parent: path, node, depth: (path ? path.depth : -1) + 1, arrays: new Set() };
         } else {
-          const { language, type, flags, attributes } = tag.value;
+          const { type, flags, attributes } = tag.value;
 
           const attributes_ = doctype?.value.attributes ?? attributes;
-          const language_ = attributes?.['bablrLanguage'] ?? language;
 
           const node = {
             flags,
-            language: language_,
             type,
             children: [],
             properties: {},
@@ -339,7 +329,7 @@ function* __treeFromStream(tags, options) {
     }
 
     if (!suppressTag) {
-      path.node.children = sumtree.push(path.node.children, tag);
+      path.node.children = Children.push(path.node.children, tag);
     }
 
     switch (tag.type) {
@@ -403,14 +393,12 @@ export const evaluateReturnAsync = async (generator) => {
   return co.value;
 };
 
-export const streamFromTree = (rootNode, options = {}) => __streamFromTree(rootNode, options);
-
 export const isEmpty = (node) => {
   const { properties } = node;
 
   let ref = null;
 
-  for (const tag of sumtree.traverse(node.children)) {
+  for (const tag of Children.traverse(node.children)) {
     switch (tag.type) {
       case ReferenceTag: {
         const { name } = tag.value;
@@ -431,8 +419,8 @@ export const isEmpty = (node) => {
         break;
       }
 
-      case EmbeddedNode: {
-        if (ref.value.name === '@') {
+      case Property: {
+        if (tag.value.reference.type === '@') {
           return false;
         }
         break;
@@ -449,7 +437,6 @@ export const isEmpty = (node) => {
 export const buildStubNode = (tag) => {
   return freeze({
     flags: nodeFlags,
-    language: null,
     type: null,
     children: freeze([tag]),
     properties: freeze({}),
@@ -457,9 +444,15 @@ export const buildStubNode = (tag) => {
   });
 };
 
+export const streamFromTree = (rootNode, options = {}) => {
+  let rootNode_ = isPlainObject(rootNode) ? rootNode : rootNode.node;
+
+  return __streamFromTree(rootNode_, options);
+};
+
 function* __streamFromTree(rootNode, options) {
   const { unshift = false } = options;
-  if (!rootNode || !sumtree.getSize(rootNode.children)) return;
+  if (!rootNode || !Children.getSize(rootNode.children)) return;
 
   let tagPath = TagPath.fromNode(rootNode, 0);
 
@@ -469,7 +462,14 @@ function* __streamFromTree(rootNode, options) {
     if (tagPath.tag.type === OpenNodeTag) count++;
     if (tagPath.tag.type === CloseNodeTag) count--;
 
-    yield tagPath.tag;
+    if (
+      !(
+        tagPath.tag.type === AttributeDefinition ||
+        (tagPath.tag.type === BindingTag && !tagPath.tag.value.languagePath?.length)
+      )
+    ) {
+      yield tagPath.tag;
+    }
   } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
 
   if (count !== 0) throw new Error();
@@ -487,26 +487,30 @@ export const getCooked = (cookable) => {
   // const openTag = getOpenTag(cookable);
   // const closeTag = getCloseTag(cookable);
 
-  let reference = null;
+  let referenceTag = null;
 
-  for (const tag of sumtree.traverse(children)) {
+  for (let tag of Children.traverse(children)) {
     switch (tag.type) {
       case ReferenceTag: {
-        const { name } = tag.value;
+        let { type } = tag.value;
 
-        if (!(name === '#' || name === '@')) {
+        if (!(type === '#' || type === '@')) {
           throw new Error('cookable nodes must not contain other nodes');
         }
 
-        reference = tag;
+        referenceTag = tag;
         break;
       }
 
-      case EmbeddedNode: {
-        const { attributes } = tag.value;
+      case BindingTag:
+        break;
+
+      case Property: {
+        let { node, reference } = tag.value;
+        let { attributes } = node;
 
-        if (reference.value.name === '@') {
-          const { cooked: cookedValue } = attributes;
+        if (reference.type === '@') {
+          let { cooked: cookedValue } = attributes;
 
           if (!isString(cookedValue))
             throw new Error('cannot cook string: it contains uncooked escapes');
@@ -556,22 +560,27 @@ export const sourceTextFor = printSource;
 export const getRange = (node) => {
   const { children } = node;
   let path = Path.from(node);
-  return sumtree.getSize(children) ? [TagPath.from(path, 0), TagPath.from(path, -1)] : null;
+  return Children.getSize(children) ? [TagPath.from(path, 0), TagPath.from(path, -1)] : null;
 };
 
 export const createNode = (openTag) => {
   if (!openTag || openTag.type === GapTag || openTag.type === NullTag) {
     return {
       flags: nodeFlags,
-      language: openTag?.language,
       type: openTag && ([NullTag, GapTag].includes(openTag.type) ? null : openTag.type),
       children: [],
       properties: {},
       attributes: openTag?.attributes || {},
     };
   } else {
-    const { flags, language, type, attributes = {} } = openTag.value || {};
-    return { flags, language, type, children: [], properties: {}, attributes };
+    const { flags, type, attributes = {} } = openTag.value || {};
+    return {
+      flags,
+      type,
+      children: [],
+      properties: {},
+      attributes,
+    };
   }
 };
 
@@ -595,7 +604,7 @@ export const branchProperties = (properties) => {
 
   for (const { 0: key, 1: value } of Object.entries(copy)) {
     if (isArray(value)) {
-      copy[key] = btree.treeFromValues(value);
+      copy[key] = btree.fromValues(value);
     }
   }
 
@@ -603,10 +612,9 @@ export const branchProperties = (properties) => {
 };
 
 export const branchNode = (node) => {
-  const { flags, language, type, children, properties, attributes } = node;
+  const { flags, type, children, properties, attributes } = node;
   return {
     flags,
-    language,
     type,
     children,
     properties: branchProperties(properties),
@@ -622,10 +630,6 @@ export const acceptNode = (node, accepted) => {
   return node;
 };
 
-export const getRoot = (node) => {
-  return node == null ? node : isFragmentNode(node) ? node.properties['.'].node : node;
-};
-
 export function* traverseProperties(properties) {
   for (const value of Object.values(properties)) {
     if (isArray(value)) {
@@ -641,3 +645,245 @@ export function* traverseProperties(properties) {
     }
   }
 }
+
+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 isArrayInitializer = isArray(value);
+  let isInitializer = value === undefined || isArrayInitializer;
+
+  if (isArrayInitializer && value.length) throw new Error();
+
+  if (!isInitializer && property.node.type && !property.binding) {
+    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 (!referenceTag) throw new Error();
+
+  if (isInitializer) {
+    if (property.reference.name) {
+      addToProperties(node.properties, property);
+    }
+
+    if (!foundShift) {
+      node.children = Children.push(node.children, referenceTag);
+    }
+    node.children = Children.push(node.children, buildInitializerTag(isArrayInitializer));
+
+    return;
+  }
+
+  if (property.reference.name) {
+    addToProperties(node.properties, property);
+  }
+
+  if (!foundShift) {
+    node.children = Children.push(node.children, referenceTag);
+  }
+  if (!foundBinding && bindingTag) {
+    node.children = Children.push(node.children, bindingTag);
+  }
+  node.children = Children.push(node.children, buildChild(Property, property));
+
+  return node;
+};
+
+export const shiftProperty = (node, property) => {
+  if (!node || !property) throw new Error();
+  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();
+  }
+
+  let { node: value } = property;
+
+  let isArrayInitializer = isArray(value);
+  let isInitializer = value === undefined || isArrayInitializer;
+
+  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);
+  }
+
+  if (!shiftTag) throw new Error();
+
+  if (isInitializer) {
+    shiftToProperties(node.properties, property);
+
+    if (!foundShift) {
+      node.children = Children.push(node.children, shiftTag);
+    }
+    node.children = Children.push(node.children, buildInitializerTag(isArrayInitializer));
+
+    return;
+  }
+
+  let shiftStack = node.properties[property.reference.name]?.node || btree.fromValues([]);
+  let stackSize = shiftStack && property.reference.flags.expression ? btree.getSize(shiftStack) : 0;
+
+  shiftToProperties(node.properties, property);
+
+  let index = shiftTag.type === ReferenceTag ? 1 : shiftTag.value.index + 1;
+  let height = btree.getSize(shiftStack) + 1;
+
+  let newShiftTag = stackSize ? buildShiftTag(index, height) : shiftTag;
+
+  if (!foundShift) {
+    node.children = Children.push(node.children, newShiftTag);
+  }
+  if (!foundBinding) {
+    node.children = Children.push(node.children, bindingTag);
+  }
+  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 reference = referenceTag.value;
+  let binding = bindingTag
+    ? bindingTag.value
+    : lastChild.type === BindingTag
+    ? lastChild.value
+    : buildBindingTag().value;
+  return addProperty(node, buildProperty(reference, binding, value));
+};
+
+export const shift = (node, referenceTag, value, bindingTag) => {
+  let lastChild = Children.getAt(-1, node.children);
+  let reference = referenceTag.value;
+  let binding = bindingTag
+    ? bindingTag.value
+    : lastChild.type === BindingTag
+    ? lastChild.value
+    : buildBindingTag().value;
+  return shiftProperty(node, buildProperty(reference, binding, value));
+};