@weborigami/async-tree 0.0.66 → 0.0.67-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.66",
+  "version": "0.0.67-beta.1",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/types": "0.0.66"
+    "@weborigami/types": "0.0.67-beta.1"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/FileTree.js

@@ -190,8 +190,11 @@ export default class FileTree {
       // Special case: empty object means create an empty directory.
       await fs.mkdir(destPath, { recursive: true });
     } else if (Tree.isTreelike(value)) {
-      // Treat value as a tree and write it out as a subdirectory.
+      // Treat value as a subtree and write it out as a subdirectory.
       const destTree = Reflect.construct(this.constructor, [destPath]);
+      // Create the directory here, even if the subtree is empty.
+      await fs.mkdir(destPath, { recursive: true });
+      // Write out the subtree.
       await Tree.assign(destTree, value);
     } else {
       const typeName = value?.constructor?.name ?? "unknown";

package/src/SiteTree.js

@@ -35,14 +35,20 @@ export default class SiteTree {
       );
     }
 
-    // If the keys ends with a slash, return a tree for the indicated route.
-    if (trailingSlash.has(key)) {
+    // A key with a trailing slash and no extension is for a folder; return a
+    // subtree without making a network request.
+    if (trailingSlash.has(key) && !key.includes(".")) {
       const href = new URL(key, this.href).href;
       const value = Reflect.construct(this.constructor, [href]);
       setParent(value, this);
       return value;
     }
 
+    // HACK: For now we don't allow lookup of Origami extension handlers.
+    if (key.endsWith("_handler")) {
+      return undefined;
+    }
+
     const href = new URL(key, this.href).href;
 
     // Fetch the data at the given route.

package/src/operations/cache.js

@@ -60,16 +60,22 @@ export default function treeCache(
       let value = await source.get(key);
       if (value !== undefined) {
         // If a filter is defined, does the key match the filter?
-        const filterValue = await filter?.get(key);
+        const filterValue = filter ? await filter.get(key) : undefined;
         const filterMatch = !filter || filterValue !== undefined;
         if (filterMatch) {
           if (Tree.isAsyncTree(value)) {
             // Construct merged tree for a tree result.
             if (cacheValue === undefined) {
-              // Construct new container in cache
-              cacheValue = new ObjectTree({});
-              cacheValue.parent = this;
-              await cache.set(key, cacheValue);
+              // Construct new empty container in cache
+              await cache.set(key, {});
+              cacheValue = await cache.get(key);
+              if (!Tree.isAsyncTree(cacheValue)) {
+                // Coerce to tree and then save it back to the cache. This is
+                // necessary, e.g., if cache is an ObjectTree; we want the
+                // subtree to also be an ObjectTree, not a plain object.
+                cacheValue = Tree.from(cacheValue);
+                await cache.set(key, cacheValue);
+              }
             }
             value = treeCache(value, cacheValue, filterValue);
           } else {

package/test/FileTree.test.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { describe, test } from "node:test";
 import { fileURLToPath } from "node:url";
 import FileTree from "../src/FileTree.js";
-import { Tree } from "../src/internal.js";
+import { ObjectTree, Tree } from "../src/internal.js";
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const tempDirectory = path.join(dirname, "fixtures/temp");
@@ -81,7 +81,7 @@ describe("FileTree", async () => {
     await removeTempDirectory();
   });
 
-  test("can create empty subfolder via set()", async () => {
+  test("create subfolder via set() with empty object value", async () => {
     await createTempDirectory();
 
     // Write out new, empty folder called "empty".
@@ -98,6 +98,23 @@ describe("FileTree", async () => {
     await removeTempDirectory();
   });
 
+  test("create subfolder via set() with empty tree value", async () => {
+    await createTempDirectory();
+
+    // Write out new, empty folder called "empty".
+    const tempFiles = new FileTree(tempDirectory);
+    await tempFiles.set("empty", new ObjectTree({}));
+
+    // Verify folder exists and has no contents.
+    const folderPath = path.join(tempDirectory, "empty");
+    const stats = await fs.stat(folderPath);
+    assert(stats.isDirectory());
+    const files = await fs.readdir(folderPath);
+    assert.deepEqual(files, []);
+
+    await removeTempDirectory();
+  });
+
   test("can write out subfolder via set()", async () => {
     await createTempDirectory();