@bablr/boot 0.1.5 → 0.1.6

package/lib/index.js

@@ -35,6 +35,6 @@ const spam = buildTag(spamex, 'Matcher');
 const re = buildTag(regex, 'Pattern');
 const str = buildTag(string, 'String');
 const num = buildTag(number, 'Number');
-const cst = buildTag(cstml, 'Node');
+const cst = buildTag(cstml, 'Fragment');
 
 module.exports = { re, spam, str, num, i, cst };

package/lib/languages/cstml.js

@@ -19,28 +19,87 @@ const covers = buildCovers({
     'Property',
     'TagType',
     'Node',
+    'OpenFragmentNodeTag',
+    'OpenTerminalNodeTag',
     'OpenNodeTag',
     'CloseNodeTag',
     'Terminal',
   ],
-  [sym.fragment]: ['Attributes'],
+  [sym.fragment]: ['Attributes', 'Fragment'],
   Attribute: ['MappingAttribute', 'BooleanAttribute'],
   AttributeValue: ['String:String', 'Number:Number'],
   TagType: ['Identifier', 'GlobalIdentifier'],
   Terminal: ['Literal', 'Trivia', 'Escape'],
+  EmbeddedTerminal: ['Literal', 'Escape'],
 });
 
 const grammar = class CSTMLMiniparserGrammar {
   Fragment(p) {
     p.eatMatchTrivia(_);
-    while (p.match(/['"]|<[^/]/y) || p.atExpression) {
-      if (p.match(/['"]/y)) {
-        p.eatProduction('Terminal', { path: 'properties[]' });
+    p.eatProduction('OpenFragmentNodeTag', { path: 'open' });
+    p.eatProduction('FragmentChildren');
+    p.eatProduction('CloseNodeTag', { path: 'close' });
+    p.eatMatchTrivia(_);
+  }
+
+  FragmentChildren(p) {
+    p.eatMatchTrivia(_);
+    while (p.match(/#['"]|\w/y) || p.atExpression) {
+      if (p.match(/#['"]/y)) {
+        p.eatProduction('Trivia', { path: 'children[]' });
+      } else {
+        p.eatProduction('Property', { path: 'children[]' });
+      }
+      p.eatMatchTrivia(_);
+    }
+  }
+
+  // @Node
+  Node(p) {
+    const openType = p.match('<|') ? 'OpenTerminalNodeTag' : 'OpenNodeTag';
+    const childrenType = openType === 'OpenNodeTag' ? 'NodeChildren' : 'TerminalNodeChildren';
+
+    if (p.match('<>')) throw new Error('Fragment is not a node');
+
+    const open = p.eatProduction(openType, { path: 'open' });
+    if (!open.attributes.selfClosing) {
+      p.eatProduction(childrenType);
+      p.eatProduction('CloseNodeTag', { path: 'close' });
+    }
+  }
+
+  NodeChildren(p) {
+    let properties = 0;
+
+    p.eatMatchTrivia(_);
+    while (p.match(/#['"]|\w/y) || p.atExpression) {
+      if (p.match(/#['"]/y)) {
+        p.eatProduction('Trivia', { path: 'children[]' });
       } else {
-        p.eatProduction('Property', { path: 'properties[]' });
+        p.eatProduction('Property', { path: 'children[]' });
+        properties++;
       }
       p.eatMatchTrivia(_);
     }
+
+    if (!properties) throw new Error('Nodes must match text');
+  }
+
+  TerminalNodeChildren(p) {
+    let properties = 0;
+
+    p.eatMatchTrivia(_);
+    while (p.match(/[!#]?['"]|\w/y) || p.atExpression) {
+      if (p.match(/[!#]?['"]/y)) {
+        p.eatProduction('Terminal', { path: 'children[]' });
+      } else {
+        p.eatProduction('Property', { path: 'children[]' });
+        properties++;
+      }
+      p.eatMatchTrivia(_);
+    }
+
+    if (!properties) throw new Error('Nodes must match text');
   }
 
   // @Node
@@ -53,10 +112,9 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   // @Node
-  Node(p) {
-    p.eatProduction('OpenNodeTag', { path: 'open' });
-    p.eatProduction('Fragment');
-    p.eatProduction('CloseNodeTag', { path: 'close' });
+  OpenFragmentNodeTag(p) {
+    p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
+    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
   }
 
   // @Node
@@ -75,6 +133,31 @@ const grammar = class CSTMLMiniparserGrammar {
     p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
   }
 
+  // @Node
+  OpenTerminalNodeTag(p) {
+    p.eat('<|', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('TagType', { path: 'type' });
+
+    let sp = p.eatMatchTrivia(_);
+
+    let value;
+    if (sp && p.match(/['"/]/y)) {
+      value = p.eatProduction('EmbeddedTerminal', { path: 'value' });
+      sp = p.eatMatchTrivia(_);
+    }
+
+    if ((sp && p.match(/\w+/y)) || p.atExpression) {
+      p.eatProduction('Attributes');
+      sp = p.eatMatchTrivia(_);
+    }
+
+    p.eatMatchTrivia(_);
+    p.eat('|>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+
+    return { attrs: { selfClosing: !!value } };
+  }
+
   // @Node
   CloseNodeTag(p) {
     p.eat('</', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
@@ -158,8 +241,21 @@ const grammar = class CSTMLMiniparserGrammar {
       p.eatProduction('Escape');
     } else if (p.match(/#['"]/y)) {
       p.eatProduction('Trivia');
+    } else if (p.match(/['"]/y)) {
+      p.eatProduction('Literal');
     } else {
+      throw new Error();
+    }
+  }
+
+  // @Cover
+  EmbeddedTerminal(p) {
+    if (p.match(/!['"]/y)) {
+      p.eatProduction('Escape');
+    } else if (p.match(/['"]/y)) {
       p.eatProduction('Literal');
+    } else {
+      throw new Error();
     }
   }
 

package/lib/miniparser.js

@@ -5,7 +5,8 @@ const isString = require('iter-tools-es/methods/is-string');
 const isObject = require('iter-tools-es/methods/is-object');
 const sym = require('./symbols.js');
 const { Match } = require('./match.js');
-const { set, isRegex, isArray, getPrototypeOf, buildNode, parsePath } = require('./utils.js');
+const { parsePath } = require('./path.js');
+const { set, isRegex, isArray, getPrototypeOf, buildNode } = require('./utils.js');
 
 class TemplateParser {
   constructor(rootLanguage, quasis, expressions) {
@@ -163,19 +164,20 @@ class TemplateParser {
           for (const { 0: key, 1: property } of Object.entries(result.properties)) {
             if (isArray(property)) {
               for (const value of property) {
-                set(properties, `[${key}]`, value);
+                set(properties, { pathName: key, pathIsArray: true }, value);
               }
             } else {
-              set(properties, key, property);
+              set(properties, { pathName: key, pathIsArray: false }, property);
             }
           }
         }
       } else if (parentPath?.node && (isNode || covers.has(type))) {
         const { properties, children } = parentPath.node;
+        const path = parsePath(this.m.attrs.path);
 
-        children.push({ ...ref(this.m.attrs.path), id });
+        children.push({ ...ref(path), id });
 
-        set(properties, this.m.attrs.path, result);
+        set(properties, path, result);
       }
     } else {
       if (isEmbedded) {
@@ -194,9 +196,11 @@ class TemplateParser {
           node.attributes = result.attrs;
         }
         if (parentPath?.node && !covers.has(type)) {
-          parentPath.node.children.push(ref(this.m.attrs.path));
+          const path = parsePath(this.m.attrs.path);
 
-          set(parentPath.node.properties, this.m.attrs.path, node);
+          parentPath.node.children.push(ref(path));
+
+          set(parentPath.node.properties, path, node);
         }
       }
     }
@@ -258,8 +262,10 @@ class TemplateParser {
 
     this.held = null;
 
-    children.push(ref(attrs.path));
-    set(properties, attrs.path, held);
+    const path = parsePath(attrs.path);
+
+    children.push(ref(path));
+    set(properties, path, held);
 
     return held;
   }
@@ -276,8 +282,7 @@ class TemplateParser {
       throw new Error();
     }
 
-    const path = lastChild.value;
-    const { pathIsArray, pathName } = parsePath(path);
+    const { pathIsArray, pathName } = lastChild.value;
 
     this.held = pathIsArray ? arrayLast(properties[pathName]) : properties[pathName];
 
@@ -304,9 +309,11 @@ class TemplateParser {
 
     this.updateSpans(attrs);
 
-    set(this.node.properties, attrs.path, buildNode(this.buildId(type), [lit(result)]));
+    const path = parsePath(attrs.path);
 
-    this.node.children.push(ref(attrs.path));
+    set(this.node.properties, path, buildNode(this.buildId(type), [lit(result)]));
+
+    this.node.children.push(ref(path));
 
     return result;
   }
@@ -332,9 +339,11 @@ class TemplateParser {
 
       this.idx += result.length;
 
-      set(this.node.properties, attrs.path, buildNode(this.buildId(type), [lit(result)]));
+      const path = parsePath(attrs.path);
+
+      set(this.node.properties, path, buildNode(this.buildId(type), [lit(result)]));
 
-      this.node.children.push(ref(attrs.path));
+      this.node.children.push(ref(path));
     }
     return result;
   }

package/lib/path.js

@@ -10,6 +10,16 @@ const buildNode = (id) => {
   };
 };
 
+const stripPathBraces = (str) => (str.endsWith('[]') ? str.slice(0, -2) : str);
+
+const parsePath = (str) => {
+  const pathName = stripPathBraces(str);
+
+  if (!/^\w+$/.test(pathName)) throw new Error();
+
+  return { pathIsArray: pathName !== str, pathName };
+};
+
 class Path {
   constructor(id, attributes, parent = null) {
     this.id = id;
@@ -44,4 +54,4 @@ class Path {
   }
 }
 
-module.exports = { Path, buildNode };
+module.exports = { Path, buildNode, parsePath };

package/lib/utils.js

@@ -1,7 +1,6 @@
 const every = require('iter-tools-es/methods/every');
 const isArray = require('iter-tools-es/methods/is-array');
 const isString = require('iter-tools-es/methods/is-string');
-const { parsePath, stripPathBraces } = require('@bablr/boot-helpers/path');
 
 const { hasOwn, getPrototypeOf, getOwnPropertySymbols } = Object;
 const isSymbol = (value) => typeof value === 'symbol';
@@ -54,7 +53,11 @@ const buildCovers = (rawAliases) => {
 };
 
 const set = (obj, path, value) => {
-  const { pathIsArray, pathName } = parsePath(path);
+  const { pathIsArray, pathName } = path;
+
+  if (!pathName) {
+    throw new Error();
+  }
 
   if (pathIsArray) {
     if (!obj[pathName]) {
@@ -105,8 +108,6 @@ const id = (...args) => {
 };
 
 module.exports = {
-  parsePath,
-  stripPathBraces,
   buildCovers,
   set,
   resolveDependentLanguage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"
@@ -18,7 +18,7 @@
     "@babel/helper-module-imports": "^7.22.15",
     "@babel/template": "^7.22.15",
     "@babel/types": "7.23.0",
-    "@bablr/boot-helpers": "0.1.1",
+    "@bablr/boot-helpers": "0.1.2",
     "escape-string-regexp": "4.0.0",
     "iter-tools-es": "^7.5.3"
   },

package/shorthand.macro.js

@@ -23,20 +23,21 @@ const isBoolean = (v) => typeof v === 'boolean';
 
 const isPlainObject = (v) => isObject(v) && !isArray(v);
 
-const set = (obj, path, value, pathIsArray) => {
+const set = (obj, path, value) => {
+  const { pathName, pathIsArray } = path;
   if (pathIsArray) {
-    if (!obj[path]) {
-      obj[path] = [];
+    if (!obj[pathName]) {
+      obj[pathName] = [];
     }
 
-    if (!isArray(obj[path])) throw new Error('bad array value');
+    if (!isArray(obj[pathName])) throw new Error('bad array value');
 
-    obj[path].push(value);
+    obj[pathName].push(value);
   } else {
-    if (hasOwn(obj, path)) {
+    if (hasOwn(obj, pathName)) {
       throw new Error('duplicate child name');
     }
-    obj[path] = value;
+    obj[pathName] = value;
   }
 };
 
@@ -64,7 +65,9 @@ const getASTValue = (v, exprs, bindings) => {
 
 const generateNodeChild = (child, bindings) => {
   if (child.type === 'Reference') {
-    return expression(`%%t%%.ref\`${child.value}\``)({ t: bindings.t });
+    const { pathName, pathIsArray } = child.value;
+    const printedRef = pathIsArray ? `${pathName}[]` : pathName;
+    return expression(`%%t%%.ref\`${printedRef}\``)({ t: bindings.t });
   } else if (child.type === 'Literal') {
     return expression(`%%t%%.lit\`${child.value.replace(/\\/g, '\\\\')}\``)({ t: bindings.t });
   } else if (child.type === 'Trivia') {
@@ -82,7 +85,7 @@ const generateNodeChild = (child, bindings) => {
 
 const generateNode = (node, exprs, bindings) => {
   const resolver = new PathResolver(node);
-  const { children, type, language, attributes, properties } = node;
+  const { children, type, language, attributes } = node;
   const properties_ = {};
   const children_ = [];
 
@@ -95,8 +98,8 @@ const generateNode = (node, exprs, bindings) => {
 
     if (child.type === 'Reference') {
       const path = child.value;
+      const { pathIsArray } = path;
       const resolved = resolver.get(path);
-      const pathIsArray = isArray(properties[path]);
 
       let embedded = resolved;
       if (resolved) {
@@ -118,7 +121,7 @@ const generateNode = (node, exprs, bindings) => {
         }
       }
 
-      set(properties_, path, embedded, pathIsArray);
+      set(properties_, path, embedded);
     }
   }
 
@@ -157,7 +160,7 @@ const topTypes = {
   spam: 'Matcher',
   str: 'String',
   num: 'Number',
-  cst: 'Node',
+  cst: 'Fragment',
 };
 
 const getTopScope = (scope) => {