@weborigami/origami 0.5.8 → 0.6.1

package/src/origami/static.js

@@ -1,43 +1,68 @@
-import { Tree, getTreeArgument, jsonKeys } from "@weborigami/async-tree";
+import {
+  AsyncMap,
+  Tree,
+  getTreeArgument,
+  jsonKeys,
+} from "@weborigami/async-tree";
 import indexPage from "./indexPage.js";
 
 /**
  * Expose common static keys (index.html, .keys.json) for a tree.
  *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {Treelike} treelike
- * @returns {Promise<AsyncTree>}
+ * @param {Maplike} maplike
+ * @returns {Promise<AsyncMap>}
  */
-export default async function staticBuiltin(treelike) {
-  const tree = await getTreeArgument(treelike, "static");
-  return staticTree(tree);
+export default async function staticBuiltin(maplike) {
+  const source = await getTreeArgument(maplike, "static");
+  return staticMap(source);
 }
 
 // The name we'll register as a builtin
 staticBuiltin.key = "static";
 
-function staticTree(tree) {
-  return Object.assign(Object.create(tree), {
+function staticMap(source) {
+  const result = Object.assign(new AsyncMap(), {
+    description: "static",
+
     async get(key) {
-      let value = await tree.get(key);
+      let value = await source.get(key);
       if (value === undefined && key === "index.html") {
         value = await indexPage(this);
       } else if (value === undefined && key === ".keys.json") {
         value = await jsonKeys.stringify(this);
-      } else if (Tree.isTreelike(value)) {
-        const subtree = Tree.from(value, { parent: this });
-        value = staticTree(subtree);
+      } else if (Tree.isMaplike(value)) {
+        const subtree = Tree.from(value, { parent: result });
+        value = staticMap(subtree);
       }
       return value;
     },
 
-    async keys() {
-      const keys = new Set(await tree.keys());
-      keys.add("index.html");
-      keys.add(".keys.json");
-      return keys;
+    async *keys() {
+      let needsIndex = true;
+      let needsKeysJson = true;
+      for await (const key of source.keys()) {
+        if (key === "index.html") {
+          needsIndex = false;
+        }
+        if (key === ".keys.json") {
+          needsKeysJson = false;
+        }
+        yield key;
+      }
+      if (needsIndex) {
+        yield "index.html";
+      }
+      if (needsKeysJson) {
+        yield ".keys.json";
+      }
     },
+
+    source: source,
+
+    trailingSlashKeys: source.trailingSlashKeys,
   });
+
+  return result;
 }

package/src/origami/unpack.js

@@ -5,5 +5,8 @@
  * @param {any} obj
  */
 export default function unpack(obj) {
-  return obj?.unpack?.() ?? obj;
+  if (obj == null) {
+    throw new ReferenceError("Cannot unpack null or undefined value");
+  }
+  return obj.unpack?.() ?? obj;
 }

package/src/origami/yaml.js

@@ -1,4 +1,3 @@
-/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 import YAML from "yaml";
 

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.`);
-}