@weborigami/language 0.0.61 → 0.0.62

package/src/runtime/HandleExtensionsTransform.js

@@ -1,5 +1,4 @@
-import { isStringLike } from "@weborigami/async-tree";
-import handleExtension from "./handleExtension.js";
+import { attachHandlerIfApplicable } from "./extensions.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -12,13 +11,7 @@ export default function HandleExtensionsTransform(Base) {
   return class FileLoaders extends Base {
     async get(key) {
       let value = await super.get(key);
-
-      // If the key is string-like and has an extension, attach a loader (if one
-      // exists) that handles that extension.
-      if (value && isStringLike(key)) {
-        value = await handleExtension(this, String(key), value);
-      }
-
+      value = attachHandlerIfApplicable(this, value, key);
       return value;
     }
   };

package/src/runtime/OrigamiFiles.d.ts

@@ -1,10 +1,10 @@
 import { FileTree } from "@weborigami/async-tree";
 import EventTargetMixin from "./EventTargetMixin.js";
+import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import ImportModulesMixin from "./ImportModulesMixin.js";
-import OrigamiTransform from "./OrigamiTransform.js";
 import WatchFilesMixin from "./WatchFilesMixin.js";
 
-export default class OrigamiFiles extends OrigamiTransform(
+export default class OrigamiFiles extends HandleExtensionsTransform(
   (
     ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
   )

package/src/runtime/OrigamiFiles.js

@@ -1,9 +1,9 @@
 import { FileTree } from "@weborigami/async-tree";
 import EventTargetMixin from "./EventTargetMixin.js";
+import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import ImportModulesMixin from "./ImportModulesMixin.js";
-import OrigamiTransform from "./OrigamiTransform.js";
 import WatchFilesMixin from "./WatchFilesMixin.js";
 
-export default class OrigamiFiles extends OrigamiTransform(
+export default class OrigamiFiles extends HandleExtensionsTransform(
   ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
 ) {}

package/src/runtime/evaluate.js

@@ -27,7 +27,7 @@ export default async function evaluate(code) {
   }
 
   let evaluated;
-  const unevaluatedFns = [ops.lambda, ops.object, ops.tree];
+  const unevaluatedFns = [ops.lambda, ops.object];
   if (unevaluatedFns.includes(code[0])) {
     // Don't evaluate instructions, use as is.
     evaluated = code;
@@ -79,12 +79,7 @@ export default async function evaluate(code) {
   }
 
   // To aid debugging, add the code to the result.
-  if (
-    result &&
-    typeof result === "object" &&
-    Object.isExtensible(result) &&
-    !isPlainObject(result)
-  ) {
+  if (Object.isExtensible(result) && !isPlainObject(result)) {
     try {
       result[codeSymbol] = code;
       if (/** @type {any} */ (code).location) {

package/src/runtime/expressionObject.js

@@ -0,0 +1,103 @@
+import { ObjectTree, symbols } from "@weborigami/async-tree";
+import { attachHandlerIfApplicable, extname } from "./extensions.js";
+import { evaluate, ops } from "./internal.js";
+
+/**
+ * Given an array of entries with string keys and Origami code values (arrays of
+ * ops and operands), return an object with the same keys defining properties
+ * whose getters evaluate the code.
+ *
+ * The value can take three forms:
+ *
+ * 1. A primitive value (string, etc.). This will be defined directly as an
+ *    object property.
+ * 1. An immediate code entry. This will be evaluated during this call and its
+ *    result defined as an object property.
+ * 1. A code entry that starts with ops.getter. This will be defined as a
+ *    property getter on the object.
+ *
+ * @param {*} entries
+ * @param {import("@weborigami/types").AsyncTree | null} parent
+ */
+export default async function expressionObject(entries, parent) {
+  // Create the object and set its parent
+  const object = {};
+  Object.defineProperty(object, symbols.parent, {
+    value: parent,
+    writable: true,
+    configurable: true,
+    enumerable: false,
+  });
+
+  let tree;
+  const immediateProperties = [];
+  for (let [key, value] of entries) {
+    // Determine if we need to define a getter or a regular property. If the key
+    // 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) {
+      defineProperty = false;
+    } else if (!(value instanceof Array)) {
+      defineProperty = true;
+    } else if (value[0] === ops.getter && !(value[1] instanceof Array)) {
+      defineProperty = true;
+      value = value[1];
+    } else {
+      defineProperty = false;
+    }
+
+    if (defineProperty) {
+      // Define simple property
+      object[key] = value;
+    } else {
+      // Property getter
+      let code;
+      if (value[0] === ops.getter) {
+        code = value[1];
+      } else {
+        immediateProperties.push(key);
+        code = value;
+      }
+
+      let get;
+      if (extension) {
+        // Key has extension, getter will invoke code then attach unpack method
+        get = async () => {
+          tree ??= new ObjectTree(object);
+          const result = await evaluate.call(tree, code);
+          return attachHandlerIfApplicable(tree, result, key);
+        };
+      } else {
+        // No extension, so getter just invokes code.
+        get = async () => {
+          tree ??= new ObjectTree(object);
+          return evaluate.call(tree, code);
+        };
+      }
+
+      Object.defineProperty(object, key, {
+        configurable: true,
+        enumerable: true,
+        get,
+      });
+    }
+  }
+
+  // Evaluate any properties that were declared as immediate: get their value
+  // and overwrite the property getter with the actual value.
+  for (const key of immediateProperties) {
+    const value = await object[key];
+    Object.defineProperty(object, key, {
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true,
+    });
+  }
+
+  return object;
+}

package/src/runtime/extensions.js

@@ -0,0 +1,94 @@
+import {
+  box,
+  isPacked,
+  isStringLike,
+  isUnpackable,
+  scope,
+  symbols,
+  toString,
+} from "@weborigami/async-tree";
+
+/**
+ * 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
+ * found, attach it to the value.
+ *
+ * @param {import("@weborigami/types").AsyncTree} parent
+ * @param {any} value
+ * @param {any} key
+ */
+export async function attachHandlerIfApplicable(parent, value, key) {
+  if (isPacked(value) && isStringLike(key)) {
+    key = toString(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 the value is a primitive, box it so we can attach data to it.
+        value = box(value);
+
+        if (handler.mediaType) {
+          value.mediaType = handler.mediaType;
+        }
+        value[symbols.parent] = parent;
+
+        const unpack = handler.unpack;
+        if (unpack) {
+          // Wrap the unpack function so its only called once per value.
+          let loaded;
+          value.unpack = async () => {
+            loaded ??= await unpack(value, { key, parent });
+            return loaded;
+          };
+        }
+      }
+    }
+  }
+  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/internal.js

@@ -12,7 +12,3 @@ export * as ops from "./ops.js";
 export { default as evaluate } from "./evaluate.js";
 
 export * as expressionFunction from "./expressionFunction.js";
-
-export { default as ExpressionTree } from "./ExpressionTree.js";
-
-export { default as OrigamiTree } from "./OrigamiTree.js";

package/src/runtime/ops.js

@@ -11,11 +11,12 @@ import {
   scope as scopeFn,
   concat as treeConcat,
 } from "@weborigami/async-tree";
+import expressionObject from "./expressionObject.js";
+import { attachHandlerIfApplicable } from "./extensions.js";
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
-import OrigamiFiles from "./OrigamiFiles.js";
-import handleExtension from "./handleExtension.js";
-import { OrigamiTree, evaluate, expressionFunction } from "./internal.js";
+import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
+import OrigamiFiles from "./OrigamiFiles.js";
 
 // For memoizing lambda functions
 const lambdaFnMap = new Map();
@@ -104,12 +105,18 @@ async function fetchResponse(href) {
   const url = new URL(href);
   const filename = url.pathname.split("/").pop();
   if (this && filename) {
-    buffer = await handleExtension(this, filename, buffer);
+    buffer = await attachHandlerIfApplicable(this, buffer, filename);
   }
 
   return buffer;
 }
 
+/**
+ * This op is only used during parsing. It signals to ops.object that the
+ * "arguments" of the expression should be used to define a property getter.
+ */
+export const getter = new String("«ops.getter»");
+
 /**
  * Construct a files tree for the filesystem root.
  *
@@ -246,13 +253,7 @@ merge.toString = () => "«ops.merge»";
  * @param {any[]} entries
  */
 export async function object(...entries) {
-  const tree = this;
-  const promises = entries.map(async ([key, value]) => [
-    key,
-    await evaluate.call(tree, value),
-  ]);
-  const evaluated = await Promise.all(promises);
-  return Object.fromEntries(evaluated);
+  return expressionObject(entries, this);
 }
 object.toString = () => "«ops.object»";
 
@@ -286,29 +287,6 @@ spread.toString = () => "«ops.spread»";
  */
 export const traverse = Tree.traverseOrThrow;
 
-/**
- * Construct an tree. This is similar to ops.object but the values are turned
- * into functions rather than being immediately evaluated, and the result is an
- * OrigamiTree.
- *
- * @this {AsyncTree|null}
- * @param {any[]} entries
- */
-export async function tree(...entries) {
-  const fns = entries.map(([key, code]) => {
-    const value =
-      code instanceof Array
-        ? expressionFunction.createExpressionFunction(code)
-        : code;
-    return [key, value];
-  });
-  const object = Object.fromEntries(fns);
-  const result = new OrigamiTree(object);
-  result.parent = this;
-  return result;
-}
-tree.toString = () => "«ops.tree»";
-
 /**
  * A website tree via HTTP.
  *

package/test/compiler/compile.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
@@ -24,7 +24,7 @@ describe("compile", () => {
   test("tree", async () => {
     const fn = compile.expression("{ message = greet(name) }");
     const tree = await fn.call(null);
-    tree.parent = shared;
+    tree[symbols.parent] = shared;
     assert.deepEqual(await Tree.plain(tree), {
       message: "Hello, Alice!",
     });

package/test/compiler/parse.test.js

@@ -24,22 +24,6 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("treeAssignment", () => {
-    assertParse("treeAssignment", "data = obj.json", [
-      "data",
-      [ops.scope, "obj.json"],
-    ]);
-    assertParse("treeAssignment", "foo = fn 'bar'", [
-      "foo",
-      [[ops.scope, "fn"], "bar"],
-    ]);
-  });
-
-  test("treeEntry", () => {
-    assertParse("treeEntry", "foo", ["foo", [ops.inherited, "foo"]]);
-    assertParse("treeEntry", "foo = 1", ["foo", 1]);
-  });
-
   test("expr", () => {
     assertParse("expr", "obj.json", [ops.scope, "obj.json"]);
     assertParse("expr", "(fn a, b, c)", [
@@ -93,20 +77,26 @@ describe("Origami parser", () => {
         }
       `,
       [
-        ops.tree,
+        ops.object,
         [
           "index.html",
           [
-            [ops.scope, "index.ori"],
-            [ops.scope, "teamData.yaml"],
+            ops.getter,
+            [
+              [ops.scope, "index.ori"],
+              [ops.scope, "teamData.yaml"],
+            ],
           ],
         ],
         [
           "thumbnails",
           [
-            [ops.scope, "@map"],
-            [ops.scope, "images"],
-            [ops.object, ["value", [ops.scope, "thumbnail.js"]]],
+            ops.getter,
+            [
+              [ops.scope, "@map"],
+              [ops.scope, "images"],
+              [ops.object, ["value", [ops.scope, "thumbnail.js"]]],
+            ],
           ],
         ],
       ]
@@ -297,13 +287,22 @@ describe("Origami parser", () => {
     assertParse("object", "{ a: 1, b }", [
       ops.object,
       ["a", 1],
-      ["b", [ops.scope, "b"]],
+      ["b", [ops.inherited, "b"]],
     ]);
     assertParse("object", `{ "a": 1, "b": 2 }`, [
       ops.object,
       ["a", 1],
       ["b", 2],
     ]);
+    assertParse("object", "{ a = b, b: 2 }", [
+      ops.object,
+      ["a", [ops.getter, [ops.scope, "b"]]],
+      ["b", 2],
+    ]);
+    assertParse("object", "{ x = fn('a') }", [
+      ops.object,
+      ["x", [ops.getter, [[ops.scope, "fn"], "a"]]],
+    ]);
     assertParse("object", "{ a: 1, ...b }", [
       ops.merge,
       [ops.object, ["a", 1]],
@@ -311,6 +310,22 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("objectEntry", () => {
+    assertParse("objectEntry", "foo", ["foo", [ops.inherited, "foo"]]);
+    assertParse("objectEntry", "x: y", ["x", [ops.scope, "y"]]);
+  });
+
+  test("objectGetter", () => {
+    assertParse("objectGetter", "data = obj.json", [
+      "data",
+      [ops.getter, [ops.scope, "obj.json"]],
+    ]);
+    assertParse("objectGetter", "foo = fn 'bar'", [
+      "foo",
+      [ops.getter, [[ops.scope, "fn"], "bar"]],
+    ]);
+  });
+
   test("objectProperty", () => {
     assertParse("objectProperty", "a: 1", ["a", 1]);
     assertParse("objectProperty", "name: 'Alice'", ["name", "Alice"]);
@@ -320,11 +335,6 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("objectEntry", () => {
-    assertParse("objectEntry", "foo", ["foo", [ops.scope, "foo"]]);
-    assertParse("objectEntry", "x: y", ["x", [ops.scope, "y"]]);
-  });
-
   test("parameterizedLambda", () => {
     assertParse("parameterizedLambda", "() => foo", [
       ops.lambda,
@@ -496,24 +506,6 @@ describe("Origami parser", () => {
     assertParse("templateSubstitution", "${foo}", [ops.scope, "foo"]);
   });
 
-  test("tree", () => {
-    assertParse("tree", "{}", [ops.tree]);
-    assertParse("tree", "{ a = 1, b }", [
-      ops.tree,
-      ["a", 1],
-      ["b", [ops.inherited, "b"]],
-    ]);
-    assertParse("tree", "{ x = fn('a') }", [
-      ops.tree,
-      ["x", [[ops.scope, "fn"], "a"]],
-    ]);
-    assertParse("tree", "{ a = 1, ...b }", [
-      ops.merge,
-      [ops.tree, ["a", 1]],
-      [ops.scope, "b"],
-    ]);
-  });
-
   test("whitespace block", () => {
     assertParse(
       "__",

package/test/runtime/expressionObject.test.js

@@ -0,0 +1,66 @@
+import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+
+import expressionObject from "../../src/runtime/expressionObject.js";
+import { ops } from "../../src/runtime/internal.js";
+
+describe("expressionObject", () => {
+  test("can instantiate an object", async () => {
+    const scope = new ObjectTree({
+      upper: (s) => s.toUpperCase(),
+    });
+
+    const entries = [
+      ["hello", [[ops.scope, "upper"], "hello"]],
+      ["world", [[ops.scope, "upper"], "world"]],
+    ];
+
+    const object = await expressionObject(entries, scope);
+    assert.equal(await object.hello, "HELLO");
+    assert.equal(await object.world, "WORLD");
+    assert.equal(object[symbols.parent], scope);
+  });
+
+  test("can define a property getter", async () => {
+    let count = 0;
+    const increment = () => count++;
+    const entries = [["count", [ops.getter, [increment]]]];
+    const object = await expressionObject(entries, null);
+    assert.equal(await object.count, 0);
+    assert.equal(await object.count, 1);
+  });
+
+  test("treats a getter for a primitive value as a regular property", async () => {
+    const entries = [["name", [ops.getter, "world"]]];
+    const object = await expressionObject(entries, null);
+    assert.equal(object.name, "world");
+  });
+
+  test("can instantiate an Origami tree", async () => {
+    const entries = [
+      ["name", "world"],
+      ["message", [ops.concat, "Hello, ", [ops.scope, "name"], "!"]],
+    ];
+    const parent = new ObjectTree({});
+    const object = await expressionObject(entries, parent);
+    assert.deepEqual(await Tree.plain(object), {
+      name: "world",
+      message: "Hello, world!",
+    });
+    assert.equal(object[symbols.parent], parent);
+  });
+
+  test("returned object values can be unpacked", async () => {
+    const entries = [["data.json", `{ "a": 1 }`]];
+    const parent = new ObjectTree({
+      json_handler: {
+        unpack: JSON.parse,
+      },
+    });
+    const result = await expressionObject(entries, parent);
+    const dataJson = await result["data.json"];
+    const json = await dataJson.unpack();
+    assert.deepEqual(json, { a: 1 });
+  });
+});

package/test/runtime/extensions.test.js

@@ -0,0 +1,36 @@
+import { ObjectTree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { attachHandlerIfApplicable } from "../../src/runtime/extensions.js";
+
+describe("extensions", () => {
+  test("attaches an unpack method to a value with an extension", async () => {
+    const fixture = createFixture();
+    const numberValue = await fixture.get("foo");
+    assert(typeof numberValue === "number");
+    assert.equal(numberValue, 1);
+    const jsonFile = await fixture.get("bar.json");
+    const withHandler = await attachHandlerIfApplicable(
+      fixture,
+      jsonFile,
+      "bar.json"
+    );
+    assert.equal(String(withHandler), `{ "bar": 2 }`);
+    const data = await withHandler.unpack();
+    assert.deepEqual(data, { bar: 2 });
+  });
+});
+
+function createFixture() {
+  const parent = new ObjectTree({
+    json_handler: {
+      unpack: (buffer) => JSON.parse(String(buffer)),
+    },
+  });
+  let tree = new ObjectTree({
+    foo: 1, // No extension, should be left alone
+    "bar.json": `{ "bar": 2 }`,
+  });
+  tree.parent = parent;
+  return tree;
+}

package/test/runtime/ops.test.js

@@ -1,13 +1,8 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
-import {
-  OrigamiTree,
-  evaluate,
-  expressionFunction,
-  ops,
-} from "../../src/runtime/internal.js";
+import { evaluate, ops } from "../../src/runtime/internal.js";
 
 describe("ops", () => {
   test("can resolve substitutions in a template literal", async () => {
@@ -85,30 +80,6 @@ describe("ops", () => {
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
   });
 
-  test("can instantiate an Origami tree", async () => {
-    const code = [
-      ops.tree,
-      ["name", "world"],
-      [
-        "message",
-        expressionFunction.createExpressionFunction([
-          ops.concat,
-          "Hello, ",
-          [ops.scope, "name"],
-          "!",
-        ]),
-      ],
-    ];
-    const parent = new ObjectTree({});
-    const result = await evaluate.call(parent, code);
-    assert(result instanceof OrigamiTree);
-    assert.deepEqual(await Tree.plain(result), {
-      name: "world",
-      message: "Hello, world!",
-    });
-    assert.equal(result.parent, parent);
-  });
-
   test("can search inherited scope", async () => {
     const parent = new ObjectTree({
       a: 1, // This is the inherited value we want

package/src/runtime/ExpressionTree.js

@@ -1,6 +0,0 @@
-import { DeepObjectTree } from "@weborigami/async-tree";
-import InvokeFunctionsTransform from "./InvokeFunctionsTransform.js";
-
-export default class ExpressionTree extends InvokeFunctionsTransform(
-  DeepObjectTree
-) {}

package/src/runtime/OrigamiTransform.d.ts

@@ -1,5 +0,0 @@
-import { Mixin } from "../../index.ts";
-
-declare const OrigamiTransform: Mixin<{}>;
-
-export default OrigamiTransform;

package/src/runtime/OrigamiTransform.js

@@ -1,3 +0,0 @@
-// Right now this just applies HandleExtensionsTransform.
-import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
-export default HandleExtensionsTransform;