@weborigami/origami 0.5.3 → 0.5.5

package/src/tree/match.js

@@ -1,79 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
-/**
- * Return a tree with the indicated keys (if provided).
- *
- * The pattern can a string with a simplified pattern syntax that tries to match
- * against the entire key and uses brackets to identify named wildcard values.
- * E.g. `[name].html` will match `Alice.html` with wildcard values { name:
- * "Alice" }.
- *
- * The pattern can also be a JavaScript regular expression.
- *
- * If a key is requested, match against the given pattern and, if matches,
- * invokes the given function with an object containing the matched values.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../index.ts").Invocable} Invocable
- *
- * @this {AsyncTree|null}
- * @param {string|RegExp} pattern
- * @param {Invocable} resultFn
- * @param {Treelike} [keys]
- */
-export default function match(pattern, resultFn, keys = []) {
-  assertTreeIsDefined(this, "match");
-  let regex;
-  if (typeof pattern === "string") {
-    // Convert the simple pattern format into a regular expression.
-    const regexText = pattern.replace(
-      /\[(?<variable>.+)\]/g,
-      (match, p1, offset, string, groups) => `(?<${groups.variable}>.+)`
-    );
-    regex = new RegExp(`^${regexText}$`);
-  } else if (pattern instanceof RegExp) {
-    regex = pattern;
-  } else {
-    throw new Error(`match(): Unsupported pattern`);
-  }
-
-  const tree = this;
-
-  const result = {
-    async get(key) {
-      const keyMatch = regex.exec(key);
-      if (!keyMatch) {
-        return undefined;
-      }
-
-      if (
-        typeof resultFn !== "function" &&
-        !(Tree.isAsyncTree(resultFn) && "parent" in resultFn)
-      ) {
-        // Simple return value; return as is
-        return resultFn;
-      }
-
-      // Copy the `groups` property to a real object
-      const matches = { ...keyMatch.groups };
-
-      // Invoke the result function with the extended scope.
-      let value;
-      if (typeof resultFn === "function") {
-        value = await resultFn.call(this, matches);
-      } else {
-        value = Object.create(resultFn);
-      }
-
-      return value;
-    },
-
-    async keys() {
-      return typeof keys === "function" ? await keys.call(tree) : keys;
-    },
-  };
-
-  return result;
-}

package/src/tree/merge.js

@@ -1,41 +0,0 @@
-import { isPlainObject, isUnpackable, merge } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
-/**
- * Create a tree that's the result of merging the given trees.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {AsyncTree|null}
- * @param {(Treelike|null)[]} trees
- */
-export default async function treeMerge(...trees) {
-  assertTreeIsDefined(this, "merge");
-
-  // Filter out null or undefined trees.
-  /** @type {Treelike[]}
-   * @ts-ignore */
-  const filtered = trees.filter((tree) => tree);
-
-  if (filtered.length === 1) {
-    // Only one tree, no need to merge.
-    return filtered[0];
-  }
-
-  // Unpack any packed objects.
-  const unpacked = await Promise.all(
-    filtered.map((obj) =>
-      isUnpackable(obj) ? /** @type {any} */ (obj).unpack() : obj
-    )
-  );
-
-  // If all trees are plain objects, return a plain object.
-  if (unpacked.every((tree) => isPlainObject(tree))) {
-    return merge(...unpacked);
-  }
-
-  // Merge the trees.
-  const result = merge(...unpacked);
-  return result;
-}

package/src/tree/paginate.js

@@ -1,20 +0,0 @@
-import { paginate } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Return a new grouping of the treelike's values into chunks of the specified
- * size.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- * @param {number} [size=10]
- */
-export default async function paginateBuiltin(treelike, size = 10) {
-  const tree = await getTreeArgument(this, arguments, treelike, "paginate");
-  const paginated = await paginate(tree, size);
-  paginated.parent = this;
-  return paginated;
-}

package/src/tree/parent.js

@@ -1,15 +0,0 @@
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Returns the parent of the current tree.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function parent(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "parent");
-  return tree.parent;
-}

package/src/tree/plain.js

@@ -1,15 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Return the interior nodes of the tree.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function plain(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "plain");
-  return Tree.plain(tree);
-}

package/src/tree/regExpKeys.js

