@weborigami/origami 0.0.69 → 0.0.71-beta.1

package/exports/exports.js

@@ -7,6 +7,7 @@ export { default as cache } from "../src/builtins/@cache.js";
 export { default as calendarTree } from "../src/builtins/@calendarTree.js";
 export { default as changes } from "../src/builtins/@changes.js";
 export { default as clean } from "../src/builtins/@clean.js";
+export { default as code } from "../src/builtins/@code.js";
 export { default as concat } from "../src/builtins/@concat.js";
 export { default as config } from "../src/builtins/@config.js";
 export { default as copy } from "../src/builtins/@copy.js";
@@ -40,6 +41,7 @@ export { default as imageFormat } from "../src/builtins/@image/format.js";
 export { default as imageFormatFn } from "../src/builtins/@image/formatFn.js";
 export { default as imageResize } from "../src/builtins/@image/resize.js";
 export { default as imageResizeFn } from "../src/builtins/@image/resizeFn.js";
+export { default as indent } from "../src/builtins/@indent.js";
 export { default as index } from "../src/builtins/@index.js";
 export { default as inherited } from "../src/builtins/@inherited.js";
 export { default as inline } from "../src/builtins/@inline.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.69",
+  "version": "0.0.71-beta.1",
   "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.69",
-    "@weborigami/language": "0.0.69",
-    "@weborigami/types": "0.0.69",
+    "@weborigami/async-tree": "0.0.71-beta.1",
+    "@weborigami/language": "0.0.71-beta.1",
+    "@weborigami/types": "0.0.71-beta.1",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.10.0",

package/src/builtins/@code.js

@@ -0,0 +1,37 @@
+import { symbols } from "@weborigami/language";
+import getTreeArgument from "../misc/getTreeArgument.js";
+
+/**
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {any} value
+ */
+export default async function code(value) {
+  if (value === undefined) {
+    value = await getTreeArgument(this, arguments, value, "@clean");
+  }
+  if (value === undefined) {
+    return undefined;
+  }
+  const code = value.code ?? value[symbols.codeSymbol];
+  return code ? functionNames(code) : undefined;
+}
+
+function functionNames(code) {
+  if (!Array.isArray(code)) {
+    return code;
+  }
+  let [head, ...tail] = code;
+  if (typeof head === "function") {
+    const text = head.toString();
+    if (text.startsWith("«ops.")) {
+      head = text;
+    } else {
+      head = head.name;
+    }
+  } else {
+    head = functionNames(head);
+  }
+  return [head, ...tail.map(functionNames)];
+}

package/src/builtins/@indent.js

