@weborigami/origami 0.5.8 → 0.6.0

package/src/server/constructResponse.js

@@ -3,7 +3,7 @@ import {
   isPacked,
   isPlainObject,
   isStringlike,
-  SiteTree,
+  SiteMap,
   toString,
   Tree,
 } from "@weborigami/async-tree";
@@ -30,8 +30,8 @@ export default async function constructResponse(request, resource) {
   // Determine media type, what data we'll send, and encoding.
   const url = new URL(request.url ?? "", `https://${request.headers.host}`);
 
-  if (!url.pathname.endsWith("/") && Tree.isTreelike(resource)) {
-    // Treelike resource: redirect to its index page.
+  if (!url.pathname.endsWith("/") && Tree.isMaplike(resource)) {
+    // Maplike resource: redirect to its index page.
     const Location = `${url.pathname}/`;
     return new Response("ok", {
       headers: {
@@ -87,11 +87,11 @@ export default async function constructResponse(request, resource) {
   if (!mediaType) {
     // Maybe it's HTML?
     const text = toString(resource);
-    if (text && maybeHtml(text)) {
-      mediaType = "text/html";
+    if (text) {
+      mediaType = maybeHtml(text) ? "text/html" : "text/plain";
       body = text;
     }
-  } else if (mediaType && SiteTree.mediaTypeIsText(mediaType)) {
+  } else if (mediaType && SiteMap.mediaTypeIsText(mediaType)) {
     // Assume text is encoded in UTF-8.
     body = toString(resource);
     mediaType += "; charset=utf-8";

package/src/server/server.js

@@ -44,9 +44,9 @@ async function copyResponse(constructed, response) {
  *
  * @param {import("node:http").IncomingMessage} request
  * @param {ServerResponse} response
- * @param {import("@weborigami/types").AsyncTree} tree
+ * @param {import("@weborigami/async-tree").SyncOrAsyncMap} map
  */
-export async function handleRequest(request, response, tree) {
+export async function handleRequest(request, response, map) {
   // For parsing purposes, we assume HTTPS -- it doesn't affect parsing.
   const url = new URL(request.url ?? "", `https://${request.headers.host}`);
   const keys = keysFromUrl(url);
@@ -56,7 +56,7 @@ export async function handleRequest(request, response, tree) {
   // Ask the tree for the resource with those keys.
   let resource;
   try {
-    resource = await Tree.traverseOrThrow(tree, ...keys);
+    resource = await Tree.traverseOrThrow(map, ...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.
@@ -97,11 +97,11 @@ function keysFromUrl(url) {
  * A request listener for use with the node http.createServer and
  * https.createServer calls, letting you serve an async tree as a set of pages.
  *
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @param {Treelike} treelike
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
+ * @param {Maplike} maplike
  */
-export function requestListener(treelike) {
-  const tree = Tree.from(treelike);
+export function requestListener(maplike) {
+  const tree = Tree.from(maplike);
   return async function (request, response) {
     console.log(decodeURI(request.url));
     const handled = await handleRequest(request, response, tree);
@@ -142,8 +142,8 @@ ${message}
 }
 
 // Asynchronous tree router as Express middleware.
-export function treeRouter(treelike) {
-  const tree = Tree.from(treelike, { deep: true });
+export function treeRouter(maplike) {
+  const tree = Tree.from(maplike, { deep: true });
   // Return a router for the tree source.
   return async function (request, response, next) {
     const handled = await handleRequest(request, response, tree);

package/src/common/getTreeArgument.js

@@ -1,67 +0,0 @@
-import { Tree, isUnpackable } from "@weborigami/async-tree";
-import assertTreeIsDefined from "./assertTreeIsDefined.js";
-
-/**
- * Many Origami built-in functions accept an optional treelike object as their
- * first argument. If no tree is supplied, then the current context for the
- * Origami command is used as the tree.
- *
- * So the argument is optional -- but if supplied, it must be defined. The
- * caller should pass its `arguments` object to this function so that the actual
- * number of supplied arguments can be checked.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @param {AsyncTree|null} parent
- * @param {IArguments} args
- * @param {Treelike|undefined} treelike
- * @param {string} methodName
- * @param {boolean} [deep]
- * @returns {Promise<AsyncTree>}
- */
-export default async function getTreeArgument(
-  parent,
-  args,
-  treelike,
-  methodName,
-  deep
-) {
-  assertTreeIsDefined(parent, methodName);
-
-  if (treelike !== undefined) {
-    if (isUnpackable(treelike)) {
-      treelike = await treelike.unpack();
-    }
-    if (Tree.isTreelike(treelike)) {
-      const options = deep !== undefined ? { deep } : undefined;
-      let tree = Tree.from(treelike, options);
-      // If the tree was created from a treelike object and does not yet have a
-      // parent, make the current tree its parent.
-      if (!tree.parent && parent !== undefined) {
-        if (parent !== null && !Tree.isAsyncTree(parent)) {
-          throw new Error(
-            `The parent argument passed to ${methodName} must be a tree.`
-          );
-        }
-        tree.parent = parent;
-      }
-      return tree;
-    }
-    throw new Error(
-      `The first argument to ${methodName} must be a tree, like an array, object, or files.`
-    );
-  }
-
-  if (args.length === 0) {
-    if (!parent) {
-      // Should never happen because assertTreeIsDefined throws an exception.
-      throw new Error(
-        `${methodName} was called with no tree argument and no parent.`
-      );
-    }
-    return parent;
-  }
-
-  throw new Error(`The first argument to ${methodName} was undefined.`);
-}