@bablr/agast-helpers 0.7.1 → 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,49 +10,63 @@ import {
   NullTag,
   InitializerTag,
   LiteralTag,
-  TokenGroup,
-  EmbeddedNode,
+  AttributeDefinition,
+  BindingTag,
+  Document,
 } from './symbols.js';
 
-const { freeze } = Object;
+const { freeze, hasOwn } = Object;
 const { isArray } = Array;
 
-const isObject = (val) => val !== null && typeof val === 'object';
-
-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;
-    }
-  }
-}
+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();
 
-const find = (predicate, iterable) => {
-  for (const value of iterable) {
-    if (predicate(value)) return value;
-  }
+  if (reference.value) throw new Error();
+
+  return freeze({ reference, binding, node });
 };
 
-export const buildTokenGroup = (tokens) => {
-  return freeze({ type: TokenGroup, value: tokens });
+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 buildEmbeddedNode = (node) => {
-  if (!isObject(node)) throw new Error();
-  return freeze({ type: EmbeddedNode, value: node });
+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.tags) throw new Error();
+
+  if (reference.value) throw new Error();
+
+  return freeze({ reference, binding, node });
 };
 
 export const buildBeginningOfStreamToken = () => {
   return freeze({ type: Symbol.for('@bablr/beginning-of-stream'), value: undefined });
 };
 
-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();
+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;
@@ -60,49 +74,82 @@ export const buildReferenceTag = (name, isArray = false, flags = referenceFlags,
 
   return freeze({
     type: ReferenceTag,
-    value: freeze({ name, isArray, index, flags: freeze({ hasGap, expression }) }),
+    value: freeze({ type, name, isArray, flags: freeze({ hasGap, expression }) }),
   });
 };
 
+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: { 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 = []) => {
+  if (!isArray(languagePath)) throw new Error();
+  return freeze({ type: BindingTag, value: freeze({ languagePath }) });
+};
+
+export const buildChild = (type, value) => {
+  if (!isSymbol(type)) throw new Error();
+  return freeze({ type, value });
 };
 
 export const buildGapTag = () => {
   return freeze({ type: GapTag, value: undefined });
 };
 
-export const buildShiftTag = (index) => {
+export const buildShiftTag = (index, height) => {
   if (!Number.isFinite(index)) throw new Error();
-  return freeze({ type: ShiftTag, value: freeze({ index }) });
+  if (!Number.isFinite(height)) throw new Error();
+  return freeze({ type: ShiftTag, value: freeze({ index, height }) });
 };
 
-export const buildDoctypeTag = (attributes = {}) => {
+export const buildDoctypeTag = (version = 0) => {
   return freeze({
     type: DoctypeTag,
-    value: { doctype: 'cstml', version: 0, attributes: freeze(attributes) },
+    value: freeze({ doctype: 'cstml', version }),
   });
 };
 
 export const buildOpenNodeTag = (
   flags = nodeFlags,
-  language = null,
   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),
-      language,
       type: isString(type) ? Symbol.for(type) : type,
+      literalValue,
       attributes,
+      selfClosing,
     }),
   });
 };
@@ -118,12 +165,20 @@ 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 }) });
+};
+
 const flagsWithGap = new WeakMap();
 
