@bablr/agast-helpers 0.9.0 → 0.10.0

package/lib/builders.js

@@ -1,5 +1,5 @@
-import { isSymbol } from './object.js';
-import { printType } from './print.js';
+import emptyStack from '@iter-tools/imm-stack';
+import { isObject, isSymbol } from './object.js';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -8,106 +8,124 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  InitializerTag,
   LiteralTag,
   AttributeDefinition,
   BindingTag,
   Document,
+  Property,
+  NullNode,
+  GapNode,
+  TreeNode,
 } from './symbols.js';
 
-const { freeze, hasOwn } = Object;
+const { freeze } = Object;
 const { isArray } = Array;
 
-export const buildProperty = (reference, binding = null, node = undefined) => {
-  if (node?.binding) throw new Error();
-  if (!reference.flags) throw new Error();
-  if (!isArray(node) && typeof node === 'object' && !hasOwn(node, 'tags')) throw new Error();
+export const deepFreeze = (object) => {
+  let list = emptyStack.push(object);
+  while (list.size) {
+    let item = list.value;
+    list = list.pop();
 
-  if (reference.value) throw new Error();
+    for (const value of Object.values(item)) {
+      if (isObject(value)) {
+        list = list.push(value);
+      }
+    }
 
-  return freeze({ reference, binding, node });
+    Object.freeze(item);
+  }
 };
 
-export const buildPropertyWrapper = (tags, property) => {
+export const buildProperty = (tags, shift) => {
+  if (shift && !shift.index) throw new Error();
   freeze(tags);
-  freeze(property);
 
-  if (![ReferenceTag, ShiftTag].includes(tags[0].type)) throw new Error();
-  if (property.node && !(tags[1]?.type === InitializerTag || tags.length === 3)) 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({ tags, property });
-};
+  // if (property.node && !(tags.length === 3)) throw new Error();
+  // if (tags[0].type === ShiftTag && !property.shift) throw new Error();
 
-export const buildDocument = (doctypeTag, fragment) => {
-  return freeze({ type: Document, value: freeze({ doctypeTag, fragment }) });
-};
+  if ((tags[0]?.type == ShiftTag) !== !!shift) throw new Error();
+  if (tags[2] && ![NullNode, GapNode, TreeNode].includes(tags[2].type)) 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.tags) 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,
+  });
+};
 
-  if (reference.value) throw new Error();
+export const buildPropertyTag = (tags, shift) => {
+  return freeze({ type: Property, value: buildProperty(tags, shift) });
+};
 
-  return freeze({ reference, binding, node });
+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 && !['.', '#', '@', '_'].includes(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,
-  isArray = false,
-  flags = referenceFlags,
-  index,
-) => {
-  return buildReferenceTag(type, name, isArray, flags, index).value;
+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 buildNullTag = () => {
-  return freeze({ type: NullTag, value: undefined });
+export const referenceFromMatcher = (matcher) => {
+  let { type, name, flags } = matcher;
+  return buildReference(type, name, flags);
 };
 
-export const buildInitializer = (isArray = false) => {
-  return freeze({ isArray });
+export const buildShift = (index, height) => {
+  if (index == null || height == null) throw new Error();
+  return freeze({ index, height });
 };
 
-export const buildInitializerTag = (isArray = false) => {
-  return freeze({ type: InitializerTag, value: buildInitializer(isArray) });
+export const buildNullTag = () => {
+  return freeze({ type: NullTag, value: undefined });
 };
 
-export const buildBinding = (languagePath = []) => {
-  if (!isArray(languagePath)) throw new Error();
-  return freeze({ languagePath });
+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) => {
@@ -119,33 +137,70 @@ 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 = (version = 0) => {
+export const buildDoctypeTag = (version = 0, attributes = Object.freeze({})) => {
   return freeze({
     type: DoctypeTag,
-    value: freeze({ doctype: 'cstml', version }),
+    value: freeze({ doctype: 'cstml', version, attributes }),
   });
 };
 
+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 = nodeFlags,
-  type = null,
+  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 (printType(type).startsWith('https://')) throw new Error();
-  if (literalValue && (!isString(literalValue) || !flags.token)) throw new Error();
+  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,
@@ -165,10 +220,10 @@ export const buildLiteralTag = (value) => {
   return freeze({ type: LiteralTag, value });
 };
 
-export const buildAttributeDefinition = (path, value) => {
-  if (!path?.length) throw new Error();
-  freeze(path);
-  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();
@@ -178,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;
@@ -187,42 +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: true,
-});
-
-export const multiFragmentFlags = freeze({
-  token: false,
-  hasGap: false,
-  fragment: true,
-  cover: false,
 });
 
 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,
 });