@weborigami/origami 0.0.39 → 0.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -15,13 +15,13 @@
   "devDependencies": {
     "@types/chai": "4.3.11",
     "@types/mocha": "10.0.6",
-    "@types/node": "20.11.3",
+    "@types/node": "20.11.7",
     "typescript": "5.3.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.39",
-    "@weborigami/language": "0.0.39",
-    "@weborigami/types": "0.0.39",
+    "@weborigami/async-tree": "0.0.40",
+    "@weborigami/language": "0.0.40",
+    "@weborigami/types": "0.0.40",
     "graphviz-wasm": "3.0.1",
     "highlight.js": "11.9.0",
     "marked": "11.1.1",
@@ -34,7 +34,7 @@
   "scripts": {
     "build": "ori exports/buildExports.js src > exports/exports.js",
     "prepublishOnly": "npm run build",
-    "test": "node --test --test-reporter=spec test/*/*.test.js test/*/*/*.test.js",
+    "test": "node --test --test-reporter=spec",
     "typecheck": "node node_modules/typescript/bin/tsc"
   }
 }

package/src/builtins/@explore.js

@@ -1,5 +1,5 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { ObjectTree } from "@weborigami/async-tree";
+import { ObjectTree, Tree } from "@weborigami/async-tree";
 import { OrigamiFiles, Scope } from "@weborigami/language";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -14,14 +14,8 @@ const miscFiles = Scope.treeWithScope(new OrigamiFiles(miscDir), builtins);
 /**
  * @this {AsyncTree|null}
  */
