@weborigami/origami 0.6.16 → 0.6.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.6.16",
+  "version": "0.6.17",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -18,9 +18,9 @@
   },
   "dependencies": {
     "@hpcc-js/wasm-graphviz": "^1.21.0",
-    "@weborigami/async-tree": "0.6.16",
+    "@weborigami/async-tree": "0.6.17",
     "@weborigami/json-feed-to-rss": "1.0.1",
-    "@weborigami/language": "0.6.16",
+    "@weborigami/language": "0.6.17",
     "css-tree": "3.1.0",
     "highlight.js": "11.11.1",
     "jsdom": "28.1.0",

package/src/common/hashBytes.js

@@ -0,0 +1,26 @@
+import { toString } from "@weborigami/async-tree";
+import { createHash } from "node:crypto";
+
+/**
+ * Given data, return a 256-bit hash of that data. The data can be a string or a
+ * Uint8Array.
+ *
+ * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
+ *
+ * @param {Uint8Array|Stringlike} data
+ */
+export default function hashBytes(data) {
+  let bytes;
+  if (data instanceof Uint8Array) {
+    bytes = data;
+  } else {
+    const text = toString(data);
+    if (!text) {
+      throw new TypeError("Data must be a string or Uint8Array");
+    }
+    bytes = new TextEncoder().encode(text);
+  }
+
+  const hash = createHash("sha256").update(bytes).digest();
+  return hash;
+}

package/src/dev/changes2.js

@@ -0,0 +1,38 @@
+import { args, isStringlike, toString, Tree } from "@weborigami/async-tree";
+
+/**
+ * Given an old tree and a new tree, return a tree of changes indicated
+ * by the values: "added", "changed", or "deleted".
+ *
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
+ *
+ * @param {Maplike} oldMaplike
+ * @param {Maplike} newMaplike
+ */
+export default async function changes(oldMaplike, newMaplike) {
+  const oldTree = await args.map(oldMaplike, "Dev.changes", {
+    deep: true,
+    position: 1,
+  });
+  const newTree = await args.map(newMaplike, "Dev.changes", {
+    deep: true,
+    position: 2,
+  });
+
+  const combination = await Tree.combine(oldTree, newTree, compare);
+  return combination;
+}
+
+function compare(oldValue, newValue) {
+  if (oldValue !== undefined && newValue === undefined) {
+    return "deleted";
+  } else if (oldValue === undefined && newValue !== undefined) {
+    return "added";
+  } else if (isStringlike(oldValue) && isStringlike(newValue)) {
+    const oldText = toString(oldValue);
+    const newText = toString(newValue);
+    return oldText === newText ? undefined : "changed";
+  } else {
+    return oldValue === newValue ? undefined : "changed";
+  }
+}

package/src/dev/dev.js

@@ -6,6 +6,7 @@ export { default as indexPage } from "../origami/indexPage.js";
 export { default as yaml } from "../origami/yaml.js";
 export { default as breakpoint } from "./breakpoint.js";
 export { default as changes } from "./changes.js";
+export { default as changes2 } from "./changes2.js";
 export { default as code } from "./code.js";
 export { default as copy } from "./copy.js";
 export { default as audit } from "./crawler/audit.js";

package/src/dev/help.yaml

@@ -68,9 +68,15 @@ Origami:
     fetch:
       args: (url, options)
       description: Fetch a resource from a URL with support for extensions
+    hash:
+      args: (data)
+      description: A hex string hash of the data
     htmlEscape:
       args: (text)
       description: Escape HTML entities in the text
+    htmlParse:
+      args: (html)
+      description: Parse HTML into a plain JavaScript object
     image:
       description: Collection of functions for working with images
     indexPage:
@@ -79,9 +85,6 @@ Origami:
     inline:
       args: (text)
       description: Inline Origami expressions found in the text
-    htmlParse:
-      args: (html)
-      description: Parse HTML into a plain JavaScript object
     json:
       args: (obj)
       description: Render the object in JSON format
@@ -110,6 +113,12 @@ Origami:
       description: POST the given data to the URL
     projectRoot:
       description: The root folder for the current Origami project
+    randomFrom:
+      args: (data)
+      description: Returns a random value based on the data
+    randomsFrom:
+      args: (data)
+      description: Returns a function to produce random values based on the data
     redirect:
       args: (url, options)
       description: Redirect to the given URL
@@ -193,6 +202,9 @@ Tree:
     clear:
       args: (map)
       description: Remove all values from the map
+    combine:
+      args: (tree1, tree2, combineFn)
+      description: Pairwise application of combineFn to the trees' values
     concat:
       args: (...trees)
       description: Merge trees, renumbering numeric keys

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

@@ -4,6 +4,7 @@ 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 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";
@@ -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";

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;
+  };
+}