@bablr/agast-vm-helpers 0.6.1 → 0.7.1

package/lib/builders.js

@@ -0,0 +1,69 @@
+import {
+  EmbeddedNode,
+  EmbeddedMatcher,
+  EmbeddedRegex,
+  EmbeddedTag,
+  EmbeddedObject,
+  EmbeddedInstruction,
+} from './symbols.js';
+
+const isObject = (val) => val !== null && typeof val === 'object';
+
+const { freeze } = Object;
+
+export const buildCall = (verb, ...args) => {
+  return freeze({ verb, arguments: freeze(args) });
+};
+
+export const buildEmbeddedObject = (obj) => {
+  if (!isObject(obj)) throw new Error();
+  return freeze({ type: EmbeddedObject, value: freeze(obj) });
+};
+
+export const buildEmbeddedMatcher = (matcher) => {
+  if (!isObject(matcher)) throw new Error();
+  return freeze({ type: EmbeddedMatcher, value: matcher });
+};
+
+export const buildEmbeddedInstruction = (instr) => {
+  if (!isObject(instr)) throw new Error();
+  return freeze({ type: EmbeddedInstruction, value: instr });
+};
+
+export const buildEmbeddedRegex = (re) => {
+  if (!isObject(re)) throw new Error();
+  return freeze({ type: EmbeddedRegex, value: re });
+};
+
+export const buildEmbeddedTag = (tag) => {
+  if (!isObject(tag)) throw new Error();
+  return freeze({ type: EmbeddedTag, value: tag });
+};
+
+export const buildEffect = (value) => {
+  return freeze({ type: 'Effect', value });
+};
+
+export const buildWriteEffect = (text, options = {}) => {
+  return buildEffect(
+    freeze({
+      verb: 'write',
+      value: buildEmbeddedObject(freeze({ text, options: buildEmbeddedObject(freeze(options)) })),
+    }),
+  );
+};
+
+export const buildAnsiPushEffect = (spans = '') => {
+  return buildEffect(
+    freeze({
+      verb: 'ansi-push',
+      value: buildEmbeddedObject(
+        freeze({ spans: spans === '' ? freeze([]) : freeze(spans.split(' ')) }),
+      ),
+    }),
+  );
+};
+
+export const buildAnsiPopEffect = () => {
+  return buildEffect(freeze({ verb: 'ansi-pop', value: undefined }));
+};

package/lib/deembed.js

