@weborigami/origami 0.0.55 → 0.0.57

package/package.json

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

package/src/builtins/@clean.js

@@ -8,7 +8,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  * @param {import("@weborigami/async-tree").Treelike} treelike
  */
 export default async function clean(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "@sequence");
+  const tree = await getTreeArgument(this, arguments, treelike, "@clean");
   if (!Tree.isAsyncMutableTree(tree)) {
     throw new TypeError("@clean: the given tree is read-only.");
   }

package/src/builtins/@mapFn.js

@@ -129,17 +129,22 @@ export default function mapFnBuiltin(operation) {
 function parseExtensions(specifier) {
   const lowercase = specifier?.toLowerCase() ?? "";
   const extensionRegex =
-    /^\.?(?<sourceExtension>\S*)(?:\s*(→|->)\s*)\.?(?<extension>\S+)$/;
-  let resultExtension;
-  let sourceExtension;
+    /^(\.?(?<sourceExtension>\S*)\s*(→|->)\s*\.?(?<resultExtension>\S*))|(\.?(?<extension>\S*))$/;
   const match = lowercase.match(extensionRegex);
-  if (match?.groups) {
+  if (!match) {
+    // Shouldn't happen because the regex is exhaustive.
+    throw new Error(`@mapFn: Invalid extension specifier "${specifier}".`);
+  }
+  // @ts-ignore
+  const { extension, resultExtension, sourceExtension } = match.groups;
+  if (sourceExtension || resultExtension) {
     // foo→bar
-    ({ extension: resultExtension, sourceExtension } = match.groups);
+    return { resultExtension, sourceExtension };
   } else {
     // foo
-    resultExtension = lowercase;
-    sourceExtension = lowercase;
+    return {
+      resultExtension: specifier,
+      sourceExtension: specifier,
+    };
   }
-  return { resultExtension, sourceExtension };
 }

package/src/builtins/@project.js

@@ -26,40 +26,49 @@ export default async function project(key) {
 
   const dirname = process.cwd();
   const currentTree = new OrigamiFiles(dirname);
-  let containerTree = await findConfigContainer(currentTree);
 
-  let config;
-  if (containerTree) {
+  // Search up the tree for the configuration file or package.json to determine
+  // the project root.
+  let rootTree =
+    (await findAncestorFile(currentTree, configFileName)) ??
+    (await findAncestorFile(currentTree, "package.json"));
+
+  let config = null;
+  if (rootTree) {
     // Load the configuration.
-    const configParent = Scope.treeWithScope(containerTree, builtins);
+    const configParent = Scope.treeWithScope(rootTree, builtins);
     const buffer = await configParent.get(configFileName);
-    config = await fileTypeOrigami.unpack(buffer, {
-      key: configFileName,
-      parent: configParent,
-    });
-    if (!config) {
-      const configPath = /** @type {any} */ (configParent).path;
-      throw new Error(
-        `Couldn't load the Origami configuration in ${configPath}/${configFileName}`
-      );
+    if (buffer) {
+      // Project has configuration file
+      config = await fileTypeOrigami.unpack(buffer, {
+        key: configFileName,
+        parent: configParent,
+      });
+      if (!config) {
+        const configPath = /** @type {any} */ (configParent).path;
+        throw new Error(
+          `Couldn't load the Origami configuration in ${configPath}/${configFileName}`
+        );
+      }
     }
   } else {
-    containerTree = currentTree;
-    config = null;
+    rootTree = currentTree;
   }
 
   // Add the configuration as the context for the project root.
   const scope = new Scope(config, builtins);
-  const result = Scope.treeWithScope(containerTree, scope);
+  const result = Scope.treeWithScope(rootTree, scope);
   return key === undefined ? result : result.get(key);
 }
 
-async function findConfigContainer(start) {
+// Return the first ancestor of the given tree that contains a file with the
+// given name.
+async function findAncestorFile(start, fileName) {
   let current = start;
   while (current) {
-    const config = await current.get(configFileName);
-    if (config) {
-      // Found a configuration; its container is the project root.
+    const value = await current.get(fileName);
+    if (value) {
+      // Found the desired file; its container is the project root.
       return current;
     }
     // Not found; try the parent.