@@ -0,0 +1,115 @@
+const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
+
+const mapStringsToModifications = new Map();
+
+/**
+ * Normalize indentation in a tagged template string.
+ *
+ * @param {TemplateStringsArray} strings
+ * @param  {...any} values
+ * @returns {string}
+ */
+export default function indent(strings, ...values) {
+  let modified = mapStringsToModifications.get(strings);
+  if (!modified) {
+    modified = modifyStrings(strings);
+    mapStringsToModifications.set(strings, modified);
+  }
+  const { blockIndentations, strings: modifiedStrings } = modified;
+  return joinBlocks(modifiedStrings, values, blockIndentations);
+}
+
+// Join strings and values, applying the given block indentation to the lines of
+// values for block placholders.
+function joinBlocks(strings, values, blockIndentations) {
+  let result = strings[0];
+  for (let i = 0; i < values.length; i++) {
+    let text = values[i];
+    if (text) {
+      const blockIndentation = blockIndentations[i];
+      if (blockIndentation) {
+        const lines = text.split("\n");
+        text = "";
+        if (lines.at(-1) === "") {
+          // Drop empty last line
+          lines.pop();
+        }
+        for (let line of lines) {
+          text += blockIndentation + line + "\n";
+        }
+      }
+      result += text;
+    }
+    result += strings[i + 1];
+  }
+  return result;
+}
+
+// Given an array of template boilerplate strings, return an object { modified,
+// blockIndentations } where `strings` is the array of strings with indentation
+// removed, and `blockIndentations` is an array of indentation strings for each
+// block placeholder.
+function modifyStrings(strings) {
+  // Phase one: Identify the indentation based on the first real line of the
+  // first string (skipping the initial newline), and remove this indentation
+  // from all lines of all strings.
+  let indent;
+  if (strings.length > 0 && strings[0].startsWith("\n")) {
+    // Look for indenttation
+    const firstLineWhitespaceRegex = /^\n(?<indent>[ \t]*)/;
+    const match = strings[0].match(firstLineWhitespaceRegex);
+    indent = match?.groups.indent;
+  }
+
+  // Determine the modified strings. If this invoked as a JS tagged template
+  // literal, the `strings` argument will be an odd array-ish object that we'll
+  // want to convert to a real array.
+  let modified;
+  if (indent) {
+    // De-indent the strings.
+    const indentationRegex = new RegExp(`\n${indent}`, "g");
+    // The `replaceAll` also converts strings to a real array.
+    modified = strings.map((string) =>
+      string.replaceAll(indentationRegex, "\n")
+    );
+    // Remove indentation from last line of last string
+    modified[modified.length - 1] = modified
+      .at(-1)
+      .replace(lastLineWhitespaceRegex, "\n");
+  } else {
+    // No indentation; just copy the strings so we have a real array
+    modified = strings.slice();
+  }
+
+  // Phase two: Identify any block placholders, identify and remove their
+  // preceding indentation, and remove the following newline. Work backward from
+  // the end towards the start because we're modifying the strings in place and
+  // our pattern matching won't work going forward from start to end.
+  let blockIndentations = [];
+  for (let i = modified.length - 2; i >= 0; i--) {
+    // Get the modified before and after substitution with index `i`
+    const beforeString = modified[i];
+    const afterString = modified[i + 1];
+    const match = beforeString.match(lastLineWhitespaceRegex);
+    if (match && afterString.startsWith("\n")) {
+      // The substitution between these strings is a block substitution
+      let blockIndentation = match.groups.indent;
+      blockIndentations[i] = blockIndentation;
+      // Trim the before and after strings
+      if (blockIndentation) {
+        modified[i] = beforeString.slice(0, -blockIndentation.length);
+      }
+      modified[i + 1] = afterString.slice(1);
+    }
+  }
+
+  // Remove newline from start of first string *after* removing indentation.
+  if (modified[0].startsWith("\n")) {
+    modified[0] = modified[0].slice(1);
+  }
+
+  return {
+    blockIndentations,
+    strings: modified,
+  };
+}

package/src/builtins/@index.js

