@bablr/bablr-vm 0.19.1 → 0.20.0

package/lib/node.js

@@ -4,17 +4,20 @@ import {
   buildOpenNodeTag,
   buildReferenceTag,
   buildStubNode,
-  isFragmentNode,
   isNullNode,
   parseReference,
-  referenceFlags,
 } from '@bablr/agast-helpers/tree';
 import { getStreamIterator } from '@bablr/agast-helpers/stream';
 import { agast } from '@bablr/agast-vm';
-import * as btree from '@bablr/agast-helpers/btree';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
 import { Pump } from './utils/pump.js';
 import { OpenNodeTag, ReferenceTag } from '@bablr/agast-helpers/symbols';
-import { get, getProperties } from '@bablr/agast-helpers/path';
+import {
+  buildFullRange,
+  get,
+  getProperties,
+  getPropertyChildrenIndex,
+} from '@bablr/agast-helpers/path';
 import { isArray } from '@bablr/helpers/object';
 
 export const states = new WeakMap();
@@ -22,18 +25,35 @@ export const internalStates = new WeakMap();
 
 const { hasOwn } = Object;
 
-const buildFullRange = (node) => {
-  const sum = btree.getSum(node.children);
-  return sum ? [0, sum - 1] : null;
-};
-
 export const FragmentFacade = class BABLRFragmentFacade {
+  static wrapNode(
+    node,
+    context,
+    transparent = false,
+    childrenIndexRange = null,
+    dotPropertyReference = null,
+    dotPropertyIndex = null,
+  ) {
+    return (
+      node &&
+      new FragmentFacade(
+        node,
+        context,
+        transparent,
+        false,
+        childrenIndexRange,
+        dotPropertyReference,
+        dotPropertyIndex,
+      )
+    );
+  }
+
   static wrap(
     node,
     context,
     transparent = false,
-    childrenIndexRange = node && buildFullRange(node),
-    dotPropertyName = null,
+    childrenIndexRange = null,
+    dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
     return (
@@ -42,53 +62,86 @@ export const FragmentFacade = class BABLRFragmentFacade {
         node,
         context,
         transparent,
+        true,
         childrenIndexRange,
-        dotPropertyName,
+        dotPropertyReference,
         dotPropertyIndex,
       )
     );
   }
 
-  constructor(node, context, transparent, childrenIndexRange, dotPropertyName, dotPropertyIndex) {
+  constructor(
+    node,
+    context,
+    transparent = false,
+    isFragmentNode = true,
+    childrenIndexRange = null,
+    dotPropertyReference = null,
+    dotPropertyIndex = null,
+  ) {
+    if (!node) throw new Error();
+
     if (childrenIndexRange && (childrenIndexRange[0] == null || !childrenIndexRange[1] == null)) {
       throw new Error();
     }
 
     if (!context) throw new Error();
 
-    if (dotPropertyName && !hasOwn(node.properties, dotPropertyName)) throw new Error();
+    if (dotPropertyReference && !hasOwn(node.properties, dotPropertyReference.value.name))
+      throw new Error();
+
+    if (isArray(dotPropertyReference?.value.isArray && dotPropertyIndex == null)) throw new Error();
+
+    let resolvedNode = node;
+    let fragmentNode = node;
+
+    if (dotPropertyReference) {
+      let { name, isArray, flags } = dotPropertyReference.value;
 
-    if (isArray(node.properties[dotPropertyName]) && dotPropertyIndex == null) throw new Error();
+      let dotReference = buildReferenceTag(name, isArray, flags, dotPropertyIndex);
+
+      resolvedNode = get(dotReference, fragmentNode);
+    }
 
     states.set(this, {
       context,
       openTag: buildOpenNodeTag(),
       closeTag: buildCloseNodeTag(),
-      node,
+      node: resolvedNode,
+      fragmentNode: node,
       transparent,
+      isFragmentNode,
       childrenIndexRange,
-      dotPropertyName,
+      dotPropertyReference,
       dotPropertyIndex,
     });
   }
 
+  get dotPropertyName() {
+    return states.get(this).dotPropertyReference?.value.name;
+  }
+
   get isTransparent() {
     return states.get(this).transparent;
   }
 
-  get isFragmentNode() {
-    return isFragmentNode(states.get(this).node);
+  get isNull() {
+    let { node } = states.get(this);
+    return isNullNode(node);
   }
 
   get children() {
-    const { node, transparent, childrenIndexRange } = states.get(this);
+    let { node, isFragmentNode, transparent, childrenIndexRange } = states.get(this);
+
+    childrenIndexRange =
+      isFragmentNode || !childrenIndexRange ? buildFullRange(node) : childrenIndexRange;
 
     return {
       *[Symbol.iterator]() {
         for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
           const interpolated = false; // TODO
           if (!interpolated || transparent) {
-            yield btree.getAt(i, node.children);
+            yield sumtree.getAt(i, node.children);
           }
         }
       },
@@ -103,7 +156,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
     if (childrenIndexRange[0] > childrenIndexRange[1]) throw new Error();
 
     for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
-      let tag = btree.getAt(i, node.children);
+      let tag = sumtree.getAt(i, node.children);
       if (tag.type === ReferenceTag) {
         const { name, isArray } = tag.value;
         let resolvedTagName = name === '.' ? dotPropertyName : name;
@@ -124,75 +177,120 @@ export const FragmentFacade = class BABLRFragmentFacade {
   }
 
   get language() {
-    let { node } = states.get(this);
+    let { node, isFragmentNode } = states.get(this);
 
-    return node.language;
+    return isFragmentNode ? null : node.language;
   }
 
   get type() {
-    let { node } = states.get(this);
+    let { node, isFragmentNode } = states.get(this);
 
-    return node.type;
+    return isFragmentNode ? null : node.type;
   }
 
   get attributes() {
-    let { node } = states.get(this);
+    let { node, isFragmentNode } = states.get(this);
 
-    return node.attributes;
+    return isFragmentNode ? {} : node.attributes;
   }
 
   get openTag() {
-    const state = states.get(this);
-    const { children } = state.node;
+    const { node, openTag, isFragmentNode } = states.get(this);
 
-    return state.openTag || btree.getAt(0, children);
+    return isFragmentNode ? openTag : sumtree.getAt(0, node.children);
   }
 
   get closeTag() {
-    const state = states.get(this);
-    const { children } = state.node;
+    const { node, closeTag, isFragmentNode } = states.get(this);
 
-    return state.closeTag || btree.getAt(btree.getSum(children) - 1, children);
+    return isFragmentNode
+      ? closeTag
+      : sumtree.getAt(sumtree.getSize(node.children) - 1, node.children);
+  }
+
+  merge(targetFragment) {
+    let {
+      fragmentNode,
+      context,
+      transparent,
+      isFragmentNode,
+      childrenIndexRange,
+      dotPropertyReference,
+      dotPropertyIndex,
+    } = states.get(this);
+    const { fragmentNode: targetFragmentNode, childrenIndexRange: targetChildrenIndexRange } =
+      states.get(targetFragment);
+    if (fragmentNode === targetFragmentNode) {
+      // TODO restrict what is legal here
+
+      return new FragmentFacade(
+        fragmentNode,
+        context,
+        transparent,
+        isFragmentNode,
+        targetChildrenIndexRange,
+        dotPropertyReference,
+        dotPropertyIndex,
+      );
+    } else {
+      throw new Error('not implemented');
+    }
   }
 
   get(path) {
     let {
-      node,
+      node: ownNode,
+      fragmentNode,
       context,
       transparent,
-      dotPropertyName,
+      isFragmentNode,
+      childrenIndexRange,
+      dotPropertyReference: dotReference,
       dotPropertyIndex: dotIndex,
     } = states.get(this);
-    // let { path: nodePath } = internalStates.get(node);
     const parsedRef = parseReference(path);
-    // const resolvedPath = resolvePath(node, path);
-    // const childNode = getAtPath(resolvedPath, node);
 
-    // array resolve
+    let node = fragmentNode;
 
-    if (dotPropertyName) {
-      let dotReference = buildReferenceTag(
-        dotPropertyName,
-        dotIndex != null,
-        referenceFlags,
-        dotIndex,
-      );
+    if (parsedRef.value.name !== '.') {
+      if (dotReference) {
+        fragmentNode = ownNode;
+        dotReference = parsedRef;
 
-      node = get(dotReference, node);
-    }
+        isFragmentNode = false;
+      } else {
+        dotReference = parsedRef;
+        dotIndex = parsedRef.value.index;
+      }
+
+      let { name, isArray, flags } = parsedRef.value;
+      let resolvedReference = buildReferenceTag(name, isArray, flags, dotIndex);
+      let refIndex = getPropertyChildrenIndex(fragmentNode, resolvedReference);
+      childrenIndexRange = [refIndex, refIndex + 1];
 
-    const binding = getProperties(parsedRef, node.properties);
+      const binding = getProperties(parsedRef, fragmentNode.properties);
 
-    if (!binding) return null;
+      if (!binding) return null;
 
-    const ref = binding.reference;
+      const ref = binding.reference;
 
-    const node_ =
-      (ref && ref.type === ReferenceTag && !ref.value.flags.hasGap) || transparent
-        ? binding.node
-        : buildStubNode(buildGapTag());
+      node =
+        (ref && ref.type === ReferenceTag && !ref.value.flags.hasGap) || transparent
+          ? binding.node
+          : buildStubNode(buildGapTag());
+    }
 
-    return isNullNode(node_) ? null : FragmentFacade.wrap(node_, context, transparent);
+    return isNullNode(node)
+      ? null
+      : new FragmentFacade(
+          fragmentNode,
+          context,
+          transparent,
+          isFragmentNode,
+          childrenIndexRange,
+          dotReference,
+          dotIndex,
+        );
   }
 
   has(path) {

package/lib/source.js

@@ -251,7 +251,9 @@ export const Source = class BABLRSource extends WeakStackFrame {
   }
 
   [Symbol.for('@@streamIterator')]() {
-    return this.holding ? emptyStreamIterator : this.fork.clone()[Symbol.for('@@streamIterator')]();
+    return (this.holding ? emptyStreamIterator() : this.fork.clone())[
+      Symbol.for('@@streamIterator')
+    ]();
   }
 
   formatIndex() {