@weborigami/origami 0.5.4 → 0.5.6

package/src/dev/help.yaml

@@ -175,12 +175,12 @@ Tree:
     cache:
       args: (tree, [cache])
       description: Caches values from the tree
+    calendar:
+      args: (options)
+      description: Return a tree structure for years/months/days
     clear:
       args: (tree)
       description: Remove all values from the tree
-    concat:
-      args: (...objs)
-      description: Concatenate text and/or trees of text
     constant:
       args: (value)
       description: Return a deep tree with a single constant value
@@ -202,9 +202,9 @@ Tree:
     deepValues:
       args: (tree)
       description: The in-order leaf values of the tree
-    defineds:
-      args: (tree)
-      description: Only the defined values of the tree
+    delete:
+      args: (tree, key)
+      description: Delete the value for the key from tree
     entries:
       args: (tree)
       description: The tree's [key, value] pairs
@@ -220,19 +220,17 @@ Tree:
     from:
       args: (object, options)
       description: Create a tree from an object
-    fromFn:
-      args: (fn, [keys])
-      description: A tree defined by a value function
     globKeys:
       args: (patterns)
       description: A tree whose keys can include glob wildcard patterns
-    group:
+    groupBy:
       args: (tree, fn)
       description: A new tree with values grouped by the function
     has:
       args: (tree, key)
       description: True if key exists in tree
     indent:
+      args: "`…`"
       description: Tagged template literal for normalizing indentation
     inners:
       args: (tree)
@@ -261,8 +259,11 @@ Tree:
     map:
       args: (tree, options)
       description: Create a new tree by mapping keys and/or values
+    mapExtension:
+      args: (tree, ext, options)
+      description: Map extensions and values
     mapReduce:
-      args: (tree, valueFn, reduceFn)
+      args: (tree, mapFn, reduceFn)
       description: Map values and reduce them
     mask:
       args: (source, mask)
@@ -288,9 +289,6 @@ Tree:
     regExpKeys:
       args: (tree)
       description: A tree whose keys are regular expression strings
-    remove:
-      args: (tree, key)
-      description: Remove the value for the key from tree
     reverse:
       args: (tree)
       description: Reverse the order of the tree's keys
@@ -309,6 +307,9 @@ Tree:
     take:
       args: (tree, n)
       description: The first n values in the tree
+    text:
+      args: "`…`"
+      description: Tagged template literal for rendering trees
     traverse:
       args: (tree, ...keys)
       description: Return the value at the path of keys
@@ -321,3 +322,6 @@ Tree:
     values:
       args: (tree)
       description: The tree's values
+    withKeys:
+      args: (tree, keys)
+      description: Use the given keys for the tree

package/src/dev/log.js

@@ -4,12 +4,11 @@ import yaml from "../origami/yaml.js";
  * Log the first argument to the console as a side effect and return the second
  * argument. If no second argument is provided, return the first argument.
  *
