@weborigami/language 0.0.66-beta.1 → 0.0.66-beta.2

package/src/compiler/parserHelpers.js

@@ -13,6 +13,22 @@ export function annotate(parseResult, location) {
   return parseResult;
 }
 
+// Return true if the code will generate an async object.
+function isAsyncObject(code) {
+  if (!(code instanceof Array)) {
+    return false;
+  }
+  if (code[0] !== ops.object) {
+    return false;
+  }
+  // Are any of the properties getters?
+  const entries = code.slice(1);
+  const hasGetter = entries.some(([key, value]) => {
+    return value instanceof Array && value[0] === ops.getter;
+  });
+  return hasGetter;
+}
+
 export function makeArray(entries) {
   let currentEntries = [];
   const spreads = [];
@@ -72,9 +88,14 @@ export function makeFunctionCall(target, chain, location) {
 
     // @ts-ignore
     fnCall =
-      args[0] === ops.traverse
-        ? [ops.traverse, value, ...args.slice(1)]
-        : [value, ...args];
+      args[0] !== ops.traverse
+        ? // Function call
+          [value, ...args]
+        : args.length > 1
+        ? // Traverse
+          [ops.traverse, value, ...args.slice(1)]
+        : // Traverse without arguments equates to unpack
+          [ops.unpack, value];
 
     // Create a location spanning the newly-constructed function call.
     if (args instanceof Array) {
@@ -97,14 +118,28 @@ export function makeObject(entries, op) {
   let currentEntries = [];
   const spreads = [];
 
-  for (const [key, value] of entries) {
+  for (let [key, value] of entries) {
     if (key === ops.spread) {
+      // Accumulate spread entry
       if (currentEntries.length > 0) {
         spreads.push([op, ...currentEntries]);
         currentEntries = [];
       }
       spreads.push(value);
     } else {
+      if (
+        value instanceof Array &&
+        value[0] === ops.getter &&
+        value[1] instanceof Array &&
+        value[1][0] === ops.primitive
+      ) {
+        // Simplify a getter for a primitive value to a regular property
+        value = value[1];
+      } else if (isAsyncObject(value)) {
+        // Add a trailing slash to key if value is an async object
+        key = key + "/";
+      }
+
       currentEntries.push([key, value]);
     }
   }

package/src/runtime/HandleExtensionsTransform.js

@@ -1,4 +1,4 @@
-import { attachHandlerIfApplicable } from "./extensions.js";
+import { handleExtension } from "./extensions.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -10,9 +10,8 @@ import { attachHandlerIfApplicable } from "./extensions.js";
 export default function HandleExtensionsTransform(Base) {
   return class FileLoaders extends Base {
     async get(key) {
-      let value = await super.get(key);
-      value = attachHandlerIfApplicable(this, value, key);
-      return value;
+      const value = await super.get(key);
+      return handleExtension(this, value, key);
     }
   };
 }

package/src/runtime/ImportModulesMixin.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { maybeOrigamiSourceCode } from "./formatError.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -25,21 +26,23 @@ export default function ImportModulesMixin(Base) {
         }
 
         // Does the module exist as a file?
-        let stats;
         try {
-          stats = await fs.stat(filePath);
+          await fs.stat(filePath);
         } catch (error) {
-          // Ignore errors.
+          // File doesn't exist
+          return undefined;
         }
-        if (stats) {
-          // Module exists, but we can't load it. This is often due to a syntax
-          // error in the target module, so we offer that as a hint.
-          const message = `Error loading ${filePath}, possibly due to a syntax error.\n${error.message}`;
-          throw new SyntaxError(message);
+
+        // Module exists, but we can't load it. Is the error internal?
+        if (maybeOrigamiSourceCode(error.message)) {
+          throw new Error(
+            `Internal Origami error loading ${filePath}\n${error.message}`
+          );
         }
 
-        // Module doesn't exist.
-        return undefined;
+        // Error may be a syntax error, so we offer that as a hint.
+        const message = `Error loading ${filePath}, possibly due to a syntax error.\n${error.message}`;
+        throw new SyntaxError(message);
       }
 
       if ("default" in obj) {

package/src/runtime/InvokeFunctionsTransform.js

@@ -21,11 +21,5 @@ export default function InvokeFunctionsTransform(Base) {
       }
       return value;
     }
-
-    // Need to evaluate the value before checking if it is a tree.
-    async isKeyForSubtree(key) {
-      const value = await this.get(key);
-      return Tree.isAsyncTree(value);
-    }
   };
 }

package/src/runtime/expressionObject.js

@@ -1,5 +1,5 @@
 import { ObjectTree, symbols } from "@weborigami/async-tree";
-import { attachHandlerIfApplicable, extname } from "./extensions.js";
+import { extname, handleExtension } from "./extensions.js";
 import { evaluate, ops } from "./internal.js";
 
 /**
@@ -36,7 +36,6 @@ export default async function expressionObject(entries, parent) {
     // has an extension, we need to define a getter. If the value is code (an
     // array), we need to define a getter -- but if that code takes the form
     // [ops.getter, <primitive>], we can define a regular property.
-
     let defineProperty;
     const extension = extname(key);
     if (extension) {
@@ -50,6 +49,7 @@ export default async function expressionObject(entries, parent) {
       defineProperty = false;
     }
 
+    // If the key is wrapped in parentheses, it is not enumerable.
     let enumerable = true;
     if (key[0] === "(" && key[key.length - 1] === ")") {
       key = key.slice(1, -1);
@@ -81,7 +81,7 @@ export default async function expressionObject(entries, parent) {
         get = async () => {
           tree ??= new ObjectTree(object);
           const result = await evaluate.call(tree, code);
-          return attachHandlerIfApplicable(tree, result, key);
+          return handleExtension(tree, result, key);
         };
       } else {
         // No extension, so getter just invokes code.

package/src/runtime/extensions.js

@@ -5,9 +5,53 @@ import {
   isUnpackable,
   scope,
   symbols,
-  toString,
+  trailingSlash,
 } from "@weborigami/async-tree";
 
+/**
+ * If the given path ends in an extension, return it. Otherwise, return the
+ * empty string.
+ *
+ * This is meant as a basic replacement for the standard Node `path.extname`.
+ * That standard function inaccurately returns an extension for a path that
+ * includes a near-final extension but ends in a final slash, like `foo.txt/`.
+ * Node thinks that path has a ".txt" extension, but for our purposes it
+ * doesn't.
+ *
+ * @param {string} path
+ */
+export function extname(path) {
+  // We want at least one character before the dot, then a dot, then a non-empty
+  // sequence of characters after the dot that aren't slahes or dots.
+  const extnameRegex = /[^/](?<ext>\.[^/\.]+)$/;
+  const match = String(path).match(extnameRegex);
+  const extension = match?.groups?.ext.toLowerCase() ?? "";
+  return extension;
+}
+
+/**
+ * Find an extension handler for a file in the given container.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {AsyncTree} parent
+ * @param {string} extension
+ */
+export async function getExtensionHandler(parent, extension) {
+  const handlerName = `${extension.slice(1)}_handler`;
+  const parentScope = scope(parent);
+  /** @type {import("../../index.ts").ExtensionHandler} */
+  let extensionHandler = await parentScope?.get(handlerName);
+  if (isUnpackable(extensionHandler)) {
+    // The extension handler itself needs to be unpacked. E.g., if it's a
+    // buffer containing JavaScript file, we need to unpack it to get its
+    // default export.
+    // @ts-ignore
+    extensionHandler = await extensionHandler.unpack();
+  }
+  return extensionHandler;
+}
+
 /**
  * If the given value is packed (e.g., buffer) and the key is a string-like path
  * that ends in an extension, search for a handler for that extension and, if
@@ -17,15 +61,23 @@ import {
  * @param {any} value
  * @param {any} key
  */
-export async function attachHandlerIfApplicable(parent, value, key) {
+export async function handleExtension(parent, value, key) {
   if (isPacked(value) && isStringLike(key)) {
-    key = toString(key);
+    const hasSlash = trailingSlash.has(key);
+    if (hasSlash) {
+      key = trailingSlash.remove(key);
+    }
 
     // Special case: `.ori.<ext>` extensions are Origami documents.
     const extension = key.match(/\.ori\.\S+$/) ? ".ori_document" : extname(key);
     if (extension) {
       const handler = await getExtensionHandler(parent, extension);
       if (handler) {
+        if (hasSlash && handler.unpack) {
+          // Key like `data.json/` ends in slash -- unpack immediately
+          return handler.unpack(value, { key, parent });
+        }
+
         // If the value is a primitive, box it so we can attach data to it.
         value = box(value);
 
@@ -48,47 +100,3 @@ export async function attachHandlerIfApplicable(parent, value, key) {
   }
   return value;
 }
-
-/**
- * Find an extension handler for a file in the given container.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- *
- * @param {AsyncTree} parent
- * @param {string} extension
- */
-export async function getExtensionHandler(parent, extension) {
-  const handlerName = `${extension.slice(1)}_handler`;
-  const parentScope = scope(parent);
-  /** @type {import("../../index.ts").ExtensionHandler} */
-  let extensionHandler = await parentScope?.get(handlerName);
-  if (isUnpackable(extensionHandler)) {
-    // The extension handler itself needs to be unpacked. E.g., if it's a
-    // buffer containing JavaScript file, we need to unpack it to get its
-    // default export.
-    // @ts-ignore
-    extensionHandler = await extensionHandler.unpack();
-  }
-  return extensionHandler;
-}
-
-/**
- * If the given path ends in an extension, return it. Otherwise, return the
- * empty string.
- *
- * This is meant as a basic replacement for the standard Node `path.extname`.
- * That standard function inaccurately returns an extension for a path that
- * includes a near-final extension but ends in a final slash, like `foo.txt/`.
- * Node thinks that path has a ".txt" extension, but for our purposes it
- * doesn't.
- *
- * @param {string} path
- */
-export function extname(path) {
-  // We want at least one character before the dot, then a dot, then a non-empty
-  // sequence of characters after the dot that aren't slahes or dots.
-  const extnameRegex = /[^/](?<ext>\.[^/\.]+)$/;
-  const match = String(path).match(extnameRegex);
-  const extension = match?.groups?.ext.toLowerCase() ?? "";
-  return extension;
-}

package/src/runtime/formatError.js

@@ -23,7 +23,7 @@ export default function formatError(error) {
     let lines = error.stack.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      if (origamiSourceSignals.some((signal) => line.includes(signal))) {
+      if (maybeOrigamiSourceCode(line)) {
         break;
       }
       if (message) {
@@ -50,3 +50,7 @@ export default function formatError(error) {
   }
   return message;
 }
+
+export function maybeOrigamiSourceCode(text) {
+  return origamiSourceSignals.some((signal) => text.includes(signal));
+}

package/src/runtime/ops.js

@@ -5,14 +5,16 @@
 
 import {
   ObjectTree,
+  OpenSiteTree,
   SiteTree,
   Tree,
   isUnpackable,
   scope as scopeFn,
+  trailingSlash,
   concat as treeConcat,
 } from "@weborigami/async-tree";
 import expressionObject from "./expressionObject.js";
-import { attachHandlerIfApplicable } from "./extensions.js";
+import { handleExtension } from "./extensions.js";
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
@@ -47,24 +49,6 @@ export async function concat(...args) {
 }
 concat.toString = () => "«ops.concat»";
 
-/**
- * Given a protocol, a host, and a list of keys, construct an href.
- *
- * @param {string} protocol
- * @param {string} host
- * @param  {...string|Symbol} keys
- */
-function constructHref(protocol, host, ...keys) {
-  let href = [host, ...keys].join("/");
-  if (!href.startsWith(protocol)) {
-    if (!href.startsWith("//")) {
-      href = `//${href}`;
-    }
-    href = `${protocol}${href}`;
-  }
-  return href;
-}
-
 /**
  * Find the indicated constructor in scope, then return a function which invokes
  * it with `new`.
@@ -88,6 +72,49 @@ export async function constructor(...keys) {
 }
 constructor.toString = () => "«ops.constructor»";
 
+/**
+ * Given a protocol, a host, and a list of keys, construct an href.
+ *
+ * @param {string} protocol
+ * @param {string} host
+ * @param  {...string|Symbol} keys
+ */
+function constructHref(protocol, host, ...keys) {
+  // Remove trailing slashes
+  const baseKeys = keys.map((key) => trailingSlash.remove(key));
+  let href = [host, ...baseKeys].join("/");
+  if (!href.startsWith(protocol)) {
+    if (!href.startsWith("//")) {
+      href = `//${href}`;
+    }
+    href = `${protocol}${href}`;
+  }
+  return href;
+}
+
+/**
+ * Given a protocol, a host, and a list of keys, construct an href.
+ *
+ * @param {string} protocol
+ * @param {import("../../index.ts").Constructor<AsyncTree>} treeClass
+ * @param {AsyncTree|null} parent
+ * @param {string} host
+ * @param  {...string|Symbol} keys
+ */
+async function constructSiteTree(protocol, treeClass, parent, host, ...keys) {
+  // If the last key doesn't end in a slash, remove it for now.
+  let lastKey;
+  if (keys.length > 0 && keys.at(-1) && !trailingSlash.has(keys.at(-1))) {
+    lastKey = keys.pop();
+  }
+
+  const href = constructHref(protocol, host, ...keys);
+  let result = new (HandleExtensionsTransform(treeClass))(href);
+  result.parent = parent;
+
+  return lastKey ? result.get(lastKey) : result;
+}
+
 /**
  * Fetch the resource at the given href.
  *
@@ -105,7 +132,7 @@ async function fetchResponse(href) {
   const url = new URL(href);
   const filename = url.pathname.split("/").pop();
   if (this && filename) {
-    buffer = await attachHandlerIfApplicable(this, buffer, filename);
+    buffer = await handleExtension(this, buffer, filename);
   }
 
   return buffer;
@@ -257,6 +284,18 @@ export async function object(...entries) {
 }
 object.toString = () => "«ops.object»";
 
+/**
+ * An open tree with JSON Keys via HTTPS.
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string|Symbol} keys
+ */
+export function openSite(host, ...keys) {
+  return constructSiteTree("https:", OpenSiteTree, this, host, ...keys);
+}
+openSite.toString = () => "«ops.openSite»";
+
 /**
  * Look up the given key in the scope for the current tree.
  *
@@ -303,10 +342,7 @@ export const traverse = Tree.traverseOrThrow;
  * @param  {...string|Symbol} keys
  */
 export function treeHttp(host, ...keys) {
-  const href = constructHref("http:", host, ...keys);
-  let result = new (HandleExtensionsTransform(SiteTree))(href);
-  result.parent = this;
-  return result;
+  return constructSiteTree("http:", SiteTree, this, host, ...keys);
 }
 treeHttp.toString = () => "«ops.treeHttp»";
 
@@ -318,9 +354,16 @@ treeHttp.toString = () => "«ops.treeHttp»";
  * @param  {...string|Symbol} keys
  */
 export function treeHttps(host, ...keys) {
-  const href = constructHref("https:", host, ...keys);
-  let result = new (HandleExtensionsTransform(SiteTree))(href);
-  result.parent = this;
-  return result;
+  return constructSiteTree("https:", SiteTree, this, host, ...keys);
 }
 treeHttps.toString = () => "«ops.treeHttps»";
+
+/**
+ * If the value is packed but has an unpack method, call it and return that as
+ * the result; otherwise, return the value as is.
+ *
+ * @param {any} value
+ */
+export async function unpack(value) {
+  return isUnpackable(value) ? value.unpack() : value;
+}

package/test/compiler/compile.test.js

@@ -36,11 +36,17 @@ describe("compile", () => {
     await assertCompile("-1", -1);
   });
 
-  test("object", async () => {
+  test("sync object", async () => {
     await assertCompile("{a:1, b:2}", { a: 1, b: 2 });
     await assertCompile("{ a: { b: { c: 0 } } }", { a: { b: { c: 0 } } });
   });
 
+  test("async object", async () => {
+    const fn = compile.expression("{ a: { b = name }}");
+    const object = await fn.call(shared);
+    assert.deepEqual(await object["a/"].b, "Alice");
+  });
+
   test("templateDocument", async () => {
     const fn = compile.templateDocument("Documents can contain ` backticks");
     const templateFn = await fn.call(shared);