@bablr/bablr-vm 0.22.1 → 0.23.1

package/lib/source.js

@@ -1,5 +1,4 @@
 import { maybeWait, getStreamIterator } from '@bablr/agast-helpers/stream';
-import { facades, actuals } from './facades.js';
 import { streamIteratorSymbol } from '@bablr/stream-iterator';
 
 // Queue item instances are shared between all sources.
@@ -29,9 +28,9 @@ class Exchange {
   }
 
   allocateSource(source) {
-    const { head = this.tail, exchange = this, index, holding, prevValue } = source || {};
+    const { head = this.tail, exchange = this, index, prevValue } = source || {};
     ++this.sources;
-    return new Source(head, exchange, index, holding, prevValue);
+    return new Source(head, exchange, index, prevValue);
   }
 
   releaseSource(source) {
@@ -71,7 +70,7 @@ class SourceIterator {
   static from(source) {
     const { exchange } = source;
     return source.done
-      ? sources.get(source) ?? new SourceIterator(source)
+      ? new SourceIterator(source)
       : new SourceIterator(exchange.allocateSource(source));
   }
 
@@ -82,10 +81,10 @@ class SourceIterator {
   next() {
     const source = sources.get(this);
     if (!source.done) {
-      const { holding, head } = source;
+      const { head } = source;
       source.advance();
       return maybeWait(source.head.step, () => {
-        return holding ? { value: null, done: false } : head.step;
+        return head.step;
       });
     } else {
       return { value: undefined, done: true };
@@ -107,58 +106,23 @@ class SourceIterator {
   }
 }
 
-export const SourceFacade = class BABLRSourceFacade {
-  static from(iterable) {
-    return facades.get(Source.from(iterable));
-  }
-
-  constructor(source) {
-    facades.set(source, this);
-
-    Object.freeze(this);
-  }
-
-  [streamIteratorSymbol]() {
-    return actuals.get(this)[streamIteratorSymbol]();
-  }
-
-  get done() {
-    return actuals.get(this).done;
-  }
-
-  get value() {
-    return actuals.get(this).value;
-  }
-
-  get index() {
-    return actuals.get(this).index;
-  }
-
-  get atGap() {
-    return actuals.get(this).atGap;
-  }
-};
-
 export const Source = class BABLRSource {
   static from(iterable) {
     const exchange = Exchange.from(iterable);
     return exchange.allocateSource();
   }
 
-  constructor(head, exchange, index = -1, holding = false, prevValue = undefined) {
+  constructor(head, exchange, index = -1, prevValue = undefined) {
     if (!head || !exchange) throw new Error();
 
     this.head = head;
     this.exchange = exchange;
     this.index = index;
-    this.holding = holding;
     this.prevValue = prevValue;
-
-    new SourceFacade(this);
   }
 
   get value() {
-    return this.holding ? null : this.head.step?.value;
+    return this.head.step?.value;
   }
 
   get done() {
@@ -166,25 +130,12 @@ export const Source = class BABLRSource {
   }
 
   get atGap() {
-    return this.holding || (!this.done && this.value == null);
-  }
-
-  shift() {
-    this.holding = true;
-  }
-
-  unshift() {
-    this.holding = false;
+    return !this.done && this.value == null;
   }
 
   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) {
@@ -202,6 +153,7 @@ export const Source = class BABLRSource {
             this.head = head = nextItem;
             this.prevValue = value;
 
+            // TODO what if head.step is a promise?
             if (head.step?.done) {
               exchange.releaseSource(this);
             }
@@ -235,7 +187,6 @@ export const Source = class BABLRSource {
   accept(source) {
     this.head = source.head;
     this.index = source.index;
-    this.holding = source.holding;
     this.prevValue = source.prevValue;
 
     source.release();

package/lib/spans.js

@@ -1,85 +1,46 @@
 import { ReferenceTag } from '@bablr/agast-helpers/symbols';
-
-export function updateSpans(m, node, phase) {
+import * as BTree from '@bablr/agast-helpers/btree';
+
+const popSpan = (s) => {
+  s.spans = s.spans.pop();
+};
+
+const pushSpan = (s, type, name, guard) => {
+  let isSubspan = name[0] === '.';
+  let topFrame = s.spans.value;
+
+  // if (isSubspan) {
+  //   let buildGuard = () => {
+  //     return buildPattern();
+  //   };
+  //   let name_ = topFrame.name + name;
+  //   let subframes = BTree.push(topFrame.subframes, topFrame);
+  //   let guard_ = guard;
+
+  //   s.spans = s.spans.push({ type, name: name_, guard: guard_, subframes });
+  // } else {
+  s.spans = s.spans.push({ type, name, guard, subframes: BTree.fromValues([]) });
+  // }
+};
+
+export function updateSpans(m, phase) {
   const { state: s } = m;
-  const { attributes } = node;
   const refPath = m.reference;
 
   if (refPath && refPath.tag.type !== ReferenceTag) throw new Error();
 
-  const intrinsic = !refPath || (refPath.tag.type === ReferenceTag && !refPath.tag.value.hasGap);
-
   switch (phase) {
     case 'open': {
-      const { balancedSpan, span: innerSpan, balanced, balancer, openSpan } = attributes || {};
-
-      if (!intrinsic && (balancer || balanced)) {
-        throw new Error('balanced tokens must be instrinsic');
-      }
-
-      if (balancedSpan && !balanced) throw new Error();
-
-      if (openSpan) {
-        s.spans = s.spans.push({
-          type: 'Explicit',
-          name: openSpan,
-          guard: null,
-        });
-      }
-
-      if (innerSpan) {
-        s.spans = s.spans.push({
-          type: 'Inner',
-          name: innerSpan,
-          guard: null,
-        });
-      }
-
-      if (m.language !== m.parent.language) {
-        s.spans = s.spans.push({ name: 'Bare' });
+      if (m.language !== m.parent?.language) {
+        pushSpan(s, 'Explicit', 'Bare', null);
       }
 
       break;
     }
 
     case 'close': {
-      const { balancedSpan, span: innerSpan, closeSpan, balanced, balancer } = attributes || {};
-
-      if (balanced) {
-        s.balanced = s.balanced.push(node);
-
-        s.spans = s.spans.push({
-          type: 'Lexical',
-          name: balancedSpan || s.span.name,
-          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();
-      }
-
-      if (innerSpan) {
-        s.spans = s.spans.pop();
-      }
-
-      if (m.language !== m.parent.language) {
-        s.spans = s.spans.pop();
+      if (m.language !== m.parent?.language) {
+        popSpan(s);
       }
 
       break;