@bablr/agast-vm 0.1.2 → 0.1.3

package/README.md

@@ -2,19 +2,11 @@
 
 The agAST VM provides consistency guarantees when with CSTML documents to parse or transform code. It has no language-specific functionality of any kind. Instead it acts as a streaming traversal engine for CSTML.
 
-## Why
-
-The goal of this project is to transition editors towards being a lot more like web browsers. You can have many of them, and they can be written in a variety of languages (though many share internals). You can even have a terminal browser like Lynx that does presentation very differently, yet it is still possible (if not trivial) to write a website once that will run on all (er, most) web browsers.
-
-If the parallel is not immediately obvious, try thinking about it this way: a webapp is really more or less a set of automated tools for editing a DOM tree. As programmers we have all these amazing web libraries and frameworks that can exist because at the end of the day everything comes down to editing a shared DOM tree. There's a great explanation of those dynamics here: https://glazkov.com/2024/01/02/the-protocol-force/
-
-If a code-DOM existed and was shared by all IDEs there would spring up a rich ecosystem of tools for accomplishing many kinds of tree alterations. For example it could become common for library authors to publish codemods that could help any project upgrade past breaking changes in its APIs!
-
 ## API
 
-The VM responds to several instructions, but its primary API is `advance(token)`, where `token` may be a `StartFragmentTag`, `EndFragmentTag`, `StartNodeTag`, `EndNodeTag`, `Literal`, `Reference`, or `Gap`.
+The VM responds to several instructions, but its primary API is `advance(token)`, where `token` may be a `OpenFragmentTag`, `CloseFragmentTag`, `OpenNodeTag`, `CloseNodeTag`, `Literal`, `Reference`, or `Gap`.
 
-The VM requires the basic invariants of CSTML to be followed, for example that `Reference` must be followed by either a `StartNodeTag` or a `Gap`. In fact, `agast-vm` is the reference implementation of these invariants.
+The VM requires the basic invariants of CSTML to be followed, for example that `Reference` must be followed by either a `OpenNodeTag` or a `Gap`. In fact, `agast-vm` is the reference implementation of these invariants.
 
 The VM supports `branch()`, `accept()`, and `reject()` instructions, which allow a series of instructions to have their effects applied or discarded together in a kind of transaction.
 
