@weborigami/async-tree 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "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.1.0"
+    "@weborigami/types": "0.2.0"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/Tree.d.ts

@@ -15,6 +15,7 @@ export function map(tree: Treelike, options: TreeMapOptions|ValueKeyFn): AsyncTr
 export function mapReduce(tree: Treelike, mapFn: ValueKeyFn | null, reduceFn: ReduceFn): Promise<any>;
 export function paths(tree: Treelike, base?: string): string[];
 export function plain(tree: Treelike): Promise<PlainObject>;
+export function root(tree: Treelike): AsyncTree;
 export function remove(AsyncTree: AsyncMutableTree, key: any): Promise<boolean>;
 export function toFunction(tree: Treelike): Function;
 export function traverse(tree: Treelike, ...keys: any[]): Promise<any>;

package/src/Tree.js

@@ -354,6 +354,19 @@ export async function remove(tree, key) {
   }
 }
 
+/**
+ * Walk up the `parent` chain to find the root of the tree.
+ *
+ * @param {AsyncTree} tree
+ */
+export function root(tree) {
+  let current = from(tree);
+  while (current.parent) {
+    current = current.parent;
+  }
+  return current;
+}
+
 /**
  * Returns a function that invokes the tree's `get` method.
  *

package/src/drivers/FileTree.js

@@ -103,8 +103,11 @@ export default class FileTree {
       entries = [];
     }
 
-    let names = entries.map((entry) =>
-      trailingSlash.toggle(entry.name, entry.isDirectory())
+    // Add slashes to directory names.
+    let names = await Promise.all(
+      entries.map(async (entry) =>
+        trailingSlash.toggle(entry.name, await isDirectory(entry, this.dirname))
+      )
     );
 
     // Filter out unhelpful file names.
@@ -211,6 +214,23 @@ export default class FileTree {
   }
 }
 
+/**
+ * Return true if the entry is a directory or is a symbolic link to a directory.
+ */
+async function isDirectory(entry, dirname) {
+  if (entry.isSymbolicLink()) {
+    const entryPath = path.resolve(dirname, entry.name);
+    try {
+      const realPath = await fs.realpath(entryPath);
+      entry = await fs.stat(realPath);
+    } catch (error) {
+      // The slash isn't crucial, so if link doesn't work that's okay
+      return false;
+    }
+  }
+  return entry.isDirectory();
+}
+
 /**
  * Return true if the object is a string or object with a non-trival `toString`
  * method.

package/src/operations/concat.js

@@ -18,9 +18,17 @@ export default async function concatTreeValues(treelike) {
 
   const strings = [];
   for await (const value of deepValuesIterator(treelike, { expand: true })) {
-    if (value) {
-      strings.push(toString(value));
+    let string;
+    if (value === null) {
+      console.warn("Warning: Origami template encountered a null value");
+      string = "null";
+    } else if (value === undefined) {
+      console.warn("Warning: Origami template encountered an undefined value");
+      string = "undefined";
+    } else {
+      string = toString(value);
     }
+    strings.push(string);
   }
   return strings.join("");
 }