@@ -1,19 +0,0 @@
-import { setParent } from "@weborigami/async-tree";
-import regExpKeys from "@weborigami/async-tree/src/operations/regExpKeys.js";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
-/**
- * Define a tree whose keys are regular expression strings.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @param {Treelike} tree
- * @this {AsyncTree|null}
- */
-export default async function regExpKeysBuiltin(tree) {
-  assertTreeIsDefined(this, "regExpKeys");
-  const result = regExpKeys(tree);
-  setParent(this, result);
-  return result;
-}

package/src/tree/reverse.js

@@ -1,17 +0,0 @@
-import { reverse } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Reverse the order of the top-level keys in the tree.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function reverseBuiltin(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "reverse");
-  const reversed = reverse(tree);
-  return reversed;
-}

package/src/tree/setDeep.js

@@ -1,49 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {import("@weborigami/types").AsyncTree|null}
- * @param {Treelike} target
- * @param {Treelike} source
- */
-export default async function setDeep(target, source) {
-  const targetTree = Tree.from(target, { parent: this });
-  const sourceTree = Tree.from(source, { parent: this });
-  await applyUpdates(sourceTree, targetTree);
-}
-
-// Apply all updates from the source to the target.
-async function applyUpdates(source, target) {
-  // Fire off requests to update all keys, then wait for all of them to finish.
-  const promises = [];
-  for (const key of await source.keys()) {
-    const updateKeyPromise = applyUpdateForKey(source, target, key);
-    promises.push(updateKeyPromise);
-  }
-  await Promise.all(promises);
-
-  // HACK: Transforms like KeysTransform that maintain caches will need to
-  // recalculate things now that updates have been applied. This should be an
-  // automatic part of calling set() -- but triggering those changes inside
-  // set() produces cases where set() and get() calls can be interleaved. The
-  // atomicity of set() needs to be reconsidered. For now, we work around the
-  // problem by triggering `onChange` after the updates have been applied.
-  target.onChange?.();
-}
-
-// Copy the value for the given key from the source to the target.
-async function applyUpdateForKey(source, target, key) {
-  const sourceValue = await source.get(key);
-  if (Tree.isAsyncTree(sourceValue)) {
-    const targetValue = await target.get(key);
-    if (Tree.isAsyncTree(targetValue)) {
-      // Both source and target are async dictionaries; recurse.
-      await applyUpdates(sourceValue, targetValue);
-      return;
-    }
-  }
-
-  // Copy the value from the source to the target.
-  await target.set(key, sourceValue);
-}

package/src/tree/shuffle.js

@@ -1,57 +0,0 @@
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Return a new tree with the original's keys shuffled
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- * @param {boolean} [reshuffle]
- */
-export default async function shuffleTree(treelike, reshuffle = false) {
-  // Special case: If the treelike is an array, shuffle it directly. Otherwise
-  // we'll end up shuffling the array's indexes, and if this is directly
-  // displayed by the ori CLI, this will end up creating a plain object. Even
-  // though this object will be created with the keys in the correct shuffled
-  // order, a JS object will always return numeric keys in numeric order --
-  // undoing the shuffle.
-  if (Array.isArray(treelike)) {
-    const array = treelike.slice();
-    shuffle(array);
-    return array;
-  }
-
-  const tree = await getTreeArgument(this, arguments, treelike, "shuffle");
-
-  let keys;
-  return {
-    async get(key) {
-      return tree.get(key);
-    },
-
-    async keys() {
-      if (!keys || reshuffle) {
-        keys = Array.from(await tree.keys());
-        shuffle(keys);
-      }
-      return keys;
-    },
-  };
-}
-
-/*
- * Shuffle an array.
- *
- * Performs a Fisher-Yates shuffle. From http://sedition.com/perl/javascript-fy.html
- */
-export function shuffle(array) {
-  let i = array.length;
-  while (--i >= 0) {
-    const j = Math.floor(Math.random() * (i + 1));
-    const temp = array[i];
-    array[i] = array[j];
-    array[j] = temp;
-  }
-}

package/src/tree/sort.js

