@weborigami/origami 0.6.15 → 0.6.17

package/src/origami/domNodeToObject.js

@@ -0,0 +1,93 @@
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const CDATA_SECTION_NODE = 4;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+export default function domNodeToObject(node) {
+  switch (node.nodeType) {
+    case DOCUMENT_NODE:
+      return {
+        name: "#document",
+        children: [...node.childNodes]
+          .filter((child) => !isWhitespaceOnly(child))
+          .map(domNodeToObject),
+      };
+
+    case DOCUMENT_FRAGMENT_NODE:
+      return {
+        name: "#document-fragment",
+        children: [...node.childNodes]
+          .filter((child) => !isWhitespaceOnly(child))
+          .map(domNodeToObject),
+      };
+
+    case ELEMENT_NODE: {
+      const attributes = Object.fromEntries(
+        [...node.attributes].map((attr) => [attr.name, attr.value]),
+      );
+
+      const relevantChildren = [...node.childNodes].filter(
+        (child) =>
+          (child.nodeType === ELEMENT_NODE ||
+            child.nodeType === TEXT_NODE ||
+            child.nodeType === CDATA_SECTION_NODE) &&
+          !isWhitespaceOnly(child),
+      );
+
+      const onlyText = relevantChildren.every(
+        (child) =>
+          child.nodeType === TEXT_NODE || child.nodeType === CDATA_SECTION_NODE,
+      );
+
+      const result = {
+        name: node.localName,
+      };
+      if (Object.keys(attributes).length > 0) {
+        result.attributes = attributes;
+      }
+      if (onlyText) {
+        const text = relevantChildren
+          .map((child) => collapseWhitespace(child.nodeValue ?? ""))
+          .join("")
+          .trim();
+        if (text.length > 0) {
+          result.text = text;
+        }
+      } else if (relevantChildren.length > 0) {
+        result.children = relevantChildren.map(domNodeToObject);
+      }
+
+      return result;
+    }
+
+    case TEXT_NODE:
+      return {
+        name: "#text",
+        text: collapseWhitespace(node.nodeValue ?? ""),
+      };
+
+    case CDATA_SECTION_NODE:
+      return {
+        name: "#cdata-section",
+        text: collapseWhitespace(node.nodeValue ?? ""),
+      };
+
+    default:
+      return {
+        name: `#node-${node.nodeType}`,
+      };
+  }
+}
+
+// Collapse leading or trailing whitespace characters to a single space
+function collapseWhitespace(str) {
+  return str.replace(/^\s+/, " ").replace(/\s+$/, " ");
+}
+
+function isWhitespaceOnly(node) {
+  return (
+    (node.nodeType === TEXT_NODE || node.nodeType === CDATA_SECTION_NODE) &&
+    node.nodeValue.trim() === ""
+  );
+}

package/src/origami/hash.js

@@ -0,0 +1,17 @@
+import hashBytes from "../common/hashBytes.js";
+
+/**
+ * Given string or Uint8Array data, return a hex-encoded hash of that data.
+ *
+ * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
+ *
+ * @param {Uint8Array|Stringlike} data
+ */
+export default function hash(data) {
+  const bytes = hashBytes(data);
+  const text = Array.from(bytes)
+    .slice(0, 20) // Limit to first 20 bytes (160 bits) for a shorter hash string
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("");
+  return text;
+}

package/src/origami/htmlParse.js

@@ -0,0 +1,22 @@
+import { args } from "@weborigami/async-tree";
+import loadJsDom from "../common/loadJsDom.js";
+import domNodeToObject from "./domNodeToObject.js";
+
+/**
+ * Return the DOM structure for the given HTML as a plain object.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} html
+ */
+export default async function htmlParse(html) {
+  html = args.stringlike(html, "Origami.htmlParse");
+  const { JSDOM } = await loadJsDom();
+  const dom = JSDOM.fragment(html);
+  let object = domNodeToObject(dom);
+  if (
+    (object.name === "#document" || object.name === "#document-fragment") &&
+    object.children.length === 1
+  ) {
+    object = object.children[0];
+  }
+  return object;
+}

package/src/origami/mdHtml.js

