@bablr/bablr-vm 0.18.1 → 0.19.0

package/lib/node.js

@@ -1,97 +1,226 @@
-import { parsePath } from '@bablr/agast-helpers/path';
-import { ReferenceTag } from '@bablr/agast-helpers/symbols';
 import {
+  buildCloseNodeTag,
   buildGapTag,
+  buildOpenNodeTag,
+  buildReferenceTag,
   buildStubNode,
-  get,
-  getCloseTag,
-  getOpenTag,
+  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 { Pump } from './utils/pump.js';
+import { OpenNodeTag, ReferenceTag } from '@bablr/agast-helpers/symbols';
+import { get, getProperties } from '@bablr/agast-helpers/path';
+import { isArray } from '@bablr/helpers/object';
+
+export const states = new WeakMap();
+export const internalStates = new WeakMap();
 
 const { hasOwn } = Object;
 
-export const contexts = new WeakMap();
-export const actuals = new WeakMap();
-// eslint-disable-next-line no-undef
-export const transparentFacades = new WeakSet();
+const buildFullRange = (node) => {
+  const sum = btree.getSum(node.children);
+  return sum ? [0, sum - 1] : null;
+};
 
-export const NodeFacade = class BABLRNodeFacade {
-  static wrap(node, context, transparent) {
-    if (!node || !context) throw new Error();
-    return node && new NodeFacade(node, context, transparent);
+export const FragmentFacade = class BABLRFragmentFacade {
+  static wrap(
+    node,
+    context,
+    transparent = false,
+    childrenIndexRange = node && buildFullRange(node),
+    dotPropertyName = null,
+    dotPropertyIndex = null,
+  ) {
+    return (
+      node &&
+      new FragmentFacade(
+        node,
+        context,
+        transparent,
+        childrenIndexRange,
+        dotPropertyName,
+        dotPropertyIndex,
+      )
+    );
   }
 
-  constructor(node, context, transparent) {
-    actuals.set(this, node);
-    contexts.set(this, context);
-    if (transparent) {
-      transparentFacades.add(this);
+  constructor(node, context, transparent, childrenIndexRange, dotPropertyName, dotPropertyIndex) {
+    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 (isArray(node.properties[dotPropertyName]) && dotPropertyIndex == null) throw new Error();
+
+    states.set(this, {
+      context,
+      openTag: buildOpenNodeTag(),
+      closeTag: buildCloseNodeTag(),
+      node,
+      transparent,
+      childrenIndexRange,
+      dotPropertyName,
+      dotPropertyIndex,
+    });
   }
 
   get isTransparent() {
-    return transparentFacades.has(this);
+    return states.get(this).transparent;
+  }
+
+  get isFragmentNode() {
+    return isFragmentNode(states.get(this).node);
   }
 
   get children() {
-    const node = actuals.get(this);
-    const isTransparent = transparentFacades.has(this);
+    const { node, transparent, childrenIndexRange } = states.get(this);
+
     return {
       *[Symbol.iterator]() {
-        if (isTransparent) {
-          yield* btree.traverse(node.children);
-        } else {
-          for (const child of btree.traverse(node.children)) {
-            const interpolated = false; // TODO
-            if (!interpolated) {
-              yield child;
-            }
+        for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
+          const interpolated = false; // TODO
+          if (!interpolated || transparent) {
+            yield btree.getAt(i, node.children);
           }
         }
       },
     };
   }
 
+  getRootIndex() {
+    const { node, dotPropertyName, childrenIndexRange } = states.get(this);
+
+    if (!childrenIndexRange) return null;
+
+    if (childrenIndexRange[0] > childrenIndexRange[1]) throw new Error();
+
+    for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
+      let tag = btree.getAt(i, node.children);
+      if (tag.type === ReferenceTag) {
+        const { name, isArray } = tag.value;
+        let resolvedTagName = name === '.' ? dotPropertyName : name;
+
+        if (resolvedTagName === dotPropertyName) {
+          return i;
+        }
+      }
+    }
+
+    return null;
+  }
+
   get flags() {
-    return actuals.get(this).flags;
+    const { openTag } = this;
+
+    return openTag.type === OpenNodeTag ? openTag.value.flags : null;
   }
 
   get language() {
-    return actuals.get(this).language;
+    let { node } = states.get(this);
+
+    return node.language;
   }
 
   get type() {
-    return actuals.get(this).type;
+    let { node } = states.get(this);
+
+    return node.type;
   }
 
   get attributes() {
-    return actuals.get(this).attributes;
+    let { node } = states.get(this);
+
+    return node.attributes;
   }
 
   get openTag() {
-    return getOpenTag(actuals.get(this));
+    const state = states.get(this);
+    const { children } = state.node;
+
+    return state.openTag || btree.getAt(0, children);
   }
 
   get closeTag() {
-    return getCloseTag(actuals.get(this));
+    const state = states.get(this);
+    const { children } = state.node;
+
+    return state.closeTag || btree.getAt(btree.getSum(children) - 1, children);
   }
 
   get(path) {
-    const context = contexts.get(this);
-    const node = get(actuals.get(this), path);
-    const isTransparent = transparentFacades.has(this);
+    let {
+      node,
+      context,
+      transparent,
+      dotPropertyName,
+      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
+
+    if (dotPropertyName) {
+      let dotReference = buildReferenceTag(
+        dotPropertyName,
+        dotIndex != null,
+        referenceFlags,
+        dotIndex,
+      );
+
+      node = get(dotReference, node);
+    }
+
+    const binding = getProperties(parsedRef, node.properties);
+
+    if (!binding) return null;
+
+    const ref = binding.reference;
 
-    const ref = node && context.agast.getPreviousTag(btree.getAt(0, node.children));
     const node_ =
-      (ref && ref.type === ReferenceTag && !ref.value.hasGap) || isTransparent
-        ? node
+      (ref && ref.type === ReferenceTag && !ref.value.flags.hasGap) || transparent
+        ? binding.node
         : buildStubNode(buildGapTag());
 
-    return node && NodeFacade.wrap(node_, context, isTransparent);
+    return isNullNode(node_) ? null : FragmentFacade.wrap(node_, context, transparent);
   }
 
   has(path) {
-    return hasOwn(actuals.get(this).properties, parsePath(path).name);
+    return hasOwn(states.get(this).node.properties, parseReference(path).value.name);
   }
 };
+
+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;
+};

package/lib/source.js

@@ -187,8 +187,8 @@ export const Source = class BABLRSource extends WeakStackFrame {
     return Source.create(exchange.allocateFork(), exchange);
   }
 
-  constructor(fork, exchange, index = -1, holding = false) {
-    super();
+  constructor(parent, fork, exchange, index = -1, holding = false) {
+    super(parent);
 
     if (!fork || !exchange) throw new Error();
 

package/lib/spans.js

@@ -1,14 +1,16 @@
 import { ReferenceTag } from '@bablr/agast-helpers/symbols';
 import { getOpenTag } from '@bablr/agast-helpers/tree';
 
-export function updateSpans(ctx, s, node, phase) {
+export function updateSpans(m, node, phase) {
+  const { state: s } = m;
   const { flags, attributes } = node;
+  const refPath = m.reference;
 
-  const openTag = getOpenTag(node);
+  if (refPath && refPath.tag.type !== ReferenceTag) throw new Error();
 
-  const ref = ctx.agast.getPreviousTag(openTag);
+  const openTag = getOpenTag(node);
 
-  const intrinsic = ref.type === ReferenceTag && !ref.hasGap;
+  const intrinsic = !refPath || (refPath.tag.type === ReferenceTag && !refPath.tag.value.hasGap);
 
   switch (phase) {
     case 'open': {
@@ -24,51 +26,52 @@ export function updateSpans(ctx, s, node, phase) {
         s.spans = s.spans.push({
           type: 'Explicit',
           name: openSpan,
-          path: s.path,
           guard: null,
         });
       }
 
-      if (balancer) {
-        const balancedNode = s.balanced.value;
-
-        if (!s.balanced.size) throw new Error();
-
-        if (!balancedNode.attributes.balanced) {
-          throw new Error();
-        }
-
-        s.balanced = s.balanced.pop();
-
-        s.spans = s.spans.pop();
-      }
-
       if (innerSpan) {
         s.spans = s.spans.push({
           type: 'Inner',
           name: innerSpan,
-          path: s.path,
           guard: null,
         });
       }
 
+      if (m.language !== m.parent.language) {
+        s.spans = s.spans.push({ name: 'Bare' });
+      }
+
       break;
     }
 
     case 'close': {
-      const { balancedSpan, span: innerSpan, closeSpan, balanced } = attributes || {};
+      const { balancedSpan, span: innerSpan, closeSpan, balanced, balancer } = attributes || {};
 
       if (balanced) {
-        s.balanced = s.balanced.push(s.nodeForTag(s.result));
+        s.balanced = s.balanced.push(node);
 
         s.spans = s.spans.push({
           type: 'Lexical',
           name: balancedSpan || s.span.name,
-          path: s.path,
           guard: balanced === true ? null : balanced,
         });
       }
 
+      if (balancer) {
+        const balancedNode = s.balanced.value;
+
+        if (!s.balanced.size) throw new Error();
+
+        if (!balancedNode.attributes.balanced) {
+          throw new Error();
+        }
+
+        s.balanced = s.balanced.pop();
+
+        s.spans = s.spans.pop();
+      }
+
       if (closeSpan) {
         if (s.spans.value.type !== 'Explicit') throw new Error();
         s.spans = s.spans.pop();
@@ -77,6 +80,11 @@ export function updateSpans(ctx, s, node, phase) {
       if (innerSpan) {
         s.spans = s.spans.pop();
       }
+
+      if (m.language !== m.parent.language) {
+        s.spans = s.spans.pop();
+      }
+
       break;
     }
     default: