@weborigami/origami 0.2.3 → 0.2.5

package/main.js

@@ -7,6 +7,7 @@ export * from "./src/handlers/handlers.js";
 export * from "./src/image/image.js";
 export { builtinsTree } from "./src/internal.js";
 export * from "./src/origami/origami.js";
+export * from "./src/server/server.js";
 export * from "./src/site/site.js";
 export * from "./src/text/text.js";
 export * from "./src/tree/tree.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -17,9 +17,9 @@
     "typescript": "5.7.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.3",
-    "@weborigami/language": "0.2.3",
-    "@weborigami/types": "0.2.3",
+    "@weborigami/async-tree": "0.2.5",
+    "@weborigami/language": "0.2.5",
+    "@weborigami/types": "0.2.5",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.11.0",

package/src/dev/watch.js

@@ -1,5 +1,5 @@
 import { Tree } from "@weborigami/async-tree";
-import { formatError } from "@weborigami/language";
+import { formatError, moduleCache } from "@weborigami/language";
 import ConstantTree from "../common/ConstantTree.js";
 import getTreeArgument from "../common/getTreeArgument.js";
 
@@ -42,6 +42,7 @@ export default async function watch(treelike, fn) {
   // Reevaluate the function whenever the tree changes.
   container.addEventListener?.("change", async () => {
     const tree = await evaluateTree(container, fn);
+    moduleCache.resetTimestamp();
     updateIndirectPointer(handle, tree);
   });
 

package/src/handlers/getParent.js

@@ -0,0 +1,29 @@
+import { symbols } from "@weborigami/async-tree";
+
+/**
+ * Return a suitable parent for the packed file.
+ *
+ * @param {any} packed
+ * @param {any} options
+ * @returns {import("@weborigami/types").AsyncTree|null}
+ */
+export default function getParent(packed, options) {
+  // Prefer parent set on options
+  if (options?.parent) {
+    return options.parent;
+  }
+
+  // If the packed object has a `parent` property, use that. Exception: Node
+  // Buffer objects have a `parent` property that we ignore.
+  if (packed.parent && !(packed instanceof Buffer)) {
+    return packed.parent;
+  }
+
+  // If the packed object has a parent symbol, use that.
+  if (packed[symbols.parent]) {
+    return packed[symbols.parent];
+  }
+
+  // Otherwise, return null.
+  return null;
+}

package/src/handlers/ori.handler.js

@@ -1,7 +1,7 @@
-import { symbols } from "@weborigami/async-tree";
 import { compile } from "@weborigami/language";
 import * as utilities from "../common/utilities.js";
 import { builtinsTree, processUnpackedContent } from "../internal.js";
+import getParent from "./getParent.js";
 
 /**
  * An Origami expression file
@@ -13,16 +13,13 @@ export default {
 
   /** @type {import("@weborigami/language").UnpackFunction} */
   async unpack(packed, options = {}) {
-    const parent =
-      options.parent ??
-      /** @type {any} */ (packed).parent ??
-      /** @type {any} */ (packed)[symbols.parent];
+    const parent = getParent(packed, options);
 
     // Construct an object to represent the source code.
     const sourceName = options.key;
     let url;
-    if (sourceName && parent?.url) {
-      let parentHref = parent.url.href;
+    if (sourceName && /** @type {any} */ (parent)?.url) {
+      let parentHref = /** @type {any} */ (parent).url.href;
       if (!parentHref.endsWith("/")) {
         parentHref += "/";
       }

package/src/handlers/oridocument.handler.js

@@ -8,6 +8,7 @@ import { compile } from "@weborigami/language";
 import { parseYaml } from "../common/serialize.js";
 import { toString } from "../common/utilities.js";
 import { processUnpackedContent } from "../internal.js";
+import getParent from "./getParent.js";
 import parseFrontMatter from "./parseFrontMatter.js";
 
 /**
@@ -19,11 +20,7 @@ export default {
 
   /** @type {import("@weborigami/language").UnpackFunction} */
   async unpack(packed, options = {}) {
-    const parent =
-      options.parent ??
-      /** @type {any} */ (packed).parent ??
-      /** @type {any} */ (packed)[symbols.parent] ??
-      null;
+    const parent = getParent(packed, options);
 
     // Unpack as a text document
     const unpacked = toString(packed);
@@ -31,8 +28,8 @@ export default {
     // See if we can construct a URL to use in error messages
     const key = options.key;
     let url;
-    if (key && parent?.url) {
-      let parentHref = parent.url.href;
+    if (key && /** @type {any} */ (parent)?.url) {
+      let parentHref = /** @type {any} */ (parent).url.href;
       if (!parentHref.endsWith("/")) {
         parentHref += "/";
       }

package/src/help/help.yaml

@@ -274,6 +274,9 @@ tree:
     concat:
       args: (...objs)
       description: Concatenate text and/or trees of text
+    constant:
+      args: (value)
+      description: Return a deep tree with a single constant value
     copy:
       args: (source, target)
       description: Copy the source tree to the target
@@ -298,6 +301,9 @@ tree:
     entries:
       args: (tree)
       description: The tree's [key, value] pairs
+    filter:
+      args: (source, filter)
+      description: Filter the source tree using the filter tree
     first:
       args: (tree)
       description: The first value in the tree
@@ -310,9 +316,9 @@ tree:
     fromFn:
       args: (fn, [keys])
       description: A tree defined by a value function
-    globs:
+    globKeys:
       args: (patterns)
-      description: A tree whose keys can include wildcard patterns
+      description: A tree whose keys can include glob wildcard patterns
     group:
       args: (tree, fn)
       description: A new tree with values grouped by the function
@@ -364,6 +370,9 @@ tree:
     plain:
       args: (tree)
       description: Render the tree as a plain JavaScript object
+    regExpKeys:
+      args: (tree)
+      description: A tree whose keys are regular expression strings
     remove:
       args: (tree, key)
       description: Remove the value for the key from tree

package/src/js.js

@@ -18,6 +18,7 @@ export default {
   Number,
   Object,
   RegExp,
+  Response,
   Set,
   String,
   Symbol,

package/src/origami/once.js

@@ -1,6 +1,7 @@
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
-const fnPromiseMap = new WeakMap();
+const fnPromiseMap = new Map();
+const codePromiseMap = new Map();
 
 /**
  * Evaluate the given function only once and cache the result.
@@ -11,8 +12,23 @@ const fnPromiseMap = new WeakMap();
  */
 export default async function once(fn) {
   assertTreeIsDefined(this, "origami:once");
+
+  const code = /** @type {any} */ (fn).code;
+  if (code) {
+    // Origami function, cache by code
+    if (!codePromiseMap.has(code)) {
+      // Don't wait for promise to resolve
+      const promise = fn.call(this);
+      codePromiseMap.set(code, promise);
+    }
+    return codePromiseMap.get(code);
+  }
+
+  // Regular function, cache by function
   if (!fnPromiseMap.has(fn)) {
-    fnPromiseMap.set(fn, fn.call(this));
+    // Don't wait for promise to resolve
+    const promise = fn.call(this);
+    fnPromiseMap.set(fn, promise);
   }
   return fnPromiseMap.get(fn);
 }

package/src/server/constructResponse.js

@@ -46,6 +46,9 @@ export default async function constructResponse(request, resource) {
     if (typeof resource === "function") {
       resource = await resource();
     }
+    if (resource instanceof Response) {
+      return resource;
+    }
   }
 
   let mediaType;

package/src/server/server.js

@@ -193,7 +193,8 @@ ${message}
 }
 
 // Asynchronous tree router as Express middleware.
-export function treeRouter(tree) {
+export function treeRouter(treelike) {
+  const tree = Tree.from(treelike, { deep: true });
   // Return a router for the tree source.
   return async function (request, response, next) {
     const handled = await handleRequest(request, response, tree);

package/src/tree/cache.js

@@ -9,19 +9,14 @@ import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @param {Treelike} sourceTreelike
  * @param {Treelike} [cacheTreelike]
- * @param {Treelike} [filterTreelike]
  * @this {AsyncTree|null}
  */
-export default async function cacheBuiltin(
-  sourceTreelike,
-  cacheTreelike,
-  filterTreelike
-) {
+export default async function cacheBuiltin(sourceTreelike, cacheTreelike) {
   assertTreeIsDefined(this, "tree:cache");
   /** @type {any} */
   const cacheTree = cacheTreelike
     ? Tree.from(cacheTreelike, { parent: this })
     : undefined;
-  const result = cache(sourceTreelike, cacheTree, filterTreelike);
+  const result = cache(sourceTreelike, cacheTree);
   return result;
 }

package/src/tree/constant.js

@@ -0,0 +1 @@
+export { constantTree as default } from "@weborigami/async-tree";

package/src/tree/deepMerge.js

@@ -11,16 +11,8 @@ import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
  */
 export default async function treeDeepMerge(...trees) {
   assertTreeIsDefined(this, "tree:deepMerge");
-
-  // Filter out null or undefined trees.
-  const filtered = trees.filter((tree) => tree);
-
-  if (filtered.length === 1) {
-    // Only one tree, no need to merge.
-    return filtered[0];
-  }
-
   // Merge the trees.
-  const result = deepMerge(...filtered);
+  const result = deepMerge(...trees);
+  result.parent = this;
   return result;
 }

package/src/tree/filter.js

@@ -1,21 +1,19 @@
-import { Tree } from "@weborigami/async-tree";
+import { filter } from "@weborigami/async-tree";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import FilterTree from "./FilterTree.js";
 
 /**
  * Apply a filter to a tree.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
  * @this {AsyncTree|null}
  * @param {Treelike} sourceTreelike
  * @param {Treelike} filterTreelike
  */
-export default async function filter(sourceTreelike, filterTreelike) {
+export default async function filterBuiltin(sourceTreelike, filterTreelike) {
   assertTreeIsDefined(this, "tree:filter");
-  const sourceTree = Tree.from(sourceTreelike, { parent: this });
-  const filterTree = Tree.from(filterTreelike, { deep: true, parent: this });
-  const result = new FilterTree(sourceTree, filterTree);
+  const result = filter(sourceTreelike, filterTreelike);
   result.parent = this;
   return result;
 }

package/src/tree/{globs.js → globKeys.js}

@@ -1,5 +1,6 @@
+import { setParent } from "@weborigami/async-tree";
+import globKeys from "@weborigami/async-tree/src/operations/globKeys.js";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import GlobTree from "./GlobTree.js";
 
 /**
  * Define a tree whose keys are globs.
@@ -10,8 +11,9 @@ import GlobTree from "./GlobTree.js";
  * @param {Treelike} tree
  * @this {AsyncTree|null}
  */
-export default async function globs(tree) {
+export default async function globKeysBuiltin(tree) {
   assertTreeIsDefined(this, "tree:globs");
-  const result = new GlobTree(tree);
+  const result = globKeys(tree);
+  setParent(this, result);
   return result;
 }

package/src/tree/map.js

@@ -21,16 +21,22 @@ import { toFunction } from "../common/utilities.js";
  * @param {ValueKeyFn|TreeMapOptions} operation
  */
 export default async function map(treelike, operation) {
-  // The tree we're going to map
-  const source = await getTreeArgument(this, arguments, treelike, "tree:map");
-  // The tree in which the map operation happens
-  const context = this;
-
   if (isUnpackable(operation)) {
     operation = await operation.unpack();
   }
+  // The tree in which the map operation happens
+  const context = this;
   const options = extendedOptions(context, operation);
 
+  // The tree we're going to map
+  const source = await getTreeArgument(
+    this,
+    arguments,
+    treelike,
+    "tree:map",
+    options?.deep
+  );
+
   const mapped = mapTransform(source, options);
   mapped.parent = context;
   return mapped;

package/src/tree/regExpKeys.js

@@ -0,0 +1,19 @@
+import { setParent } from "@weborigami/async-tree";
+import regExpKeys from "@weborigami/async-tree/src/operations/regExpKeys.js";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+
+/**
+ * Define a tree whose keys are regular expression strings.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @param {Treelike} tree
+ * @this {AsyncTree|null}
+ */
+export default async function regExpKeysBuiltin(tree) {
+  assertTreeIsDefined(this, "tree:globs");
+  const result = regExpKeys(tree);
+  setParent(this, result);
+  return result;
+}

package/src/tree/tree.js

@@ -4,6 +4,7 @@ export { default as cache } from "./cache.js";
 export { default as calendar } from "./calendar.js";
 export { default as clear } from "./clear.js";
 export { default as concat } from "./concat.js";
+export { default as constant } from "./constant.js";
 export { default as copy } from "./copy.js";
 export { default as deepMap } from "./deepMap.js";
 export { default as deepMerge } from "./deepMerge.js";
@@ -14,7 +15,7 @@ export { default as defineds } from "./defineds.js";
 export { default as filter } from "./filter.js";
 export { default as first } from "./first.js";
 export { default as fromFn } from "./fromFn.js";
-export { default as globs } from "./globs.js";
+export { default as globKeys } from "./globKeys.js";
 export { default as group } from "./group.js";
 export { default as inners } from "./inners.js";
 export { default as keys } from "./keys.js";
@@ -25,6 +26,7 @@ export { default as merge } from "./merge.js";
 export { default as paginate } from "./paginate.js";
 export { default as parent } from "./parent.js";
 export { default as plain } from "./plain.js";
+export { default as regExpKeys } from "./regExpKeys.js";
 export { default as reverse } from "./reverse.js";
 export { default as setDeep } from "./setDeep.js";
 export { default as shuffle } from "./shuffle.js";

package/src/tree/FilterTree.js

@@ -1,61 +0,0 @@
-import { trailingSlash, Tree } from "@weborigami/async-tree";
-
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @implements {AsyncTree}
- */
-export default class FilterTree {
-  constructor(tree, filter) {
-    this.tree = Tree.from(tree);
-    this.filter = Tree.from(filter, { deep: true });
-    this.parent = null;
-  }
-
-  async get(key) {
-    let value = await this.tree.get(key);
-
-    let filterValue = await this.filter.get(key);
-    if (!Tree.isAsyncTree(value)) {
-      if (filterValue === undefined) {
-        value = undefined;
-      } else if (Tree.isAsyncTree(filterValue)) {
-        value = undefined;
-      }
-    } else if (Tree.isAsyncTree(filterValue)) {
-      // Wrap value with corresponding filter.
-      value = Reflect.construct(this.constructor, [value, filterValue]);
-    }
-
-    return value;
-  }
-
-  async keys() {
-    const keys = new Set();
-
-    // Enumerate all keys in the tree that can be found in the filter tree.
-    for (const key of await this.tree.keys()) {
-      const filterValue = await this.filter.get(key);
-      const isFilterValueTree = Tree.isAsyncTree(filterValue);
-      // If the filter value is a tree, the corresponding value in the tree
-      // must be a tree too.
-      const match =
-        (!isFilterValueTree && filterValue) ||
-        (isFilterValueTree && trailingSlash.has(key));
-      if (match) {
-        keys.add(key);
-      }
-    }
-
-    // Also include any keys in the filter that are found in the tree. This
-    // lets the filter "pull" values from a tree that, e.g., is defined by a
-    // function without an explicit domain.
-    // for (const key of await this.filter.keys()) {
-    //   const value = await this.tree.get(key);
-    //   if (value !== undefined) {
-    //     keys.add(key);
-    //   }
-    // }
-
-    return keys;
-  }
-}

package/src/tree/GlobTree.js

@@ -1,76 +0,0 @@
-import { ObjectTree, Tree, merge, trailingSlash } from "@weborigami/async-tree";
-
-const globstar = "**";
-
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @implements {AsyncTree}
- */
-export default class GlobTree {
-  constructor(globs) {
-    this.globs = Tree.from(globs, { deep: true });
-  }
-
-  async get(key) {
-    if (typeof key !== "string") {
-      return undefined;
-    }
-
-    // Remove trailing slash if it exists
-    key = trailingSlash.remove(key);
-
-    let value = await matchGlobs(this.globs, key);
-    if (Tree.isAsyncTree(value)) {
-      value = Reflect.construct(this.constructor, [value]);
-    }
-    return value;
-  }
-
-  async keys() {
-    return this.globs.keys();
-  }
-}
-
-// Convert the glob to a regular expression
-function matchGlob(glob, text) {
-  const regexText = glob
-    // Escape special regex characters
-    .replace(/[+?^${}()|\[\]\\]/g, "\\$&")
-    // Replace the glob wildcards with regex wildcards
-    .replace(/\*/g, ".+")
-    .replace(/\?/g, ".");
-  const regex = new RegExp(`^${regexText}$`);
-  return regex.test(text);
-}
-
-async function matchGlobs(globs, text) {
-  let value;
-  for (let glob of await globs.keys()) {
-    if (typeof glob !== "string") {
-      continue;
-    }
-
-    // Remove trailing slash if it exists
-    glob = trailingSlash.remove(glob);
-
-    if (glob !== globstar && matchGlob(glob, text)) {
-      value = await globs.get(glob);
-      if (value !== undefined) {
-        break;
-      }
-    }
-  }
-
-  const globstarGlobs = await globs.get(globstar);
-  if (globstarGlobs) {
-    const globstarTree = new ObjectTree({ [globstar]: globstarGlobs });
-    if (value === undefined) {
-      const globstarValue = await matchGlobs(globstarGlobs, text);
-      value = globstarValue !== undefined ? globstarValue : globstarTree;
-    } else if (Tree.isAsyncTree(value)) {
-      value = merge(value, globstarTree);
-    }
-  }
-
-  return value;
-}