@weborigami/origami 0.6.0 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -17,9 +17,9 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.0",
-    "@weborigami/json-feed-to-rss": "1.0.0",
-    "@weborigami/language": "0.6.0",
+    "@weborigami/async-tree": "0.6.2",
+    "@weborigami/json-feed-to-rss": "1.0.1",
+    "@weborigami/language": "0.6.2",
     "css-tree": "3.1.0",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.11.1",

package/src/common/serialize.js

@@ -5,12 +5,7 @@
  * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
  */
 
-import {
-  castArraylike,
-  SyncMap,
-  toPlainValue,
-  trailingSlash,
-} from "@weborigami/async-tree";
+import { castArraylike, toPlainValue } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 
 // The "yaml" package doesn't seem to provide a default export that the browser can
@@ -26,10 +21,9 @@ export function parseYaml(text) {
   return YAML.parse(text);
 }
 
-function reduceToMap(values, keys, map) {
-  // Normalize slashes in keys.
-  keys = keys.map(trailingSlash.remove);
-  return castArraylike(keys, values, (entries) => new SyncMap(entries));
+function reduceToMap(map) {
+  // createFn parameter returns as map as is
+  return castArraylike(map, (result) => result);
 }
 
 /**

package/src/dev/copy.js

@@ -1,7 +1,11 @@
-import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import {
+  AsyncMap,
+  getTreeArgument,
+  SyncMap,
+  Tree,
+} from "@weborigami/async-tree";
 import { formatError } from "@weborigami/language";
 import process, { stdout } from "node:process";
-import { transformObject } from "../common/utilities.js";
 
 /**
  * @typedef {import("@weborigami/async-tree").Maplike} Maplike
@@ -13,75 +17,87 @@ export default async function copy(source, target) {
   const sourceTree = await getTreeArgument(source, "copy", { position: 0 });
   let targetTree = await getTreeArgument(target, "copy", { position: 1 });
 
+  let progressTree;
   if (stdout.isTTY) {
-    targetTree =
-      targetTree instanceof Map
-        ? transformObject(SyncProgressTransform, targetTree)
-        : transformObject(AsyncProgressTransform, targetTree);
-    copyRoot = targetTree;
-    countFiles = 0;
-    countCopied = 0;
+    progressTree = showSetProgress(targetTree, {
+      copied: 0,
+      total: 0,
+    });
+  } else {
+    progressTree = targetTree;
   }
 
-  await Tree.assign(targetTree, sourceTree);
+  await Tree.assign(progressTree, sourceTree);
 
   if (stdout.isTTY) {
     process.stdout.clearLine(0);
     process.stdout.cursorTo(0);
-    copyRoot = null;
-    countFiles = null;
-    countCopied = null;
   }
 }
 
-let countFiles;
-let countCopied;
-let copyRoot;
+// Wrap the source tree to show progress on set() operations. Handle both sync
+// and async trees. All child trees will share the same counts object.
+function showSetProgress(source, counts) {
+  function showProgress() {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(`Copied ${counts.copied} of ${counts.total}`);
+  }
 
-function AsyncProgressTransform(Base) {
-  return class Progress extends Base {
-    async set(...args) {
-      countFiles++;
-      copyRoot.showProgress();
-      let result;
-      try {
-        result = await super.set(...args);
-        countCopied++;
-      } catch (/** @type {any} */ error) {
-        console.error(formatError(error));
-      }
-      copyRoot.showProgress();
-      return result;
-    }
+  const isSync = source instanceof Map;
+  const MapClass = isSync ? SyncMap : AsyncMap;
+  const iteratorKey = isSync ? Symbol.iterator : Symbol.asyncIterator;
 
