@bablr/agast-helpers 0.8.0 → 0.10.0

package/lib/builders.js

@@ -1,5 +1,5 @@
-import * as btree from './btree.js';
-import { printType } from './print.js';
+import emptyStack from '@iter-tools/imm-stack';
+import { isObject, isSymbol } from './object.js';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -8,98 +8,128 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  InitializerTag,
   LiteralTag,
-  TokenGroup,
   AttributeDefinition,
   BindingTag,
+  Document,
+  Property,
+  NullNode,
+  GapNode,
+  TreeNode,
 } from './symbols.js';
 
-const { freeze, hasOwn } = Object;
+const { freeze } = Object;
 const { isArray } = Array;
 
-function* relatedNodes(properties) {
-  for (const value of Object.values(properties)) {
-    if (isArray(value)) {
-      for (let value of btree.traverse(value)) {
-        yield value.node;
+export const deepFreeze = (object) => {
+  let list = emptyStack.push(object);
+  while (list.size) {
+    let item = list.value;
+    list = list.pop();
+
+    for (const value of Object.values(item)) {
+      if (isObject(value)) {
+        list = list.push(value);
       }
-    } else {
-      yield value.node;
     }
-  }
-}
 
-const find = (predicate, iterable) => {
-  for (const value of iterable) {
-    if (predicate(value)) return value;
+    Object.freeze(item);
   }
 };
 
-export const buildProperty = (reference, binding, node) => {
-  if (node?.binding) throw new Error();
-  if (!reference.flags) throw new Error();
-  if (!isArray(node) && typeof node === 'object' && !hasOwn(node, 'properties')) throw new Error();
+export const buildProperty = (tags, shift) => {
+  if (shift && !shift.index) throw new Error();
+  freeze(tags);
 
-  if (reference.value) throw new Error();
+  if (tags[0] && ![ReferenceTag, ShiftTag].includes(tags[0].type)) throw new Error();
+  if (tags.length > 1 && !isArray(tags[1])) throw new Error();
 
-  return freeze({ reference, binding, node });
-};
+  // if (property.node && !(tags.length === 3)) throw new Error();
+  // if (tags[0].type === ShiftTag && !property.shift) throw new Error();
 
-export const buildFacadeProperty = (reference, binding, node) => {
-  if (node?.binding) throw new Error();
-  if (!reference.flags) throw new Error();
-  if (!isArray(node) && typeof node === 'object' && !node.properties) throw new Error();
+  if ((tags[0]?.type == ShiftTag) !== !!shift) throw new Error();
+  if (tags[2] && ![NullNode, GapNode, TreeNode].includes(tags[2].type)) throw new Error();
 
-  if (reference.value) throw new Error();
+  return freeze({
+    tags,
+    reference: tags[0]?.type === ShiftTag ? null : tags[0]?.value || buildReference(),
+    bindings: freeze(tags[1]?.map((tag) => tag.value) || []),
+    node: tags[2] || null,
+    shift: tags[0]?.type == ShiftTag ? shift : null,
+  });
+};
 
-  return freeze({ reference, binding, node });
+export const buildPropertyTag = (tags, shift) => {
+  return freeze({ type: Property, value: buildProperty(tags, shift) });
 };
 
-export const buildTokenGroup = (tokens) => {
-  return freeze({ type: TokenGroup, value: tokens });
+export const buildDocument = (doctypeTag, tree) => {
+  return freeze({ type: Document, value: freeze({ doctypeTag, tree }) });
 };
 
 export const buildBeginningOfStreamToken = () => {
   return freeze({ type: Symbol.for('@bablr/beginning-of-stream'), value: undefined });
 };
 
-export const buildReferenceTag = (
-  type = null,
-  name = null,
-  isArray = false,
-  flags = referenceFlags,
-  index,
-) => {
-  if (type != null && !isString(type)) throw new Error();
-  if (name != null && !isString(name)) throw new Error();
-  if (name == null && type == null) throw new Error();
-  if (index) throw new Error();
-  let { hasGap, expression } = flags;
-
-  hasGap = !!hasGap;
-  expression = !!expression;
-
+export const buildReferenceTag = (type = null, name = null, flags = referenceFlags) => {
+  if (!Object.isFrozen(flags)) throw new Error();
   return freeze({
     type: ReferenceTag,
-    value: freeze({ type, name, isArray, flags: freeze({ hasGap, expression }) }),
+    value: buildReference(type, name, flags),
   });
 };
 
+export const buildReference = (type = null, name = null, flags = referenceFlags) => {
+  if (type != null && !['_', '.', '#', '@'].includes(type)) throw new Error();
+  if (type && ['_', '#', '@'].includes(type) && (flags.intrinsic || flags.hasGap))
+    throw new Error();
+  if (name != null && (!isString(name) || !name)) throw new Error();
+  let { array, expression, intrinsic, hasGap } = flags;
+
+  array = !!array;
+  expression = !!expression;
+  intrinsic = !!intrinsic;
+  hasGap = !!hasGap;
+
+  let type_ = type == null && name == null ? '.' : type;
+
+  return freeze({ type: type_, name, flags: freeze({ array, expression, intrinsic, hasGap }) });
+};
+
+export const referenceFromMatcher = (matcher) => {
+  let { type, name, flags } = matcher;
+  return buildReference(type, name, flags);
+};
+
+export const buildShift = (index, height) => {
+  if (index == null || height == null) throw new Error();
+  return freeze({ index, height });
+};
+
 export const buildNullTag = () => {
   return freeze({ type: NullTag, value: undefined });
 };
 
-export const buildInitializerTag = (isArray = false) => {
-  return freeze({ type: InitializerTag, value: freeze({ isArray }) });
+export const buildBinding = (segments = []) => {
+  // TODO relax this restriction
+  if (!isArray(segments) || !segments.length) throw new Error();
+  if (segments.includes(undefined)) throw new Error();
+  return freeze({
+    segments: segments.map((segment) =>
+      freeze(isString(segment) ? { type: null, name: segment } : segment),
+    ),
+  });
 };
 
-export const buildBindingTag = (languagePath = []) => {
-  if (!isArray(languagePath)) throw new Error();
-  return freeze({ type: BindingTag, value: freeze({ languagePath }) });
+export const buildBindingTag = (segments = []) => {
+  return freeze({
+    type: BindingTag,
+    value: buildBinding(segments),
+  });
 };
 
 export const buildChild = (type, value) => {
+  if (!isSymbol(type)) throw new Error();
   return freeze({ type, value });
 };
 
@@ -107,28 +137,74 @@ export const buildGapTag = () => {
   return freeze({ type: GapTag, value: undefined });
 };
 
-export const buildShiftTag = (index, height) => {
-  if (!Number.isFinite(index)) throw new Error();
-  if (!Number.isFinite(height)) throw new Error();
-  return freeze({ type: ShiftTag, value: freeze({ index, height }) });
+export const buildShiftTag = () => {
+  let value = Object.defineProperties(
+    {},
+    {
+      index: {
+        get() {
+          throw new Error('moved');
+        },
+      },
+      height: {
+        get() {
+          throw new Error('moved');
+        },
+      },
+    },
+  );
+  return freeze({ type: ShiftTag, value });
 };
 
-export const buildDoctypeTag = (attributes = {}, version = 0) => {
+export const buildDoctypeTag = (version = 0, attributes = Object.freeze({})) => {
   return freeze({
     type: DoctypeTag,
-    value: freeze({ doctype: 'cstml', version, attributes: freeze(attributes) }),
+    value: freeze({ doctype: 'cstml', version, attributes }),
   });
 };
 
-export const buildOpenNodeTag = (flags = nodeFlags, type = null, attributes = {}) => {
-  if (printType(type).startsWith('https://')) throw new Error();
+export const buildOpenFragmentTag = (flags = nodeFlags, selfClosing = false) => {
+  return buildFullOpenNodeTag(flags, Symbol.for('__'), null, null, {}, selfClosing);
+};
+
+export const buildOpenCoverTag = (flags = nodeFlags, name = null, selfClosing = false) => {
+  return buildFullOpenNodeTag(flags, Symbol.for('_'), name, null, {}, selfClosing);
+};
+
+export const buildOpenNodeTag = (
+  flags,
+  name,
+  literalValue = null,
+  attributes = {},
+  selfClosing = !!literalValue,
+) => {
+  if (!name && !flags.token) throw new Error();
+  return buildFullOpenNodeTag(flags, null, name, literalValue, attributes, selfClosing);
+};
+
+export const buildFullOpenNodeTag = (
+  flags = nodeFlags,
+  type = Symbol.for('__'),
+  name = null,
+  literalValue = null,
+  attributes = {},
+  selfClosing = !!literalValue,
+) => {
+  if (!isObject(attributes)) throw new Error();
+  if (literalValue && !isString(literalValue)) throw new Error();
+  if (!type && !name && !flags.token && !literalValue) throw new Error();
+
+  deepFreeze(attributes);
 
   return freeze({
     type: OpenNodeTag,
     value: freeze({
       flags: freeze(flags),
+      name: isString(name) ? Symbol.for(name) : name,
       type: isString(type) ? Symbol.for(type) : type,
+      literalValue,
       attributes,
+      selfClosing,
     }),
   });
 };
@@ -144,8 +220,10 @@ export const buildLiteralTag = (value) => {
   return freeze({ type: LiteralTag, value });
 };
 
-export const buildAttributeDefinition = (path, value) => {
-  return freeze({ type: AttributeDefinition, value: freeze({ path, value }) });
+export const buildAttributeDefinition = (key, value) => {
+  if (!key?.length) throw new Error();
+  freeze(key);
+  return freeze({ type: AttributeDefinition, value: freeze({ path: key, value }) });
 };
 
 const flagsWithGap = new WeakMap();
@@ -155,7 +233,10 @@ export const getFlagsWithGap = (flags, hasGap = true) => {
 
   let gapFlags = flagsWithGap.get(flags);
   if (!gapFlags) {
-    gapFlags = { ...flags, hasGap };
+    gapFlags = freeze({
+      token: flags.token,
+      hasGap,
+    });
     flagsWithGap.set(flags, gapFlags);
   }
   return gapFlags;
@@ -164,47 +245,37 @@ export const getFlagsWithGap = (flags, hasGap = true) => {
 export const nodeFlags = freeze({
   token: false,
   hasGap: false,
-  fragment: false,
-  cover: false,
 });
 
-export const fragmentFlags = freeze({
-  token: false,
-  hasGap: false,
-  fragment: true,
-  cover: false,
-});
-
-const hasGap = (properties) => {
-  return find((node) => node.flags.hasGap, relatedNodes(properties));
-};
-
-const getFlags = (flags, properties) => {
-  if (!hasGap(properties)) {
-    return flags;
-  } else {
-    return getFlagsWithGap(flags);
-  }
-};
-
 export const tokenFlags = freeze({
   token: true,
   hasGap: false,
-  fragment: false,
-  cover: false,
 });
 
 export const referenceFlags = freeze({
+  array: false,
+  expression: false,
+  intrinsic: false,
+  hasGap: false,
+});
+
+export const intrinsicReferenceFlags = freeze({
+  array: false,
   expression: false,
+  intrinsic: true,
   hasGap: false,
 });
 
 export const gapReferenceFlags = freeze({
+  array: false,
   expression: false,
+  intrinsic: false,
   hasGap: true,
 });
 
 export const expressionReferenceFlags = freeze({
+  array: false,
   expression: true,
+  intrinsic: false,
   hasGap: false,
 });