@weborigami/origami 0.5.4 → 0.5.6

package/src/tree/fromFn.js

@@ -1,29 +0,0 @@
-import { FunctionTree, isUnpackable } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import { toFunction } from "../common/utilities.js";
-
-/**
- * Create a tree from a function and a set of keys.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../index.ts").Invocable} Invocable
- *
- * @this {AsyncTree|null}
- * @param {Invocable} [invocable]
- */
-export default async function fromFn(invocable, keys = []) {
-  assertTreeIsDefined(this, "fromFn");
-  if (invocable === undefined) {
-    throw new Error(
-      "An Origami function was called with an initial argument, but its value is undefined."
-    );
-  }
-  const fn = toFunction(invocable);
-  if (isUnpackable(keys)) {
-    keys = await keys.unpack();
-  }
-  const tree = new FunctionTree(fn, keys);
-  tree.parent = this;
-  return tree;
-}

package/src/tree/globKeys.js

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

package/src/tree/group.js

@@ -1,26 +0,0 @@
-import { group as groupTransform } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-import { toFunction } from "../common/utilities.js";
-
-/**
- * Map a tree to a new tree with the values from the original tree grouped by
- * the given function.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- *
- * @this {AsyncTree|null}
- * @param {import("@weborigami/async-tree").Treelike} treelike
- * @param {import("../../index.ts").Invocable} groupKey
- */
-export default async function groupBuiltin(treelike, groupKey) {
-  const tree = await getTreeArgument(this, arguments, treelike, "group");
-
-  const groupKeyFn = toFunction(groupKey);
-  // Have the group key function run in this tree.
-  const extendedGroupKeyFn = groupKeyFn.bind(tree);
-
-  // @ts-ignore
-  const grouped = await groupTransform(tree, extendedGroupKeyFn);
-  grouped.parent = tree;
-  return grouped;
-}

package/src/tree/inners.js

@@ -1,30 +0,0 @@
-import { trailingSlash, Tree } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Return the interior nodes of the tree. This relies on subtree keys having
- * trailing slashes.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function inners(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "inners");
-
-  const result = {
-    async get(key) {
-      const value = await tree.get(key);
-      return Tree.isAsyncTree(value) ? inners.call(this, value) : undefined;
-    },
-
-    async keys() {
-      const keys = [...(await tree.keys())];
-      const subtreeKeys = keys.filter(trailingSlash.has);
-      return subtreeKeys;
-    },
-  };
-
-  return result;
-}

package/src/tree/keys.js

@@ -1,15 +0,0 @@
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Return the top-level keys in the tree as an array.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function keys(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "keys");
-  const keys = await tree.keys();
-  return Array.from(keys);
-}

package/src/tree/length.js

@@ -1,15 +0,0 @@
-import getTreeArgument from "../common/getTreeArgument.js";
-
-/**
- * Return the number of 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 length(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "length");
-  const keys = Array.from(await tree.keys());
-  return keys.length;
-}

package/src/tree/map.d.ts

@@ -1,11 +0,0 @@
-import { TreeMapOptions as AsyncTreeMapOptions, Treelike, ValueKeyFn } from "@weborigami/async-tree";
-import { AsyncTree } from "@weborigami/types";
-
-/* Add more properties to TreeMapOptions */
-type TreeMapOptions = AsyncTreeMapOptions &{
-  description?: string;
-  extension?: string;
-  needsSourceValue?: boolean;
-};
-
-export default function treeMap(treelike: Treelike, options: ValueKeyFn | TreeMapOptions): AsyncTree;

package/src/tree/map.js

