@bablr/agast-helpers 0.7.1 → 0.8.0

package/lib/builders.js

@@ -11,14 +11,13 @@ import {
   InitializerTag,
   LiteralTag,
   TokenGroup,
-  EmbeddedNode,
+  AttributeDefinition,
+  BindingTag,
 } 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)) {
@@ -37,22 +36,45 @@ const find = (predicate, iterable) => {
   }
 };
 
-export const buildTokenGroup = (tokens) => {
-  return freeze({ type: TokenGroup, value: tokens });
+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();
+
+  if (reference.value) throw new Error();
+
+  return freeze({ reference, binding, node });
 };
 
-export const buildEmbeddedNode = (node) => {
-  if (!isObject(node)) throw new Error();
-  return freeze({ type: EmbeddedNode, value: node });
+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 (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 });
 };
 
-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 && !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;
@@ -60,7 +82,7 @@ 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 }) }),
   });
 };
 
@@ -69,38 +91,42 @@ export const buildNullTag = () => {
 };
 
 export const buildInitializerTag = (isArray = false) => {
-  return freeze({ type: InitializerTag, value: { isArray } });
+  return freeze({ type: InitializerTag, value: freeze({ isArray }) });
+};
+
+export const buildBindingTag = (languagePath = []) => {
+  if (!isArray(languagePath)) throw new Error();
+  return freeze({ type: BindingTag, value: freeze({ languagePath }) });
+};
+
+export const buildChild = (type, value) => {
+  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 = (attributes = {}, version = 0) => {
   return freeze({
     type: DoctypeTag,
-    value: { doctype: 'cstml', version: 0, attributes: freeze(attributes) },
+    value: freeze({ doctype: 'cstml', version, attributes: freeze(attributes) }),
   });
 };
 
-export const buildOpenNodeTag = (
-  flags = nodeFlags,
-  language = null,
-  type = null,
-  attributes = {},
-) => {
+export const buildOpenNodeTag = (flags = nodeFlags, type = null, attributes = {}) => {
   if (printType(type).startsWith('https://')) throw new Error();
 
   return freeze({
     type: OpenNodeTag,
     value: freeze({
       flags: freeze(flags),
-      language,
       type: isString(type) ? Symbol.for(type) : type,
       attributes,
     }),
@@ -118,12 +144,18 @@ export const buildLiteralTag = (value) => {
   return freeze({ type: LiteralTag, value });
 };
 
+export const buildAttributeDefinition = (path, value) => {
+  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,6 +164,15 @@ export const getFlagsWithGap = (flags) => {
 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) => {
@@ -149,6 +190,8 @@ const getFlags = (flags, properties) => {
 export const tokenFlags = freeze({
   token: true,
   hasGap: false,
+  fragment: false,
+  cover: false,
 });
 
 export const referenceFlags = freeze({

package/lib/children.js

@@ -0,0 +1,120 @@
+import { buildModule, defaultNodeSize } from '@bablr/btree/enhanceable';
+import {
+  BindingTag,
+  InitializerTag,
+  LiteralTag,
+  OpenNodeTag,
+  Property,
+  ReferenceTag,
+} from './symbols.js';
+
+const { isArray } = Array;
+const { freeze } = Object;
+
+export { defaultNodeSize };
+
+const {
+  btreeFrom: sumTreeFrom,
+  from,
+  btreeFromValues: sumTreeFromValues,
+  fromValues,
+  findBalancePoint,
+  splitValues,
+  collapses,
+  nodeCollapses,
+  nodeCanDonate,
+  pop,
+  push: push_,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getValues,
+  getSums,
+  setValues,
+  isLeafNode,
+  traverse,
+  getSize,
+  findPath,
+  getAt,
+  replaceAt,
+} = buildModule(
+  defaultNodeSize,
+  (acc, val) => {
+    const { references, specialTypes } = acc;
+    if (isArray(val)) {
+      acc.lineBreaks += val[2].lineBreaks;
+      for (const { 0: key, 1: value } of Object.entries(val[2].references)) {
+        references[key] = (references[key] ?? 0) + value;
+      }
+
+      for (const { 0: key, 1: value } of Object.entries(val[2].specialTypes)) {
+        specialTypes[key] = (specialTypes[key] ?? 0) + value;
+      }
+    } else {
+      if (val.type === LiteralTag) {
+        let text = val.value;
+        let idx = 0;
+        while ((idx = text.indexOf('\n', idx + 1)) >= 0) {
+          acc.lineBreaks++;
+        }
+      } else if (val.type === ReferenceTag) {
+        const { type, name } = val.value;
+        if (type) {
+          specialTypes[type] = (specialTypes[type] ?? 0) + 1;
+        } else {
+          references[name] = (references[name] ?? 0) + 1;
+        }
+      }
+    }
+    return acc;
+  },
+  () => ({
+    lineBreaks: 0,
+    references: {},
+    specialTypes: {},
+  }),
+  (stats) => {
+    freeze(stats);
+    freeze(stats.references);
+  },
+);
+
+const push = (children, tag) => {
+  let lastTag = getAt(-1, children);
+
+  if (tag.type === Property && lastTag.type !== BindingTag) {
+    throw new Error();
+  }
+
+  if (lastTag?.type === ReferenceTag && ![BindingTag, InitializerTag].includes(tag.type)) {
+    throw new Error();
+  }
+
+  return push_(children, tag);
+};
+
+export {
+  sumTreeFrom as btreeFrom,
+  from,
+  sumTreeFromValues as btreeFromValues,
+  fromValues,
+  findBalancePoint,
+  splitValues,
+  collapses,
+  nodeCollapses,
+  nodeCanDonate,
+  pop,
+  push,
+  addAt,
+  isValidNode,
+  assertValidNode,
+  getValues,
+  getSums,
+  setValues,
+  isLeafNode,
+  traverse,
+  getSize,
+  findPath,
+  getAt,
+  replaceAt,
+};

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,39 @@
+import { CloseNodeTag, 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 path = startPath;
+
+  while (path) {
+    if (path.inner && path.previousSibling.tag.type === ReferenceTag) {
+      path = path.inner.tagPathAt(0);
+    }
+
+    if (path.path.depth < startPath.path.depth) {
+      return;
+    }
+
+    yield path;
+
+    if (endPath && endPath.equalTo(path)) {
+      return;
+    }
+
+    let propPath = path.path.parent && path.path.parent.tagPathAt(path.path.referenceIndex + 2);
+
+    if (endPath && path.tag.type === CloseNodeTag && propPath && endPath.equalTo(propPath)) {
+      return;
+    }
+    path = unshift ? path.nextUnshifted : path.next;
+  }
+}
+
+export function* allTagsFor(range, options = {}) {
+  for (let path of allTagPathsFor(range, options)) {
+    yield path.tag;
+  }
+}