@weborigami/origami 0.6.17 → 0.7.0-beta.1

package/src/dev/debug2/oriEval.js

@@ -1,5 +1,5 @@
 import { trailingSlash, Tree } from "@weborigami/async-tree";
-import { evaluate, projectGlobals } from "@weborigami/language";
+import { evaluate, getGlobalsForTree } from "@weborigami/language";
 import debugTransform from "./debugTransform.js";
 
 const mapParentToResult = new WeakMap();
@@ -16,7 +16,7 @@ const mapParentToResult = new WeakMap();
  * counter to force reevaluation of the same expression.
  */
 export default async function oriEval(parent) {
-  const globals = await projectGlobals(parent);
+  const globals = getGlobalsForTree(parent);
   return async (key) => {
     const normalizedKey = trailingSlash.remove(key);
     let result = mapParentToResult.get(parent);

package/src/dev/dev.js

@@ -6,7 +6,6 @@ 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";
@@ -19,5 +18,6 @@ export { default as log } from "./log.js";
 export { default as serve } from "./serve.js";
 export { default as stdin } from "./stdin.js";
 export { default as svg } from "./svg.js";
+export { default as syscache } from "./syscache.js";
 export { default as version } from "./version.js";
 export { default as watch } from "./watch.js";

package/src/dev/explore.js

@@ -44,6 +44,7 @@ async function getScopeData(scope) {
 async function loadTemplate() {
   const folderPath = path.resolve(fileURLToPath(import.meta.url), "..");
   const folder = new OrigamiFileMap(folderPath);
+  await folder.initializeGlobals();
   const templateFile = await folder.get("explore.ori");
   const template = await Handlers.ori_handler.unpack(templateFile, {
     parent: folder,

package/src/dev/help.yaml

@@ -13,12 +13,12 @@ Dev:
     clear:
       args: (tree)
       description: Remove all values from the tree (alias of Tree.clear)
-    crawl:
-      args: (tree, base)
-      description: A tree of a site's discoverable resources
     copy:
       args: (source, target)
       description: Copy the source tree to the target
+    crawl:
+      args: (tree, base)
+      description: A tree of a site's discoverable resources
     debug:
       args: (tree)
       description: Add debug features to the tree
@@ -63,6 +63,9 @@ Origami:
     document:
       args: (text, [data])
       description: Create a document object with the text and data
+    domObject:
+      args: (dom)
+      description: Convert a DOM tree to a plain JavaScript object
     extension:
       description: Helpers for working with file extensions
     fetch:
@@ -71,12 +74,12 @@ Origami:
     hash:
       args: (data)
       description: A hex string hash of the data
+    htmlDom:
+      args: (html)
+      description: Parse HTML into a DOM tree
     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:
@@ -102,9 +105,9 @@ Origami:
       description: The outline structure of the markdown document
     naturalOrder:
       description: A comparison function for natural sort order
-    once:
-      args: (fn)
-      description: Run the function only once, return the same result
+    # once:
+    #   args: (fn)
+    #   description: Run the function only once, return the same result
     ori:
       args: (text)
       description: Evaluate the text as an Origami expression
@@ -148,12 +151,15 @@ Origami:
     toFunction:
       args: (obj)
       description: Coerce a tree or packed function definition to a function
+    tsv:
+      args: (tree)
+      description: Render the tree as a TSV file
     unpack:
       args: (buffer)
       description: Unpack the buffer into a usable form
-    xmlParse:
+    xmlDom:
       args: (xml)
-      description: Parse XML into a plain JavaScript object
+      description: Parse XML into a DOM tree
     yaml:
       args: (obj)
       description: Render the object in YAML format

package/src/dev/syscache.js

@@ -0,0 +1,56 @@
+import { activeProjectRoot, systemCache, volatile } from "@weborigami/language";
+import path from "node:path";
+import * as YAMLModule from "yaml";
+
+// The "yaml" package doesn't seem to provide a default export that the browser can
+// recognize, so we have to handle two ways to accommodate Node and the browser.
+// @ts-ignore
+const YAML = YAMLModule.default ?? YAMLModule.YAML;
+
+export default function syscache() {
+  const projectRoot = activeProjectRoot.get();
+
+  /** @type {any} */
+  const entries = [...systemCache.entries()].map(([path, entry]) => {
+    const result = {};
+    if (entry.downstreams) {
+      result.downstreams = preferRelativePaths(projectRoot, entry.downstreams);
+    }
+    if (entry.upstreams) {
+      result.upstreams = preferRelativePaths(projectRoot, entry.upstreams);
+    }
+    return [preferRelativePath(projectRoot, path), result];
+  });
+
+  // Sort the entries by key
+  entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+
+  const result = volatile(new Map(entries));
+
+  // When served, render as YAML and preserve trailing slashes
+  Object.defineProperty(result, "pack", {
+    configurable: true,
+    enumerable: false,
+    get() {
+      return () => volatile(YAML.stringify(result));
+    },
+  });
+
+  return result;
+}
+
+function preferRelativePath(projectRoot, inputPath) {
+  if (!path.isAbsolute(inputPath)) {
+    return inputPath;
+  }
+  const prefix = `${projectRoot.path}${path.sep}`;
+  if (!inputPath.startsWith(prefix)) {
+    return inputPath;
+  }
+  const relativePath = inputPath.slice(prefix.length);
+  return relativePath;
+}
+
+function preferRelativePaths(projectRoot, paths) {
+  return Array.from(paths).map((path) => preferRelativePath(projectRoot, path));
+}

package/src/handlers/xml_handler.js

@@ -1,5 +1,5 @@
 import { symbols, toString } from "@weborigami/async-tree";
-import xmlParse from "../origami/xmlParse.js";
+import xmlParse from "../origami/xmlDom.js";
 
 export default {
   mediaType: "application/xml",

package/src/origami/{domNodeToObject.js → domObject.js}

@@ -1,17 +1,29 @@
+import { isUnpackable } from "@weborigami/async-tree";
+
 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) {
+/**
+ * Given a DOM node, return a plain object representation of it.
+ */
+export default async function domObject(input) {
+  if (isUnpackable(input)) {
+    input = await input.unpack();
+  }
+  return nodeObject(input);
+}
+
+function nodeObject(node) {
   switch (node.nodeType) {
     case DOCUMENT_NODE:
       return {
         name: "#document",
         children: [...node.childNodes]
           .filter((child) => !isWhitespaceOnly(child))
-          .map(domNodeToObject),
+          .map(nodeObject),
       };
 
     case DOCUMENT_FRAGMENT_NODE:
@@ -19,7 +31,7 @@ export default function domNodeToObject(node) {
         name: "#document-fragment",
         children: [...node.childNodes]
           .filter((child) => !isWhitespaceOnly(child))
-          .map(domNodeToObject),
+          .map(nodeObject),
       };
 
     case ELEMENT_NODE: {
@@ -55,7 +67,7 @@ export default function domNodeToObject(node) {
           result.text = text;
         }
       } else if (relevantChildren.length > 0) {
-        result.children = relevantChildren.map(domNodeToObject);
+        result.children = relevantChildren.map(nodeObject);
       }
 
       return result;

package/src/origami/fetch.js

@@ -1,22 +1 @@
-import { args } from "@weborigami/async-tree";
-import { handleExtension } from "@weborigami/language";
-
-/**
- * Extend the JavaScript `fetch` function to implicity return an ArrayBuffer
- * with an unpack() method if the resource has a known file extension.
- */
-export default async function fetchBuiltin(resource, options, state) {
-  resource = args.string(resource, "Origami.fetch");
-  const response = await fetch(resource, options);
-  if (!response.ok) {
-    return undefined;
-  }
-
-  const value = await response.arrayBuffer();
-
-  const url = new URL(resource);
-  const key = url.pathname;
-
-  return handleExtension(value, key, state?.parent);
-}
-fetchBuiltin.needsState = true;
+export { fetchAndHandleExtension as default } from "@weborigami/language";

package/src/origami/htmlDom.js

@@ -0,0 +1,21 @@
+import { args } from "@weborigami/async-tree";
+import loadJsDom from "../common/loadJsDom.js";
+
+/**
+ * Return the DOM structure for the given HTML.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} html
+ */
+export default async function htmlDom(html) {
+  html = args.stringlike(html, "Origami.htmlDom");
+  const { JSDOM } = await loadJsDom();
+  let dom = JSDOM.fragment(html);
+  if (
+    (dom.nodeType === 9 || dom.nodeType === 11) &&
+    dom.children.length === 1
+  ) {
+    // Document or DocumentFragment with a single child: return the child
+    dom = dom.children[0];
+  }
+  return dom;
+}

package/src/origami/htmlParse.js

@@ -1,22 +1,15 @@
 import { args } from "@weborigami/async-tree";
-import loadJsDom from "../common/loadJsDom.js";
-import domNodeToObject from "./domNodeToObject.js";
+import htmlDom from "./htmlDom.js";
 
 /**
- * Return the DOM structure for the given HTML as a plain object.
+ * Return the DOM structure for the given HTML.
  *
  * @param {import("@weborigami/async-tree").Stringlike} html
  */
 export default async function htmlParse(html) {
+  console.warn("Origami.htmlParse is deprecated. Use Origami.htmlDom instead.");
+
   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;
+  const dom = await htmlDom(html);
+  return dom;
 }

package/src/origami/once.js

@@ -1,4 +1,4 @@
-import { args } from "@weborigami/async-tree";
+import { args, interop } from "@weborigami/async-tree";
 
 const fnPromiseMap = new Map();
 const codePromiseMap = new Map();
@@ -9,6 +9,9 @@ const codePromiseMap = new Map();
  * @param {Function} fn
  */
 export default async function once(fn) {
+  interop.warn(
+    `Now that Origami caches most results, Origami.once is no longer needed and will be removed in a future release. If you believe you have a need for it, please mention your use case in the Origami chat.`,
+  );
   fn = args.fn(fn, "Origami.once");
   const code = /** @type {any} */ (fn).code;
   if (code) {

package/src/origami/ori.js

@@ -1,5 +1,10 @@
-import { Tree, args, getRealmObjectPrototype } from "@weborigami/async-tree";
-import { compile, projectGlobals } from "@weborigami/language";
+import {
+  args,
+  assignPropertyDescriptors,
+  getRealmObjectPrototype,
+  Tree,
+} from "@weborigami/async-tree";
+import { compile, getGlobalsForTree } from "@weborigami/language";
 import { toYaml } from "../common/serialize.js";
 import * as dev from "../dev/dev.js";
 
@@ -17,18 +22,12 @@ export default async function ori(expression, options = {}) {
 
   expression = args.stringlike(expression, "Origami.ori");
 
-  // Add Dev builtins as top-level globals
-  const globals = {
-    ...(await projectGlobals(parent)),
-    ...dev,
-  };
+  // Add Dev builtins as top-level globals; avoid invoking getters
+  const globals = assignPropertyDescriptors({}, getGlobalsForTree(parent), dev);
 
-  // Compile the expression. Avoid caching scope references so that, e.g.,
-  // passing a function to the `watch` builtin will always look the current
-  // value of things in scope.
+  // Compile the expression
   const fn = compile.expression(expression, {
     globals,
-    enableCaching: false,
     mode: "shell",
     parent,
   });

package/src/origami/origami.js

@@ -3,8 +3,10 @@ export { default as help } from "../dev/help.js"; // Alias
 export { default as basename } from "./basename.js";
 export { default as csv } from "./csv.js";
 export { default as document } from "./document.js";
+export { default as domObject } from "./domObject.js";
 export { default as fetch } from "./fetch.js";
 export { default as hash } from "./hash.js";
+export { default as htmlDom } from "./htmlDom.js";
 export { default as htmlEscape } from "./htmlEscape.js";
 export { default as htmlParse } from "./htmlParse.js";
 export { default as format } from "./image/format.js";
@@ -22,7 +24,6 @@ export { default as once } from "./once.js";
 export { default as ori } from "./ori.js";
 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";
@@ -37,6 +38,8 @@ 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 volatile } from "./volatile.js";
+export { default as xmlDom } from "./xmlDom.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/volatile.js

@@ -0,0 +1 @@
+export { volatile as default } from "@weborigami/language";

package/src/origami/xmlDom.js

@@ -0,0 +1,32 @@
+import { args } from "@weborigami/async-tree";
+import loadJsDom from "../common/loadJsDom.js";
+
+let parser;
+
+/**
+ * Return the DOM for the given XML.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} xml
+ */
+export default async function xmlDom(xml) {
+  xml = args.stringlike(xml, "Origami.xmlDom");
+  const parser = await getParser();
+  let dom = parser.parseFromString(xml, "application/xml");
+  if (
+    (dom.nodeType === 9 || dom.nodeType === 11) &&
+    dom.children.length === 1
+  ) {
+    // Document or DocumentFragment with a single child: return the child
+    dom = dom.children[0];
+  }
+  return dom;
+}
+
+async function getParser() {
+  if (!parser) {
+    const { JSDOM } = await loadJsDom();
+    const dom = new JSDOM();
+    parser = new dom.window.DOMParser();
+  }
+  return parser;
+}

package/src/origami/xmlParse.js

@@ -1,33 +1,15 @@
 import { args } from "@weborigami/async-tree";
-import loadJsDom from "../common/loadJsDom.js";
-import domNodeToObject from "./domNodeToObject.js";
-
-let parser;
+import xmlDom from "./xmlDom.js";
 
 /**
- * Return the DOM for the given XML as a plain object.
+ * Return the DOM structure for the given XML.
  *
  * @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;
-}
+  console.warn("Origami.xmlParse is deprecated. Use Origami.xmlDom instead.");
 
-async function getParser() {
-  if (!parser) {
-    const { JSDOM } = await loadJsDom();
-    const dom = new JSDOM();
-    parser = new dom.window.DOMParser();
-  }
-  return parser;
+  xml = args.stringlike(xml, "Origami.xmlParse");
+  const dom = await xmlDom(xml);
+  return dom;
 }

package/src/server/constructResponse.js

@@ -1,4 +1,6 @@
 import { extension, isPacked, toString, Tree } from "@weborigami/async-tree";
+import { symbols } from "@weborigami/language";
+import { createHash } from "node:crypto";
 import { computedMIMEType } from "whatwg-mimetype";
 import { mediaTypeForExtension } from "./mediaTypes.js";
 
@@ -19,6 +21,16 @@ export default async function constructResponse(request, resource) {
   // Determine media type, what data we'll send, and encoding.
   const url = new URL(request?.url ?? "", `https://${request?.headers.host}`);
 
+  if (!isPacked(resource) && typeof resource.pack === "function") {
+    resource = await resource.pack();
+    if (typeof resource === "function") {
+      resource = await resource();
+    }
+    if (resource instanceof Response) {
+      return resource;
+    }
+  }
+
   if (!url.pathname.endsWith("/") && Tree.isMaplike(resource)) {
     // Maplike resource: redirect to its index page.
     const Location = `${url.pathname}/`;
@@ -30,16 +42,6 @@ export default async function constructResponse(request, resource) {
     });
   }
 
-  if (!isPacked(resource) && typeof resource.pack === "function") {
-    resource = await resource.pack();
-    if (typeof resource === "function") {
-      resource = await resource();
-    }
-    if (resource instanceof Response) {
-      return resource;
-    }
-  }
-
   let body = resource;
   if (!isPacked(resource)) {
     // Can we treat it as text?
@@ -50,6 +52,7 @@ export default async function constructResponse(request, resource) {
   }
 
   // Determine MIME type
+  /** @type {string | undefined} */
   let mediaType;
   if (resource.mediaType) {
     // Resource indicates its own media type.
@@ -77,6 +80,10 @@ export default async function constructResponse(request, resource) {
         } else {
           mediaType = sniffedType.toString();
         }
+        if (mediaType === "text/plain") {
+          // Prefer UTF-8 encoding for text/plain
+          mediaType += "; charset=utf-8";
+        }
       }
     }
   }
@@ -91,7 +98,35 @@ export default async function constructResponse(request, resource) {
     );
   }
 
-  const options = mediaType ? { headers: { "Content-Type": mediaType } } : {};
-  const response = new Response(body, options);
+  // Compute ETag from the body content.
+  let etag;
+  if (!resource[symbols.volatileSymbol]) {
+    const hash = createHash("sha1");
+    if (typeof body === "string" || body instanceof String) {
+      hash.update(String(body), "utf8");
+    } else {
+      hash.update(body);
+    }
+    const digest = hash.digest("hex");
+    // Store ETag with quotes in cache to match If-None-Match header
+    etag = `"${digest}"`;
+  }
+
+  /** @type {Record<string, string>} */
+  const headers = {};
+  if (mediaType) {
+    headers["Content-Type"] = mediaType;
+  }
+  if (etag) {
+    headers["Cache-Control"] = "no-cache";
+    headers.ETag = etag;
+  }
+
+  const response = new Response(body, { headers });
+
+  if (resource[symbols.volatileSymbol]) {
+    response[symbols.volatileSymbol] = true;
+  }
+
   return response;
 }