@bablr/bablr-vm 0.20.0 → 0.21.0

package/lib/node.js

@@ -2,28 +2,24 @@ import {
   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, 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(
@@ -74,12 +70,12 @@ export const FragmentFacade = class BABLRFragmentFacade {
     node,
     context,
     transparent = false,
-    isFragmentNode = true,
+    isFragmentFacade = true,
     childrenIndexRange = null,
     dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
-    if (!node) throw new Error();
+    if (!node || hasOwn(node, 'properties')) throw new Error();
 
     if (childrenIndexRange && (childrenIndexRange[0] == null || !childrenIndexRange[1] == null)) {
       throw new Error();
@@ -87,34 +83,35 @@ export const FragmentFacade = class BABLRFragmentFacade {
 
     if (!context) throw new Error();
 
-    if (dotPropertyReference && !hasOwn(node.properties, dotPropertyReference.value.name))
-      throw new Error();
+    if (dotPropertyReference && !node.properties.at(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,
+      isFragmentFacade,
       childrenIndexRange,
       dotPropertyReference,
       dotPropertyIndex,
     });
+
+    Object.freeze(this);
   }
 
   get dotPropertyName() {
@@ -127,7 +124,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
 
   get isNull() {
     let { node } = states.get(this);
-    return isNullNode(node);
+    return node.sigilTag.type === NullTag;
   }
 
   get children() {
@@ -141,7 +138,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
         for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
           const interpolated = false; // TODO
           if (!interpolated || transparent) {
-            yield sumtree.getAt(i, node.children);
+            yield node.children.at(i);
           }
         }
       },
@@ -156,7 +153,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 = sumtree.getAt(i, node.children);
+      let tag = node.children.at(i);
       if (tag.type === ReferenceTag) {
         const { name, isArray } = tag.value;
         let resolvedTagName = name === '.' ? dotPropertyName : name;
@@ -171,41 +168,44 @@ 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.children.at(1)
+      : isFragmentFacade
+      ? openTag
+      : node.children.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.children.at(-1);
   }
 
   merge(targetFragment) {
@@ -213,8 +213,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
       fragmentNode,
       context,
       transparent,
-      isFragmentNode,
-      childrenIndexRange,
+      isFragmentFacade,
       dotPropertyReference,
       dotPropertyIndex,
     } = states.get(this);
@@ -227,7 +226,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
         fragmentNode,
         context,
         transparent,
-        isFragmentNode,
+        isFragmentFacade,
         targetChildrenIndexRange,
         dotPropertyReference,
         dotPropertyIndex,
@@ -240,85 +239,87 @@ export const FragmentFacade = class BABLRFragmentFacade {
   get(path) {
     let {
       node: ownNode,
-      fragmentNode,
       context,
       transparent,
-      isFragmentNode,
+      isFragmentFacade,
       childrenIndexRange,
       dotPropertyReference: dotReference,
       dotPropertyIndex: dotIndex,
     } = states.get(this);
-    const parsedRef = parseReference(path);
 
-    let node = fragmentNode;
+    if (typeof path === 'string') {
+      path = [path];
+    }
 
-    if (parsedRef.value.name !== '.') {
-      if (dotReference) {
-        fragmentNode = ownNode;
-        dotReference = parsedRef;
+    if (!isArray(path)) throw new Error();
 
-        isFragmentNode = false;
-      } else {
-        dotReference = parsedRef;
-        dotIndex = parsedRef.value.index;
+    let node = ownNode;
+    let ref = dotReference;
+    let index = dotIndex;
+    let outerNode;
+
+    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.getPropertyChildrenIndex(null, seg.name, seg.index);
+      childrenIndexRange = [refIndex, refIndex + 2];
 
-      const binding = getProperties(parsedRef, fragmentNode.properties);
+      let boundRef = outerNode.properties.referenceAt(seg.name, seg.index);
 
-      if (!binding) return null;
+      if (!node) return null;
 
-      const ref = binding.reference;
+      ref = boundRef;
+      index = seg.index === -1 ? outerNode.properties.at(seg.name).size + 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,
+          isFragmentFacade,
           childrenIndexRange,
-          dotReference,
-          dotIndex,
+          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.at(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;
-};

package/lib/source.js

@@ -1,8 +1,14 @@
-import { WeakStackFrame } from '@bablr/weak-stack';
-import { maybeWait, getStreamIterator, emptyStreamIterator } from '@bablr/agast-helpers/stream';
+import { maybeWait, getStreamIterator, StreamIterable } from '@bablr/agast-helpers/stream';
 import { facades, actuals } from './facades.js';
 
-// Queue item instances are shared between all forks.
+function* __concat(...iterables) {
+  for (let iter of iterables) {
+    yield* getStreamIterator(iter);
+  }
+}
+const concat = (...iterables) => new StreamIterable(__concat(...iterables));
+
+// Queue item instances are shared between all sources.
 class QueueItem {
   constructor(step) {
     this.step = step;
@@ -17,7 +23,7 @@ class Exchange {
     this.iterator = iterator;
     this.tail = new QueueItem(null);
     this.head = this.tail;
-    this.forks = 0;
+    this.sources = 0;
   }
 
   static from(iterable) {
@@ -28,10 +34,19 @@ class Exchange {
     return this.head.step instanceof Promise;
   }
 
-  allocateFork(fork) {
-    const { head = this.tail, exchange = this, current } = fork || {};
-    ++this.forks;
-    return new Fork(head, exchange, current);
+  allocateSource(source) {
+    const { head = this.tail, exchange = this, index, holding } = source || {};
+    ++this.sources;
+    return new Source(head, exchange, index, holding);
+  }
+
+  releaseSource(source) {
+    --this.sources;
+    if (this.sources === 0) {
+      this.iterator.return?.();
+    }
+    source.exchange = null;
+    return { value: undefined, done: true };
   }
 
   advance() {
@@ -44,7 +59,6 @@ class Exchange {
     if (step instanceof Promise) {
       step = step.then((step) => {
         newItem.step = step;
-        return step;
       });
     }
 
@@ -55,99 +69,47 @@ class Exchange {
 
     return newItem;
   }
+}
 
-  releaseFork(fork) {
-    --this.forks;
-    if (this.forks === 0) {
-      this.iterator.return?.();
-    }
-    return { value: undefined, done: true };
+let sources = new WeakMap();
+
+class SourceIterator {
+  static from(source) {
+    const { exchange } = source;
+    return source.done
+      ? sources.get(source) ?? new SourceIterator(source)
+      : new SourceIterator(exchange.allocateSource(source));
   }
-}
 
-class ForkIterator {
-  constructor(fork) {
-    facades.set(fork.clone(), this);
+  constructor(source) {
+    sources.set(this, source);
   }
 
   next() {
-    const fork = actuals.get(this);
-    if (!fork.done) {
-      const { head } = fork;
-      fork.advance();
-      return maybeWait(fork.head.step, () => head.step);
+    const source = sources.get(this);
+    if (!source.done) {
+      const { holding, head } = source;
+      source.advance();
+      return maybeWait(source.head.step, () => {
+        return holding ? { value: null, done: false } : head.step;
+      });
     } else {
       return { value: undefined, done: true };
     }
   }
 
   return() {
-    actuals.get(this).return();
+    sources.get(this).release();
+
     return { value: undefined, done: true };
   }
 
-  [Symbol.for('@@streamIterator')]() {
+  [Symbol.iterator]() {
     return this;
   }
-}
-
-class Fork {
-  constructor(head, exchange, done = false) {
-    this.head = head; // QueueItem
-    this.exchange = exchange;
-    this._done = done;
-  }
-
-  get done() {
-    return this._done || this.head.step?.done;
-  }
-
-  get value() {
-    return this.done ? { value: undefined, done: true } : this.head.step?.value;
-  }
-
-  advance() {
-    const { exchange } = this;
-
-    if (this.done) {
-      throw new Error('cannot advance a fork that is done');
-    } else {
-      let { head } = this;
-
-      let nextItem = this.head.next;
-
-      if (!head.step?.done) {
-        if (!nextItem) {
-          nextItem = exchange.fetch();
-        }
-
-        this.head = nextItem;
-      }
-
-      return nextItem;
-    }
-  }
-
-  return() {
-    const { done, exchange } = this;
-
-    if (!done) exchange.releaseFork(this);
-
-    const step = { value: undefined, done: true };
-
-    this._current = step;
-
-    return step;
-  }
-
-  clone() {
-    const { exchange } = this;
-
-    return exchange.allocateFork(this);
-  }
 
   [Symbol.for('@@streamIterator')]() {
-    return new ForkIterator(this);
+    return this;
   }
 }
 
@@ -158,6 +120,8 @@ export const SourceFacade = class BABLRSourceFacade {
 
   constructor(source) {
     facades.set(source, this);
+
+    Object.freeze(this);
   }
 
   [Symbol.for('@@streamIterator')]() {
@@ -181,18 +145,16 @@ export const SourceFacade = class BABLRSourceFacade {
   }
 };
 
-export const Source = class BABLRSource extends WeakStackFrame {
+export const Source = class BABLRSource {
   static from(iterable) {
     const exchange = Exchange.from(iterable);
-    return Source.create(exchange.allocateFork(), exchange);
+    return exchange.allocateSource();
   }
 
-  constructor(parent, fork, exchange, index = -1, holding = false) {
-    super(parent);
+  constructor(head, exchange, index = -1, holding = false) {
+    if (!head || !exchange) throw new Error();
 
-    if (!fork || !exchange) throw new Error();
-
-    this.fork = fork;
+    this.head = head;
     this.exchange = exchange;
     this.index = index;
     this.holding = holding;
@@ -201,27 +163,17 @@ export const Source = class BABLRSource extends WeakStackFrame {
   }
 
   get value() {
-    return this.holding ? null : this.fork.value;
+    return this.holding ? null : this.head.step?.value;
   }
 
   get done() {
-    return this.fork.done;
+    return !this.exchange || this.head.step?.done;
   }
 
   get atGap() {
     return this.holding || (!this.done && this.value == null);
   }
 
-  advance(n = 1) {
-    return new Array(n).fill(null).reduce((acc) => {
-      return maybeWait(acc, () => {
-        this.fork.advance();
-        this.index++;
-        return this.fork.step;
-      });
-    }, this.fork.step);
-  }
-
   shift() {
     this.holding = true;
   }
@@ -230,30 +182,78 @@ export const Source = class BABLRSource extends WeakStackFrame {
     this.holding = false;
   }
 
+  advance(n = 1) {
+    let { exchange } = this;
+
+    if (this.holding) {
+      this.holding = false;
+      n--;
+    }
+
+    return new Array(n).fill(null).reduce((acc) => {
+      return maybeWait(acc, () => {
+        if (this.done) {
+          throw new Error('cannot advance a source that is done');
+        } else {
+          let { head } = this;
+
+          let nextItem = head.next;
+
+          if (!this.done) {
+            if (!nextItem) {
+              nextItem = exchange.fetch();
+            }
+
+            this.head = head = nextItem;
+
+            if (head.step?.done) {
+              exchange.releaseSource(this);
+            }
+          }
+        }
+
+        this.index++;
+        return this.head.step;
+      });
+    }, this.head.step);
+  }
+
   branch() {
-    const { fork, exchange, index, holding } = this;
-    return this.push(exchange.allocateFork(fork), exchange, index, holding);
+    const { exchange } = this;
+
+    return exchange ? exchange.allocateSource(this) : this;
   }
 
   release() {
-    this.fork.return();
+    const { exchange, head } = this;
+
+    if (exchange) exchange.releaseSource(this);
+
+    const step = { value: undefined, done: true };
+
+    this.head = { ...head, step };
+
+    return step;
   }
 
   accept(source) {
-    this.release();
-    this.fork = source.fork;
+    this.head = source.head;
     this.index = source.index;
     this.holding = source.holding;
+
+    source.release();
   }
 
   reject() {
     this.release();
   }
 
+  [Symbol.iterator]() {
+    return SourceIterator.from(this);
+  }
+
   [Symbol.for('@@streamIterator')]() {
-    return (this.holding ? emptyStreamIterator() : this.fork.clone())[
-      Symbol.for('@@streamIterator')
-    ]();
+    return SourceIterator.from(this);
   }
 
   formatIndex() {