@bablr/bablr-vm 0.20.1 → 0.22.0

package/lib/node.js

@@ -1,36 +1,34 @@
 import {
+  buildBindingTag,
   buildCloseNodeTag,
   buildGapTag,
   buildOpenNodeTag,
   buildReferenceTag,
   buildStubNode,
+  fragmentFlags,
   isNullNode,
-  parseReference,
 } from '@bablr/agast-helpers/tree';
-import { getStreamIterator } from '@bablr/agast-helpers/stream';
-import { agast } from '@bablr/agast-vm';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
-import { Pump } from './utils/pump.js';
-import { OpenNodeTag, ReferenceTag } from '@bablr/agast-helpers/symbols';
+import { NullTag, OpenNodeTag, PropertyWrapper, ReferenceTag } from '@bablr/agast-helpers/symbols';
 import {
+  buildFullPathSegment,
   buildFullRange,
-  get,
-  getProperties,
-  getPropertyChildrenIndex,
+  buildPathSegment,
+  buildTypePathSegment,
 } from '@bablr/agast-helpers/path';
-import { isArray } from '@bablr/helpers/object';
+import { hasOwn, isArray } from '@bablr/helpers/object';
 
 export const states = new WeakMap();
-export const internalStates = new WeakMap();
 
-const { hasOwn } = Object;
+export const isFragmentNode = (node) => {
+  return node.type === null && node.sigilTag.type === OpenNodeTag;
+};
 
 export const FragmentFacade = class BABLRFragmentFacade {
   static wrapNode(
     node,
     context,
     transparent = false,
-    childrenIndexRange = null,
+    tagsIndexRange = null,
     dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
@@ -41,7 +39,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
         context,
         transparent,
         false,
-        childrenIndexRange,
+        tagsIndexRange,
         dotPropertyReference,
         dotPropertyIndex,
       )
@@ -52,7 +50,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
     node,
     context,
     transparent = false,
-    childrenIndexRange = null,
+    tagsIndexRange = null,
     dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
@@ -63,7 +61,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
         context,
         transparent,
         true,
-        childrenIndexRange,
+        tagsIndexRange,
         dotPropertyReference,
         dotPropertyIndex,
       )
@@ -74,47 +72,49 @@ export const FragmentFacade = class BABLRFragmentFacade {
     node,
     context,
     transparent = false,
-    isFragmentNode = true,
-    childrenIndexRange = null,
+    isFragmentFacade = true,
+    tagsIndexRange = null,
     dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
-    if (!node) throw new Error();
+    if (!node || hasOwn(node, 'tags')) throw new Error();
+    if (isNaN(dotPropertyIndex)) throw new Error();
 
-    if (childrenIndexRange && (childrenIndexRange[0] == null || !childrenIndexRange[1] == null)) {
+    if (tagsIndexRange && (tagsIndexRange[0] == null || !tagsIndexRange[1] == null)) {
       throw new Error();
     }
 
     if (!context) throw new Error();
 
-    if (dotPropertyReference && !hasOwn(node.properties, dotPropertyReference.value.name))
-      throw new Error();
+    if (dotPropertyReference && !node.properties.get(dotPropertyReference.name)) throw new Error();
 
-    if (isArray(dotPropertyReference?.value.isArray && dotPropertyIndex == null)) throw new Error();
+    if (dotPropertyReference?.isArray && dotPropertyIndex == null) throw new Error();
 
     let resolvedNode = node;
     let fragmentNode = node;
 
     if (dotPropertyReference) {
-      let { name, isArray, flags } = dotPropertyReference.value;
+      let { type, name } = dotPropertyReference;
 
-      let dotReference = buildReferenceTag(name, isArray, flags, dotPropertyIndex);
-
-      resolvedNode = get(dotReference, fragmentNode);
+      resolvedNode = fragmentNode.get(buildFullPathSegment(type, name, dotPropertyIndex));
     }
 
+    if (dotPropertyReference?.value) throw new Error();
+
     states.set(this, {
       context,
-      openTag: buildOpenNodeTag(),
+      openTag: buildOpenNodeTag(fragmentFlags),
       closeTag: buildCloseNodeTag(),
       node: resolvedNode,
-      fragmentNode: node,
+      fragmentNode,
       transparent,
-      isFragmentNode,
-      childrenIndexRange,
+      isFragmentFacade,
+      tagsIndexRange,
       dotPropertyReference,
       dotPropertyIndex,
     });
+
+    Object.freeze(this);
   }
 
   get dotPropertyName() {
@@ -127,21 +127,26 @@ export const FragmentFacade = class BABLRFragmentFacade {
 
   get isNull() {
     let { node } = states.get(this);
-    return isNullNode(node);
+    return node.sigilTag.type === NullTag;
   }
 
-  get children() {
-    let { node, isFragmentNode, transparent, childrenIndexRange } = states.get(this);
+  get tagsInner() {
+    let { node, isFragmentNode, transparent, tagsIndexRange } = states.get(this);
 
-    childrenIndexRange =
-      isFragmentNode || !childrenIndexRange ? buildFullRange(node) : childrenIndexRange;
+    tagsIndexRange = isFragmentNode || !tagsIndexRange ? buildFullRange(node) : tagsIndexRange;
 
     return {
       *[Symbol.iterator]() {
-        for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
-          const interpolated = false; // TODO
-          if (!interpolated || transparent) {
-            yield sumtree.getAt(i, node.children);
+        for (let tag of node.tags) {
+          if (tag.type === PropertyWrapper) {
+            let { property, tags } = tag.value;
+            if (transparent || !property.reference.flags.hasGap) {
+              yield* tags;
+            } else {
+              yield buildReferenceTag(property.reference);
+              yield buildBindingTag();
+              yield buildGapTag();
+            }
           }
         }
       },
@@ -149,14 +154,14 @@ export const FragmentFacade = class BABLRFragmentFacade {
   }
 
   getRootIndex() {
-    const { node, dotPropertyName, childrenIndexRange } = states.get(this);
+    const { node, dotPropertyName, tagsIndexRange } = states.get(this);
 
-    if (!childrenIndexRange) return null;
+    if (!tagsIndexRange) return null;
 
-    if (childrenIndexRange[0] > childrenIndexRange[1]) throw new Error();
+    if (tagsIndexRange[0] > tagsIndexRange[1]) throw new Error();
 
-    for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
-      let tag = sumtree.getAt(i, node.children);
+    for (let i = tagsIndexRange[0]; i <= tagsIndexRange[1]; i++) {
+      let tag = node.tags.at(i);
       if (tag.type === ReferenceTag) {
         const { name, isArray } = tag.value;
         let resolvedTagName = name === '.' ? dotPropertyName : name;
@@ -171,41 +176,36 @@ export const FragmentFacade = class BABLRFragmentFacade {
   }
 
   get flags() {
-    const { openTag } = this;
-
-    return openTag.type === OpenNodeTag ? openTag.value.flags : null;
-  }
-
-  get language() {
-    let { node, isFragmentNode } = states.get(this);
+    const { node } = states.get(this);
+    let openTag = node.sigilTag;
 
-    return isFragmentNode ? null : node.language;
+    return openTag?.value.flags;
   }
 
   get type() {
-    let { node, isFragmentNode } = states.get(this);
+    let { node } = states.get(this);
+    let openTag = node.sigilTag;
 
-    return isFragmentNode ? null : node.type;
+    return openTag?.value.type;
   }
 
   get attributes() {
-    let { node, isFragmentNode } = states.get(this);
+    let { node } = states.get(this);
+    let openTag = node.sigilTag;
 
-    return isFragmentNode ? {} : node.attributes;
+    return openTag?.value.attributes;
   }
 
   get openTag() {
-    const { node, openTag, isFragmentNode } = states.get(this);
+    const { node, openTag, isFragmentFacade } = states.get(this);
 
-    return isFragmentNode ? openTag : sumtree.getAt(0, node.children);
+    return isFragmentNode(node) ? node.tags.at(1) : isFragmentFacade ? openTag : node.tags.at(0);
   }
 
   get closeTag() {
-    const { node, closeTag, isFragmentNode } = states.get(this);
+    const { node, closeTag, isFragmentFacade } = states.get(this);
 
-    return isFragmentNode
-      ? closeTag
-      : sumtree.getAt(sumtree.getSize(node.children) - 1, node.children);
+    return isFragmentFacade ? (isFragmentNode(node) ? node.closeTag : closeTag) : node.tags.at(-1);
   }
 
   merge(targetFragment) {
@@ -213,12 +213,11 @@ export const FragmentFacade = class BABLRFragmentFacade {
       fragmentNode,
       context,
       transparent,
-      isFragmentNode,
-      childrenIndexRange,
+      isFragmentFacade,
       dotPropertyReference,
       dotPropertyIndex,
     } = states.get(this);
-    const { fragmentNode: targetFragmentNode, childrenIndexRange: targetChildrenIndexRange } =
+    const { fragmentNode: targetFragmentNode, tagsIndexRange: targetTagsIndexRange } =
       states.get(targetFragment);
     if (fragmentNode === targetFragmentNode) {
       // TODO restrict what is legal here
@@ -227,8 +226,8 @@ export const FragmentFacade = class BABLRFragmentFacade {
         fragmentNode,
         context,
         transparent,
-        isFragmentNode,
-        targetChildrenIndexRange,
+        isFragmentFacade,
+        targetTagsIndexRange,
         dotPropertyReference,
         dotPropertyIndex,
       );
@@ -240,85 +239,89 @@ export const FragmentFacade = class BABLRFragmentFacade {
   get(path) {
     let {
       node: ownNode,
-      fragmentNode,
       context,
       transparent,
-      isFragmentNode,
-      childrenIndexRange,
+      isFragmentFacade,
+      tagsIndexRange,
       dotPropertyReference: dotReference,
       dotPropertyIndex: dotIndex,
     } = states.get(this);
-    const parsedRef = parseReference(path);
 
-    let node = fragmentNode;
+    if (typeof path === 'string') {
+      path = [path];
+    }
+
+    if (!isArray(path)) throw new Error();
 
-    if (parsedRef.value.name !== '.') {
-      if (dotReference) {
-        fragmentNode = ownNode;
-        dotReference = parsedRef;
+    let node = ownNode;
+    let ref = dotReference;
+    let index = dotIndex;
+    let outerNode;
 
-        isFragmentNode = false;
-      } else {
-        dotReference = parsedRef;
-        dotIndex = parsedRef.value.index;
+    for (let i = 0; i < path.length; i++) {
+      let name = path[i];
+      let seg = typeof name === 'string' ? buildPathSegment(name) : name;
+      outerNode = node;
+
+      node = node.get(seg);
+      if (node?.sigilTag.type === NullTag) {
+        node = null;
       }
 
-      let { name, isArray, flags } = parsedRef.value;
-      let resolvedReference = buildReferenceTag(name, isArray, flags, dotIndex);
-      let refIndex = getPropertyChildrenIndex(fragmentNode, resolvedReference);
-      childrenIndexRange = [refIndex, refIndex + 1];
+      if (!node) break;
+      let refIndex = outerNode.getPropertyTagsIndex(null, seg.name, seg.index);
+      tagsIndexRange = [refIndex, refIndex];
+
+      let boundRef = outerNode.properties.referenceAt(seg.name, seg.index);
 
-      const binding = getProperties(parsedRef, fragmentNode.properties);
+      if (!node) return null;
 
-      if (!binding) return null;
+      let arraySize = outerNode.countList(seg.name);
 
-      const ref = binding.reference;
+      ref = boundRef;
+      index = seg.index < 0 ? arraySize + seg.index : seg.index;
 
       node =
-        (ref && ref.type === ReferenceTag && !ref.value.flags.hasGap) || transparent
-          ? binding.node
+        (ref && ref.type === ReferenceTag && !ref.flags.hasGap) || transparent
+          ? node
           : buildStubNode(buildGapTag());
     }
 
-    return isNullNode(node)
+    return !node || isNullNode(node)
       ? null
       : new FragmentFacade(
-          fragmentNode,
+          outerNode,
           context,
           transparent,
-          isFragmentNode,
-          childrenIndexRange,
-          dotReference,
-          dotIndex,
+          isFragmentFacade,
+          tagsIndexRange,
+          ref,
+          index,
         );
   }
 
   has(path) {
-    return hasOwn(states.get(this).node.properties, parseReference(path).value.name);
+    let node = states.get(this).node;
+    let path_ = path;
+    if (typeof path === 'string') {
+      path_ = [path];
+    }
+
+    if (!isArray(path_)) throw new Error();
+
+    for (let i = 0; i < path_.length; i++) {
+      if (!node.properties.has(path_[i])) return false;
+      if (i < path.length - 1) {
+        node = node.properties.get(path_[i]);
+      }
+    }
+
+    return true;
+  }
+
+  hasRoot() {
+    return this.type != null ? false : !!states.get(this).node.get([buildTypePathSegment('.')]);
   }
 };
 
 Object.seal(FragmentFacade);
-
-export const buildInternalState = () => {
-  let instructionsPump = new Pump();
-  let expressionsPump = new Pump();
-  let agastState = null;
-  let agast_ = getStreamIterator(
-    agast(
-      (ctx, s) => {
-        agastState = s;
-        return instructionsPump;
-      },
-      { expressions: expressionsPump },
-    ),
-  );
-  let internalState = {
-    instructionsPump,
-    expressionsPump,
-    agastState,
-    agast: agast_,
-    path: agastState.path,
-  };
-  return internalState;
-};