@bablr/agast-helpers 0.3.2 → 0.4.0

package/lib/btree.js

@@ -0,0 +1 @@
+export * from '@bablr/btree';

package/lib/builders.js

@@ -1,4 +1,20 @@
 import * as sym from './symbols.js';
+import * as btree from './btree.js';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  EmbeddedNode,
+  EmbeddedExpression,
+  EmbeddedTag,
+  TokenGroup,
+} from './symbols.js';
 
 const { freeze } = Object;
 
@@ -6,11 +22,11 @@ const isObject = (val) => val !== null && typeof value !== 'object';
 
 export const buildEmbeddedExpression = (expr) => {
   if (!isObject(expr)) return expr;
-  return freeze({ type: 'EmbeddedExpression', value: expr });
+  return freeze({ type: EmbeddedExpression, value: expr });
 };
 
 export const buildEmbeddedTag = (tag) => {
-  return freeze({ type: 'EmbeddedTag', value: tag });
+  return freeze({ type: EmbeddedTag, value: tag });
 };
 
 export const buildEffect = (value) => {
@@ -48,7 +64,7 @@ export const buildAnsiPopEffect = () => {
 };
 
 export const buildTokenGroup = (tokens) => {
-  return freeze({ type: 'TokenGroup', value: tokens });
+  return freeze({ type: TokenGroup, value: tokens });
 };
 
 export const buildCall = (verb, ...args) => {
@@ -59,29 +75,33 @@ export const buildBeginningOfStreamToken = () => {
   return freeze({ type: Symbol.for('@bablr/beginning-of-stream'), value: undefined });
 };
 
-export const buildReference = (name, isArray) => {
-  return freeze({ type: 'Reference', value: freeze({ name, isArray }) });
+export const buildReferenceTag = (name, isArray = false) => {
+  return freeze({ type: ReferenceTag, value: freeze({ name, isArray }) });
 };
 
-export const buildNull = () => {
-  return freeze({ type: 'Null', value: undefined });
+export const buildNullTag = () => {
+  return freeze({ type: NullTag, value: undefined });
 };
 
-export const buildGap = () => {
-  return freeze({ type: 'Gap', value: undefined });
+export const buildArrayTag = () => {
+  return freeze({ type: ArrayTag, value: undefined });
 };
 
-export const buildShift = () => {
-  return freeze({ type: 'Shift', value: undefined });
+export const buildGapTag = () => {
+  return freeze({ type: GapTag, value: undefined });
+};
+
+export const buildShiftTag = () => {
+  return freeze({ type: ShiftTag, value: undefined });
 };
 
 export const buildEmbeddedNode = (node) => {
-  return freeze({ type: 'EmbeddedNode', value: node });
+  return freeze({ type: EmbeddedNode, value: node });
 };
 
 export const buildDoctypeTag = (attributes) => {
   return freeze({
-    type: 'DoctypeTag',
+    type: DoctypeTag,
     value: { doctype: 'cstml', version: 0, attributes: freeze(attributes) },
   });
 };
@@ -96,7 +116,7 @@ export const buildNodeOpenTag = (flags = {}, language = null, type = null, attri
   intrinsic = !!intrinsic;
 
   return freeze({
-    type: 'OpenNodeTag',
+    type: OpenNodeTag,
     value: freeze({
       flags: freeze({ token, trivia, escape, intrinsic, expression }),
       language,
@@ -107,14 +127,14 @@ export const buildNodeOpenTag = (flags = {}, language = null, type = null, attri
 };
 
 export const buildNodeCloseTag = (type = null, language = null) => {
-  return freeze({ type: 'CloseNodeTag', value: freeze({ language, type }) });
+  return freeze({ type: CloseNodeTag, value: freeze({ language, type }) });
 };
 
 const isString = (val) => typeof val === 'string';
 
-export const buildLiteral = (value) => {
+export const buildLiteralTag = (value) => {
   if (!isString(value)) throw new Error('invalid literal');
-  return freeze({ type: 'Literal', value });
+  return freeze({ type: LiteralTag, value });
 };
 
 export const buildNodeWithFlags = (
@@ -124,15 +144,19 @@ export const buildNodeWithFlags = (
   children = [],
   properties = {},
   attributes = {},
-) =>
-  freeze({
+) => {
+  const openTag = buildNodeOpenTag(nodeFlags, language, type, attributes);
+  const closeTag = buildNodeCloseTag(type);
+
+  return freeze({
     flags,
     language,
     type,
-    children: freeze(children),
+    children: btree.addAt(0, btree.addAt(btree.getSum(children), children, closeTag), openTag),
     properties: freeze(properties),
     attributes: freeze(attributes),
   });
+};
 
 export const nodeFlags = freeze({
   token: false,
@@ -142,15 +166,9 @@ export const nodeFlags = freeze({
   expression: false,
 });
 
-export const buildNode = (language, type, children = [], properties = {}, attributes = {}) =>
-  freeze({
-    flags: nodeFlags,
-    language,
-    type,
-    children: freeze(children),
-    properties: freeze(properties),
-    attributes: freeze(attributes),
-  });
+export const buildNode = (language, type, children = [], properties = {}, attributes = {}) => {
+  return buildNodeWithFlags(nodeFlags, language, type, children, properties, attributes);
+};
 
 export const syntacticFlags = freeze({
   token: true,
@@ -160,15 +178,16 @@ export const syntacticFlags = freeze({
   expression: false,
 });
 
-export const buildSyntacticNode = (language, type, value, attributes = {}) =>
-  freeze({
-    flags: syntacticFlags,
+export const buildSyntacticNode = (language, type, value, attributes = {}) => {
+  return buildNodeWithFlags(
+    syntacticFlags,
     language,
     type,
-    children: [buildLiteral(value)],
-    properties: freeze({}),
-    attributes: freeze(attributes),
-  });
+    [buildLiteralTag(value)],
+    {},
+    attributes,
+  );
+};
 
 export const syntacticIntrinsicFlags = freeze({
   token: true,
@@ -177,15 +196,16 @@ export const syntacticIntrinsicFlags = freeze({
   intrinsic: true,
   expression: false,
 });
-export const buildSyntacticIntrinsicNode = (language, type, value, attributes = {}) =>
-  freeze({
-    flags: syntacticIntrinsicFlags,
+export const buildSyntacticIntrinsicNode = (language, type, value, attributes = {}) => {
+  return buildNodeWithFlags(
+    syntacticIntrinsicFlags,
     language,
     type,
-    children: [buildLiteral(value)],
-    properties: freeze({}),
-    attributes: freeze(attributes),
-  });
+    [buildLiteralTag(value)],
+    {},
+    attributes,
+  );
+};
 
 export const escapeFlags = freeze({
   token: false,
@@ -195,15 +215,15 @@ export const escapeFlags = freeze({
   expression: false,
 });
 
-export const buildEscapeNode = (language, type, children = [], properties = {}, attributes = {}) =>
-  freeze({
-    flags: escapeFlags,
-    language,
-    type,
-    children: freeze(children),
-    properties: freeze(properties),
-    attributes: freeze(attributes),
-  });
+export const buildEscapeNode = (
+  language,
+  type,
+  children = [],
+  properties = {},
+  attributes = {},
+) => {
+  return buildNodeWithFlags(escapeFlags, language, type, children, properties, attributes);
+};
 
 export const syntacticEscapeFlags = freeze({
   token: true,
@@ -219,15 +239,9 @@ export const buildSyntacticEscapeNode = (
   children = [],
   properties = {},
   attributes = {},
-) =>
-  freeze({
-    flags: syntacticEscapeFlags,
-    language,
-    type,
-    children: freeze(children),
-    properties: freeze(properties),
-    attributes: freeze(attributes),
-  });
+) => {
+  return buildNodeWithFlags(syntacticEscapeFlags, language, type, children, properties, attributes);
+};
 
 export const syntacticTriviaFlags = freeze({
   token: true,
@@ -243,15 +257,9 @@ export const buildSyntacticTriviaNode = (
   children = [],
   properties = {},
   attributes = {},
-) =>
-  freeze({
-    flags: syntacticTriviaFlags,
-    language,
-    type,
-    children: freeze(children),
-    properties: freeze(properties),
-    attributes: freeze(attributes),
-  });
+) => {
+  return buildNodeWithFlags(syntacticTriviaFlags, language, type, children, properties, attributes);
+};
 
 export const triviaFlags = freeze({
   token: false,
@@ -261,22 +269,33 @@ export const triviaFlags = freeze({
   expression: false,
 });
 
-export const buildTriviaNode = (language, type, children = [], properties = {}, attributes = {}) =>
-  freeze({
-    flags: triviaFlags,
-    language,
-    type,
-    children: freeze(children),
-    properties: freeze(properties),
-    attributes: freeze(attributes),
-  });
+export const buildTriviaNode = (
+  language,
+  type,
+  children = [],
+  properties = {},
+  attributes = {},
+) => {
+  return buildNodeWithFlags(triviaFlags, language, type, children, properties, attributes);
+};
 
-export const buildNullNode = () => {
+export const buildNullNode = (nullToken = buildNullTag()) => {
   return freeze({
     flags: nodeFlags,
     language: null,
     type: sym.null,
-    children: freeze([buildNull()]),
+    children: btree.freeze([nullToken]),
+    properties: freeze({}),
+    attributes: freeze({}),
+  });
+};
+
+export const buildGapNode = (gapToken = buildGapTag()) => {
+  return freeze({
+    flags: nodeFlags,
+    language: null,
+    type: sym.gap,
+    children: btree.freeze([gapToken]),
     properties: freeze({}),
     attributes: freeze({}),
   });

package/lib/path.js

@@ -4,7 +4,7 @@ export const parsePath = (str) => {
 
   if (!/^[a-zA-Z]+$/.test(name)) throw new Error();
 
-  return { isArray, name };
+  return { name, isArray };
 };
 
 export const printPath = (path) => {

package/lib/print.js

@@ -1,3 +1,18 @@
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  EmbeddedNode,
+  EmbeddedTag,
+  EmbeddedExpression,
+} from './symbols.js';
+
 const { isInteger, isFinite } = Number;
 const { isArray } = Array;
 const isString = (val) => typeof val === 'string';
@@ -13,14 +28,14 @@ export const printCall = (call) => {
   return `${verb}${printTuple(args)}`;
 };
 
-export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(', ')}]`;
+export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(' ')}]`;
 
-export const printTuple = (tup) => `(${tup.map((v) => printExpression(v)).join(', ')})`;
+export const printTuple = (tup) => `(${tup.map((v) => printExpression(v)).join(' ')})`;
 
 export const printObject = (obj) => {
   const entries = Object.entries(obj);
   return entries.length
-    ? `{ ${entries.map(([k, v]) => `${k}: ${printExpression(v)}`).join(', ')} }`
+    ? `{ ${entries.map(([k, v]) => `${k}: ${printExpression(v)}`).join(' ')} }`
     : '{}';
 };
 
@@ -49,14 +64,14 @@ export const printExpression = (expr) => {
 
 export const printEmbedded = (value) => {
   switch (value.type) {
-    case 'EmbeddedTag':
-      return printTerminal(value.value);
+    case EmbeddedTag:
+      return printTag(value.value);
 
-    case 'EmbeddedExpression': {
+    case EmbeddedExpression: {
       return printObject(value.value);
     }
 
-    case 'EmbeddedNode': {
+    case EmbeddedNode: {
       throw new Error('not implemented');
       break;
     }
@@ -83,7 +98,7 @@ export const printLanguage = (language) => {
 export const printTagPath = (language, type) => {
   return [
     ...when(type && language?.length, () => [printLanguage(language)]),
-    ...when(type, [type]),
+    ...when(type, [printType(type)]),
   ].join(':');
 };
 
@@ -115,29 +130,35 @@ export const printString = (str) => {
   return str === "'" ? printDoubleString(str) : printSingleString(str);
 };
 
-export const printGap = (terminal) => {
-  if (terminal?.type !== 'Gap') throw new Error();
+export const printGapTag = (tag) => {
+  if (tag?.type !== GapTag) throw new Error();
 
   return `<//>`;
 };
 
-export const printShift = (terminal) => {
-  if (terminal?.type !== 'Shift') throw new Error();
+export const printArrayTag = (tag) => {
+  if (tag?.type !== ArrayTag) throw new Error();
+
+  return `[]`;
+};
+
+export const printShiftTag = (tag) => {
+  if (tag?.type !== ShiftTag) throw new Error();
 
   return `^^^`;
 };
 
-export const printReference = (terminal) => {
-  if (terminal?.type !== 'Reference') throw new Error();
+export const printReferenceTag = (tag) => {
+  if (tag?.type !== ReferenceTag) throw new Error();
 
-  const { name, isArray } = terminal.value;
+  const { name, isArray } = tag.value;
   const pathBraces = isArray ? '[]' : '';
 
   return `${name}${pathBraces}:`;
 };
 
-export const printNull = (terminal) => {
-  if (terminal && terminal.type !== 'Null') {
+export const printNullTag = (tag) => {
+  if (tag && tag.type !== NullTag) {
     throw new Error();
   }
 
@@ -148,14 +169,14 @@ export const printType = (type) => {
   return typeof type === 'string'
     ? type
     : typeof type === 'symbol'
-    ? `$${type.description.replace('@bablr/', '')}`
+    ? type.description.replace('@bablr/', '')
     : String(type);
 };
 
-export const printDoctypeTag = (terminal) => {
-  if (terminal?.type !== 'DoctypeTag') throw new Error();
+export const printDoctypeTag = (tag) => {
+  if (tag?.type !== DoctypeTag) throw new Error();
 
-  let { doctype, version, attributes } = terminal.value;
+  let { doctype, version, attributes } = tag.value;
 
   attributes =
     attributes && Object.values(attributes).length ? ` ${printAttributes(attributes)}` : '';
@@ -163,10 +184,10 @@ export const printDoctypeTag = (terminal) => {
   return `<!${version}:${doctype}${attributes}>`;
 };
 
-export const printLiteral = (terminal) => {
-  if (terminal?.type !== 'Literal') throw new Error();
+export const printLiteralTag = (tag) => {
+  if (tag?.type !== LiteralTag) throw new Error();
 
-  return printString(terminal.value);
+  return printString(tag.value);
 };
 
 export const printFlags = (flags) => {
@@ -181,10 +202,10 @@ export const printFlags = (flags) => {
   return `${hash}${tilde}${star}${at}${plus}`;
 };
 
-export const printOpenNodeTag = (terminal) => {
-  if (terminal?.type !== 'OpenNodeTag') throw new Error();
+export const printOpenNodeTag = (tag) => {
+  if (tag?.type !== OpenNodeTag) throw new Error();
 
-  const { flags, language: tagLanguage, type, attributes } = terminal.value;
+  const { flags, language: tagLanguage, type, attributes } = tag.value;
 
   const printedAttributes = attributes && printAttributes(attributes);
   const attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
@@ -192,10 +213,10 @@ export const printOpenNodeTag = (terminal) => {
   return `<${printFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
 };
 
-export const printSelfClosingNodeTag = (terminal, intrinsicValue) => {
-  if (terminal?.type !== 'OpenNodeTag') throw new Error();
+export const printSelfClosingNodeTag = (tag, intrinsicValue) => {
+  if (tag?.type !== OpenNodeTag) throw new Error();
 
-  const { flags, language: tagLanguage, type, attributes } = terminal.value;
+  const { flags, language: tagLanguage, type, attributes } = tag.value;
 
   const printedAttributes = attributes && printAttributes(attributes);
   const attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
@@ -207,39 +228,42 @@ export const printSelfClosingNodeTag = (terminal, intrinsicValue) => {
   )}${intrinsicFrag}${attributesFrag} />`;
 };
 
-export const printCloseNodeTag = (terminal) => {
-  if (terminal?.type !== 'CloseNodeTag') throw new Error();
+export const printCloseNodeTag = (tag) => {
+  if (tag?.type !== CloseNodeTag) throw new Error();
 
   return `</>`;
 };
 
-export const printTerminal = (terminal) => {
-  if (!isObject(terminal)) throw new Error();
+export const printTag = (tag) => {
+  if (!isObject(tag)) throw new Error();
+
+  switch (tag?.type || NullTag) {
+    case NullTag:
+      return printNullTag(tag);
 
-  switch (terminal?.type || 'Null') {
-    case 'Null':
-      return printNull(terminal);
+    case GapTag:
+      return printGapTag(tag);
 
-    case 'Gap':
-      return printGap(terminal);
+    case ArrayTag:
+      return printArrayTag(tag);
 
-    case 'Shift':
-      return printShift(terminal);
+    case ShiftTag:
+      return printShiftTag(tag);
 
-    case 'Literal':
-      return printLiteral(terminal);
+    case LiteralTag:
+      return printLiteralTag(tag);
 
-    case 'DoctypeTag':
-      return printDoctypeTag(terminal);
+    case DoctypeTag:
+      return printDoctypeTag(tag);
 
-    case 'Reference':
-      return printReference(terminal);
+    case ReferenceTag:
+      return printReferenceTag(tag);
 
-    case 'OpenNodeTag':
-      return printOpenNodeTag(terminal);
+    case OpenNodeTag:
+      return printOpenNodeTag(tag);
 
-    case 'CloseNodeTag':
-      return printCloseNodeTag(terminal);
+    case CloseNodeTag:
+      return printCloseNodeTag(tag);
 
     default:
       throw new Error();

package/lib/shorthand.js

@@ -1,18 +1,20 @@
 import {
-  buildReference,
-  buildGap,
+  buildReferenceTag,
+  buildGapTag,
   buildEmbeddedNode,
   buildNodeOpenTag,
   buildNodeCloseTag,
-  buildLiteral,
+  buildLiteralTag,
+  buildNullNode,
+  buildArrayTag,
   buildNode,
+  buildGapNode,
   buildSyntacticNode,
   buildSyntacticIntrinsicNode,
   buildEscapeNode,
   buildSyntacticEscapeNode,
   buildSyntacticTriviaNode,
   buildTriviaNode,
-  buildNullNode,
 } from './builders.js';
 
 export * from './builders.js';
@@ -34,20 +36,22 @@ export const ref = (path) => {
   if (isArray(path)) {
     const pathIsArray = path[0].endsWith('[]');
     const name = pathIsArray ? path[0].slice(0, -2) : path[0];
-    return buildReference(name, pathIsArray);
+    return buildReferenceTag(name, pathIsArray);
   } else {
     const { name, isArray: pathIsArray } = path;
-    return buildReference(name, pathIsArray);
+    return buildReferenceTag(name, pathIsArray);
   }
 };
 
-export const lit = (str) => buildLiteral(stripArray(str));
+export const lit = (str) => buildLiteralTag(stripArray(str));
 
-export const gap = buildGap;
+export const gap = buildGapTag;
+export const arr = buildArrayTag;
 export const embedded = buildEmbeddedNode;
 export const nodeOpen = buildNodeOpenTag;
 export const nodeClose = buildNodeCloseTag;
 export const node = buildNode;
+export const g_node = buildGapNode;
 export const s_node = buildSyntacticNode;
 export const s_i_node = buildSyntacticIntrinsicNode;
 export const e_node = buildEscapeNode;