@weborigami/origami 0.6.15 → 0.6.17

package/main.js

@@ -1,7 +1,9 @@
 export { default as documentObject } from "./src/common/documentObject.js";
 export * from "./src/common/serialize.js";
 export { default as debugParent } from "./src/dev/debug2/debugParent.js";
+export { default as debugTransform } from "./src/dev/debug2/debugTransform.js";
 export * as Dev from "./src/dev/dev.js";
+export * from "./src/handlers/origamiHandlers.js";
 export * as Origami from "./src/origami/origami.js";
 export { default as origamiHighlightDefinition } from "./src/origami/origamiHighlightDefinition.js";
 export { default as constructResponse } from "./src/server/constructResponse.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.6.15",
+  "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.15",
+    "@weborigami/async-tree": "0.6.17",
     "@weborigami/json-feed-to-rss": "1.0.1",
-    "@weborigami/language": "0.6.15",
+    "@weborigami/language": "0.6.17",
     "css-tree": "3.1.0",
     "highlight.js": "11.11.1",
     "jsdom": "28.1.0",
@@ -29,6 +29,7 @@
     "marked-highlight": "2.2.3",
     "marked-smartypants": "1.1.11",
     "sharp": "0.34.5",
+    "whatwg-mimetype": "5.0.0",
     "yaml": "2.8.2"
   },
   "scripts": {

package/src/common/findOpenPort.js

@@ -0,0 +1,58 @@
+import net from "node:net";
+
+const DEFAULT_PORT = 5000;
+
+/**
+ * Return the first open port number on or after the given port number.
+ *
+ * @param {number} startPort
+ * @returns {Promise<number>}
+ */
+export async function findOpenPort(startPort = DEFAULT_PORT) {
+  for (let port = startPort; port <= 65535; port++) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+
+  throw new Error(`No open port found on or after ${startPort}`);
+}
+
+/**
+ * Check whether a port is available on both IPv4 and IPv6 loopback addresses
+ * by attempting TCP connections. On macOS, IPv4 and IPv6 port spaces are
+ * independent (IPV6_V6ONLY=1 by default), so a server bound to [::]:PORT is
+ * invisible to a 127.0.0.1 bind check. Using connect probes on both loopbacks
+ * catches servers regardless of which protocol family they listen on. Any
+ * connection error (ECONNREFUSED, EADDRNOTAVAIL, etc.) means nothing is
+ * listening there, so the function is safe on systems without IPv6.
+ *
+ * @param {number} port
+ * @returns {Promise<boolean>}
+ */
+async function isPortAvailable(port) {
+  const [v4, v6] = await Promise.all([
+    isPortListening("127.0.0.1", port),
+    isPortListening("::1", port),
+  ]);
+  return !v4 && !v6;
+}
+
+/**
+ * @param {string} host
+ * @param {number} port
+ * @returns {Promise<boolean>}
+ */
+function isPortListening(host, port) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection(port, host);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}

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

@@ -1,4 +1,5 @@
-import { execute } from "@weborigami/language";
+import { OrigamiFileMap } from "@weborigami/language";
+import path from "node:path";
 import debugParent from "./debugParent.js";
 
 /**
@@ -9,25 +10,13 @@ import debugParent from "./debugParent.js";
  * extract the source code of the expression to be debugged. (If it were
  * evaluated, the function will be called with the result of the expression.)
  *
- * The `options` argument can include:
- * - `enableUnsafeEval`: if true, enables the `!eval` debug command in the child
- *   process; default is false
- * - `debugFilesPath`: path to resources that will be added to the served tree
- *
  * @typedef {import("@weborigami/language").RuntimeState} RuntimeState
  * @typedef {import("@weborigami/language").AnnotatedCode} AnnotatedCode
  *
  * @param {AnnotatedCode} code
- * @param {any | RuntimeState} options
  * @param {RuntimeState} state
  */
