@weborigami/origami 0.5.7 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -13,23 +13,22 @@
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "24.3.0",
-    "typescript": "5.9.2"
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.7",
+    "@weborigami/async-tree": "0.6.0",
     "@weborigami/json-feed-to-rss": "1.0.0",
-    "@weborigami/language": "0.5.7",
-    "@weborigami/types": "0.5.7",
+    "@weborigami/language": "0.6.0",
     "css-tree": "3.1.0",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.11.1",
-    "jsdom": "26.1.0",
-    "marked": "16.2.0",
-    "marked-gfm-heading-id": "4.1.2",
-    "marked-highlight": "2.2.2",
-    "marked-smartypants": "1.1.10",
-    "sharp": "0.34.3",
+    "jsdom": "27.2.0",
+    "marked": "17.0.0",
+    "marked-gfm-heading-id": "4.1.3",
+    "marked-highlight": "2.2.3",
+    "marked-smartypants": "1.1.11",
+    "sharp": "0.34.5",
     "yaml": "2.8.1"
   },
   "scripts": {

package/src/cli/cli.js

@@ -14,7 +14,7 @@ async function main(...args) {
   const expression = args.join(" ");
 
   // Need to initialize builtins before calling projectRoot, which instantiates
-  // an OrigamiFiles object that handles extensions, which requires builtins.
+  // an OrigamiFileMap object that handles extensions, which requires builtins.
   initializeBuiltins();
 
   // Find the project root.

package/src/common/assertTreeIsDefined.js

@@ -1,7 +1,7 @@
 import { Tree } from "@weborigami/async-tree";
 
 export default function assertTreeIsDefined(tree, methodName) {
-  const isValid = tree === null || Tree.isAsyncTree(tree);
+  const isValid = tree === null || Tree.isMap(tree);
   if (!isValid) {
     throw new Error(
       `${methodName} must be called with a tree target. If you don't want to pass a tree, invoke with: ${methodName}.call(null)`

package/src/common/documentObject.js

@@ -26,14 +26,7 @@ export default async function documentObject(input, data) {
     text = toString(input);
     inputData = null;
   }
-  // TODO: Either restore this code, or move responsibility for packing a
-  // document to HandleExtensionsTransform set().
-  // const base = {
-  //   pack() {
-  //     return txt_handler.pack(this);
-  //   },
-  // };
-  // const result = Object.create(base);
+
   const result = {};
   Object.assign(result, inputData, data);
   Object.defineProperty(result, "_body", {

package/src/common/serialize.d.ts

@@ -1,7 +1,7 @@
-import type { AsyncTree } from "@weborigami/types";
+import type { SyncOrAsyncMap } from "@weborigami/async-tree";
 import type { JsonValue } from "../../index.ts";
 
-export function evaluateYaml(text: string, parent?: AsyncTree|null): Promise<JsonValue>;
+export function evaluateYaml(text: string, parent?: SyncOrAsyncMap|null): Promise<JsonValue>;
 export function parseYaml(text: string): JsonValue;
-export function toJson(obj: JsonValue | AsyncTree): Promise<string>;
-export function toYaml(obj: JsonValue | AsyncTree): Promise<string>;
+export function toJson(object: any): Promise<string>;
+export function toYaml(object: any): Promise<string>;

package/src/common/serialize.js

@@ -1,11 +1,16 @@
 /**
  * @typedef {import("../../index.ts").JsonValue} JsonValue
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
  */
 
-import { Tree, toPlainValue } from "@weborigami/async-tree";
+import {
+  castArraylike,
+  SyncMap,
+  toPlainValue,
+  trailingSlash,
+} from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 
 // The "yaml" package doesn't seem to provide a default export that the browser can
@@ -13,21 +18,6 @@ import * as YAMLModule from "yaml";
 // @ts-ignore
 const YAML = YAMLModule.default ?? YAMLModule.YAML;
 
-/**
- *
- * @param {string} text
- * @param {AsyncTree|null} [parent]
- */
-export async function evaluateYaml(text, parent) {
-  const data = parseYaml(String(text));
-  if (Tree.isAsyncTree(data)) {
-    data.parent = parent;
-    return Tree.plain(data);
-  } else {
-    return data;
-  }
-}
-
 /**
  * @param {string} text
  * @returns {JsonValue}
@@ -36,23 +26,29 @@ export function parseYaml(text) {
   return YAML.parse(text);
 }
 
+function reduceToMap(values, keys, map) {
+  // Normalize slashes in keys.
+  keys = keys.map(trailingSlash.remove);
+  return castArraylike(keys, values, (entries) => new SyncMap(entries));
+}
+
 /**
  * Serializes an object as a JSON string.
  *
- * @param {any} obj
+ * @param {any} object
  */
-export async function toJson(obj) {
-  const serializable = await toPlainValue(obj);
+export async function toJson(object) {
+  const serializable = await toPlainValue(object);
   return JSON.stringify(serializable, null, 2);
 }
 
 /**
  * Serializes an object as a JSON string.
  *
- * @param {any} obj
+ * @param {any} object
  * @returns {Promise<string>}
  */
-export async function toYaml(obj) {
-  const serializable = await toPlainValue(obj);
+export async function toYaml(object) {
+  const serializable = await toPlainValue(object, reduceToMap);
   return YAML.stringify(serializable);
 }

package/src/dev/ExplorableSiteTransform.js

@@ -18,9 +18,11 @@ import indexPage from "../origami/indexPage.js";
  * As a convenience, this transform also provides a default index.html page if
  * the tree doesn't define one.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ * @typedef {import("../../index.ts").Constructor<Map>} MapConstructor
+ * @typedef {import("../../index.ts").Constructor<AsyncMap>} AsyncMapConstructor
+ *
+ * @param {MapConstructor|AsyncMapConstructor} Base
  */
 export default function ExplorableSiteTransform(Base) {
   return class ExplorableSite extends Base {
@@ -38,7 +40,7 @@ export default function ExplorableSiteTransform(Base) {
         }
       }
 
-      if (Tree.isAsyncTree(value)) {
+      if (Tree.isMap(value)) {
         // Ensure this transform is applied to any tree result so the user
         // browse into data and trees of classes other than the current class.
         if (!isTransformApplied(ExplorableSiteTransform, value)) {

package/src/dev/OriCommandTransform.js

@@ -7,11 +7,11 @@ import { projectGlobals } from "@weborigami/language";
  * E.g., asking this tree for `!yaml` will invoke the yaml() builtin function,
  * passing the current tree as the first argument.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Constructor<AsyncTree>}
- * AsyncTreeConstructor
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ * @typedef {import("../../index.ts").Constructor<Map>} MapConstructor
+ * @typedef {import("../../index.ts").Constructor<AsyncMap>} AsyncMapConstructor
  *
- * @param {AsyncTreeConstructor} Base
+ * @param {MapConstructor|AsyncMapConstructor} Base
  */
 export default function OriCommandTransform(Base) {
   return class OriCommand extends Base {

package/src/dev/changes.js

@@ -4,23 +4,23 @@ import { getTreeArgument, trailingSlash, 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").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {Treelike} oldTreelike
- * @param {Treelike} newTreelike
+ * @param {Maplike} oldMaplike
+ * @param {Maplike} newMaplike
  */
-export default async function changes(oldTreelike, newTreelike) {
-  const oldTree = await getTreeArgument(oldTreelike, "changes", {
+export default async function changes(oldMaplike, newMaplike) {
+  const oldTree = await getTreeArgument(oldMaplike, "changes", {
     deep: true,
     position: 0,
   });
-  const newTree = await getTreeArgument(newTreelike, "changes", {
+  const newTree = await getTreeArgument(newMaplike, "changes", {
     deep: true,
     position: 1,
   });
 
-  const oldKeys = Array.from(await oldTree.keys());
-  const newKeys = Array.from(await newTree.keys());
+  const oldKeys = await Tree.keys(oldTree);
+  const newKeys = await Tree.keys(newTree);
 
   const oldKeysNormalized = oldKeys.map(trailingSlash.remove);
   const newKeysNormalized = newKeys.map(trailingSlash.remove);
@@ -38,7 +38,7 @@ export default async function changes(oldTreelike, newTreelike) {
     const oldValue = await oldTree.get(oldKey);
     const newValue = await newTree.get(oldKey);
 
-    if (Tree.isAsyncTree(oldValue) && Tree.isAsyncTree(newValue)) {
+    if (Tree.isMap(oldValue) && Tree.isMap(newValue)) {
       const treeChanges = await changes(oldValue, newValue);
       if (treeChanges && Object.keys(treeChanges).length > 0) {
         result ??= {};

package/src/dev/code.js

@@ -2,7 +2,6 @@ import { toString } from "@weborigami/async-tree";
 import { compile } from "@weborigami/language";
 
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {import("@weborigami/async-tree").Stringlike} input
  */

package/src/dev/copy.js

@@ -4,18 +4,20 @@ import process, { stdout } from "node:process";
 import { transformObject } from "../common/utilities.js";
 
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {Treelike} source
- * @param {Treelike} target
+ * @param {Maplike} source
+ * @param {Maplike} target
  */
 export default async function copy(source, target) {
   const sourceTree = await getTreeArgument(source, "copy", { position: 0 });
   let targetTree = await getTreeArgument(target, "copy", { position: 1 });
 
   if (stdout.isTTY) {
-    targetTree = transformObject(ProgressTransform, targetTree);
+    targetTree =
+      targetTree instanceof Map
+        ? transformObject(SyncProgressTransform, targetTree)
+        : transformObject(AsyncProgressTransform, targetTree);
     copyRoot = targetTree;
     countFiles = 0;
     countCopied = 0;
@@ -36,7 +38,7 @@ let countFiles;
 let countCopied;
 let copyRoot;
 
-function ProgressTransform(Base) {
+function AsyncProgressTransform(Base) {
   return class Progress extends Base {
     async set(...args) {
       countFiles++;
@@ -59,3 +61,27 @@ function ProgressTransform(Base) {
     }
   };
 }
+
+function SyncProgressTransform(Base) {
+  return class Progress extends Base {
+    set(...args) {
+      countFiles++;
+      copyRoot.showProgress();
+      let result;
+      try {
+        result = super.set(...args);
+        countCopied++;
+      } catch (/** @type {any} */ error) {
+        console.error(formatError(error));
+      }
+      copyRoot.showProgress();
+      return result;
+    }
+
+    showProgress() {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+      process.stdout.write(`Copied ${countCopied} of ${countFiles}`);
+    }
+  };
+}

package/src/dev/crawler/audit.js

@@ -11,15 +11,14 @@ import { getBaseUrl } from "./utilities.js";
  * Crawl the indicated tree and return an audit of any broken links to internal
  * pages or other resources.
  *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {Treelike} treelike
+ * @param {Maplike} maplike
  * @param {string} [baseHref]
  */
-export default async function audit(treelike, baseHref) {
-  const tree = await getTreeArgument(treelike, "audit");
-  const baseUrl = getBaseUrl(baseHref, treelike);
+export default async function audit(maplike, baseHref) {
+  const tree = await getTreeArgument(maplike, "audit");
+  const baseUrl = getBaseUrl(baseHref, maplike);
 
   let errors = {};
   let report;

package/src/dev/crawler/crawl.js

@@ -1,10 +1,9 @@
 import {
-  DeepObjectTree,
+  DeepObjectMap,
   Tree,
   getTreeArgument,
   keysFromPath,
 } from "@weborigami/async-tree";
-import { InvokeFunctionsTransform } from "@weborigami/language";
 import crawlResources from "./crawlResources.js";
 import { addValueToObject, getBaseUrl } from "./utilities.js";
 
@@ -16,16 +15,16 @@ import { addValueToObject, getBaseUrl } from "./utilities.js";
  * in-memory. Referenced resources like images will be represented as functions
  * that obtain the requested value from the original site.
  *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {Treelike} treelike
+ * @param {Maplike} maplike
  * @param {string} [baseHref]
- * @returns {Promise<AsyncTree>}
+ * @returns {Promise<AsyncMap>}
  */
-export default async function crawlBuiltin(treelike, baseHref) {
-  const tree = await getTreeArgument(treelike, "crawl");
-  const baseUrl = getBaseUrl(baseHref, treelike);
+export default async function crawlBuiltin(maplike, baseHref) {
+  const tree = await getTreeArgument(maplike, "crawl");
+  const baseUrl = getBaseUrl(baseHref, maplike);
 
   const cache = {};
   const resources = {};
@@ -54,8 +53,8 @@ export default async function crawlBuiltin(treelike, baseHref) {
   // for something already, that's better than a function that will get that
   // value.
   const result = Tree.deepMerge(
-    new DeepObjectTree(cache),
-    new (InvokeFunctionsTransform(DeepObjectTree))(resources)
+    new DeepObjectMap(cache),
+    await Tree.invokeFunctions(resources)
   );
   return result;
 }

package/src/dev/crawler/crawlResources.js

@@ -136,7 +136,7 @@ async function processPath(tree, path, baseUrl) {
     value = await Tree.traverse(tree, ...keys);
     normalizedKeys = keys.slice();
     normalizedPath = path;
-    if (Tree.isTreelike(value)) {
+    if (Tree.isMaplike(value)) {
       // Path is actually a directory. See if we can get the empty string or
       // "index.html".
       value =

package/src/dev/debug.js

@@ -6,14 +6,14 @@ import OriCommandTransform from "./OriCommandTransform.js";
 /**
  * Add debugging features to the indicated tree.
  *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {Treelike} treelike
- * @returns {Promise<AsyncTree>}
+ * @param {Maplike} maplike
+ * @returns {Promise<Map|AsyncMap>}
  */
-export default async function debug(treelike) {
-  let tree = await getTreeArgument(treelike, "debug");
+export default async function debug(maplike) {
+  let tree = await getTreeArgument(maplike, "debug");
 
   if (!isTransformApplied(DebugTransform, tree)) {
     tree = transformObject(DebugTransform, tree);
@@ -26,8 +26,8 @@ export default async function debug(treelike) {
 }
 
 /**
- * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
+ * @typedef {import("../../index.ts").Constructor<AsyncMap>} AsyncMapConstructor
+ * @param {AsyncMapConstructor} Base
  */
 function DebugTransform(Base) {
   return class Debug extends OriCommandTransform(Base) {
@@ -35,11 +35,12 @@ function DebugTransform(Base) {
       let value = await super.get(key);
       const parent = this;
 
-      // Since this transform is for diagnostic purposes, cast any treelike
+      // Since this transform is for diagnostic purposes, cast any maplike
       // result to a tree so we can debug the result too. (Don't do this for
       // functions, as that can be undesirable, e.g., when writing functions
       // that handle POST requests.)
-      if (Tree.isTreelike(value) && typeof value !== "function") {
+      if (Tree.isMaplike(value) && typeof value !== "function") {
+        // @ts-ignore
         value = Tree.from(value, { parent });
         if (!isTransformApplied(DebugTransform, value)) {
           value = transformObject(DebugTransform, value);
@@ -54,6 +55,7 @@ function DebugTransform(Base) {
             return content;
           }
           /** @type {any} */
+          // @ts-ignore
           let tree = Tree.from(content, { parent });
           if (!isTransformApplied(DebugTransform, tree)) {
             tree = transformObject(DebugTransform, tree);

package/src/dev/explore.js

@@ -1,6 +1,5 @@
-/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { getTreeArgument, Tree } from "@weborigami/async-tree";
-import { Handlers, OrigamiFiles } from "@weborigami/language";
+import { Handlers, OrigamiFileMap } from "@weborigami/language";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { getDescriptor } from "../common/utilities.js";
@@ -11,8 +10,8 @@ let templatePromise;
 /**
  * Display a debug/explore page for the current tree.
  */
-export default async function explore(treelike) {
-  const tree = await getTreeArgument(treelike, "explore");
+export default async function explore(maplike) {
+  const tree = await getTreeArgument(maplike, "explore");
 
   // Construct the template page
   const scope = await Tree.scope(tree);
@@ -44,7 +43,7 @@ async function getScopeData(scope) {
 
 async function loadTemplate() {
   const folderPath = path.resolve(fileURLToPath(import.meta.url), "..");
-  const folder = new OrigamiFiles(folderPath);
+  const folder = new OrigamiFileMap(folderPath);
   const templateFile = await folder.get("explore.ori");
   const template = await Handlers.ori_handler.unpack(templateFile, {
     parent: folder,

package/src/dev/help.js

@@ -5,7 +5,6 @@ import YAML from "yaml";
 import version from "./version.js";
 
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} [key]
  */