@@ -22,42 +22,40 @@ export default async function index(treelike) {
   for (const key of filtered) {
     const keyText = String(key);
     // Simple key.
-    const link = `<li><a href="${keyText}">${keyText}</a></li>`;
+    const link = `      <li><a href="${keyText}">${keyText}</a></li>`;
     links.push(link);
   }
 
   const heading = tree[keySymbol] ?? "Index";
-  const list = `
-    <h1>${heading.trim()}</h1>
-    <ul>\n${links.join("\n").trim()}\n</ul>
-  `;
+  const list = `    <ul>\n${links.join("\n")}\n    </ul>`;
 
-  const html = `
-    <!DOCTYPE html>
-    <html lang="en">
-      <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width,initial-scale=1" />
-        <style>
-          li {
-            margin-bottom: 0.20em;
-          }
+  const html = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <style>
+      li {
+        margin-bottom: 0.20em;
+      }
 
-          a {
-            text-decoration: none;
-          }
-          a:hover {
-            text-decoration: revert;
-          }
-        </style>
-      </head>
-      <body>
-        ${list.trim()}
-      </body>
-    </html>`;
+      a {
+        text-decoration: none;
+      }
+      a:hover {
+        text-decoration: revert;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>${heading.trim()}</h1>
+${list}
+  </body>
+</html>
+`;
 
   /** @type {any} */
-  const result = new String(html.trim());
+  const result = new String(html);
   result.unpack = () => tree;
   return result;
 }

package/src/builtins/@match.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { Tree } from "@weborigami/async-tree";
 import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
@@ -12,8 +12,7 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * The pattern can also be a JavaScript regular expression.
  *
  * If a key is requested, match against the given pattern and, if matches,
- * incorporate the matched pattern's wildcard values into the scope and invoke
- * the indicated function to produce a result.
+ * invokes the given function with an object containing the matched values.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
@@ -57,23 +56,13 @@ export default function match(pattern, resultFn, keys = []) {
         return resultFn;
       }
 
-      // If the pattern contained named wildcards, extend the scope. It appears
-      // that the `groups` property of a match is *not* a real plain object, so
-      // we have to make one.
-      let target;
-      if (keyMatch.groups) {
-        target = new ObjectTree(
-          Object.fromEntries(Object.entries(keyMatch.groups))
-        );
-        target.parent = tree;
-      } else {
-        target = tree;
-      }
+      // Copy the `groups` property to a real object
+      const matches = { ...keyMatch.groups };
 
       // Invoke the result function with the extended scope.
       let value;
       if (typeof resultFn === "function") {
-        value = await resultFn.call(target);
+        value = await resultFn.call(this, matches);
       } else {
         value = Object.create(resultFn);
       }

package/src/common/processUnpackedContent.js

@@ -24,7 +24,11 @@ export default function processUnpackedContent(content, parent, attachedData) {
     } else {
       target = base;
     }
-    return content.bind(target);
+    const result = content.bind(target);
+    if (content.code) {
+      result.code = content.code;
+    }
+    return result;
   } else if (Tree.isAsyncTree(content) && !content.parent) {
     const result = Object.create(content);
     result.parent = parent;

package/src/common/utilities.js

@@ -3,6 +3,7 @@ import {
   toString as asyncTreeToString,
   isPlainObject,
   isUnpackable,
+  trailingSlash,
 } from "@weborigami/async-tree";
 
 // Return true if the text appears to contain non-printable binary characters;
@@ -37,6 +38,8 @@ export const keySymbol = Symbol("key");
  * period), replace that extension with the result extension (which again should
  * generally include a period). Otherwise, return the key as is.
  *
+ * If the key ends in a trailing slash, that will be preserved in the result.
+ *
  * @param {string} key
  * @param {string} sourceExtension
  * @param {string} resultExtension
@@ -44,11 +47,16 @@ export const keySymbol = Symbol("key");
 export function replaceExtension(key, sourceExtension, resultExtension) {
   if (!key) {
     return undefined;
-  } else if (!key.endsWith(sourceExtension)) {
-    return key;
-  } else {
-    return key.slice(0, -sourceExtension.length) + resultExtension;
   }
+
+  const normalizedKey = trailingSlash.remove(key);
+  if (!normalizedKey.endsWith(sourceExtension)) {
+    return normalizedKey;
+  }
+
+  const replaced =
+    normalizedKey.slice(0, -sourceExtension.length) + resultExtension;
+  return trailingSlash.toggle(replaced, trailingSlash.has(key));
 }
 
 /**
@@ -64,13 +72,16 @@ export function toFunction(obj) {
     return obj;
   } else if (isUnpackable(obj)) {
     // Extract the contents of the object and convert that to a function.
-    let fn;
+    let fnPromise;
     /** @this {any} */
     return async function (...args) {
-      if (!fn) {
-        const content = await obj.unpack();
-        fn = toFunction(content);
+      if (!fnPromise) {
+        // unpack() may return a function or a promise for a function; normalize
+        // to a promise for a function
+        const unpackPromise = Promise.resolve(obj.unpack());
+        fnPromise = unpackPromise.then((content) => toFunction(content));
       }
+      const fn = await fnPromise;
       return fn.call(this, ...args);
     };
   } else if (Tree.isTreelike(obj)) {

package/src/crawler/crawlResources.js

@@ -27,9 +27,10 @@ export default async function* crawlResources(tree, baseUrl) {
 
   let errorPaths = [];
 
-  // Seed the promise dictionary with robots.txt at the root and an empty path
-  // indicating the current directory (relative to the baseUrl).
-  const initialPaths = ["/robots.txt", ""];
+  // Seed the promise dictionary with robots.txt at the root, a sitemap.xml at
+  // the root, and an empty path indicating the current directory (relative to
+  // the baseUrl).
+  const initialPaths = ["/robots.txt", "/sitemap.xml", ""];
   initialPaths.forEach((path) => {
     promisesForPaths[path] = processPath(tree, path, baseUrl);
   });