-    showProgress() {
-      process.stdout.clearLine(0);
-      process.stdout.cursorTo(0);
-      process.stdout.write(`Copied ${countCopied} of ${countFiles}`);
-    }
-  };
-}
+  const progressTree = Object.assign(new MapClass(), {
+    delete: source.delete.bind(source),
+    keys: source.keys.bind(source),
+    [iteratorKey]: source[iteratorKey].bind(source),
+
+    // Wrap get() to apply progress tracking
+    get(key) {
+      return awaitIfPromise(source.get(key), (value) => {
+        return Tree.isMap(value) ? showSetProgress(value, counts) : value;
+      });
+    },
 
-function SyncProgressTransform(Base) {
-  return class Progress extends Base {
-    set(...args) {
-      countFiles++;
-      copyRoot.showProgress();
-      let result;
+    // Wrap set() to show progress
+    set(key, value) {
+      counts.total++;
+      showProgress();
       try {
-        result = super.set(...args);
-        countCopied++;
+        const setResult = source.set(key, value);
+        return awaitIfPromise(setResult, () => {
+          counts.copied++;
+          showProgress();
+          return progressTree;
+        });
       } catch (/** @type {any} */ error) {
         console.error(formatError(error));
+        return progressTree;
       }
-      copyRoot.showProgress();
-      return result;
-    }
+    },
+  });
+
+  if (typeof source.child === "function") {
+    // @ts-ignore
+    progressTree.child = async function (key) {
+      counts.total++;
+      showProgress();
+      const childResult = source.child(key);
+      return awaitIfPromise(childResult, (child) => {
+        counts.copied++;
+        showProgress();
+        return showSetProgress(child, counts);
+      });
+    };
+  }
+
+  return progressTree;
+}
 
-    showProgress() {
-      process.stdout.clearLine(0);
-      process.stdout.cursorTo(0);
-      process.stdout.write(`Copied ${countCopied} of ${countFiles}`);
-    }
-  };
+// Helper function that awaits a value if it's a Promise, then gives it to the
+// function; otherwise calls the function directly. This helps us write code
+// that can handle both sync and async values.
+function awaitIfPromise(value, fn) {
+  return value instanceof Promise ? value.then(fn) : fn(value);
 }

package/src/dev/crawler/audit.js

@@ -1,10 +1,6 @@
-import {
-  getTreeArgument,
-  pathFromKeys,
-  symbols,
-  Tree,
-} from "@weborigami/async-tree";
+import { pathFromKeys, symbols, Tree } from "@weborigami/async-tree";
 import crawlResources from "./crawlResources.js";
