@bablr/agast-helpers 0.5.2 → 0.6.0

package/lib/builders.js

@@ -1,21 +1,21 @@
-import * as sym from './symbols.js';
 import * as btree from './btree.js';
+import { printType } from './print.js';
 import {
   DoctypeTag,
   OpenNodeTag,
   CloseNodeTag,
-  OpenFragmentTag,
-  CloseFragmentTag,
   ReferenceTag,
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   LiteralTag,
-  EmbeddedNode,
-  EmbeddedExpression,
+  EmbeddedObject,
   EmbeddedTag,
   TokenGroup,
+  EmbeddedMatcher,
+  EmbeddedRegex,
+  EmbeddedNode,
 } from './symbols.js';
 
 const { freeze } = Object;
@@ -26,9 +26,11 @@ const isObject = (val) => val !== null && typeof value !== 'object';
 function* relatedNodes(properties) {
   for (const value of Object.values(properties)) {
     if (isArray(value)) {
-      yield* btree.traverse(value);
+      for (let value of btree.traverse(value)) {
+        yield value.node;
+      }
     } else {
-      yield value;
+      yield value.node;
     }
   }
 }
@@ -39,13 +41,28 @@ const find = (predicate, iterable) => {
   }
 };
 
-export const buildEmbeddedExpression = (expr) => {
-  if (!isObject(expr)) return expr;
-  return freeze({ type: EmbeddedExpression, value: expr });
+export const buildEmbeddedObject = (expr) => {
+  if (!isObject(expr)) throw new Error();
+  return freeze({ type: EmbeddedObject, value: expr });
+};
+
+export const buildEmbeddedNode = (node) => {
+  if (!isObject(node)) throw new Error();
+  return freeze({ type: EmbeddedNode, value: node });
+};
+
+export const buildEmbeddedMatcher = (node) => {
+  if (!isObject(node)) throw new Error();
+  return freeze({ type: EmbeddedMatcher, value: node });
+};
+
+export const buildEmbeddedRegex = (node) => {
+  if (!isObject(node)) throw new Error();
+  return freeze({ type: EmbeddedRegex, value: node });
 };
 
 export const buildEmbeddedTag = (tag) => {
-  if (!isObject(tag)) return tag;
+  if (!isObject(tag)) throw new Error();
   return freeze({ type: EmbeddedTag, value: tag });
 };
 
@@ -57,18 +74,7 @@ export const buildWriteEffect = (text, options = {}) => {
   return buildEffect(
     freeze({
       verb: 'write',
-      value: buildEmbeddedExpression(
-        freeze({ text, options: buildEmbeddedExpression(freeze(options)) }),
-      ),
-    }),
-  );
-};
-
-export const buildYieldEffect = (tag) => {
-  return buildEffect(
-    freeze({
-      verb: 'yield',
-      value: buildEmbeddedTag(freeze(tag)),
+      value: buildEmbeddedObject(freeze({ text, options: buildEmbeddedObject(freeze(options)) })),
     }),
   );
 };
@@ -77,7 +83,7 @@ export const buildAnsiPushEffect = (spans = '') => {
   return buildEffect(
     freeze({
       verb: 'ansi-push',
-      value: buildEmbeddedExpression(
+      value: buildEmbeddedObject(
         freeze({ spans: spans === '' ? freeze([]) : freeze(spans.split(' ')) }),
       ),
     }),
@@ -100,28 +106,27 @@ export const buildBeginningOfStreamToken = () => {
   return freeze({ type: Symbol.for('@bablr/beginning-of-stream'), value: undefined });
 };
 
-export const buildReferenceTag = (name, isArray = false, hasGap = false) => {
-  return freeze({ type: ReferenceTag, value: freeze({ name, isArray, hasGap }) });
+export const buildReferenceTag = (name, isArray = false, flags = referenceFlags, index = null) => {
+  if (name == null || !/[a-zA-Z.#@]/.test(name)) throw new Error('reference must have a name');
+  if (index != null && !Number.isFinite(index)) throw new Error();
+  return freeze({ type: ReferenceTag, value: freeze({ name, isArray, index, flags }) });
 };
 
 export const buildNullTag = () => {
   return freeze({ type: NullTag, value: undefined });
 };
 
-export const buildArrayTag = () => {
-  return freeze({ type: ArrayTag, value: undefined });
+export const buildArrayInitializerTag = () => {
+  return freeze({ type: ArrayInitializerTag, 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 });
+export const buildShiftTag = (index) => {
+  if (!Number.isFinite(index)) throw new Error();
+  return freeze({ type: ShiftTag, value: freeze({ index }) });
 };
 
 export const buildDoctypeTag = (attributes = {}) => {
@@ -131,37 +136,27 @@ export const buildDoctypeTag = (attributes = {}) => {
   });
 };
 
-export const buildNodeOpenTag = (flags = {}, language = null, type = null, attributes = {}) => {
+export const buildOpenNodeTag = (
+  flags = nodeFlags,
+  language = null,
+  type = null,
+  attributes = {},
+) => {
+  if (printType(type).startsWith('https://')) throw new Error();
+
   return freeze({
     type: OpenNodeTag,
     value: freeze({
       flags: freeze(flags),
       language,
-      type,
+      type: isString(type) ? Symbol.for(type) : type,
       attributes,
     }),
   });
 };
 
-export const buildNodeCloseTag = (type = null, language = null) => {
-  return freeze({ type: CloseNodeTag, value: freeze({ language, type }) });
-};
-
-export const buildFragmentOpenTag = (flags = {}) => {
-  return freeze({
-    type: OpenFragmentTag,
-    value: freeze({
-      flags: freeze(flags),
-    }),
-  });
-};
-
-export const buildFragmentCloseTag = (type = null, language = null) => {
-  return freeze({ type: CloseFragmentTag, value: freeze({ language, type }) });
-};
-
-export const wrapFragment = (node) => {
-  return buildFragment([buildReferenceTag('.')], { '.': node });
+export const buildCloseNodeTag = () => {
+  return freeze({ type: CloseNodeTag, value: undefined });
 };
 
 const isString = (val) => typeof val === 'string';
@@ -171,191 +166,50 @@ export const buildLiteralTag = (value) => {
   return freeze({ type: LiteralTag, value });
 };
 
-export const buildNodeWithFlags = (
-  flags,
-  language,
-  type,
-  children = [],
-  properties = {},
-  attributes = {},
-) => {
-  const openTag = buildNodeOpenTag(flags, language, type, attributes);
-  const closeTag = buildNodeCloseTag(type);
-
-  return freeze({
-    flags,
-    language,
-    type,
-    children: btree.addAt(0, btree.addAt(btree.getSum(children), children, closeTag), openTag),
-    properties: freeze(properties),
-    attributes: freeze(attributes),
-  });
-};
-
 const flagsWithGap = new WeakMap();
 
-export const getFlagsWithGap = (flags) => flagsWithGap.get(flags);
+export const getFlagsWithGap = (flags) => {
+  let gapFlags = flagsWithGap.get(flags);
+  if (!gapFlags) {
+    gapFlags = { ...flags, hasGap: true };
+    flagsWithGap.set(flags, gapFlags);
+  }
+  return gapFlags;
+};
 
 export const nodeFlags = freeze({
   token: false,
-  escape: false,
-  trivia: false,
-  expression: false,
   hasGap: false,
 });
 
-const hasGap = (flags, children, properties) => {
+const hasGap = (properties) => {
   return find((node) => node.flags.hasGap, relatedNodes(properties));
 };
 
-const getGapFlags = (flags) => {
-  let gapFlags = flagsWithGap.get(flags);
-  if (!gapFlags) {
-    gapFlags = { ...flags, hasGap: true };
-    flagsWithGap.set(flags, gapFlags);
-  }
-  return gapFlags;
-};
-
-const getFlags = (flags, children, properties) => {
-  if (!hasGap(flags, children, properties)) {
+const getFlags = (flags, properties) => {
+  if (!hasGap(properties)) {
     return flags;
   } else {
-    return getGapFlags(flags);
+    return getFlagsWithGap(flags);
   }
 };
 
-export const buildNode = (language, type, children = [], properties = {}, attributes = {}) => {
-  const flags = getFlags(nodeFlags, children, properties);
-  return buildNodeWithFlags(flags, language, type, children, properties, attributes);
-};
-
-export const buildFragmentWithFlags = (flags, children = [], properties = {}, attributes = {}) => {
-  const doctypeTag = buildDoctypeTag(attributes);
-  const openTag = buildFragmentOpenTag(flags);
-  const closeTag = buildFragmentCloseTag();
-
-  return freeze({
-    flags,
-    children: btree.addAt(
-      0,
-      btree.addAt(0, btree.addAt(btree.getSum(children), children, closeTag), openTag),
-      doctypeTag,
-    ),
-    properties: freeze(properties),
-    attributes: freeze(attributes),
-  });
-};
-
-export const buildFragment = (children = [], properties = {}, attributes = {}) => {
-  const flags = getFlags(nodeFlags, children, properties);
-  return buildFragmentWithFlags(flags, children, properties, attributes);
-};
-
-export const syntacticFlags = freeze({
+export const tokenFlags = freeze({
   token: true,
-  escape: false,
-  trivia: false,
-  expression: false,
   hasGap: false,
 });
 
-export const buildSyntacticNode = (language, type, value) => {
-  return buildNodeWithFlags(syntacticFlags, language, type, [buildLiteralTag(value)]);
-};
-
-export const escapeFlags = freeze({
-  token: false,
-  escape: true,
-  trivia: false,
-  expression: false,
-  hasGap: false,
-});
-
-export const buildEscapeNode = (
-  language,
-  type,
-  children = [],
-  properties = {},
-  attributes = {},
-) => {
-  const flags = getFlags(escapeFlags, children, properties);
-  return buildNodeWithFlags(flags, language, type, children, properties, attributes);
-};
-
-export const syntacticEscapeFlags = freeze({
-  token: true,
-  escape: true,
-  trivia: false,
+export const referenceFlags = freeze({
   expression: false,
   hasGap: false,
 });
 
-export const buildSyntacticEscapeNode = (
-  language,
-  type,
-  children = [],
-  properties = {},
-  attributes = {},
-) => {
-  return buildNodeWithFlags(syntacticEscapeFlags, language, type, children, properties, attributes);
-};
-
-export const syntacticTriviaFlags = freeze({
-  token: true,
-  escape: false,
-  trivia: true,
+export const gapReferenceFlags = freeze({
   expression: false,
-  hasGap: false,
+  hasGap: true,
 });
 
-export const buildSyntacticTriviaNode = (
-  language,
-  type,
-  children = [],
-  properties = {},
-  attributes = {},
-) => {
-  return buildNodeWithFlags(syntacticTriviaFlags, language, type, children, properties, attributes);
-};
-
-export const triviaFlags = freeze({
-  token: false,
-  escape: false,
-  trivia: true,
-  expression: false,
+export const expressionReferenceFlags = freeze({
+  expression: true,
   hasGap: false,
 });
-
-export const buildTriviaNode = (
-  language,
-  type,
-  children = [],
-  properties = {},
-  attributes = {},
-) => {
-  const flags = getFlags(triviaFlags, children, properties);
-  return buildNodeWithFlags(flags, language, type, children, properties, attributes);
-};
-
-export const buildNullNode = (nullToken = buildNullTag()) => {
-  return freeze({
-    flags: nodeFlags,
-    language: null,
-    type: sym.null,
-    children: btree.freeze([nullToken]),
-    properties: freeze({}),
-    attributes: freeze({}),
-  });
-};
-
-export const buildGapNode = (gapToken = buildGapTag()) => {
-  return freeze({
-    flags: getGapFlags(nodeFlags),
-    language: null,
-    type: sym.gap,
-    children: btree.freeze([gapToken]),
-    properties: freeze({}),
-    attributes: freeze({}),
-  });
-};