@weborigami/origami 0.0.67-beta.2 → 0.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.67-beta.2",
+  "version": "0.0.68",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -17,9 +17,9 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.67-beta.2",
-    "@weborigami/language": "0.0.67-beta.2",
-    "@weborigami/types": "0.0.67-beta.2",
+    "@weborigami/async-tree": "0.0.68",
+    "@weborigami/language": "0.0.68",
+    "@weborigami/types": "0.0.68",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.10.0",

package/src/builtins/@crawl.js

@@ -63,13 +63,14 @@ export default async function crawl(treelike, baseHref) {
     // Cache the value
     if (value) {
       addValueToObject(cache, keys, value);
-    } else if (keys) {
-      // A missing robots.txt isn't an error; anything else missing is.
-      const path = keys.join("/");
-      if (path !== "robots.txt") {
-        errors.push(path);
-      }
     }
+    // else if (keys) {
+    //   // A missing robots.txt isn't an error; anything else missing is.
+    //   const path = keys.join("/");
+    //   if (path !== "robots.txt") {
+    //     errors.push(path);
+    //   }
+    // }
 
     // Add indirect resource functions to the resource tree. When requested,
     // these functions will obtain the resource from the original site.
@@ -151,6 +152,11 @@ async function* crawlPaths(tree, baseUrl) {
   // setting its entry in the dictionary to null.
   const promisesForPaths = {};
 
+  // Keep track of which resources refer to which paths.
+  const mapResourceToPaths = {};
+
+  let errorPaths = [];
+
   // Seed the promise dictionary with robots.txt and the root path.
   const initialPaths = ["/robots.txt", "/"];
   initialPaths.forEach((path) => {
@@ -174,6 +180,9 @@ async function* crawlPaths(tree, baseUrl) {
     // Mark the promise for that result as resolved.
     promisesForPaths[result.path] = null;
 
+    // Add the crawlable paths to the map.
+    mapResourceToPaths[result.path] = result.crawlablePaths;
+
     // Add promises for crawlable paths in the result.
     result.crawlablePaths.forEach((path) => {
       // Only add a promise for this path if we don't already have one.
@@ -182,8 +191,35 @@ async function* crawlPaths(tree, baseUrl) {
       }
     });
 
+    // If there was no value, add this to the errors.
+    // A missing robots.txt isn't an error; anything else missing is.
+    if (result.value === null && result.path !== "/robots.txt") {
+      errorPaths.push(result.path);
+    }
+
     yield result;
   }
+
+  if (errorPaths.length > 0) {
+    // Create a map of the resources that refer to each error.
+    const errorsMap = {};
+    for (const resource in mapResourceToPaths) {
+      const paths = mapResourceToPaths[resource];
+      for (const path of paths) {
+        if (errorPaths.includes(path)) {
+          errorsMap[resource] ??= [];
+          errorsMap[resource].push(path);
+        }
+      }
+    }
+    const errorsJson = JSON.stringify(errorsMap, null, 2);
+    yield {
+      keys: ["crawl-errors.json"],
+      path: "crawl-errors.json",
+      resourcePaths: [],
+      value: errorsJson,
+    };
+  }
 }
 
 // Filter the paths to those that are local to the site.
@@ -470,7 +506,12 @@ async function processPath(tree, path, baseUrl) {
   }
 
   // Convert path to keys
-  const keys = keysFromPath(path);
+  let keys = keysFromPath(path);
+
+  // Paths (including those created by the filterPaths function above) will have
+  // spaces, etc., escaped. In general, these need to be unescaped so we can
+  // find them in the tree.
+  keys = keys.map(decodeURIComponent);
 
   // Traverse tree to get value.
   let value = await Tree.traverse(tree, ...keys);

package/src/builtins/@shuffle.js

@@ -1,4 +1,7 @@
-import ShuffleTransform from "../common/ShuffleTransform.js";
+import {
+  default as ShuffleTransform,
+  shuffle,
+} from "../common/ShuffleTransform.js";
 import { transformObject } from "../common/utilities.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
@@ -11,10 +14,21 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  * @this {AsyncTree|null}
  * @param {Treelike} [treelike]
  */
-export default async function shuffle(treelike) {
+export default async function shuffleTree(treelike) {
+  // Special case: If the treelike is an array, shuffle it directly. Otherwise
+  // we'll end up shuffling the array's indexes, and if this is directly
+  // displayed by the ori CLI, this will end up creating a plain object. Even
+  // though this object will be created with the keys in the correct shuffled
+  // order, a JS object will always return numeric keys in numeric order --
+  // undoing the shuffle.
+  if (Array.isArray(treelike)) {
+    const array = treelike.slice();
+    shuffle(array);
+    return array;
+  }
   const tree = await getTreeArgument(this, arguments, treelike, "@shuffle");
   return transformObject(ShuffleTransform, tree);
 }
 
-shuffle.usage = `@shuffle <tree>\tReturn a new tree with the original's keys shuffled`;
-shuffle.documentation = "https://weborigami.org/cli/builtins.html#shuffle";
+shuffleTree.usage = `@shuffle <tree>\tReturn a new tree with the original's keys shuffled`;
+shuffleTree.documentation = "https://weborigami.org/cli/builtins.html#shuffle";

package/src/common/ShuffleTransform.js

@@ -18,7 +18,7 @@ export default function ShuffleTransform(Base) {
  *
  * Performs a Fisher-Yates shuffle. From http://sedition.com/perl/javascript-fy.html
  */
-function shuffle(array) {
+export function shuffle(array) {
   let i = array.length;
   while (--i >= 0) {
     const j = Math.floor(Math.random() * (i + 1));