-export default async function explore() {
+export default async function explore(...keys) {
   const scope = Scope.getScope(this);
-  const templateFile = await miscFiles.get("explore.ori");
-  const template = await templateFile.unpack();
-
-  const data = await getScopeData(scope);
-  const text = await template(data);
-
   const ambientsTree = new ObjectTree({
     "@current": this,
   });
@@ -29,8 +23,34 @@ export default async function explore() {
   const extendedScope = new Scope(ambientsTree, scope);
 
   /** @type {any} */
-  const result = new String(text);
-  result.unpack = () => debug.call(scope, extendedScope);
+  let result;
+  if (keys.length > 0) {
+    // Traverse the scope using the given keys.
+    const debugScope = await debug.call(scope, extendedScope);
+    if (!debugScope) {
+      return undefined;
+    }
+
+    // HACK: reproduce logic of ExplorableSiteTransform that turns a trailing
+    // slash into index.html. Calling `debug` applies that transform and the
+    // transform should handle that logic, but unfortunately the `traverse`
+    // operation has special casing to treat a trailing slash, and never gives
+    // ExplorableSiteTransform a chance.
+    if (keys.at(-1) === "") {
+      keys[keys.length - 1] = "index.html";
+    }
+    result = await Tree.traverse(debugScope, ...keys);
+  } else {
+    // Return the Explore page for the current scope.
+    const templateFile = await miscFiles.get("explore.ori");
+    const template = await templateFile.unpack();
+
+    const data = await getScopeData(scope);
+    const text = await template(data);
+
+    result = new String(text);
+    result.unpack = () => debug.call(scope, extendedScope);
+  }
 
   return result;
 }

package/src/builtins/@inline.js

@@ -1,5 +1,5 @@
+import { compile } from "@weborigami/language";
 import unpackText from "../builtins/@loaders/txt.js";
-import * as utilities from "../common/utilities.js";
 import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
 import unpackOrigamiExpression from "./@loaders/ori.js";
 
@@ -28,13 +28,9 @@ export default async function inline(input) {
     inputDocument = await unpackText(input);
   }
 
-  // Treat the input text as the body of an Origami template literal.
-  const inputText = utilities.toString(inputDocument);
-  const templateDocument = Object.assign({}, inputDocument, {
-    "@text": `=\`${inputText}\``,
+  const templateFn = await unpackOrigamiExpression(inputDocument, {
+    compiler: compile.templateDocument,
   });
-
-  const templateFn = await unpackOrigamiExpression(templateDocument);
   const templateResult = await templateFn(inputDocument);
   return inputDocument
     ? Object.assign({}, inputDocument, { "@text": String(templateResult) })

package/src/builtins/@loaders/ori.js

@@ -17,10 +17,27 @@ export default async function unpackOrigamiExpression(
     options.parent ??
     /** @type {any} */ (inputDocument).parent ??
     /** @type {any} */ (inputDocument)[utilities.parentSymbol];
+  const compiler = options.compiler ?? compile.expression;
 
   // Compile the body text as an Origami expression and evaluate it.
   const inputText = utilities.toString(inputDocument);
-  const fn = compile.expression(inputText);
+  let fn;
+  try {
+    fn = compiler(inputText);
+  } catch (/** @type {any} */ error) {
+    let location = "";
+    if (options.key) {
+      location += `${options.key}`;
+    }
+    if (error.location) {
+      const { start } = error.location;
+      location += `, line ${start.line}, column ${start.column}`;
+    }
+    if (location) {
+      error.message += ` (${location})`;
+    }
+    throw error;
+  }
   const parentScope = parent ? Scope.getScope(parent) : builtins;
   let content = await fn.call(parentScope);
 

package/src/builtins/@ori.js

@@ -15,7 +15,10 @@ const TypedArray = Object.getPrototypeOf(Uint8Array);
  * @this {AsyncTree|null}
  * @param {string} expression
  */
-export default async function ori(expression) {
+export default async function ori(
+  expression,
+  options = { formatResult: true }
+) {
   assertScopeIsDefined(this);
   // In case expression is a Buffer, cast it to a string.
   expression = String(expression);
@@ -34,8 +37,7 @@ export default async function ori(expression) {
     result = await result.call(scope);
   }
 
-  const formatted = await formatResult(result);
-  return formatted;
+  return options.formatResult ? await formatResult(result) : result;
 }
 
 async function formatResult(result) {

package/src/builtins/@package.js

@@ -4,25 +4,49 @@ import project from "./@project.js";
 
 /**
  * @this {import("@weborigami/types").AsyncTree|null}
- * @param {string[]} packageKeys
+ * @param {string[]} keys
  */
-export default async function packageBuiltin(...packageKeys) {
+export default async function packageBuiltin(...keys) {
   let scope = this;
   if (!scope) {
     const projectRoot = await project.call(null);
     scope = Scope.getScope(projectRoot);
   }
+
+  const packageKeys = [keys.shift()];
+  if (packageKeys[0]?.startsWith("@")) {
+    // First key is an npm organization, get the next key too.
+    packageKeys.push(keys.shift());
+  }
+
   const packageRoot = await Tree.traverse(
     // @ts-ignore
     scope,
     "node_modules",
     ...packageKeys
   );
+  if (!packageRoot) {
+    throw new Error(`Can't find node_modules/${packageKeys.join("/")}`);
+  }
+
   const mainPath = await Tree.traverse(packageRoot, "package.json", "main");
+  if (!mainPath) {
+    throw new Error(
+      `node_modules/${keys.join(
+        "/"
+      )} doesn't contain a package.json with a "main" entry.`
+    );
+  }
+
   const mainKeys = keysFromPath(mainPath);
   const mainContainerKeys = mainKeys.slice(0, -1);
   const mainFileName = mainKeys[mainKeys.length - 1];
   const mainContainer = await Tree.traverse(packageRoot, ...mainContainerKeys);
   const packageExports = await mainContainer.import(mainFileName);
-  return packageExports;
+
+  const result =
+    keys.length > 0
+      ? await Tree.traverse(packageExports, ...keys)
+      : packageExports;
+  return result;
 }

package/src/common/FilterTree.js

@@ -1,4 +1,4 @@
-import { Tree } from "@weborigami/async-tree";
+import { DeepObjectTree, Tree, isPlainObject } from "@weborigami/async-tree";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -7,7 +7,9 @@ import { Tree } from "@weborigami/async-tree";
 export default class FilterTree {
   constructor(tree, filter) {
     this.tree = Tree.from(tree);
-    this.filter = Tree.from(filter);
+    this.filter = isPlainObject(filter)
+      ? new DeepObjectTree(filter)
+      : Tree.from(filter);
   }
 
   async get(key) {

package/src/common/GlobTree.js

@@ -1,4 +1,10 @@
-import { ObjectTree, Tree, merge } from "@weborigami/async-tree";
+import {
+  DeepObjectTree,
+  ObjectTree,
+  Tree,
+  isPlainObject,
+  merge,
+} from "@weborigami/async-tree";
 
 const globstar = "**";
 
@@ -8,7 +14,9 @@ const globstar = "**";
  */
 export default class GlobTree {
   constructor(globs) {
-    this.globs = Tree.from(globs);
+    this.globs = isPlainObject(globs)
+      ? new DeepObjectTree(globs)
+      : Tree.from(globs);
   }
 
   async get(key) {

package/src/common/processUnpackedContent.js

@@ -31,7 +31,10 @@ export default function processUnpackedContent(content, parent, inputDocument) {
 
     extendScope.code = fn.code;
     return extendScope;
-  } else if (Tree.isAsyncTree(content)) {
+  } else if (
+    Tree.isAsyncTree(content) &&
+    !(/** @type {any} */ (content).scope)
+  ) {
     const result = Object.create(content);
     result.parent = parent;
     return result;

package/src/misc/OriCommandTransform.js

@@ -33,7 +33,7 @@ export default function OriCommandTransform(Base) {
         ambientsTree[keySymbol] = "ori command";
         const extendedScope = new Scope(ambientsTree, Scope.getScope(this));
         const source = key.slice(1).trim();
-        value = await ori.call(extendedScope, source);
+        value = await ori.call(extendedScope, source, { formatResult: false });
 
         // Ensure this transform is applied to any subtree.
         if (Tree.isAsyncTree(value)) {

package/src/server/server.js

@@ -53,21 +53,7 @@ export function treeRouter(tree) {
 export async function handleRequest(request, response, tree) {
   // For parsing purposes, we assume HTTPS -- it doesn't affect parsing.
   const url = new URL(request.url, `https://${request.headers.host}`);
-
-  // Split on occurrences of `/!`, which represent Origami debug commands.
-  // Command arguments can contain slashes; don't treat those as path keys.
-  const parts = url.pathname.split(/\/!/);
-  const keys = parts.flatMap((part, index) => {
-    const decoded = decodeURIComponent(part);
-    // Split keys that aren't commands; add back the `!` to commands.
-    return index % 2 === 0 ? keysFromPath(decoded) : `!${decoded}`;
-  });
-
-  // If the path ends with a trailing slash, the final key will be an empty
-  // string. Change that to "index.html".
-  if (keys[keys.length - 1] === "") {
-    keys[keys.length - 1] = "index.html";
-  }
+  const keys = keysFromUrl(url);
 
   const extendedTree =
     url.searchParams && "parent" in tree
@@ -176,6 +162,28 @@ export async function handleRequest(request, response, tree) {
   return true;
 }
 
+function keysFromUrl(url) {
+  // Split on occurrences of `/!`, which represent Origami debug commands.
+  // Command arguments can contain slashes; don't treat those as path keys.
+  const parts = url.pathname.split(/\/!/);
+
+  // Split everything before the first command by slashes and decode those.
+  const path = parts.shift();
+  const pathKeys = keysFromPath(path).map((key) => decodeURIComponent(key));
+
+  // If there are no commands, and the path ends with a trailing slash, the
+  // final key will be an empty string. Change that to "index.html".
+  if (parts.length === 0 && pathKeys[pathKeys.length - 1] === "") {
+    pathKeys[pathKeys.length - 1] = "index.html";
+  }
+
+  // Add back the `!` to commands.
+  const commandKeys = parts.map((command) => `!${command}`);
+
+  const keys = [...pathKeys, ...commandKeys];
+  return keys;
+}
+
 /**
  * A request listener for use with the node http.createServer and
  * https.createServer calls, letting you serve an async tree as a set of pages.