-export const getFlagsWithGap = (flags) => {
+export const getFlagsWithGap = (flags, hasGap = true) => {
+  if (flags.hasGap === hasGap) return flags;
+
   let gapFlags = flagsWithGap.get(flags);
   if (!gapFlags) {
-    gapFlags = { ...flags, hasGap: true };
+    gapFlags = { ...flags, hasGap };
     flagsWithGap.set(flags, gapFlags);
   }
   return gapFlags;
@@ -132,23 +187,29 @@ export const getFlagsWithGap = (flags) => {
 export const nodeFlags = freeze({
   token: false,
   hasGap: false,
+  fragment: false,
+  cover: false,
 });
 
-const hasGap = (properties) => {
-  return find((node) => node.flags.hasGap, relatedNodes(properties));
-};
+export const fragmentFlags = freeze({
+  token: false,
+  hasGap: false,
+  fragment: true,
+  cover: true,
+});
 
-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,
   hasGap: false,
+  fragment: false,
+  cover: false,
 });
 
 export const referenceFlags = freeze({

package/lib/object.js

@@ -0,0 +1,86 @@
+export const { hasOwn, freeze, isFrozen, seal, isSealed, getPrototypeOf, getOwnPropertySymbols } =
+  Object;
+export const { isArray } = Array;
+
+export const has = (obj, path) => {
+  let value = obj;
+  for (const part of path) {
+    if (!hasOwn(value, part)) return false;
+    value = value[part];
+  }
+  return true;
+};
+
+export const get = (obj, path) => {
+  let value = obj;
+  for (const part of path) {
+    value = value[part];
+  }
+  return value;
+};
+
+export const set = (obj, path, value) => {
+  let obj_ = obj;
+
+  let lastKey;
+  for (let i = 0; i < path.length; i++) {
+    let key = path[i] < 0 ? obj_.length + path[i] : path[i];
+    let deeper = obj_[key];
+
+    if (path.length - 1 === i) {
+      lastKey = key;
+    } else if (deeper !== undefined) {
+      obj_ = deeper;
+    } else if (Number.isFinite(path[i + 1])) {
+      obj_ = deeper = obj_[key] = [];
+    } else {
+      obj_ = deeper = obj_[key] = {};
+    }
+  }
+
+  obj_[lastKey] = value;
+};
+
+export const immSet = (obj, path, value) => {
+  let obj_ = obj;
+
+  let objs = [];
+
+  for (let i = 0; i < path.length; i++) {
+    let key = path[i] < 0 ? obj_.length + path[i] : path[i];
+    let deeper = obj_[key];
+
+    if (obj_) {
+      objs.push(obj_);
+    }
+
+    if (path.length - 1 === i || hasOwn(obj_, deeper)) {
+      obj_ = deeper;
+    } else if (Number.isFinite(path[i + 1])) {
+      obj_ = [];
+      objs.push(obj_);
+    } else {
+      obj_ = {};
+    }
+  }
+
+  let newValue = value;
+  for (let i = objs.length - 1; i >= 0; i--) {
+    obj_ = objs[i];
+    obj_ = isArray(obj_) ? [...obj_] : { ...obj_ };
+    obj_[path[i]] = newValue;
+    freeze(obj_);
+    newValue = obj_;
+  }
+
+  return obj_;
+};
+
+export const isObject = (obj) => obj !== null && typeof obj === 'object';
+export const isPlainObject = (val) => val && [Object.prototype, null].includes(getPrototypeOf(val));
+export const isFunction = (obj) => typeof obj === 'function';
+export const isSymbol = (obj) => typeof obj === 'symbol';
+export const isString = (obj) => typeof obj === 'string';
+export const isType = (obj) => isSymbol(obj) || isString(obj);
+export const isRegex = (obj) => obj instanceof RegExp;
+export const isPattern = (obj) => isString(obj) || isRegex(obj);

package/lib/path-facade.js

@@ -0,0 +1,44 @@
+import { CloseNodeTag, OpenNodeTag, ReferenceTag } from './symbols.js';
+
+export function* allTagPathsFor(range, options = {}) {
+  if (range == null) return;
+
+  const { unshift = false } = options;
+  let startPath = range[0];
+  let endPath = range[1];
+  let tagPath = startPath;
+
+  while (tagPath) {
+    if (tagPath.inner && tagPath.previousSibling.tag.type === ReferenceTag) {
+      tagPath = tagPath.inner.tagPathAt(0);
+    }
+
+    if (tagPath.path.depth < startPath.path.depth) {
+      return;
+    }
+
+    yield tagPath;
+
+    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;
+      }
+    }
+
+    if (endPath && endPath.equalTo(tagPath)) {
+      return;
+    }
+
+    tagPath = unshift ? tagPath.nextUnshifted : tagPath.next;
+  }
+}
+
+export function* allTagsFor(range, options = {}) {
+  for (let path of allTagPathsFor(range, options)) {
+    yield path.tag;
+  }
+}