@bablr/agast-helpers 0.10.10 → 0.11.0

package/lib/debug.js

@@ -0,0 +1,39 @@
+import { TagPath } from '@bablr/agast-helpers/path';
+import { printTag } from '@bablr/agast-helpers/print';
+import { CloseNodeTag, LiteralTag, OpenNodeTag } from '@bablr/agast-helpers/symbols';
+
+export { printTag };
+
+export const printTree = (tree) => {
+  let printed = '';
+  let unshift = false;
+  let tagPath = TagPath.fromNode(tree, 0);
+
+  let count = 0;
+
+  do {
+    if (tagPath.type === CloseNodeTag) count--;
+
+    printed += '\n' + '  '.repeat(count) + printTag(tagPath.tag);
+
+    if (tagPath.type === OpenNodeTag && !tagPath.value.selfClosing) count++;
+  } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
+
+  return printed;
+};
+
+export const printTreeSource = (tree) => {
+  let printed = '';
+  let unshift = false;
+  let tagPath = TagPath.fromNode(tree, 0);
+
+  do {
+    if (tagPath.type === LiteralTag) {
+      printed += tagPath.value;
+    } else if (tagPath.type === OpenNodeTag && tagPath.value.literalValue) {
+      printed += tagPath.value.literalValue;
+    }
+  } while ((tagPath = unshift ? tagPath.nextUnshifted : tagPath.next));
+
+  return printed;
+};

package/lib/debug.register.js

@@ -0,0 +1,5 @@
+import { printTag, printTree, printTreeSource } from './debug.js';
+
+globalThis.printTag = printTag;
+globalThis.printTree = printTree;
+globalThis.printTreeSource = printTreeSource;

package/lib/iterable.js

@@ -0,0 +1,170 @@
+import {
+  continue_,
+  getStreamIterator,
+  StreamGenerator,
+  StreamIterable,
+  wait,
+} from '@bablr/stream-iterator';
+
+let { getPrototypeOf } = Object;
+let { isArray } = Array;
+
+export const maybeWait = (maybePromise, callback) => {
+  if (maybePromise instanceof Promise) {
+    return maybePromise.then(callback);
+  } else {
+    return callback(maybePromise);
+  }
+};
+
+function* __concat(iterables) {
+  for (const iterable of iterables) {
+    let iter = getStreamIterator(iterable);
+    let step;
+
+    for (;;) {
+      step = iter.next();
+      while (step === null || step instanceof Promise) {
+        if (step === null) yield continue_(), (step = iter.next());
+        if (step instanceof Promise) step = yield wait(step);
+      }
+      if (step.done) break;
+
+      yield step.value;
+    }
+  }
+}
+
+export const concat = (...iterables) => {
+  return new StreamIterable(__concat(iterables));
+};
+
+function* __reduce(reducer, values, initial) {
+  let acc = initial;
+  let iter = getStreamIterator(values);
+  let step;
+
+  for (;;) {
+    step = iter.next();
+    while (step === null || step instanceof Promise) {
+      if (step === null) yield continue_(), (step = iter.next());
+      if (step instanceof Promise) step = yield wait(step);
+    }
+    if (step.done) break;
+
+    let { value } = step;
+
+    acc = reducer(acc, value);
+  }
+
+  return acc;
+}
+
+export const reduce = (reducer, value, initial) => {
+  let iter = new StreamGenerator(__reduce(reducer, value, initial));
+
+  return maybeWait(iter.next(), (step) => step.value);
+};
+
+function* __isEmpty(iterable) {
+  let iter = getStreamIterator(iterable);
+  let step;
+
+  for (;;) {
+    step = iter.next();
+    while (step === null || step instanceof Promise) {
+      if (step === null) yield continue_(), (step = iter.next());
+      if (step instanceof Promise) step = yield wait(step);
+    }
+    if (step.done) break;
+
+    return false;
+  }
+
+  return true;
+}
+
+export const isEmpty = (iterable) => {
+  if (iterable == null) return true;
+  let iter = new StreamGenerator(__isEmpty(iterable));
+
+  return maybeWait(iter.next(), (step) => step.value);
+};
+
+function* __map(fn, iterable) {
+  let iter = getStreamIterator(iterable);
+  let step;
+
+  for (;;) {
+    step = iter.next();
+    while (step === null || step instanceof Promise) {
+      if (step === null) yield continue_(), (step = iter.next());
+      if (step instanceof Promise) step = yield wait(step);
+    }
+    if (step.done) break;
+
+    let value = fn(step.value);
+
+    if (value instanceof Promise) {
+      value = yield wait(value);
+    }
+
+    yield value;
+  }
+}
+
+export const map = (fn, iterable) => {
+  return new StreamIterable(__map(fn, iterable));
+};
+
+function* __flatMap(fn, tags) {
+  let iter = getStreamIterator(tags);
+  let step;
+
+  for (;;) {
+    step = iter.next();
+    while (step === null || step instanceof Promise) {
+      if (step === null) yield continue_(), (step = iter.next());
+      if (step instanceof Promise) step = yield wait(step);
+    }
+    if (step.done) break;
+
+    let { value } = step;
+
+    yield* fn(value);
+  }
+
+  return true;
+}
+
+export const flatMap = (fn, tags) => new StreamIterable(__flatMap(fn, tags));
+
+function* __arrayValues(arr) {
+  let { length } = arr;
+  for (let i = 0; i < length; i++) yield arr[i];
+}
+
+export const arrayValues = (arr) => {
+  let proto = getPrototypeOf(arr);
+  return proto === Array.prototype ? arr[Symbol.iterator]() : __arrayValues(arr);
+};
+
+function* __wrap(iterable) {
+  let iter = getStreamIterator(iterable);
+  let step;
+
+  for (;;) {
+    step = iter.next();
+    while (step === null || step instanceof Promise) {
+      if (step === null) yield continue_(), (step = iter.next());
+      if (step instanceof Promise) step = yield wait(step);
+    }
+    if (step.done) break;
+
+    yield step.value;
+  }
+}
+
+export const wrap = (iterable) => {
+  return isArray(iterable) ? arrayValues(iterable) : new StreamIterable(__wrap(iterable));
+};

