@bablr/agast-helpers 0.3.2 → 0.5.0

package/lib/btree.js

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

package/lib/builders.js

@@ -1,16 +1,51 @@
 import * as sym from './symbols.js';
+import * as btree from './btree.js';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  OpenFragmentTag,
+  CloseFragmentTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  EmbeddedNode,
+  EmbeddedExpression,
+  EmbeddedTag,
+  TokenGroup,
+} from './symbols.js';
 
 const { freeze } = Object;
+const { isArray } = Array;
 
 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);
+    } else {
+      yield value;
+    }
+  }
+}
+
+const find = (predicate, iterable) => {
+  for (const value of iterable) {
+    if (predicate(value)) return value;
+  }
+};
+
 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) => {
@@ -19,36 +54,32 @@ export const buildEffect = (value) => {
 
 export const buildWriteEffect = (text, options = {}) => {
   return buildEffect(
-    buildEmbeddedExpression(
-      freeze({
-        verb: 'write',
-        value: buildEmbeddedExpression(
-          freeze({ text, options: buildEmbeddedExpression(freeze(options)) }),
-        ),
-      }),
-    ),
+    freeze({
+      verb: 'write',
+      value: buildEmbeddedExpression(
+        freeze({ text, options: buildEmbeddedExpression(freeze(options)) }),
+      ),
+    }),
   );
 };
 
 export const buildAnsiPushEffect = (spans = '') => {
   return buildEffect(
-    buildEmbeddedExpression(
-      freeze({
-        verb: 'ansi-push',
-        value: buildEmbeddedExpression(
-          freeze({ spans: spans === '' ? freeze([]) : freeze(spans.split(' ')) }),
-        ),
-      }),
-    ),
+    freeze({
+      verb: 'ansi-push',
+      value: buildEmbeddedExpression(
+        freeze({ spans: spans === '' ? freeze([]) : freeze(spans.split(' ')) }),
+      ),
+    }),
   );
 };
 
 export const buildAnsiPopEffect = () => {
-  return buildEffect(buildEmbeddedExpression(freeze({ verb: 'ansi-pop', value: undefined })));
+  return buildEffect(freeze({ verb: 'ansi-pop', value: undefined }));
 };
 
 export const buildTokenGroup = (tokens) => {
-  return freeze({ type: 'TokenGroup', value: tokens });
+  return freeze({ type: TokenGroup, value: tokens });
 };
 
 export const buildCall = (verb, ...args) => {
@@ -59,46 +90,42 @@ 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, hasGap = false) => {
+  return freeze({ type: ReferenceTag, value: freeze({ name, isArray, hasGap }) });
 };
 
-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) => {
+export const buildDoctypeTag = (attributes = {}) => {
   return freeze({
-    type: 'DoctypeTag',
+    type: DoctypeTag,
     value: { doctype: 'cstml', version: 0, attributes: freeze(attributes) },
   });
 };
 
 export const buildNodeOpenTag = (flags = {}, language = null, type = null, attributes = {}) => {
-  let { token, trivia, escape, expression, intrinsic } = flags;
-
-  token = !!token;
-  trivia = !!trivia;
-  escape = !!escape;
-  expression = !!expression;
-  intrinsic = !!intrinsic;
-
   return freeze({
-    type: 'OpenNodeTag',
+    type: OpenNodeTag,
     value: freeze({
-      flags: freeze({ token, trivia, escape, intrinsic, expression }),
+      flags: freeze(flags),
       language,
       type,
       attributes,
@@ -107,14 +134,31 @@ 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 }) });
+};
+
+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 });
 };
 
 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,93 +168,117 @@ export const buildNodeWithFlags = (
   children = [],
   properties = {},
   attributes = {},
-) =>
-  freeze({
+) => {
+  const openTag = buildNodeOpenTag(flags, 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),
   });
+};
+
+const flagsWithGap = new WeakMap();
+
+export const getFlagsWithGap = (flags) => flagsWithGap.get(flags);
 
 export const nodeFlags = freeze({
   token: false,
   escape: false,
   trivia: false,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
-export const buildNode = (language, type, children = [], properties = {}, attributes = {}) =>
-  freeze({
-    flags: nodeFlags,
-    language,
-    type,
-    children: freeze(children),
+const hasGap = (flags, children, 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)) {
+    return flags;
+  } else {
+    return getGapFlags(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({
   token: true,
   escape: false,
   trivia: false,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
-export const buildSyntacticNode = (language, type, value, attributes = {}) =>
-  freeze({
-    flags: syntacticFlags,
-    language,
-    type,
-    children: [buildLiteral(value)],
-    properties: freeze({}),
-    attributes: freeze(attributes),
-  });
-
-export const syntacticIntrinsicFlags = freeze({
-  token: true,
-  escape: false,
-  trivia: false,
-  intrinsic: true,
-  expression: false,
-});
-export const buildSyntacticIntrinsicNode = (language, type, value, attributes = {}) =>
-  freeze({
-    flags: syntacticIntrinsicFlags,
-    language,
-    type,
-    children: [buildLiteral(value)],
-    properties: freeze({}),
-    attributes: freeze(attributes),
-  });
+export const buildSyntacticNode = (language, type, value) => {
+  return buildNodeWithFlags(syntacticFlags, language, type, [buildLiteralTag(value)]);
+};
 
 export const escapeFlags = freeze({
   token: false,
   escape: true,
   trivia: false,
-  intrinsic: false,
   expression: false,
+  hasGap: 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 = {},
+) => {
+  const flags = getFlags(escapeFlags, children, properties);
+  return buildNodeWithFlags(flags, language, type, children, properties, attributes);
+};
 
 export const syntacticEscapeFlags = freeze({
   token: true,
   escape: true,
   trivia: false,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
 export const buildSyntacticEscapeNode = (
@@ -219,22 +287,16 @@ 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,
   escape: false,
   trivia: true,
-  intrinsic: false,
   expression: false,
+  hasGap: false,
 });
 
 export const buildSyntacticTriviaNode = (
@@ -243,40 +305,46 @@ 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,
   escape: false,
   trivia: true,
-  intrinsic: false,
   expression: false,
+  hasGap: 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 = {},
+) => {
+  const flags = getFlags(triviaFlags, children, properties);
+  return buildNodeWithFlags(flags, 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: getGapFlags(nodeFlags),
+    language: null,
+    type: sym.gap,
+    children: btree.freeze([gapToken]),
     properties: freeze({}),
     attributes: freeze({}),
   });

package/lib/path.js

@@ -1,16 +1,26 @@
 export const parsePath = (str) => {
-  const isArray = str.endsWith('[]');
-  const name = isArray ? str.slice(0, -2) : str;
+  let name = str;
+  const hasGap = name.endsWith('$');
 
-  if (!/^[a-zA-Z]+$/.test(name)) throw new Error();
+  if (hasGap) name = name.slice(0, -1);
 
-  return { isArray, name };
+  const isArray = name.endsWith('[]');
+
+  if (isArray) name = name.slice(0, -2);
+
+  if (!/^(\.|[a-zA-Z]+)$/.test(name)) throw new Error();
+
+  const isRoot = name === '.';
+
+  return { name, hasGap, isArray, isRoot };
 };
 
 export const printPath = (path) => {
   if (!path) return null;
 
-  const { isArray, name } = path;
+  const { isArray, isRoot, hasGap, name } = path;
+
+  if (isRoot && name !== '.') throw new Error();
 
-  return `${name}${isArray ? '[]' : ''}`;
+  return `${name}${isArray ? '[]' : ''}${hasGap ? '$' : ''}`;
 };