@bablr/agast-helpers 0.9.0 → 0.10.0

package/lib/tree.js

@@ -1,45 +1,37 @@
-import { Coroutine } from '@bablr/coroutine';
 import {
-  nodeFlags,
   buildReferenceTag,
-  buildNullTag,
   buildOpenNodeTag,
   buildLiteralTag,
   buildCloseNodeTag,
   tokenFlags,
-  buildInitializerTag,
-  buildBindingTag,
-  buildProperty,
   buildChild,
-  buildShiftTag,
   buildGapTag,
-  buildBinding,
-  buildReference,
-  multiFragmentFlags,
-  buildPropertyWrapper,
+  buildOpenFragmentTag,
 } from './builders.js';
 import {
   printPrettyCSTML as printPrettyCSTMLFromStream,
   printCSTML as printCSTMLFromStream,
   printSource as printSourceFromStream,
-  getStreamIterator,
+  treeFromStream,
+  treeFromStreamSync,
+  treeFromStreamAsync,
+  evaluateReturnSync,
+  evaluateReturnAsync,
 } from './stream.js';
 import {
-  DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
   ReferenceTag,
   GapTag,
-  NullTag,
-  InitializerTag,
   LiteralTag,
   AttributeDefinition,
   BindingTag,
-  Property,
   ShiftTag,
-  PropertyWrapper,
+  Property,
+  NullNode,
+  TreeNode,
+  GapNode,
 } from './symbols.js';
-import * as BTree from './btree.js';
 import * as Tags from './tags.js';
 export * from './builders.js';
 export * from './print.js';
@@ -49,36 +41,37 @@ import {
   has,
   list,
   TagPath,
-  Path,
-  isFragmentNode,
+  isCover,
   isNullNode,
   isGapNode,
   getOpenTag,
   getCloseTag,
   getRoot,
-  getRootArray,
-  isStubTag,
-  wrapperIsFull,
+  getTags,
 } from './path.js';
-import { isPlainObject } from './object.js';
+import { freeze, isPlainObject } from './object.js';
 
 export {
   get,
   getOr,
   has,
   list,
-  isFragmentNode,
+  isCover,
   isNullNode,
   isGapNode,
   getOpenTag,
   getCloseTag,
   getRoot,
-  getRootArray,
+  treeFromStream,
+  treeFromStreamSync,
+  treeFromStreamAsync,
+  evaluateReturnSync,
+  evaluateReturnAsync,
 };
 
