@weborigami/origami 0.0.69 → 0.0.70

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.70",
   "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.70",
+    "@weborigami/language": "0.0.70",
+    "@weborigami/types": "0.0.70",
     "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/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

@@ -64,13 +64,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);
   });