@bablr/agast-helpers 0.8.0 → 0.9.0

package/lib/builders.js

@@ -1,4 +1,4 @@
-import * as btree from './btree.js';
+import { isSymbol } from './object.js';
 import { printType } from './print.js';
 import {
   DoctypeTag,
@@ -10,56 +10,48 @@ import {
   NullTag,
   InitializerTag,
   LiteralTag,
-  TokenGroup,
   AttributeDefinition,
   BindingTag,
+  Document,
 } from './symbols.js';
 
 const { freeze, hasOwn } = 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;
-      }
-    } else {
-      yield value.node;
-    }
-  }
-}
-
-const find = (predicate, iterable) => {
-  for (const value of iterable) {
-    if (predicate(value)) return value;
-  }
-};
-
-export const buildProperty = (reference, binding, node) => {
+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, 'properties')) throw new Error();
+  if (!isArray(node) && typeof node === 'object' && !hasOwn(node, 'tags')) throw new Error();
 
   if (reference.value) throw new Error();
 
   return freeze({ reference, binding, node });
 };
 
+export const buildPropertyWrapper = (tags, property) => {
+  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();
+
+  return freeze({ tags, property });
+};
+
+export const buildDocument = (doctypeTag, fragment) => {
+  return freeze({ type: Document, value: freeze({ doctypeTag, fragment }) });
+};
+
 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 (!isArray(node) && typeof node === 'object' && !node.tags) throw new Error();
 
   if (reference.value) throw new Error();
 
   return freeze({ reference, binding, node });
 };
 
-export const buildTokenGroup = (tokens) => {
-  return freeze({ type: TokenGroup, value: tokens });
-};
-
 export const buildBeginningOfStreamToken = () => {
   return freeze({ type: Symbol.for('@bablr/beginning-of-stream'), value: undefined });
 };
@@ -71,7 +63,7 @@ export const buildReferenceTag = (
   flags = referenceFlags,
   index,
 ) => {
-  if (type != null && !isString(type)) throw new Error();
+  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();
@@ -86,12 +78,31 @@ export const buildReferenceTag = (
   });
 };
 
+export const buildReference = (
+  type = null,
+  name = null,
+  isArray = false,
+  flags = referenceFlags,
+  index,
+) => {
+  return buildReferenceTag(type, name, isArray, flags, index).value;
+};
+
 export const buildNullTag = () => {
   return freeze({ type: NullTag, value: undefined });
 };
 
+export const buildInitializer = (isArray = false) => {
+  return freeze({ isArray });
+};
+
 export const buildInitializerTag = (isArray = false) => {
-  return freeze({ type: InitializerTag, value: freeze({ isArray }) });
+  return freeze({ type: InitializerTag, value: buildInitializer(isArray) });
+};
+
+export const buildBinding = (languagePath = []) => {
+  if (!isArray(languagePath)) throw new Error();
+  return freeze({ languagePath });
 };
 
 export const buildBindingTag = (languagePath = []) => {
@@ -100,6 +111,7 @@ export const buildBindingTag = (languagePath = []) => {
 };
 
 export const buildChild = (type, value) => {
+  if (!isSymbol(type)) throw new Error();
   return freeze({ type, value });
 };
 
@@ -113,22 +125,31 @@ export const buildShiftTag = (index, height) => {
   return freeze({ type: ShiftTag, value: freeze({ index, height }) });
 };
 
-export const buildDoctypeTag = (attributes = {}, version = 0) => {
+export const buildDoctypeTag = (version = 0) => {
   return freeze({
     type: DoctypeTag,
-    value: freeze({ doctype: 'cstml', version, attributes: freeze(attributes) }),
+    value: freeze({ doctype: 'cstml', version }),
   });
 };
 
-export const buildOpenNodeTag = (flags = nodeFlags, type = null, attributes = {}) => {
+export const buildOpenNodeTag = (
+  flags = nodeFlags,
+  type = null,
+  attributes = {},
+  literalValue = null,
+  selfClosing = !!literalValue,
+) => {
   if (printType(type).startsWith('https://')) throw new Error();
+  if (literalValue && (!isString(literalValue) || !flags.token)) throw new Error();
 
   return freeze({
     type: OpenNodeTag,
     value: freeze({
       flags: freeze(flags),
       type: isString(type) ? Symbol.for(type) : type,
+      literalValue,
       attributes,
+      selfClosing,
     }),
   });
 };
@@ -145,6 +166,8 @@ export const buildLiteralTag = (value) => {
 };
 
 export const buildAttributeDefinition = (path, value) => {
+  if (!path?.length) throw new Error();
+  freeze(path);
   return freeze({ type: AttributeDefinition, value: freeze({ path, value }) });
 };
 
@@ -172,20 +195,15 @@ export const fragmentFlags = freeze({
   token: false,
   hasGap: false,
   fragment: true,
-  cover: false,
+  cover: true,
 });
 
-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 multiFragmentFlags = freeze({
+  token: false,
+  hasGap: false,
+  fragment: true,
+  cover: false,
+});
 
 export const tokenFlags = freeze({
   token: true,

package/lib/path-facade.js

@@ -1,4 +1,4 @@
-import { CloseNodeTag, ReferenceTag } from './symbols.js';
+import { CloseNodeTag, OpenNodeTag, ReferenceTag } from './symbols.js';
 
 export function* allTagPathsFor(range, options = {}) {
   if (range == null) return;
@@ -6,29 +6,34 @@ export function* allTagPathsFor(range, options = {}) {
   const { unshift = false } = options;
   let startPath = range[0];
   let endPath = range[1];
-  let path = startPath;
+  let tagPath = startPath;
 
-  while (path) {
-    if (path.inner && path.previousSibling.tag.type === ReferenceTag) {
-      path = path.inner.tagPathAt(0);
+  while (tagPath) {
+    if (tagPath.inner && tagPath.previousSibling.tag.type === ReferenceTag) {
+      tagPath = tagPath.inner.tagPathAt(0);
     }
 
-    if (path.path.depth < startPath.path.depth) {
+    if (tagPath.path.depth < startPath.path.depth) {
       return;
     }
 
-    yield path;
+    yield tagPath;
 
-    if (endPath && endPath.equalTo(path)) {
-      return;
+    if (
+      tagPath.tag.type === CloseNodeTag ||
+      (tagPath.tag.type === OpenNodeTag && tagPath.tag.value.selfClosing)
+    ) {
+      let propPath = tagPath.path.parentPropertyPath;
+      if (endPath && propPath && endPath.equalTo(propPath.path.tagPathAt(propPath.tagsIndex, 2))) {
+        return;
+      }
     }
 
-    let propPath = path.path.parent && path.path.parent.tagPathAt(path.path.referenceIndex + 2);
-
-    if (endPath && path.tag.type === CloseNodeTag && propPath && endPath.equalTo(propPath)) {
+    if (endPath && endPath.equalTo(tagPath)) {
       return;
     }
-    path = unshift ? path.nextUnshifted : path.next;
+
+    tagPath = unshift ? tagPath.nextUnshifted : tagPath.next;
   }
 }