-export const buildToken = (type, value, attributes = {}) => {
+export const buildToken = (name, value, attributes = {}) => {
   return treeFromStreamSync([
-    buildOpenNodeTag(tokenFlags, type, attributes),
+    buildOpenNodeTag(tokenFlags, name, null, attributes),
     buildLiteralTag(value),
     buildCloseNodeTag(),
   ]);
@@ -87,10 +80,9 @@ export const buildToken = (type, value, attributes = {}) => {
 const isString = (str) => typeof str === 'string';
 
 const { isArray } = Array;
-const { freeze, hasOwn } = Object;
 
 export const mergeReferences = (outer, inner) => {
-  let { type, name, isArray, index, flags: { expression, hasGap } = {} } = outer;
+  let { type, name, index, flags: { array, expression, intrinsic, hasGap } = {} } = outer;
 
   if (
     (name != null && inner.name != null && name !== inner.name) ||
@@ -99,13 +91,15 @@ export const mergeReferences = (outer, inner) => {
     return inner;
   }
 
-  isArray = isArray || inner.isArray;
+  array = !!(array || inner.flags.array);
   expression = !!(expression || inner.flags.expression);
+  intrinsic = !!(intrinsic || inner.flags.intrinsic);
   hasGap = !!(hasGap || inner.flags.hasGap);
   name = type === '.' ? inner.name : name;
   type = type === '.' ? inner.type : type;
 
-  return buildReferenceTag(type, name, isArray, { expression, hasGap }, index).value;
+  return buildReferenceTag(type, name, freeze({ array, expression, intrinsic, hasGap }), index)
+    .value;
 };
 
 export const mergeReferenceTags = (outer, inner) => {
@@ -114,297 +108,24 @@ export const mergeReferenceTags = (outer, inner) => {
   return buildChild(ReferenceTag, value);
 };
 
-export const isEmptyReference = (ref) => {
-  let { type, isArray, flags } = ref.value;
-  return type === '.' && !isArray && !(flags.expression || flags.hasGap);
-};
-
-function* __treeFromStream(tags, options) {
-  let path = null;
-  let rootPath = null;
-  let held = null;
-  let doctype = null;
-  const co = new Coroutine(getStreamIterator(tags));
-  const expressionsCo = new Coroutine(getStreamIterator(options.expressions || []));
-  let referenceTag = null;
-  let bindingTag = null;
-
-  for (;;) {
-    co.advance();
-
-    if (co.current instanceof Promise) {
-      co.current = yield co.current;
-    }
-
-    if (co.done) break;
-
-    const tag = co.value;
-
-    if (tag.type === 'Effect') {
-      continue;
-    }
-
-    if (tag.type === DoctypeTag) {
-      doctype = tag;
-      continue;
-    }
-
-    if (held && tag.type !== OpenNodeTag && tag.type !== GapTag) {
-      throw new Error('cannot eat this type of tag while holding');
-    }
-
-    let suppressTag = false;
-
-    switch (tag.type) {
-      case LiteralTag:
-        break;
-
-      case CloseNodeTag: {
-        let { node } = path;
-        if (!node.tags[1]) throw new Error();
-        break;
-      }
-
-      case ReferenceTag: {
-        referenceTag = tag;
-        suppressTag = true;
-        break;
-      }
-
-      case BindingTag: {
-        bindingTag = tag;
-        suppressTag = true;
-        break;
-      }
-
-      case InitializerTag: {
-        add(path.node, referenceTag, []);
-        suppressTag = true;
-        referenceTag = null;
-        break;
-      }
-
-      case NullTag:
-      case GapTag: {
-        if (!path) {
-          return buildStubNode(tag);
-        }
-
-        const isGap = tag.type === GapTag;
-
-        if (path.parent && referenceTag.type !== ReferenceTag) throw new Error();
-
-        let node = createNode(tag);
-
-        suppressTag = true;
-
-        if (isGap) {
-          if (held) {
-            node = held;
-            add(path.node, referenceTag, node, bindingTag);
-          } else if (!expressionsCo.done) {
-            expressionsCo.advance();
-
-            let outerReference = referenceTag;
-
-            if (!expressionsCo.done) {
-              node =
-                node == null
-                  ? buildStubNode(buildNullTag())
-                  : expressionsCo.value == null
-                  ? buildStubNode(buildNullTag())
-                  : expressionsCo.value;
-
-              if (isFragmentNode(node)) {
-                const parentNode = path.node;
-
-                let referenceTag;
-                let bindingTag;
-
-                for (const tag of Tags.traverse(node.tags)) {
-                  switch (tag.type) {
-                    case DoctypeTag: {
-                      break;
-                    }
-
-                    case OpenNodeTag: {
-                      referenceTag = bindingTag = null;
-                      if (!tag.value.type) {
-                        break;
-                      } else {
-                        throw new Error();
-                      }
-                    }
-
-                    case ReferenceTag:
-                      referenceTag = tag;
-                      break;
-
-                    case InitializerTag: {
-                      add(parentNode, mergeReferenceTags(outerReference, referenceTag), []);
-                      break;
-                    }
-
-                    case BindingTag: {
-                      bindingTag = tag;
-                      break;
-                    }
-
-                    case GapTag:
-                    case NullTag: {
-                      add(
-                        parentNode,
-                        mergeReferenceTags(outerReference, referenceTag),
-                        buildStubNode(tag),
-                        bindingTag,
-                      );
-                      referenceTag = bindingTag = null;
-                      break;
-                    }
-
-                    default:
-                      throw new Error();
-                  }
-                }
-              } else {
-                if (path.node.flags.token) {
-                  throw new Error('not implemented');
-                }
-                add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
-              }
-            } else {
-              if (!path.node.flags.token) {
-                add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
-              }
-            }
-          }
-        }
-
-        referenceTag = null;
-        held = isGap ? null : held;
-
-        if (!path.node.flags.token) {
-          path = { parent: path, node, depth: (path.depth ?? -1) + 1, arrays: new Set() };
-        }
-
-        break;
-      }
-
-      // case ShiftTag: {
-      //   const { tags, properties } = path.node;
-
-      //   let property = properties[ref.value.name];
-      //   let node;
-
-      //   if (ref.value.isArray) {
-      //     ({ node } = btree.getAt(-1, property));
-      //     properties[ref.value.name].pop();
-      //   } else {
-      //     ({ node } = property);
-      //     properties[ref.value.name] = null;
-      //   }
-
-      //   held = node;
-      //   break;
-      // }
-
-      case OpenNodeTag: {
-        const node = createNode(tag);
-        if (path) {
-          if (path) {
-            add(path.node, referenceTag, node, bindingTag ?? buildBindingTag());
-            referenceTag = null;
-          }
-
-          path = { parent: path, node, depth: (path ? path.depth : -1) + 1, arrays: new Set() };
-        } else {
-          path = { parent: null, node, depth: 0, arrays: new Set() };
-
-          rootPath = path;
-        }
-
-        suppressTag = true;
-        break;
-      }
-
-      default: {
-        throw new Error();
-      }
-    }
-
-    if (!suppressTag) {
-      path.node.tags = Tags.push(path.node.tags, tag);
-    }
-
-    switch (tag.type) {
-      case NullTag:
-      case GapTag:
-      case CloseNodeTag: {
-        const completedNode = path.node;
-
-        if (!(tag.type === GapTag && completedNode.flags.token)) {
-          finalizeNode(completedNode);
-        }
-
-        if (tag.type === GapTag) {
-          if (path && completedNode.type === null && completedNode.flags.token) {
-            break;
-          }
-        }
-
-        path = path.parent;
-        break;
-      }
-    }
-  }
-
-  if (path && path.node.type) {
-    throw new Error('imbalanced tag stack');
-  }
-
-  return rootPath.node;
-}
-
-export const buildNullNode = () => {
-  return treeFromStreamSync([buildNullTag()]);
-};
-
-export const treeFromStream = (tags, options = {}) => __treeFromStream(tags, options);
+export const documentFromStream = (tags, options) => {
+  throw new Error('not implemented');
 
-export const treeFromStreamSync = (tokens, options = {}) => {
-  return evaluateReturnSync(treeFromStream(tokens, options));
-};
-
-export const treeFromStreamAsync = async (tokens, options = {}) => {
-  return evaluateReturnAsync(treeFromStream(tokens, options));
-};
-
-export const evaluateReturnSync = (generator) => {
-  const co = new Coroutine(generator[Symbol.iterator]());
-  while (!co.done) co.advance();
-  return co.value;
-};
+  // strip doctype tag off
 
-export const evaluateReturnAsync = async (generator) => {
-  const co = new Coroutine(getStreamIterator(generator));
-  while (!co.done) {
-    co.advance();
-
-    if (co.current instanceof Promise) {
-      co.current = await co.current;
-    }
-  }
-  return co.value;
+  // return buildChild(Document, freeze({ doctype, tree }));
 };
 
 export const isEmpty = (node) => {
-  for (const tag of Tags.traverseInner(node.tags)) {
+  if (node == null) return true;
+
+  for (const tag of Tags.traverse(getTags(node))) {
     switch (tag.type) {
       case Property: {
-        if (tag.value.reference.type === '@') {
+        if (tag.value.property.reference.type === '@') {
           return false;
         } else {
-          const property = tag.value;
+          const { property } = tag.value;
 
           if (!isNullNode(property.node)) {
             return false;
@@ -421,36 +142,15 @@ 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,
-    bounds: buildBounds(null, null),
-    tags: Tags.from(tag),
-    attributes: freeze({}),
-  });
-};
-
 export const streamFromTree = (tree, options = {}) => {
-  let rootNode = isPlainObject(tree) ? tree : tree.node;
+  if (tree && !isPlainObject(tree)) throw new Error();
 
-  return __streamFromTree(null, rootNode, options);
+  return __streamFromTree(null, tree, options);
 };
 
 function* __streamFromTree(doctypeTag, rootNode, options) {
   const { unshift = false } = options;
-  if (!rootNode || !Tags.getSize(rootNode.tags)) return;
+  if (!rootNode || !Tags.getSize(getTags(rootNode))) return;
 
   let tagPath = TagPath.fromNode(rootNode, 0);
 
@@ -461,26 +161,24 @@ function* __streamFromTree(doctypeTag, rootNode, options) {
   }
 
   do {
-    if (tagPath.tag.type === OpenNodeTag && !tagPath.tag.value.literalValue) count++;
+    if (tagPath.tag.type === OpenNodeTag && !tagPath.tag.value.selfClosing) count++;
     if (tagPath.tag.type === CloseNodeTag) count--;
 
     if (
       !(
         tagPath.tag.type === AttributeDefinition ||
-        (tagPath.tag.type === BindingTag && !tagPath.tag.value.languagePath?.length)
+        (tagPath.tag.type === BindingTag && !tagPath.tag.value.segments?.length)
       )
     ) {
       yield tagPath.tag;
     }
   } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
 
-  if (count !== 0) throw new Error();
+  // if (count !== 0) throw new Error();
 }
 
 export const vcsStreamFromTree = (rootNode) => {
-  let rootNode_ = isPlainObject(rootNode) ? rootNode : rootNode.node;
-
-  return __vcsStreamFromTree(rootNode_);
+  return __vcsStreamFromTree(rootNode);
 };
 
 function* __vcsStreamFromTree(rootNode) {
@@ -490,7 +188,7 @@ function* __vcsStreamFromTree(rootNode) {
   let nodeShifted = false;
   let i = 0;
   let seenFirstProperty = false;
-  let node = Tags.getValues(rootNode.tags);
+  let node = Tags.getValues(rootNode.value.tags);
 
   outer: while (node) {
     while (i >= node.length) {
@@ -514,7 +212,7 @@ function* __vcsStreamFromTree(rootNode) {
     if (isArray(child)) {
       stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty };
 
-      yield buildOpenNodeTag(multiFragmentFlags);
+      yield buildOpenFragmentTag();
 
       node = Tags.getValues(child);
       depth++;
@@ -522,10 +220,12 @@ function* __vcsStreamFromTree(rootNode) {
     } else {
       let wrappedTag = child;
 
-      if (wrappedTag.type === PropertyWrapper) {
+      if (wrappedTag.type === Property) {
         for (let tag of wrappedTag.value.tags) {
           switch (tag.type) {
-            case Property: {
+            case TreeNode:
+            case NullNode:
+            case GapNode: {
               let replaceWithGap = nodeShifted && !seenFirstProperty;
 
               if (replaceWithGap) {
@@ -536,11 +236,11 @@ function* __vcsStreamFromTree(rootNode) {
                 break;
               } else {
                 stack = { stack, agastNode, node, depth, i, nodeShifted, seenFirstProperty: true };
-                node = Tags.getValues(tag.value.node.tags);
+                node = Tags.getValues(tag.value.tags);
 
                 depth++;
                 i = 0;
-                agastNode = tag.value.node;
+                agastNode = tag.value;
                 nodeShifted = wrappedTag.value.tags[0].type === ShiftTag;
                 seenFirstProperty = false;
                 continue outer;
@@ -573,11 +273,11 @@ function* __vcsStreamFromTree(rootNode) {
 }
 
 export const getCooked = (cookable) => {
-  if (!cookable || isGapNode(cookable.type)) {
+  if (!cookable || isGapNode(cookable)) {
     return '';
   }
 
-  const tags = cookable.tags || cookable;
+  const tags = getTags(cookable) || cookable;
 
   let cooked = '';
 
@@ -602,9 +302,9 @@ export const getCooked = (cookable) => {
       case BindingTag:
         break;
 
-      case PropertyWrapper: {
-        let { node, reference } = tag.value.property;
-        let { attributes } = node;
+      case Property: {
+        let { node, reference } = tag.value;
+        let { attributes } = node.value;
 
         if (reference.type === '@') {
           let { cooked: cookedValue } = attributes;
@@ -618,6 +318,10 @@ export const getCooked = (cookable) => {
         break;
       }
 
+      case GapTag: {
+        return null;
+      }
+
       case LiteralTag: {
         cooked += tag.value;
         break;
@@ -654,34 +358,6 @@ export const printSource = (tree) => {
 
 export const sourceTextFor = printSource;
 
-export const getRange = (node) => {
-  const { tags } = node;
-  let path = Path.from(node);
-  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) {
-    flags = nodeFlags;
-    type = openTag && ([NullTag, GapTag].includes(openTag.type) ? null : openTag.type);
-    attributes = openTag?.attributes || {};
-  } else {
-    ({ flags, type, attributes = {} } = openTag.value || {});
-  }
-  return { flags, type, bounds, tags, attributes };
-};
-
-export const finalizeNode = (node) => {
-  freeze(node);
-  freeze(node.attributes);
-  return node;
-};
-
 export const notNull = (node) => {
   return node != null && !isNullNode(node);
 };
@@ -689,133 +365,3 @@ export const notNull = (node) => {
 export const isNull = (node) => {
   return node == null || isNullNode(node);
 };
-
-export const addProperty = (node, property) => {
-  if (!node || !property) throw new Error();
-  if (!Object.isFrozen(property)) throw new Error();
-
-  if (property.node === null) {
-    throw new Error();
-  }
-
-  let { node: value, binding, reference } = property;
-
-  let isArrayInitializer = reference.type !== '_' && isArray(value);
-  let isInitializer = value === undefined || isArrayInitializer;
-
-  if (isArrayInitializer && value.length) throw new Error();
-
-  if (!isInitializer && property.node.type && !property.binding) {
-    throw new Error();
-  }
-
-  if (reference.type === '_') {
-    node.tags = Tags.push(node.tags, value);
-    return node;
-  }
-
-  let referenceTag = buildChild(ReferenceTag, reference);
-  let propertyWrapper;
-
-  if (isInitializer) {
-    let tags = freeze([referenceTag, buildInitializerTag(isArrayInitializer)]);
-
-    propertyWrapper = buildPropertyWrapper(
-      tags,
-      buildProperty(reference, null, isArrayInitializer ? [] : null),
-    );
-  } else {
-    let tags = freeze([
-      referenceTag,
-      buildChild(BindingTag, binding),
-      buildChild(Property, property),
-    ]);
-
-    propertyWrapper = buildPropertyWrapper(tags, property);
-  }
-
-  let lastTag = Tags.getAt(-1, node.tags);
-  let unboundProperty = lastTag.type === PropertyWrapper && lastTag.value.tags.length < 3;
-
-  if (unboundProperty) {
-    node.tags = Tags.replaceAt(-1, node.tags, buildChild(PropertyWrapper, propertyWrapper));
-  } else {
-    node.tags = Tags.push(node.tags, buildChild(PropertyWrapper, propertyWrapper));
-  }
-
-  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();
-
-  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 existingProperty = Tags.getAt(-1, node.tags);
-
-  if (!wrapperIsFull(existingProperty)) {
-    existingProperty = Tags.getAt(-2, node.tags);
-  }
-
-  let existingRef = existingProperty?.value.tags[0];
-
-  let bindingTag = buildChild(BindingTag, property.binding);
-
-  let shiftStack = existingProperty?.value.property.node.bounds[0] || BTree.fromValues([]);
-  let stackSize = shiftStack && property.reference.flags.expression ? BTree.getSize(shiftStack) : 0;
-
-  let index = existingRef.type === ReferenceTag ? 1 : existingRef.value.index + 1;
-  let height = BTree.getSize(shiftStack) + 1;
-
-  let shiftTag = stackSize ? buildShiftTag(index, height) : existingRef;
-
-  let tags = freeze([shiftTag, bindingTag, buildChild(Property, property)]);
-
-  let lastTag = Tags.getAt(-1, node.tags);
-  let unboundProperty = lastTag.type === PropertyWrapper && lastTag.value.tags.length < 3;
-
-  let propertyWrapper = buildPropertyWrapper(tags, property);
-
-  if (unboundProperty) {
-    node.tags = Tags.replaceAt(-1, node.tags, buildChild(PropertyWrapper, propertyWrapper));
-  } else {
-    node.tags = Tags.push(node.tags, buildChild(PropertyWrapper, propertyWrapper));
-  }
-
-  return node;
-};
-
-export const add = (node, referenceTag, value, bindingTag) => {
-  let lastChild = Tags.getAt(-1, node.tags);
-  let reference = referenceTag.value;
-  let binding = bindingTag
-    ? bindingTag.value
-    : lastChild?.type === BindingTag
-    ? lastChild.value
-    : buildBinding();
-  return addProperty(node, buildProperty(reference, binding, value));
-};
-
-export const shift = (node, referenceTag, value, bindingTag) => {
-  let lastChild = Tags.getAt(-1, node.tags);
-  let reference = referenceTag.value;
-  let binding = bindingTag
-    ? bindingTag.value
-    : lastChild.type === BindingTag
-    ? lastChild.value
-    : buildBinding();
-  return shiftProperty(node, buildProperty(reference, binding, value));
-};