@@ -23,25 +15,20 @@ Finally the VM supports `bindAttribute(key, value)`. A node's attributes start u
 Here are the basic types used by the VM:
 
 ```ts
-type Token = StartFragmentTag | EndFragmentTag | StartNodeTag | EndNodeTag | Literal | Reference | Gap;
+type Token = OpenFragmentTag | CloseFragmentTag | OpenNodeTag | CloseNodeTag | Literal | Reference | Gap;
 
-type StartFragmentTag {
-  type: 'StartFragmentTag',
-  value: {
-    flags: {
-      trivia: boolean
-    },
-    language: string,
-  }
+type OpenFragmentTag {
+  type: 'OpenFragmentTag',
+  value: null
 }
 
-type EndFragmentTag {
-  type: 'EndFragmentTag',
+type CloseFragmentTag {
+  type: 'CloseFragmentTag',
   value: null
 }
 
-type StartNodeTag {
-  type: 'StartNodeTag',
+type OpenNodeTag {
+  type: 'OpenNodeTag',
   value: {
     flags: {
       token: boolean,
@@ -54,9 +41,12 @@ type StartNodeTag {
   }
 }
 
-type EndNodeTag {
-  type: 'EndNodeTag',
-  value: null
+type CloseNodeTag {
+  type: 'CloseNodeTag',
+  value: {
+    language: string,
+    type: string,
+  }
 }
 
 type Literal {

package/lib/evaluate.js

@@ -19,7 +19,7 @@ import { facades } from './facades.js';
 
 export const evaluate = (ctx, strategy) => new StreamIterable(__evaluate(ctx, strategy));
 
-const __evaluate = function* agastStrategy(ctx, strategy) {
+const __evaluate = function* agast(ctx, strategy) {
   let s = State.from(ctx);
 
   const co = new Coroutine(getStreamIterator(strategy(facades.get(ctx), facades.get(s))));
@@ -66,7 +66,7 @@ const __evaluate = function* agastStrategy(ctx, strategy) {
       }
 
       case 'advance': {
-        const { arguments: { 0: terminal } = [] } = instr;
+        const { arguments: { 0: terminal, 1: options } = [] } = instr;
 
         switch (terminal?.type || 'Null') {
           case 'DoctypeTag': {
@@ -163,7 +163,7 @@ const __evaluate = function* agastStrategy(ctx, strategy) {
           case 'OpenFragmentTag': {
             const openTag = buildFragmentOpenTag();
 
-            s.node = Node.from(s.path, openTag);
+            s.node = Node.from(openTag);
 
             yield* s.emit(openTag);
 
@@ -182,16 +182,9 @@ const __evaluate = function* agastStrategy(ctx, strategy) {
 
           case 'OpenNodeTag': {
             const { flags, language, type, intrinsicValue, attributes } = terminal.value;
+            const { unboundAttributes } = options || {};
             const reference = s.result;
-            const boundAttributes = Object.entries(attributes).filter((a) => a[1].type !== 'Gap');
-            const unboundAttributes = Object.entries(attributes).filter((a) => a[1].type === 'Gap');
-            const openTag = buildNodeOpenTag(
-              flags,
-              language,
-              type,
-              intrinsicValue,
-              Object.fromEntries(boundAttributes),
-            );
+            const openTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
 
             if (!flags.trivia && !flags.escape && s.path.depth > 1) {
               if (reference.type !== 'Reference' && reference.type !== 'OpenFragmentTag') {
@@ -199,29 +192,25 @@ const __evaluate = function* agastStrategy(ctx, strategy) {
               }
             }
 
-            if (intrinsicValue && !flags.token) {
-              throw new Error('intrinsic nodes must occur inside tokens');
-            }
+            const { flags: openFlags } = openTag.value;
 
-            if (!flags.expression) {
-              const { flags } = openTag.value;
+            if (!(openFlags.trivia || openFlags.escape) && !s.path.depth) {
+              const tag = buildReference('root', false);
+              s.path = s.path.push(ctx, tag);
+              s.node.resolver.consume(tag);
+            }
 
-              if (!(flags.trivia || flags.escape) && !s.path.depth) {
-                const tag = buildReference('root', false);
-                s.path = s.path.push(ctx, tag);
-                s.node.resolver.consume(tag);
-              }
-            } else if (!intrinsicValue) {
+            if (flags.expression && !flags.intrinsic) {
               s.expressionDepth++;
             }
 
-            const newNode = s.node.push(s.path, openTag);
+            const newNode = s.node.push(openTag);
 
-            newNode.unboundAttributes = new Set(unboundAttributes.map((e) => e[0]));
+            newNode.unboundAttributes = new Set(unboundAttributes);
 
             ctx.tagNodes.set(openTag, newNode);
 
-            if (!flags.intrinsic) {
+            if (!intrinsicValue) {
               s.node = newNode;
             } else {
               s.path = s.path.parent;
@@ -267,6 +256,7 @@ const __evaluate = function* agastStrategy(ctx, strategy) {
             if (!flags.escape && !flags.trivia) {
               const { name: refName, isArray } = s.path.reference.value;
 
+              // is this right?
               if (s.path.depth > 2) {
                 const { properties } = s.node.parent;
 

package/lib/path.js

@@ -97,12 +97,11 @@ export const PathFacade = class AgastPathFacade {
 };
 
 export const Node = class AgastNode extends WeakStackFrame {
-  static from(path, openTag) {
-    return AgastNode.create(path, openTag);
+  static from(openTag) {
+    return AgastNode.create(openTag);
   }
 
   constructor(
-    path,
     openTag,
     closeTag = null,
     properties = new Map(),
@@ -111,7 +110,6 @@ export const Node = class AgastNode extends WeakStackFrame {
   ) {
     super();
 
-    this.path = path;
     this.openTag = openTag;
     this.closeTag = closeTag;
     this.properties = properties;
@@ -119,10 +117,6 @@ export const Node = class AgastNode extends WeakStackFrame {
     this.unboundAttributes = unboundAttributes;
   }
 
-  get context() {
-    return this.path.context;
-  }
-
   get language() {
     return this.openTag.value?.language;
   }
@@ -140,10 +134,9 @@ export const Node = class AgastNode extends WeakStackFrame {
   }
 
   branch() {
-    const { path, openTag, closeTag, properties, resolver, unboundAttributes } = this;
+    const { openTag, closeTag, properties, resolver, unboundAttributes } = this;
 
-    return this.push(
-      path,
+    return this.replace(
       openTag,
       closeTag,
       new Map(properties), // there is probably a better way

package/lib/state.js

@@ -182,6 +182,7 @@ export const State = class AgastState extends WeakStackFrame {
 
     parent.result = this.result;
     parent.held = this.held;
+    parent.path = this.path;
     parent.expressionDepth = this.expressionDepth;
 
     return parent;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -15,8 +15,8 @@
     "test": "node ./test/runner.js"
   },
   "dependencies": {
-    "@bablr/agast-helpers": "0.1.1",
-    "@bablr/agast-vm-helpers": "0.1.1",
+    "@bablr/agast-helpers": "0.1.5",
+    "@bablr/agast-vm-helpers": "0.1.3",
     "@bablr/coroutine": "0.1.0",
     "@bablr/weak-stack": "0.1.0"
   },