@@ -55,4 +55,5 @@ export default async function mdHtml(input) {
 
 mdHtml.key = (sourceValue, sourceKey) =>
   extension.replace(sourceKey, ".md", ".html");
+mdHtml.key.needsSourceValue = false;
 mdHtml.inverseKey = (resultKey) => extension.replace(resultKey, ".html", ".md");

package/src/origami/mdOutline.js

@@ -22,18 +22,29 @@ export default async function mdOutline(input) {
   const outline = {};
   const stack = [];
   let sectionText = "";
+  let sectionTextTrimmed = null;
   /** @type {any} */
   let current = outline;
   for (const token of tokens) {
     if (token.type === "heading") {
       // Current section text gets added as content for the current node.
-      if (sectionText) {
-        current._text = sectionText.trim();
+      sectionTextTrimmed = sectionText.trim();
+      if (sectionTextTrimmed) {
+        current._text = sectionTextTrimmed;
         sectionText = "";
       }
 
-      // Pop the stack to find the right level for this heading
       const { depth, text: headingText } = token;
+
+      // Did we skip a heading level? If so, create `_skip<n>` nodes
+      while (stack.length < depth - 1) {
+        const skipNode = {};
+        current[`_skip${stack.length + 1}`] = skipNode;
+        stack.push(current);
+        current = skipNode;
+      }
+
+      // Pop the stack to find the right level for this heading
       while (stack.length >= depth) {
         current = stack.pop();
         consolidateText(current);
@@ -51,8 +62,9 @@ export default async function mdOutline(input) {
   }
 
   // Any remaining section text gets added as content for the current node.
-  if (sectionText) {
-    current._text = sectionText.trim();
+  sectionTextTrimmed = sectionText.trim();
+  if (sectionTextTrimmed) {
+    current._text = sectionTextTrimmed;
     current = stack.pop();
     if (current) {
       consolidateText(current);

package/src/origami/origami.js

@@ -4,8 +4,9 @@ export { default as basename } from "./basename.js";
 export { default as csv } from "./csv.js";
 export { default as document } from "./document.js";
 export { default as fetch } from "./fetch.js";
-export { default as htmlDom } from "./htmlDom.js";
+export { default as hash } from "./hash.js";
 export { default as htmlEscape } from "./htmlEscape.js";
+export { default as htmlParse } from "./htmlParse.js";
 export { default as format } from "./image/format.js";
 export * as image from "./image/image.js";
 export { default as resize } from "./image/resize.js";
@@ -23,6 +24,8 @@ export { default as pack } from "./pack.js";
 export { default as post } from "./post.js";
 export { default as project } from "./project.js";
 export { default as projectRoot } from "./projectRoot.js";
+export { default as randomFrom } from "./randomFrom.js";
+export { default as randomsFrom } from "./randomsFrom.js";
 export { default as redirect } from "./redirect.js";
 export { default as repeat } from "./repeat.js";
 export { default as rss } from "./rss.js";
@@ -34,5 +37,6 @@ export { default as static } from "./static.js";
 export { default as string } from "./string.js";
 export { default as tsv } from "./tsv.js";
 export { default as unpack } from "./unpack.js";
+export { default as xmlParse } from "./xmlParse.js";
 export { default as yaml } from "./yaml.js";
 export { default as yamlParse } from "./yamlParse.js";

package/src/origami/randomFrom.js

@@ -0,0 +1,15 @@
+import hashBytes from "../common/hashBytes.js";
+
+/**
+ * Given a block of seed data, derive a pseudo-random 32-bit integer.
+ *
+ * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
+ *
+ * @param {Uint8Array|Stringlike} data
+ * @return {number}
+ */
+export default function randomFrom(data) {
+  // Extract the first 32-bit integer from the hash to use as the random number
+  const hash = hashBytes(data);
+  return hash.readUInt32LE(0);
+}

package/src/origami/randomsFrom.js

@@ -0,0 +1,65 @@
+import hashBytes from "../common/hashBytes.js";
+
+/**
+ * Given a block of seed data, return a function that produces a sequence of
+ * pseudo-random 32-bit integers.
+ *
+ * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
+ *
+ * @param {Uint8Array|Stringlike} data
+ * @return {function(): number}
+ */
+export default function randomsFrom(data) {
+  const hash = hashBytes(data);
+
+  // Extract four 32-bit integers from the hash to use as the initial state of
+  // the pseudo-random number generator
+  const a = hash.readUInt32LE(0);
+  const b = hash.readUInt32LE(4);
+  const c = hash.readUInt32LE(8);
+  const d = hash.readUInt32LE(12);
+
+  const prng = xoshiro128ss(a, b, c, d);
+  return prng;
+}
+
+// Rotate left (circular left shift) for 32-bit integers
+function rotl(x, k) {
+  return ((x << k) | (x >>> (32 - k))) >>> 0;
+}
+
+/**
+ * Pseudo-random number generator based on the xoshiro128** algorithm. See
+ * the 256-bit variant: https://en.wikipedia.org/wiki/Xorshift#xoshiro256**
+ *
+ * Unlike a typical implementation, this directly returns a 32-bit integer
+ * instead of a float.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {function(): number}
+ */
+function xoshiro128ss(a, b, c, d) {
+  let s0 = a >>> 0;
+  let s1 = b >>> 0;
+  let s2 = c >>> 0;
+  let s3 = d >>> 0;
+
+  return function () {
+    const result = (rotl(Math.imul(s1, 5), 7) * 9) >>> 0;
+
+    const t = (s1 << 9) >>> 0;
+
+    s2 ^= s0;
+    s3 ^= s1;
+    s1 ^= s2;
+    s0 ^= s3;
+
+    s2 ^= t;
+    s3 = rotl(s3, 11);
+
+    return result;
+  };
+}

package/src/origami/xmlParse.js

@@ -0,0 +1,33 @@
+import { args } from "@weborigami/async-tree";
+import loadJsDom from "../common/loadJsDom.js";
+import domNodeToObject from "./domNodeToObject.js";
+
+let parser;
+
+/**
+ * Return the DOM for the given XML as a plain object.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} xml
+ */
+export default async function xmlParse(xml) {
+  xml = args.stringlike(xml, "Origami.xmlParse");
+  const parser = await getParser();
+  const dom = parser.parseFromString(xml, "application/xml");
+  let object = domNodeToObject(dom);
+  if (
+    (object.name === "#document" || object.name === "#document-fragment") &&
+    object.children.length === 1
+  ) {
+    object = object.children[0];
+  }
+  return object;
+}
+
+async function getParser() {
+  if (!parser) {
+    const { JSDOM } = await loadJsDom();
+    const dom = new JSDOM();
+    parser = new dom.window.DOMParser();
+  }
+  return parser;
+}

package/src/server/server.js

@@ -88,7 +88,14 @@ export async function handleRequest(request, response, map) {
 
 export function keysFromUrl(url) {
   const encodedKeys = keysFromPath(url.pathname);
-  const keys = encodedKeys.map((key) => decodeURIComponent(key));
+  // Decode the keys, but stop decoding if we encounter an Origami debugger command
+  let foundCommand = false;
+  const keys = encodedKeys.map((key) => {
+    if (key.startsWith("!")) {
+      foundCommand = true;
+    }
+    return foundCommand ? key : decodeURIComponent(key);
+  });
 
   // If the keys array is empty (the path was just a trailing slash) or if the
   // path ended with a slash, add "index.html" to the end of the keys.
@@ -104,12 +111,17 @@ export function keysFromUrl(url) {
  * https.createServer calls, letting you serve an async tree as a set of pages.
  *
  * @typedef {import("@weborigami/async-tree").Maplike} Maplike
+ * @param {object} options
+ * @param {boolean} [options.quiet] If true, suppresses logging of incoming requests.
  * @param {Maplike} maplike
  */
-export function requestListener(maplike) {
+export function requestListener(maplike, options = {}) {
+  const quiet = options.quiet ?? false;
   const tree = Tree.from(maplike);
   return async function (request, response) {
-    console.log(decodeURI(request.url));
+    if (!quiet) {
+      console.log(decodeURI(request.url));
+    }
     const handled = await handleRequest(request, response, tree);
     if (!handled) {
       // Not found, return a 404.

package/src/origami/htmlDom.js

@@ -1,14 +0,0 @@
-import { args } from "@weborigami/async-tree";
-import loadJsDom from "../common/loadJsDom.js";
-
-/**
- * Return the DOM for the given HTML string.
- *
- * @param {import("@weborigami/async-tree").Stringlike} html
- */
-export default async function htmlDom(html) {
-  html = args.stringlike(html, "Origami.htmlDom");
-  const { JSDOM } = await loadJsDom();
-  const dom = JSDOM.fragment(html);
-  return dom;
-}