package/lib/object.js

@@ -1,10 +1,28 @@
+import { wrap } from './iterable.js';
+
 export const { hasOwn, freeze, isFrozen, seal, isSealed, getPrototypeOf, getOwnPropertySymbols } =
   Object;
 export const { isArray } = Array;
 
+export { deepFreezeRecord, isDeepRecord, isRecord, recordValues } from '@bablr/record';
+
+let { setPrototypeOf } = Object;
+
+export const freezeRecord = (obj) => {
+  setPrototypeOf(obj, null);
+  freeze(obj);
+  return obj;
+};
+
+export const freezeClass = (constructor) => {
+  freeze(constructor);
+  freeze(constructor.prototype);
+  return constructor;
+};
+
 export const has = (obj, path) => {
   let value = obj;
-  for (const part of path) {
+  for (const part of wrap(path)) {
     if (!hasOwn(value, part)) return false;
     value = value[part];
   }
@@ -13,7 +31,7 @@ export const has = (obj, path) => {
 
 export const get = (obj, path) => {
   let value = obj;
-  for (const part of path) {
+  for (const part of wrap(path)) {
     value = value[part];
   }
   return value;
@@ -69,13 +87,42 @@ export const immSet = (obj, path, value) => {
     obj_ = objs[i];
     obj_ = isArray(obj_) ? [...obj_] : { ...obj_ };
     obj_[path[i]] = newValue;
-    freeze(obj_);
+    freezeRecord(obj_);
     newValue = obj_;
   }
 
   return obj_;
 };
 
+const emptyIterator = {
+  next() {
+    return { value: undefined, done: true };
+  },
+};
+
+const emptySpreadable = Object.freeze(
+  Object.create({
+    [Symbol.iterator]() {
+      return emptyIterator;
+    },
+  }),
+);
+
+export const when = (condition, value) => {
+  const valueType = typeof value;
+  if (
+    !(value == null || value[Symbol.iterator] || valueType === 'object' || valueType === 'function')
+  ) {
+    throw new Error('Second argument to when must be an object, iterable, or function.');
+  }
+
+  return condition && value != null
+    ? valueType === 'function'
+      ? value()
+      : value
+    : emptySpreadable;
+};
+
 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';
@@ -84,3 +131,5 @@ 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);
+
+export const arrayLast = (arr) => arr[arr.length - 1];

package/lib/parse.js

@@ -0,0 +1,30 @@
+import { isObject } from './object.js';
+
+export const buildParser = (str) => {
+  return isObject(str) ? str : { idx: 0, str };
+};
+
+export const inRange = (value, lower, upper) => value >= lower && value <= upper;
+
+let refChrs = ['.', '#', '@', '_', '`'];
+
+export const canStartIdentifier = (chr) => {
+  return (
+    inRange(chr, 'a', 'z') ||
+    inRange(chr, 'A', 'Z') ||
+    refChrs.includes(chr) ||
+    inRange(chr, '\u0080', '\u{10ffff}')
+  );
+};
+
+export const match = (p, literal) => {
+  let idx = 0;
+  let endIdx = literal.length;
+  let { idx: pIdx, str } = p;
+
+  while (idx < endIdx) {
+    if (str[pIdx + idx] !== literal[idx]) return null;
+    idx++;
+  }
+  return literal;
+};