@@ -1,52 +0,0 @@
-import { sort as sortTransform } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-import { toFunction } from "../common/utilities.js";
-
-/**
- * Return a new tree with the original's keys sorted.
- *
- * If the `options` include a `sortKey` function, that will be invoked for each
- * key in the tree to produce a sort key. If no `sortKey` function is provided,
- * the original keys will be used as sort keys.
- *
- * If the `options` include a `compare` function, that will be used to compare
- * sort keys.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("@weborigami/async-tree").ValueKeyFn} ValueKeyFn
- * @typedef {{ compare?: (a: any, b: any) => number, sortKey?: ValueKeyFn }}
- * SortOptions
- *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- * @param {SortOptions|ValueKeyFn} [options]
- */
-export default async function sortBuiltin(treelike, options) {
-  const tree = await getTreeArgument(this, arguments, treelike, "sort");
-
-  if (typeof options === "function") {
-    // Take the function as the `sortKey` option
-    options = { sortKey: options };
-  }
-
-  const compare = options?.compare;
-  let extendedSortKeyFn;
-  if (options?.sortKey) {
-    const originalSortKey = toFunction(options?.sortKey);
-    const parent = this;
-    extendedSortKeyFn = async (key, tree) => {
-      const value = await tree.get(key);
-      const sortKey = await originalSortKey.call(parent, value, key);
-      return sortKey;
-    };
-  }
-
-  const sorted = await sortTransform(tree, {
-    compare,
-    sortKey: extendedSortKeyFn,
-  });
-
-  sorted.parent = this;
-  return sorted;
-}

package/src/tree/take.js

@@ -1,19 +0,0 @@
-import { take as takeTransform } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Given a tree, take the first n items from it.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {AsyncTree|null}
- * @param {Treelike} treelike
- * @param {number} count
- */
-export default async function take(treelike, count) {
-  const tree = await getTreeArgument(this, arguments, treelike, "take");
-  const taken = await takeTransform(tree, count);
-  taken.parent = this;
-  return taken;
-}

package/src/tree/tree.js

@@ -1,52 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-export { default as addNextPrevious } from "./addNextPrevious.js";
-export { default as cache } from "./cache.js";
-export { default as calendar } from "./calendar.js";
-export { default as clear } from "./clear.js";
-export { default as concat } from "./concat.js";
-export { default as constant } from "./constant.js";
-export { default as deepMap } from "./deepMap.js";
-export { default as deepMerge } from "./deepMerge.js";
-export { default as deepReverse } from "./deepReverse.js";
-export { default as deepTake } from "./deepTake.js";
-export { default as deepValues } from "./deepValues.js";
-export { default as defineds } from "./defineds.js";
-export { default as filter } from "./filter.js";
-export { default as first } from "./first.js";
-export { default as fromFn } from "./fromFn.js";
-export { default as globKeys } from "./globKeys.js";
-export { default as group } from "./group.js";
-export { default as inners } from "./inners.js";
-export { default as keys } from "./keys.js";
-export { default as length } from "./length.js";
-export { default as map } from "./map.js";
-export { default as mask } from "./mask.js";
-export { default as match } from "./match.js";
-export { default as merge } from "./merge.js";
-export { default as paginate } from "./paginate.js";
-export { default as parent } from "./parent.js";
-export { default as plain } from "./plain.js";
-export { default as regExpKeys } from "./regExpKeys.js";
-export { default as reverse } from "./reverse.js";
-export { default as setDeep } from "./setDeep.js";
-export { default as shuffle } from "./shuffle.js";
-export { default as sort } from "./sort.js";
-export { default as take } from "./take.js";
-export { default as values } from "./values.js";
-
-export const assign = Tree.assign;
-export const entries = Tree.entries;
-export const forEach = Tree.forEach;
-export const from = Tree.from;
-export const has = Tree.has;
-export const isAsyncMutableTree = Tree.isAsyncMutableTree;
-export const isAsyncTree = Tree.isAsyncTree;
-export const isTraversable = Tree.isTraversable;
-export const isTreelike = Tree.isTreelike;
-export const mapReduce = Tree.mapReduce;
-export const paths = Tree.paths;
-export const remove = Tree.remove;
-export const root = Tree.root;
-export const traverse = Tree.traverse;
-export const traverseOrThrow = Tree.traverseOrThrow;
-export const traversePath = Tree.traversePath;

package/src/tree/values.js

@@ -1,15 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Return the interior nodes of the tree.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function values(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "values");
-  return Tree.values(tree);
-}