+import getSiteArgument from "./getSiteArgument.js";
 import { getBaseUrl } from "./utilities.js";
 
 /**
@@ -17,7 +13,7 @@ import { getBaseUrl } from "./utilities.js";
  * @param {string} [baseHref]
  */
 export default async function audit(maplike, baseHref) {
-  const tree = await getTreeArgument(maplike, "audit");
+  const tree = await getSiteArgument(maplike, "audit");
   const baseUrl = getBaseUrl(baseHref, maplike);
 
   let errors = {};

package/src/dev/crawler/crawl.js

@@ -1,10 +1,6 @@
-import {
-  DeepObjectMap,
-  Tree,
-  getTreeArgument,
-  keysFromPath,
-} from "@weborigami/async-tree";
+import { ObjectMap, Tree, keysFromPath } from "@weborigami/async-tree";
 import crawlResources from "./crawlResources.js";
+import getSiteArgument from "./getSiteArgument.js";
 import { addValueToObject, getBaseUrl } from "./utilities.js";
 
 /**
@@ -23,7 +19,7 @@ import { addValueToObject, getBaseUrl } from "./utilities.js";
  * @returns {Promise<AsyncMap>}
  */
 export default async function crawlBuiltin(maplike, baseHref) {
-  const tree = await getTreeArgument(maplike, "crawl");
+  const tree = await getSiteArgument(maplike, "crawl");
   const baseUrl = getBaseUrl(baseHref, maplike);
 
   const cache = {};
@@ -53,7 +49,7 @@ export default async function crawlBuiltin(maplike, baseHref) {
   // for something already, that's better than a function that will get that
   // value.
   const result = Tree.deepMerge(
-    new DeepObjectMap(cache),
+    new ObjectMap(cache, { deep: true }),
     await Tree.invokeFunctions(resources)
   );
   return result;

package/src/dev/crawler/getSiteArgument.js

@@ -0,0 +1,12 @@
+import { getTreeArgument, SiteMap } from "@weborigami/async-tree";
+
+/**
+ * Return a site: if it's a tree, return the tree; if it's a string, create a
+ * tree for that URL.
+ */
+export default async function getSiteArgument(site, command) {
+  if (typeof site === "string") {
+    return new SiteMap(site);
+  }
+  return getTreeArgument(site, command);
+}

package/src/dev/help.yaml

@@ -68,6 +68,9 @@ Origami:
     fetch:
       args: (url, options)
       description: Fetch a resource from a URL with support for extensions
+    htmlEscape:
+      args: (text)
+      description: Escape HTML entities in the text
     image:
       description: Collection of functions for working with images
     indexPage:
@@ -178,6 +181,9 @@ Tree:
     calendar:
       args: (options)
       description: Return a tree structure for years/months/days
+    child:
+      args: (tree, key)
+      description: Returns the indicated child node, creating it if necessary
     clear:
       args: (map)
       description: Remove all values from the map
@@ -235,6 +241,9 @@ Tree:
     inners:
       args: (tree)
       description: The tree's interior nodes
+    invokeFunctions:
+      args: (map)
+      description: Getting a map value invokes it if it's a function
     isMap:
       args: (object)
       description: True if object is a map
@@ -283,6 +292,9 @@ Tree:
     plain:
       args: (tree)
       description: Render the tree as a plain JavaScript object
+    reduce:
+      args: (tree, reduceFn)
+      description: Reduce the tree to a single value
     regExpKeys:
       args: (tree)
       description: A tree whose keys are regular expression strings
@@ -295,6 +307,9 @@ Tree:
     scope:
       args: (tree)
       description: A merged view of the tree and its ancestors
+    set:
+      args: (map, key, value)
+      description: Set the value for the key in the map
     shuffle:
       args: (map)
       description: Shuffle the keys of the map

package/src/origami/htmlEscape.js

@@ -0,0 +1,14 @@
+import { toString } from "@weborigami/async-tree";
+import loadJsDom from "../common/loadJsDom.js";
+
+/**
+ * Escapes HTML entities in a string.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} html
+ */
+export default async function htmlEscape(html) {
+  const { JSDOM } = await loadJsDom();
+  const div = JSDOM.fragment("<div></div>").firstChild;
+  div.textContent = toString(html);
+  return div.innerHTML;
+}

package/src/origami/inline.js

@@ -9,7 +9,7 @@ import documentObject from "../common/documentObject.js";
  *
  * @param {any} input
  */
-export default async function inline(input) {
+export default async function inline(input, options = {}) {
   // Get the input text and any attached front matter.
   if (isUnpackable(input)) {
     input = await input.unpack();
@@ -21,6 +21,7 @@ export default async function inline(input) {
   }
 
   const parent =
+    options.parent ??
     /** @type {any} */ (input).parent ??
     /** @type {any} */ (input)[symbols.parent];
 

package/src/origami/jsonKeys.js

@@ -41,7 +41,9 @@ function jsonKeysMap(source) {
 
     source: source,
 
-    trailingSlashKeys: source.trailingSlashKeys,
+    get trailingSlashKeys() {
+      return source.trailingSlashKeys;
+    },
   });
   return result;
 }

package/src/origami/ori.js

@@ -48,6 +48,17 @@ export default async function ori(expression, options = {}) {
   // Execute
   let result = await fn();
 
+  // if (result === undefined) {
+  //   // Was the code a path traversal?
+  //   const wasTraversal =
+  //     fn.code[0] === ops.unpack ||
+  //     (fn.code[0] instanceof Array && fn.code[0][0] === ops.scope);
+  //   if (wasTraversal) {
+  //     // Yes, probably an error
+  //     console.warn(`ori: warning: undefined ${highlightError(expression)}`);
+  //   }
+  // }
+
   // If result was a function, execute it.
   if (typeof result === "function") {
     result = await result();

package/src/origami/origami.js

@@ -14,6 +14,7 @@ export { default as static } from "../origami/static.js";
 export { default as basename } from "./basename.js";
 export { default as csv } from "./csv.js";
 export { default as fetch } from "./fetch.js";
+export { default as htmlEscape } from "./htmlEscape.js";
 export { default as format } from "./image/format.js";
 export * as image from "./image/image.js";
 export { default as resize } from "./image/resize.js";

package/src/origami/sitemap.js

@@ -14,7 +14,7 @@ const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
  * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
  * @param {Maplike} maplike
- * @param {{ assumeSlashes?: boolean, base?: string }} options
+ * @param {{ base?: string }} options
  * @returns {Promise<string>}
  */
 export default async function sitemap(maplike, options = {}) {

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

@@ -121,6 +121,8 @@ export function requestListener(maplike) {
  */
 function respondWithError(response, error) {
   let message = formatError(error);
+  // Remove ANSI escape codes from the message.
+  message = message.replace(/\x1b\[[0-9;]*m/g, "");
   // Prevent HTML in the error message from being interpreted as HTML.
   message = message.replace(/</g, "&lt;").replace(/>/g, "&gt;");
   const html = `<!DOCTYPE html>