@@ -1,125 +0,0 @@
-import {
-  isPlainObject,
-  isUnpackable,
-  map as mapTransform,
-} from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-import { toFunction } from "../common/utilities.js";
-
-/**
- * Map a hierarchical tree of keys and values to a new tree of keys and values.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("@weborigami/async-tree").ValueKeyFn} ValueKeyFn
- * @typedef {import("./map.js").TreeMapOptions} TreeMapOptions
- *
- * @this {AsyncTree|null}
- * @param {Treelike} treelike
- * @param {ValueKeyFn|TreeMapOptions} operation
- */
-export default async function map(treelike, operation) {
-  if (isUnpackable(operation)) {
-    operation = await operation.unpack();
-  }
-  // The tree in which the map operation happens
-  const context = this;
-  const options = extendedOptions(context, operation);
-
-  // The tree we're going to map
-  const source = await getTreeArgument(
-    this,
-    arguments,
-    treelike,
-    "map",
-    options?.deep
-  );
-
-  const mapped = mapTransform(source, options);
-  mapped.parent = context;
-  return mapped;
-}
-
-/**
- * Return a function that transforms a tree of keys and values to a new tree of
- * keys and values.
- *
- * @param {AsyncTree|null} context
- * @param {ValueKeyFn|TreeMapOptions} operation
- */
-function extendedOptions(context, operation) {
-  // Identify whether the map instructions take the form of a value function or
-  // a dictionary of options.
-  /** @type {TreeMapOptions} */
-  let options;
-  /** @type {ValueKeyFn|undefined} */
-  let valueFn;
-  if (isPlainObject(operation)) {
-    // @ts-ignore
-    options = operation;
-    if (`value` in options && !options.value) {
-      throw new TypeError(`map: The value function is not defined.`);
-    }
-    valueFn = options?.value;
-  } else if (
-    typeof operation === "function" ||
-    typeof (/** @type {any} */ (operation)?.unpack) === "function"
-  ) {
-    valueFn = operation;
-    options = {};
-  } else if (operation === undefined) {
-    /** @type {any} */
-    const error = new TypeError(`map: The second parameter was undefined.`);
-    error.position = 1;
-    throw error;
-  } else {
-    throw new TypeError(
-      `map: You must specify a value function or options dictionary as the second parameter.`
-    );
-  }
-
-  const { deep, extension, needsSourceValue } = options;
-  const description = options.description ?? `map ${extension ?? ""}`;
-  let keyFn = options.key;
-  let inverseKeyFn = options.inverseKey;
-
-  if (valueFn) {
-    // @ts-ignore
-    valueFn = toFunction(valueFn);
-    // By default, run the value function in the context of this tree so that
-    // Origami builtins can be used as value functions.
-    // @ts-ignore
-    const bound = valueFn.bind(context);
-    // Transfer sidecar functions
-    // @ts-ignore
-    Object.assign(bound, valueFn);
-    valueFn = bound;
-  }
-
-  if (!extension) {
-    if (keyFn) {
-      // Extend the key function to include a value parameter
-      keyFn = extendKeyFn(keyFn);
-    }
-  }
-
-  return {
-    deep,
-    description,
-    extension,
-    inverseKey: inverseKeyFn,
-    key: keyFn,
-    needsSourceValue,
-    value: valueFn,
-  };
-}
-
-// Extend the key function to include a value parameter
-function extendKeyFn(keyFn) {
-  keyFn = toFunction(keyFn);
-  return async function keyWithValueFn(sourceKey, sourceTree) {
-    const sourceValue = await sourceTree.get(sourceKey);
-    const resultKey = await keyFn(sourceValue, sourceKey, sourceTree);
-    return resultKey;
-  };
-}

package/src/tree/mask.js

@@ -1,19 +0,0 @@
-import { mask } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
-/**
- * Apply a mask to a tree
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @this {AsyncTree|null}
- * @param {Treelike} sourceTreelike
- * @param {Treelike} maskTreelike
- */
-export default async function maskBuiltin(sourceTreelike, maskTreelike) {
-  assertTreeIsDefined(this, "mask");
-  const result = mask(sourceTreelike, maskTreelike);
-  result.parent = this;
-  return result;
-}

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;
-}