@weborigami/origami 0.5.3 → 0.5.5

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/handlers/csv.handler.js

@@ -6,6 +6,9 @@ export default {
   unpack(packed, options = {}) {
     const parent = options.parent ?? null;
     const text = toString(packed);
+    if (text === null) {
+      throw new TypeError("CSV handler can only unpack text");
+    }
     const data = csvParse(text);
     // Define `parent` as non-enumerable property
     Object.defineProperty(data, symbols.parent, {

package/src/handlers/oridocument.handler.js

@@ -64,7 +64,7 @@ export default {
 
 // Return a function that adds the given extension
 function addExtension(resultExtension) {
-  return (sourceKey) => {
+  return (sourceValue, sourceKey) => {
     if (sourceKey === undefined) {
       return undefined;
     }

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/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/inline.js

@@ -1,5 +1,4 @@
 import { isUnpackable, symbols, toString } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import documentObject from "../common/documentObject.js";
 import { oridocumentHandler } from "../handlers/handlers.js";
 
@@ -8,14 +7,11 @@ import { oridocumentHandler } from "../handlers/handlers.js";
  * text.
  *
  * @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 & {_body?: StringLike}} input
+ * @param {Stringlike & {_body?: Stringlike}} 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 +24,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) {

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/mdHtml.js

@@ -32,11 +32,10 @@ marked.use(
 /**
  * Transform markdown to HTML.
  *
- * @typedef {import("@weborigami/async-tree").StringLike} StringLike
- * @typedef {import("@weborigami/async-tree").Unpackable<StringLike>} UnpackableStringlike
+ * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
+ * @typedef {import("@weborigami/async-tree").Unpackable} Unpackable
  *
- * @this {import("@weborigami/types").AsyncTree|null|void}
- * @param {StringLike|UnpackableStringlike} input
+ * @param {Stringlike|Unpackable} input
  */
 export default async function mdHtml(input) {
   if (input == null) {
@@ -56,5 +55,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/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);

package/src/origami/ori.js

@@ -1,6 +1,7 @@
 import {
   Tree,
   getRealmObjectPrototype,
+  isStringlike,
   toString,
 } from "@weborigami/async-tree";
 import { compile } from "@weborigami/language";
@@ -27,6 +28,10 @@ export default async function ori(
   assertTreeIsDefined(this, "ori");
 
   // In case expression has come from a file, cast it to a string.
+  if (!isStringlike(expression)) {
+    throw new TypeError("ori: The expression is not text.");
+  }
+  // @ts-ignore
   expression = toString(expression);
 
   // Run in the context of `this` if defined

package/src/origami/origami.js

@@ -1,8 +1,7 @@
 export { extension } from "@weborigami/async-tree";
-export { toFunction } from "../common/utilities.js";
 export { default as help } from "../dev/help.js"; // Alias
 export { default as document } from "../origami/document.js";
-export { default as htmlDom } from "../origami/htmlDom.js";
+// export { default as htmlDom } from "../origami/htmlDom.js";
 export { default as indexPage } from "../origami/indexPage.js";
 export { default as inline } from "../origami/inline.js";
 export { default as jsonKeys } from "../origami/jsonKeys.js";

package/src/origami/pack.js

@@ -1,13 +1,8 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
- * @this {AsyncTree|null}
  * @param {any} obj
- * @returns
  */
 export default function pack(obj) {
-  assertTreeIsDefined(this, "pack");
   return obj?.pack?.();
 }

package/src/origami/post.js

@@ -1,5 +1,5 @@
 import {
-  isStringLike,
+  isStringlike,
   isUnpackable,
   toPlainValue,
   toString,
@@ -7,7 +7,8 @@ import {
 } from "@weborigami/async-tree";
 
 /**
- * @this {import("@weborigami/types").AsyncTree|null}
+ * POST data to the indicated URL.
+ *
  * @param {string} url
  * @param {any} data
  */
@@ -23,7 +24,7 @@ export default async function post(url, data) {
     headers = {
       "Content-Type": "application/json",
     };
-  } else if (isStringLike(data)) {
+  } else if (isStringlike(data)) {
     body = toString(data);
     headers = {
       "Content-Type": "text/plain",

package/src/origami/rss.js

@@ -1,16 +1,15 @@
-import { Tree } from "@weborigami/async-tree";
+import { getTreeArgument, Tree } from "@weborigami/async-tree";
 import jsonFeedToRss from "@weborigami/json-feed-to-rss";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} jsonFeedTree
+ *
+ * @param {Treelike} jsonFeed
  * @param {any} options
  */
-export default async function rss(jsonFeedTree, options = {}) {
-  assertTreeIsDefined(this, "rss");
-  const jsonFeed = await Tree.plain(jsonFeedTree);
-  return jsonFeedToRss(jsonFeed, options);
+export default async function rss(jsonFeed, options = {}) {
+  const tree = await getTreeArgument(jsonFeed, "rss");
+  const jsonFeedPlain = await Tree.plain(tree);
+  return jsonFeedToRss(jsonFeedPlain, options);
 }

package/src/origami/sitemap.js

@@ -1,6 +1,4 @@
-import { Tree } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import getTreeArgument from "../common/getTreeArgument.js";
+import { getTreeArgument, Tree } from "@weborigami/async-tree";
 import { oriHandler } from "../handlers/handlers.js";
 
 const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
@@ -15,13 +13,13 @@ const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
+ *
  * @param {Treelike} treelike
  * @param {{ assumeSlashes?: boolean, base?: string }} options
+ * @returns {Promise<string>}
  */
 export default async function sitemap(treelike, options = {}) {
-  assertTreeIsDefined(this, "sitemap");
-  const tree = await getTreeArgument(this, arguments, treelike, "sitemap");
+  const tree = await getTreeArgument(treelike, "sitemap");
 
   // We're only interested in keys that end in .html or with no extension.
   function test(key) {
@@ -48,6 +46,6 @@ export default async function sitemap(treelike, options = {}) {
     .map((path) => (path.endsWith("index.html") ? path.slice(0, -10) : path));
 
   const templateFn = await oriHandler.unpack(templateText);
-  const templateResult = await templateFn.call(this, htmlPaths);
+  const templateResult = await templateFn(htmlPaths);
   return String(templateResult);
 }

package/src/origami/static.js

@@ -1,5 +1,4 @@
-import { Tree, jsonKeys } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
+import { Tree, getTreeArgument, jsonKeys } from "@weborigami/async-tree";
 import index from "./indexPage.js";
 
 /**
@@ -7,14 +6,13 @@ import index from "./indexPage.js";
  *
  * @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 staticBuiltin(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "static");
-  const result = staticTree(tree);
-  result.parent = this;
-  return result;
+  const tree = await getTreeArgument(treelike, "static");
+  return staticTree(tree);
 }
 
 // The name we'll register as a builtin

package/src/origami/string.js

@@ -1,14 +1,10 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import { toString } from "../common/utilities.js";
 
 /**
  * Convert an object to a string.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @this {AsyncTree|null}
  * @param {any} object
  */
 export default function stringBuiltin(object) {
-  assertTreeIsDefined(this, "string");
   return toString(object);
 }

package/src/origami/unpack.js

@@ -1,14 +1,9 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
 /**
  * Unpack a packed format like a Uint8Array or ArrayBuffer to a usable form like
  * text or a plain JavaScript object.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @this {AsyncTree|null}
  * @param {any} obj
  */
 export default function unpack(obj) {
-  assertTreeIsDefined(this, "unpack");
   return obj?.unpack?.() ?? obj;
 }

package/src/protocols/explore.js

@@ -6,8 +6,6 @@ import constructSiteTree from "../common/constructSiteTree.js";
  * A site tree with JSON Keys via HTTPS.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../index.ts").Invocable} Invocable
  *
  * @this {AsyncTree|null}
  * @param {string} host

package/src/protocols/httpstree.js

@@ -6,8 +6,6 @@ import constructSiteTree from "../common/constructSiteTree.js";
  * Return a website tree via HTTPS.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../index.ts").Invocable} Invocable
  *
  * @this {AsyncTree|null}
  * @param {string} host

package/src/protocols/httptree.js

@@ -6,8 +6,6 @@ import constructSiteTree from "../common/constructSiteTree.js";
  * Return a website tree via HTTP.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../index.ts").Invocable} Invocable
  *
  * @this {AsyncTree|null}
  * @param {string} host

package/src/protocols/package.js

@@ -1,4 +1,4 @@
-import { Tree, keysFromPath, scope } from "@weborigami/async-tree";
+import { Tree, keysFromPath } from "@weborigami/async-tree";
 import project from "../origami/project.js";
 
 /**
@@ -31,7 +31,7 @@ async function getPackage(parent, organization, name, keys) {
   }
   packagePath.push(name);
 
-  const parentScope = scope(parent);
+  const parentScope = await Tree.scope(parent);
   const packageRoot = await Tree.traverse(
     // @ts-ignore
     parentScope,

package/src/server/constructResponse.js

@@ -2,7 +2,7 @@ import {
   extension,
   isPacked,
   isPlainObject,
-  isStringLike,
+  isStringlike,
   SiteTree,
   Tree,
 } from "@weborigami/async-tree";
@@ -63,7 +63,7 @@ export default async function constructResponse(request, resource) {
 
   if (
     (mediaType === "application/json" || mediaType === "text/yaml") &&
-    !isStringLike(resource)
+    !isStringlike(resource)
   ) {
     // The request is for a JSON or YAML result, and the resource we got isn't
     // yet a string: convert the resource to JSON or YAML now.

package/src/server/server.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
+import { Tree, keysFromPath } from "@weborigami/async-tree";
 import { formatError } from "@weborigami/language";
 import { ServerResponse } from "node:http";
 import constructResponse from "./constructResponse.js";
@@ -39,32 +39,6 @@ async function copyResponse(constructed, response) {
   return true;
 }
 
-// Extend the tree's scope with the URL's search parameters.
-function extendTreeScopeWithParams(tree, url) {
-  // Create a tree that includes the URL's search parameters.
-  const params = {};
-  for (const [key, value] of url.searchParams) {
-    params[key] = value;
-  }
-
-  if (Object.keys(params).length === 0) {
-    // No search parameters, so return the tree as is.
-    return tree;
-  }
-
-  const paramTree = new ObjectTree({
-    "@params": params,
-  });
-
-  // Create a new tree that's like the original one, but has the parameters in
-  // its parent hierarchy.
-  const extendedTree = Object.create(tree);
-  const realParent = tree.parent;
-  paramTree.parent = realParent;
-  extendedTree.parent = paramTree;
-  return extendedTree;
-}
-
 /**
  * Handle a client request.
  *
@@ -77,17 +51,12 @@ export async function handleRequest(request, response, tree) {
   const url = new URL(request.url ?? "", `https://${request.headers.host}`);
   const keys = keysFromUrl(url);
 
-  const extendedTree =
-    url.searchParams && "parent" in tree
-      ? extendTreeScopeWithParams(tree, url)
-      : tree;
-
   const data = request.method === "POST" ? await parsePostData(request) : null;
 
   // Ask the tree for the resource with those keys.
   let resource;
   try {
-    resource = await Tree.traverseOrThrow(extendedTree, ...keys);
+    resource = await Tree.traverseOrThrow(tree, ...keys);
 
     // If resource is a function, invoke to get the object we want to return.
     // For a POST request, pass the data to the function.