-export default async function debug2(code, options, state) {
-  if (state === undefined) {
-    // Options were omitted; shift arguments
-    state = options;
-    options = [];
-  }
-
+export default async function debug2(code, state) {
   if (
     !(code instanceof Array) ||
     code.source === undefined ||
@@ -47,23 +36,45 @@ export default async function debug2(code, options, state) {
     throw new Error("Dev.debug2 couldn't work out the parent path.");
   }
 
-  // Need to evaluate options object
-  if (options.length > 0) {
-    options = await execute(options, state);
-  } else {
-    options = {};
-  }
-
-  // @ts-ignore
-  const enableUnsafeEval = options.enableUnsafeEval ?? false;
-  const debugFilesPath = options.debugFilesPath ?? "";
-
-  await debugParent({
-    debugFilesPath,
-    enableUnsafeEval,
+  // Start the debug server
+  const server = await debugParent({
     expression,
     parentPath,
   });
+
+  // Watch the parent files for changes
+  const tree = new OrigamiFileMap(parentPath);
+  tree.watch();
+  tree.addEventListener?.("change", async (event) => {
+    // @ts-ignore
+    const { filePath } = event.options;
+    if (isJavaScriptFile(filePath)) {
+      // Need to restart the child process
+      console.log("JavaScript file changed, restarting server…");
+      await server.restart();
+    } else if (path.basename(filePath) === "package.json") {
+      // Need to restart the child process
+      console.log("package.json changed, restarting server…");
+      await server.restart();
+    } else {
+      // Just have the child reevaluate the expression
+      console.log("File changed, reloading site…");
+      await server.reevaluate();
+    }
+  });
+
+  // When server closes, stop watching for file changes
+  server.on("close", () => {
+    tree.unwatch();
+  });
+
+  console.log(`Server running at ${server.origin}. Press Ctrl+C to stop.`);
 }
 debug2.needsState = true;
 debug2.unevaluatedArgs = true;
+
+function isJavaScriptFile(filePath) {
+  const extname = path.extname(filePath).toLowerCase();
+  const jsExtensions = [".cjs", ".js", ".mjs", ".ts"];
+  return jsExtensions.includes(extname);
+}

package/src/dev/debug2/debugChild.js

@@ -22,13 +22,6 @@ function fail(message) {
   process.exit(1);
 }
 
-/** @type {string} */
-const debugFilesPath = process.env.ORIGAMI_DEBUG_FILES_PATH ?? "";
-
-/** @type {boolean} */
-// @ts-ignore
-const enableUnsafeEval = process.env.ORIGAMI_ENABLE_UNSAFE_EVAL === "1";
-
 /** @type {string} */
 // @ts-ignore
 const expression = process.env.ORIGAMI_EXPRESSION;
@@ -43,6 +36,8 @@ if (parentPath === undefined) {
   fail("Missing Origami parent");
 }
 
+const quiet = process.env.ORIGAMI_QUIET === "1";
+
 // An indirect pointer to the tree of resources;
 let treeHandle = {};
 
@@ -50,7 +45,7 @@ let treeHandle = {};
 await evaluateExpression();
 
 // Serve the tree of resources
-const listener = requestListener(treeHandle);
+const listener = requestListener(treeHandle, { quiet });
 const server = http.createServer(listener);
 
 // Track live connections so we can drain/close cleanly.
@@ -96,10 +91,8 @@ function beginDrain() {
 
 async function evaluateExpression() {
   const tree = await expressionTree({
-    debugFilesPath,
     expression,
     parentPath,
-    enableUnsafeEval,
   });
   if (!tree) {
     fail("Dev.debug2: expression did not evaluate to a maplike resource tree");
@@ -118,6 +111,8 @@ async function evaluateExpression() {
   } catch {
     // Ignore errors.
   }
+
+  process.send?.({ type: "EVALUATED" });
 }
 
 function maybeFinishDrain() {

package/src/dev/debug2/debugCommands.js

@@ -1,29 +1,11 @@
 // Subset of commands made available via debugTransform
 
 import { Tree } from "@weborigami/async-tree";
+export const keys = Tree.keys;
+export const json = Tree.json;
 
-import index from "../../origami/indexPage.js";
-import yaml from "../../origami/yaml.js";
-import explore from "../explore.js";
-import svg from "../svg.js";
-import version from "../version.js";
-import oriEval from "./oriEval.js";
-
-export default function debugCommands(enableUnsafeEval = false) {
-  return Object.assign(
-    {
-      keys: Tree.keys,
-      json: Tree.json,
-      index,
-      yaml,
-      explore,
-      svg,
-      version,
-    },
-    enableUnsafeEval
-      ? {
-          eval: oriEval,
-        }
-      : {},
-  );
-}
+export { default as index } from "../../origami/indexPage.js";
+export { default as yaml } from "../../origami/yaml.js";
+export { default as explore } from "../explore.js";
+export { default as svg } from "../svg.js";
+export { default as version } from "../version.js";