- * @this {import("@weborigami/types").AsyncTree|null}
  * @param {any} object
  * @param {any} [result]
  */
 export default async function log(result, object = result) {
-  let text = object !== undefined ? await yaml.call(this, object) : "undefined";
+  let text = object !== undefined ? await yaml(object) : "undefined";
   text = text?.trim();
   console.log(text);
   return result;

package/src/dev/serve.js

@@ -1,13 +1,10 @@
-import { Tree } from "@weborigami/async-tree";
+import { getTreeArgument } from "@weborigami/async-tree";
 import http from "node:http";
 import { createServer } from "node:net";
 import process from "node:process";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import { isTransformApplied, transformObject } from "../common/utilities.js";
 import { requestListener } from "../server/server.js";
-import debug from "./debug.js";
 import ExplorableSiteTransform from "./ExplorableSiteTransform.js";
-import watch from "./watch.js";
 
 const defaultPort = 5000;
 
@@ -19,22 +16,12 @@ const defaultPort = 5000;
  *
  * @param {Treelike} treelike
  * @param {number} [port]
- * @this {AsyncTree|null}
  */
 export default async function serve(treelike, port) {
-  assertTreeIsDefined(this, "serve");
-  let tree;
-  if (treelike) {
-    tree = Tree.from(treelike, { parent: this });
-    if (!isTransformApplied(ExplorableSiteTransform, tree)) {
-      tree = transformObject(ExplorableSiteTransform, tree);
-    }
-  } else if (arguments.length === 0) {
-    // By default, watch the default tree and add default pages.
-    const withDefaults = await debug.call(this);
-    tree = await watch.call(this, withDefaults);
-  } else {
-    throw new Error("serve: no tree was provided to serve");
+  let tree = await getTreeArgument(treelike, "serve");
+
+  if (!isTransformApplied(ExplorableSiteTransform, tree)) {
+    tree = transformObject(ExplorableSiteTransform, tree);
   }
 
   if (port === undefined) {

package/src/dev/svg.js

@@ -1,5 +1,6 @@
+import { getTreeArgument } from "@weborigami/async-tree";
 import graphviz from "graphviz-wasm";
-import getTreeArgument from "../common/getTreeArgument.js";
+
 import dot from "./treeDot.js";
 
 let graphvizLoaded = false;
@@ -11,8 +12,7 @@ let graphvizLoaded = false;
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
+ * @param {Treelike} treelike
  * @param {PlainObject} [options]
  */
 export default async function svg(treelike, options = {}) {
@@ -20,8 +20,8 @@ export default async function svg(treelike, options = {}) {
     await graphviz.loadWASM();
     graphvizLoaded = true;
   }
-  const tree = await getTreeArgument(this, arguments, treelike, "svg", true);
-  const dotText = await dot.call(this, tree, options);
+  const tree = await getTreeArgument(treelike, "svg", { deep: true });
+  const dotText = await dot(tree, options);
   if (dotText === undefined) {
     return undefined;
   }

package/src/dev/treeDot.js

@@ -1,7 +1,8 @@
 import {
   Tree,
+  getTreeArgument,
   isPlainObject,
-  isStringLike,
+  isStringlike,
   toString,
   trailingSlash,
 } from "@weborigami/async-tree";
@@ -11,16 +12,14 @@ import { getDescriptor } from "../common/utilities.js";
 /**
  * Render a tree in DOT format.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
+ * @param {Treelike} treelike
  * @param {PlainObject} [options]
  */
 export default async function dot(treelike, options = {}) {
-  const tree = Tree.from(treelike, { deep: true });
+  const tree = await getTreeArgument(treelike, "treeDot", { deep: true });
   const rootLabel = getDescriptor(tree) ?? "";
   const treeArcs = await statements(tree, "", rootLabel, options);
   return `digraph g {
@@ -74,7 +73,7 @@ async function statements(tree, nodePath, nodeLabel, options) {
       const subStatements = await statements(subtree, destPath, null, options);
       result = result.concat(subStatements);
     } else {
-      const label = isStringLike(value)
+      const label = isStringlike(value)
         ? toString(value)
         : value !== undefined
         ? await serialize.toYaml(value)

package/src/dev/watch.js

@@ -1,22 +1,19 @@
-import { Tree } from "@weborigami/async-tree";
+import { constant, getTreeArgument, Tree } from "@weborigami/async-tree";
 import { formatError, moduleCache } from "@weborigami/language";
-import ConstantTree from "../common/ConstantTree.js";
-import getTreeArgument from "../common/getTreeArgument.js";
 
 /**
  * Let a tree (e.g., of files) respond to changes.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Invocable} Invocable
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../index.ts").Invocable} Invocable
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
+ * @param {Treelike} treelike
  * @param {Invocable} [fn]
+ * @returns {Promise<AsyncTree>}
  */
 export default async function watch(treelike, fn) {
-  /** @type {any} */
-  const container = await getTreeArgument(this, arguments, treelike, "watch");
+  const container = await getTreeArgument(treelike, "watch");
 
   // Watch the indicated tree.
   await /** @type {any} */ (container).watch?.();
@@ -35,7 +32,7 @@ export default async function watch(treelike, fn) {
   const handle = Object.create(tree);
 
   // Reevaluate the function whenever the tree changes.
-  container.addEventListener?.("change", async () => {
+  /** @type {any} */ (container).addEventListener?.("change", async () => {
     const tree = await evaluateTree(container, fn);
     moduleCache.resetTimestamp();
     updateIndirectPointer(handle, tree);
@@ -61,8 +58,7 @@ async function evaluateTree(parent, fn) {
     message = `Warning: watch expression did not return a tree`;
   }
   console.warn(message);
-  tree = new ConstantTree(message);
-  tree.parent = parent;
+  tree = constant(message);
   return tree;
 }
 

package/src/initializeBuiltins.js

@@ -0,0 +1,23 @@
+import { builtins } from "@weborigami/language";
+import * as dev from "./dev/dev.js";
+import help from "./dev/help.js";
+import * as origami from "./origami/origami.js";
+
+let initialized = false;
+
+/**
+ * Pass the Origami builtins to the compiler.
+ */
+export default function initializeBuiltins() {
+  if (!initialized) {
+    const origamiBuiltins = {
+      Dev: dev,
+      Origami: origami,
+      "help:": help,
+    };
+
+    Object.assign(builtins, origamiBuiltins);
+  }
+
+  initialized = true;
+}

package/src/origami/csv.js

@@ -1,5 +1,4 @@
 import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * Render the object as text in CSV format.
@@ -7,12 +6,9 @@ import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
  * The object should a treelike object such as an array. The output will include
  * a header row with field names taken from the first item in the tree/array.
  *
- * @this {import("@weborigami/types").AsyncTree|null}
- * @param {any} [object]
+ * @param {any} object
  */
 export default async function csv(object) {
-  assertTreeIsDefined(this, "csv");
-  object = object ?? this;
   if (object === undefined) {
     return undefined;
   }

package/src/origami/document.js

@@ -1,15 +1,12 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import documentObject from "../common/documentObject.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").StringLike} StringLike
+ * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
  *
- * @this {AsyncTree|null}
- * @param {StringLike} text
+ * @param {Stringlike} text
  * @param {any} [data]
  */
 export default async function documentBuiltin(text, data) {
-  assertTreeIsDefined(this, "document");
   return documentObject(text, data);
 }

package/src/origami/fetch.js

@@ -1,7 +1,8 @@
-import { getHandlers, handleExtension } from "@weborigami/language";
+import { handleExtension } from "@weborigami/language";
 
 /**
- * @this {import("@weborigami/types").AsyncTree|null|undefined}
+ * Extend the JavaScript `fetch` function to implicity return an ArrayBuffer
+ * with an unpack() method if the resource has a known file extension.
  */
 export default async function fetchBuiltin(resource, options) {
   const response = await fetch(resource, options);
@@ -10,13 +11,8 @@ export default async function fetchBuiltin(resource, options) {
   }
 
   const value = await response.arrayBuffer();
-  if (!this) {
-    // Can't get extension handlers
-    return value;
-  }
 
-  const handlers = getHandlers(this);
   const url = new URL(resource);
   const key = url.pathname;
-  return handleExtension(this, value, key, handlers);
+  return handleExtension(value, key);
 }

package/src/origami/htmlDom.js

@@ -1,6 +1,7 @@
-import { JSDOM } from "jsdom";
+import loadJsDom from "../common/loadJsDom.js";
 
-export default function htmlDom(html) {
+export default async function htmlDom(html) {
+  const { JSDOM } = await loadJsDom();
   const dom = JSDOM.fragment(html);
   return dom;
 }

package/src/origami/image/format.js

@@ -1,19 +1,14 @@
 import sharp from "sharp";
-import assertTreeIsDefined from "../../common/assertTreeIsDefined.js";
 
 /**
  * Return the image in a different format.
  *
- * @this {import("@weborigami/types").AsyncTree|null}
- *
- * @this {import("@weborigami/types").AsyncTree|null}
  * @param {import("@weborigami/async-tree").Packed} input
  * @param {keyof import("sharp").FormatEnum|import("sharp").AvailableFormatInfo}
  * format
  * @param {any} options
  */
 export default async function imageFormat(input, format, options) {
-  assertTreeIsDefined(this, "format");
   return input instanceof Uint8Array || input instanceof ArrayBuffer
     ? sharp(input).toFormat(format, options).toBuffer()
     : undefined;

package/src/origami/image/resize.js

@@ -1,15 +1,12 @@
 import sharp from "sharp";
-import assertTreeIsDefined from "../../common/assertTreeIsDefined.js";
 
 /**
  * Resize an image.
  *
- * @this {import("@weborigami/types").AsyncTree|null}
  * @param {import("@weborigami/async-tree").Packed} input
  * @param {import("sharp").ResizeOptions} options
  */
 export default async function resize(input, options) {
-  assertTreeIsDefined(this, "resize");
   return input instanceof Uint8Array || input instanceof ArrayBuffer
     ? sharp(input).rotate().resize(options).toBuffer()
     : undefined;

package/src/origami/indexPage.js

@@ -1,4 +1,4 @@
-import getTreeArgument from "../common/getTreeArgument.js";
+import { getTreeArgument } from "@weborigami/async-tree";
 import { getDescriptor } from "../common/utilities.js";
 
 /**
@@ -6,12 +6,12 @@ import { getDescriptor } from "../common/utilities.js";
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
+ *
+ * @param {Treelike} treelike
  * @param {string} [basePath]
  */
 export default async function indexPage(treelike, basePath) {
-  const tree = await getTreeArgument(this, arguments, treelike, "indexPage");
+  const tree = await getTreeArgument(treelike, "svg");
   const keys = Array.from(await tree.keys());
 
   // Skip system-ish files that start with a period. Also skip `index.html`.

package/src/origami/inline.js

@@ -1,21 +1,16 @@
 import { isUnpackable, symbols, toString } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import { oridocument_handler } from "@weborigami/language/src/handlers/handlers.js";
 import documentObject from "../common/documentObject.js";
-import { oridocumentHandler } from "../handlers/handlers.js";
 
 /**
  * Inline any Origami expressions found inside ${...} placeholders in the input
  * text.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").StringLike} StringLike
  *
- * @this {AsyncTree|null}
- * @param {StringLike & {_body?: StringLike}} input
+ * @param {any} input
  */
 export default async function inline(input) {
-  assertTreeIsDefined(this, "inline");
-
   // Get the input text and any attached front matter.
   if (isUnpackable(input)) {
     input = await input.unpack();
@@ -28,8 +23,7 @@ export default async function inline(input) {
 
   const parent =
     /** @type {any} */ (input).parent ??
-    /** @type {any} */ (input)[symbols.parent] ??
-    this;
+    /** @type {any} */ (input)[symbols.parent];
 
   let front;
   if (inputIsDocument) {
@@ -42,7 +36,7 @@ export default async function inline(input) {
   }
 
   // @ts-ignore
-  let result = await oridocumentHandler.unpack(origami, {
+  let result = await oridocument_handler.unpack(origami, {
     front,
     parent,
   });

package/src/origami/json.js

@@ -1,22 +1,18 @@
-/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * Render the given object in JSON format.
  *
- * @this {AsyncTree|null}
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
  * @param {any} [obj]
  */
 export default async function json(obj) {
-  assertTreeIsDefined(this, "json");
-  // A fragment of the logic from getTreeArgument.js
   if (arguments.length > 0 && obj === undefined) {
     throw new Error(
       "An Origami function was called with an initial argument, but its value is undefined."
     );
   }
-  obj = obj ?? this;
   if (obj === undefined) {
     return undefined;
   }

package/src/origami/jsonKeys.js

@@ -1,22 +1,16 @@
-import { Tree, jsonKeys } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
+import { Tree, getTreeArgument, jsonKeys } from "@weborigami/async-tree";
 
 /**
  * Expose .keys.json for a tree.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
+ *
  * @param {Treelike} treelike
+ * @returns {Promise<AsyncTree>}
  */
 export default async function jsonKeysBuiltin(treelike) {
-  const tree = await getTreeArgument(
-    this,
-    arguments,
-    treelike,
-    "jsonKeys",
-    true
-  );
+  const tree = await getTreeArgument(treelike, "jsonKeys");
   return jsonKeysTree(tree);
 }
 

package/src/origami/jsonParse.js

@@ -1,4 +1,4 @@
-import { toString } from "../common/utilities.js";
+import { toString } from "@weborigami/async-tree";
 
 export default async function jsonParse(input) {
   const text = toString(input);

package/src/origami/mdHtml.js

@@ -1,11 +1,10 @@
-import { extension, isUnpackable } from "@weborigami/async-tree";
+import { extension, isUnpackable, toString } from "@weborigami/async-tree";
 import highlight from "highlight.js";
 import { Marked } from "marked";
 import { gfmHeadingId as markedGfmHeadingId } from "marked-gfm-heading-id";
 import { markedHighlight } from "marked-highlight";
 import { markedSmartypants } from "marked-smartypants";
 import documentObject from "../common/documentObject.js";
-import { toString } from "../common/utilities.js";
 import origamiHighlightDefinition from "./origamiHighlightDefinition.js";
 
 highlight.registerLanguage("ori", origamiHighlightDefinition);
@@ -32,11 +31,7 @@ marked.use(
 /**
  * Transform markdown to HTML.
  *
- * @typedef {import("@weborigami/async-tree").StringLike} StringLike
- * @typedef {import("@weborigami/async-tree").Unpackable<StringLike>} UnpackableStringlike
- *
- * @this {import("@weborigami/types").AsyncTree|null|void}
- * @param {StringLike|UnpackableStringlike} input
+ * @param {any} input
  */
 export default async function mdHtml(input) {
   if (input == null) {
@@ -48,7 +43,7 @@ export default async function mdHtml(input) {
     input = await input.unpack();
   }
   const inputIsDocument = typeof input === "object" && "_body" in input;
-  const markdown = toString(input);
+  const markdown = inputIsDocument ? input._body : toString(input);
   if (markdown === null) {
     throw new Error("mdHtml: The provided input couldn't be treated as text.");
   }
@@ -56,5 +51,6 @@ export default async function mdHtml(input) {
   return inputIsDocument ? documentObject(html, input) : html;
 }
 
-mdHtml.key = (sourceKey) => extension.replace(sourceKey, ".md", ".html");
+mdHtml.key = (sourceValue, sourceKey) =>
+  extension.replace(sourceKey, ".md", ".html");
 mdHtml.inverseKey = (resultKey) => extension.replace(resultKey, ".html", ".md");

package/src/origami/mdOutline.js

@@ -1,12 +1,12 @@
-import { isUnpackable } from "@weborigami/async-tree";
+import { isUnpackable, toString } from "@weborigami/async-tree";
 import { Marked } from "marked";
-import { toString } from "../common/utilities.js";
 
 export default async function mdOutline(input) {
   if (isUnpackable(input)) {
     input = await input.unpack();
   }
-  const markdown = toString(input);
+  const inputIsDocument = typeof input === "object" && "_body" in input;
+  const markdown = inputIsDocument ? input._body : toString(input);
   if (markdown === null) {
     throw new Error("mdHtml: The provided input couldn't be treated as text.");
   }

package/src/origami/once.js

@@ -1,5 +1,3 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
 const fnPromiseMap = new Map();
 const codePromiseMap = new Map();
 
@@ -7,18 +5,16 @@ const codePromiseMap = new Map();
  * Evaluate the given function only once and cache the result.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @this {AsyncTree|null}
+ *
  * @param {Function} fn
  */
 export default async function once(fn) {
-  assertTreeIsDefined(this, "once");
-
   const code = /** @type {any} */ (fn).code;
   if (code) {
     // Origami function, cache by code
     if (!codePromiseMap.has(code)) {
       // Don't wait for promise to resolve
-      const promise = fn.call(this);
+      const promise = fn();
       codePromiseMap.set(code, promise);
     }
     return codePromiseMap.get(code);
@@ -27,7 +23,7 @@ export default async function once(fn) {
   // Regular function, cache by function
   if (!fnPromiseMap.has(fn)) {
     // Don't wait for promise to resolve
-    const promise = fn.call(this);
+    const promise = fn();
     fnPromiseMap.set(fn, promise);
   }
   return fnPromiseMap.get(fn);