@@ -4,7 +4,8 @@ import {
   EmbeddedTag,
   EmbeddedMatcher,
   EmbeddedRegex,
-} from '@bablr/agast-helpers/symbols';
+  EmbeddedInstruction,
+} from './symbols.js';
 
 export const getEmbeddedObject = (expr) => {
   if (!expr) return expr;
@@ -24,6 +25,12 @@ export const getEmbeddedMatcher = (expr) => {
   return expr.value;
 };
 
+export const getEmbeddedInstruction = (expr) => {
+  if (!expr) return expr;
+  if (expr.type !== EmbeddedInstruction) throw new Error();
+  return expr.value;
+};
+
 export const getEmbeddedRegex = (expr) => {
   if (!expr) return expr;
   if (expr.type !== EmbeddedRegex) throw new Error();

package/lib/index.js

@@ -5,7 +5,6 @@ import {
   nodeFlags,
   printType,
   buildGapTag,
-  buildEmbeddedMatcher,
   isNullNode,
   buildNullTag,
   buildStubNode,
@@ -13,12 +12,12 @@ import {
   buildReferenceTag,
 } from '@bablr/agast-helpers/tree';
 import * as btree from '@bablr/agast-helpers/btree';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
 import {
   buildCloseNodeTag,
   buildLiteralTag,
   buildDoctypeTag,
   referenceFlags,
-  buildEmbeddedRegex,
 } from '@bablr/agast-helpers/builders';
 import {
   DoctypeTag,
@@ -27,9 +26,10 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayInitializerTag,
+  InitializerTag,
   LiteralTag,
 } from '@bablr/agast-helpers/symbols';
+import { buildEmbeddedMatcher, buildEmbeddedRegex } from './builders.js';
 
 const { freeze } = Object;
 
@@ -59,11 +59,13 @@ export const shouldBranch = (effects) => {
 };
 
 export const reifyNodeFlags = (flags) => {
-  let { tokenToken, hasGapToken } = flags.properties;
+  let { tokenToken, hasGapToken, fragmentToken, coverFragmentToken } = flags.properties;
 
   return {
     token: !!(tokenToken && reifyExpression(tokenToken.node)),
     hasGap: !!(hasGapToken && reifyExpression(hasGapToken.node)),
+    fragment: !!(fragmentToken && reifyExpression(fragmentToken.node)),
+    cover: !!(coverFragmentToken && reifyExpression(coverFragmentToken.node)),
   };
 };
 
@@ -115,20 +117,20 @@ export const buildFragmentChildren = (node) => {
   open = reifyExpression(open.node);
   close = reifyExpression(close.node);
 
-  built = btree.push(built, open);
+  built = sumtree.push(built, open);
 
-  for (const child of btree.traverse(children)) {
+  for (const child of sumtree.traverse(children)) {
     if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
 
     let { reference } = child.node.properties;
 
     reference = reifyExpression(reference.node);
 
-    built = btree.push(built, reference);
-    built = btree.push(built, buildGapTag());
+    built = sumtree.push(built, reference);
+    built = sumtree.push(built, buildGapTag());
   }
 
-  built = btree.push(built, close);
+  built = sumtree.push(built, close);
 
   return built;
 };
@@ -144,25 +146,25 @@ export const buildChildren = (node) => {
   close = reifyExpression(close?.node);
 
   if (selfClosing) {
-    built = btree.push(built, open);
+    built = sumtree.push(built, open);
     if (!isNull(intrinsicValue?.node)) {
-      built = btree.push(built, buildLiteralTag(intrinsicValue.node));
+      built = sumtree.push(built, buildLiteralTag(intrinsicValue.node));
     }
-    built = btree.push(built, buildCloseNodeTag());
+    built = sumtree.push(built, buildCloseNodeTag());
   } else {
-    built = btree.push(built, open);
-    for (const child of btree.traverse(children)) {
+    built = sumtree.push(built, open);
+    for (const child of sumtree.traverse(children)) {
       if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
 
       let { reference } = child.node.properties;
 
       reference = reifyExpression(reference.node);
 
-      built = btree.push(built, reference);
-      built = btree.push(built, buildGapTag());
+      built = sumtree.push(built, reference);
+      built = sumtree.push(built, buildGapTag());
     }
 
-    built = btree.push(built, close);
+    built = sumtree.push(built, close);
   }
 
   return built;
@@ -193,7 +195,7 @@ export const reifyExpression = (node) => {
           flags: nodeFlags,
           language: attributes.bablrLanguage,
           type: null,
-          children: btree.addAt(
+          children: sumtree.addAt(
             0,
             buildFragmentChildren(node.properties.tree.node),
             buildDoctypeTag(attributes),
@@ -269,7 +271,7 @@ export const reifyExpression = (node) => {
       }
 
       case 'Identifier': {
-        return getCooked(node);
+        return getCooked(node.properties.content.node);
       }
 
       case 'IdentifierPath': {
@@ -310,8 +312,8 @@ export const reifyExpression = (node) => {
       case 'GapTag':
         return { type: GapTag, value: undefined };
 
-      case 'ArrayInitializerTag':
-        return { type: ArrayInitializerTag, value: undefined };
+      case 'InitializerTag':
+        return { type: InitializerTag, value: undefined };
 
       case 'NullTag':
         return { type: NullTag, value: undefined };
@@ -355,7 +357,7 @@ export const reifyExpression = (node) => {
       type =
         type.node.type === Symbol.for('String')
           ? getCooked(type.node.properties.content.node)
-          : getCooked(type.node);
+          : reifyExpression(type.node);
       attributes = attributes ? reifyExpression(attributes.node) : {};
       intrinsicValue = intrinsicValue && reifyExpression(intrinsicValue.node);
 
@@ -394,11 +396,7 @@ export const reifyExpression = (node) => {
     case 'ReferenceMatcher': {
       let { name, openIndexToken, flags } = node.properties;
 
-      name =
-        name &&
-        (name.node.type === Symbol.for('Identifier')
-          ? reifyExpression(name.node)
-          : getCooked(name.node));
+      name = name && reifyExpression(name.node);
       let isArray = !isNull(openIndexToken?.node);
       flags = (flags && reifyReferenceFlags(flags?.node)) || referenceFlags;
 
@@ -443,10 +441,13 @@ export const reifyExpression = (node) => {
       return [...btree.traverse(elements)].map((el) => reifyExpression(el.node));
     }
 
-    case 'LiteralTag':
-    case 'Identifier':
+    case 'Punctuator':
+    case 'Keyword':
       return getCooked(node);
 
+    case 'Identifier':
+      return getCooked(node.properties.content.node);
+
     case 'Boolean': {
       // prettier-ignore
       switch (getCooked(node.properties.sigilToken.node)) {
@@ -459,6 +460,12 @@ export const reifyExpression = (node) => {
     case 'Null':
       return null;
 
+    case 'NotANumber':
+      return NaN;
+
+    case 'Undefined':
+      return undefined;
+
     default:
       throw new Error('bad expression');
   }

package/lib/print.js

@@ -0,0 +1,66 @@
+import {
+  printSource,
+  printTag,
+  printExpression as printExpression_,
+} from '@bablr/agast-helpers/tree';
+import {
+  EmbeddedNode,
+  EmbeddedTag,
+  EmbeddedObject,
+  EmbeddedMatcher,
+  EmbeddedRegex,
+  EmbeddedInstruction,
+} from './symbols.js';
+
+export const printEmbedded = (value) => {
+  switch (value.type) {
+    case EmbeddedTag:
+      return `t\`${printTag(value.value)}\``;
+
+    case EmbeddedMatcher:
+      return `m\`${printSource(value.value)}\``;
+
+    case EmbeddedRegex:
+      return `re\`${printSource(value.value)}\``;
+
+    case EmbeddedInstruction:
+      return `i\`${printCall(value.value)}\``;
+
+    case EmbeddedObject: {
+      return printObject(value.value);
+    }
+
+    case EmbeddedNode: {
+      return printSource(value.value);
+    }
+
+    default:
+      throw new Error();
+  }
+};
+
+export const printObject = (obj) => {
+  let entries = Object.entries(obj);
+  return entries.length
+    ? `{ ${entries.map(([k, v]) => `${k}: ${printExpression(v)}`).join(', ')} }`
+    : '{}';
+};
+
+export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(', ')}]`;
+
+export const printCall = (call) => {
+  let { verb, arguments: args } = call;
+  return `${verb}${`(${args.map((v) => printExpression(v)).join(', ')})`}`;
+};
+
+export const printExpression = (expr) => {
+  if (['string', 'symbol', 'boolean', 'number'].includes(typeof expr) || expr == null) {
+    return printExpression_(expr);
+  } else if (Array.isArray(expr)) {
+    return printArray(expr);
+  } else if (typeof expr === 'object') {
+    return printEmbedded(expr);
+  } else {
+    throw new Error();
+  }
+};

package/lib/stream.js

@@ -0,0 +1,231 @@
+import { Coroutine } from '@bablr/coroutine';
+import {
+  InitializerTag,
+  CloseNodeTag,
+  EmbeddedObject,
+  GapTag,
+  NullTag,
+  OpenNodeTag,
+  ReferenceTag,
+  TokenGroup,
+} from './symbols.js';
+import {
+  getStreamIterator,
+  prettyGroupTags,
+  printSelfClosingNodeTag,
+  printTag,
+  StreamIterable,
+} from '@bablr/agast-helpers/stream';
+import { buildWriteEffect } from './builders.js';
+import { getCooked } from '@bablr/agast-helpers/tree';
+
+const getEmbeddedObject = (obj) => {
+  if (obj.type !== EmbeddedObject) throw new Error();
+  return obj.value;
+};
+
+function* __generateStandardOutput(tags) {
+  const co = new Coroutine(getStreamIterator(tags));
+
+  for (;;) {
+    co.advance();
+
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+    if (co.done) break;
+
+    const tag = co.value;
+
+    if (tag.type === 'Effect') {
+      const effect = tag.value;
+      if (effect.verb === 'write') {
+        const writeEffect = getEmbeddedObject(effect.value);
+        if (writeEffect.stream == null || writeEffect.stream === 1) {
+          yield* writeEffect.text;
+        }
+      }
+    }
+  }
+}
+
+export const generateStandardOutput = (tags) => new StreamIterable(__generateStandardOutput(tags));
+
+function* __generateAllOutput(tags) {
+  const co = new Coroutine(getStreamIterator(tags));
+
+  let currentStream = null;
+
+  for (;;) {
+    co.advance();
+
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+    if (co.done) break;
+
+    const tag = co.value;
+
+    if (tag.type === 'Effect') {
+      const effect = tag.value;
+      if (effect.verb === 'write') {
+        const writeEffect = getEmbeddedObject(effect.value);
+        const prevStream = currentStream;
+        currentStream = getEmbeddedObject(writeEffect.options).stream || 1;
+        if (
+          prevStream &&
+          (prevStream !== currentStream || currentStream === 2) &&
+          !writeEffect.text.startsWith('\n')
+        ) {
+          yield* '\n';
+        }
+        yield* writeEffect.text;
+      }
+    }
+  }
+}
+
+export const generateAllOutput = (tags) => new StreamIterable(__generateAllOutput(tags));
+
+function* __writeCSTMLStrategy(tags) {
+  if (!tags) {
+    yield buildWriteEffect('<//>');
+    return;
+  }
+
+  let prevTag = null;
+
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
+
+  for (;;) {
+    co.advance();
+
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+    if (co.done) break;
+
+    const tag = co.value;
+
+    if (tag.type === ReferenceTag && prevTag.type === NullTag) {
+      yield buildWriteEffect(' ');
+    }
+
+    if (tag.type === 'Effect') {
+      yield tag;
+
+      continue;
+    }
+
+    if (tag.type === TokenGroup) {
+      const intrinsicValue = getCooked(tag.value);
+      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
+    } else {
+      yield buildWriteEffect(printTag(tag));
+    }
+
+    prevTag = tag;
+  }
+
+  yield buildWriteEffect('\n');
+}
+
+export const writeCSTMLStrategy = (tags, options = {}) =>
+  new StreamIterable(__writeCSTMLStrategy(tags, options));
+
+function* __writePrettyCSTMLStrategy(tags, options) {
+  let { indent = '  ', emitEffects = false, inline: inlineOption = true } = options;
+
+  if (!tags) {
+    yield buildWriteEffect('<//>');
+    return;
+  }
+
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
+  let indentLevel = 0;
+  let first = true;
+  let inline = false;
+  let ref = null;
+
+  for (;;) {
+    co.advance();
+
+    if (co.done) break;
+
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+
+    const tag = co.value;
+
+    if (tag.type === 'Effect') {
+      const effect = tag.value;
+      if (emitEffects && effect.verb === 'write') {
+        const writeEffect = getEmbeddedObject(effect.value);
+        yield buildWriteEffect(
+          (first ? '' : '\n') + writeEffect.text,
+          getEmbeddedObject(writeEffect.options),
+        );
+
+        inline = false;
+        first = false;
+      } else {
+        yield tag;
+      }
+      continue;
+    }
+
+    inline =
+      inlineOption &&
+      inline &&
+      ref &&
+      (tag.type === NullTag ||
+        tag.type === GapTag ||
+        tag.type === InitializerTag ||
+        tag.type === TokenGroup);
+
+    if (!first && !inline) {
+      yield buildWriteEffect('\n');
+    }
+
+    if (tag.type === CloseNodeTag) {
+      ref = null;
+      if (indentLevel === 0) {
+        throw new Error('imbalanced tag stack');
+      }
+
+      indentLevel--;
+    }
+
+    if (!inline) {
+      yield buildWriteEffect(indent.repeat(indentLevel));
+    } else {
+      yield buildWriteEffect(' ');
+    }
+
+    if (tag.type === TokenGroup) {
+      ref = null;
+      const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
+      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
+    } else {
+      yield buildWriteEffect(printTag(tag));
+    }
+
+    if (tag.type === ReferenceTag) {
+      inline = true;
+      ref = tag;
+    }
+
+    if (tag.type === OpenNodeTag) {
+      indentLevel++;
+    }
+
+    first = false;
+  }
+
+  yield buildWriteEffect('\n');
+}
+
+export const writePrettyCSTMLStrategy = (tags, options = {}) => {
+  return new StreamIterable(__writePrettyCSTMLStrategy(tags, options));
+};

package/lib/symbols.js

@@ -0,0 +1,10 @@
+export * from '@bablr/agast-helpers/symbols';
+
+export const node = Symbol.for('@bablr/node');
+export const fragment = Symbol.for('@bablr/fragment');
+
+export const EmbeddedInstruction = Symbol.for('EmbeddedInstruction');
+export const EmbeddedMatcher = Symbol.for('EmbeddedMatcher');
+export const EmbeddedRegex = Symbol.for('EmbeddedRegex');
+export const EmbeddedTag = Symbol.for('EmbeddedTag');
+export const EmbeddedObject = Symbol.for('EmbeddedObject');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm-helpers",
   "description": "Helper functions for working with the BABLR VM",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -15,11 +15,15 @@
     "./facades": "./lib/facades.js",
     "./internal-builders": "./lib/internal-builders.js",
     "./iterable": "./lib/iterable.js",
-    "./languages": "./lib/languages.js"
+    "./languages": "./lib/languages.js",
+    "./print": "./lib/print.js",
+    "./stream": "./lib/stream.js",
+    "./symbols": "./lib/symbols.js"
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.6.1"
+    "@bablr/agast-helpers": "0.7.1",
+    "@bablr/coroutine": "0.1.0"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",