@weborigami/async-tree 0.5.1 → 0.5.2-test.1

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.5.1",
+  "version": "0.5.2-test.1",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "dependencies": {
-    "@weborigami/types": "0.5.1"
+    "@weborigami/types": "0.5.2-test.1"
   },
   "devDependencies": {
     "@types/node": "24.3.0",

package/src/Tree.d.ts

@@ -13,7 +13,7 @@ export function isTraversable(obj: any): boolean;
 export function isTreelike(obj: any): obj is Treelike;
 export function map(tree: Treelike, options: TreeMapOptions|ValueKeyFn): AsyncTree;
 export function mapReduce(tree: Treelike, mapFn: ValueKeyFn | null, reduceFn: ReduceFn): Promise<any>;
-export function paths(tree: Treelike, base?: string): string[];
+export function paths(tree: Treelike, options?: { assumeSlashes?: boolean, 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>;

package/src/Tree.js

@@ -292,17 +292,35 @@ export async function mapReduce(treelike, valueFn, reduceFn) {
  * Returns slash-separated paths for all values in the tree.
  *
  * @param {Treelike} treelike
- * @param {string?} base
+ * @param {{ assumeSlashes?: boolean, base?: string }} options
  */
-export async function paths(treelike, base = "") {
+export async function paths(treelike, options = {}) {
   const tree = from(treelike);
+  const base = options.base ?? "";
+  const assumeSlashes = options.assumeSlashes ?? false;
   const result = [];
   for (const key of await tree.keys()) {
     const separator = trailingSlash.has(base) ? "" : "/";
     const valuePath = base ? `${base}${separator}${key}` : key;
-    const value = await tree.get(key);
-    if (await isAsyncTree(value)) {
-      const subPaths = await paths(value, valuePath);
+    let isSubtree;
+    let value;
+    if (assumeSlashes) {
+      // Subtree needs to have a trailing slash
+      isSubtree = trailingSlash.has(key);
+      if (isSubtree) {
+        // We'll need the value to recurse
+        value = await tree.get(key);
+      }
+    } else {
+      // Get value and check
+      value = await tree.get(key);
+    }
+    if (value) {
+      // If we got the value we can check if it's a subtree
+      isSubtree = isAsyncTree(value);
+    }
+    if (isSubtree) {
+      const subPaths = await paths(value, { assumeSlashes, base: valuePath });
       result.push(...subPaths);
     } else {
       result.push(valuePath);

package/test/Tree.test.js

@@ -232,6 +232,27 @@ describe("Tree", () => {
     assert.deepEqual(await Tree.paths(tree), ["a", "b", "c/d", "c/e"]);
   });
 
+  test("paths can focus just on keys with trailing slashes", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+      b: 2,
+      // This is a shallow ObjectTree, so `c` won't have a trailing slash
+      c: {
+        d: 3,
+      },
+      // Explicitly include a trailing slash to signal a subtree
+      "d/": new ObjectTree({
+        e: 4,
+      }),
+    });
+    assert.deepEqual(await Tree.paths(tree, { assumeSlashes: true }), [
+      "a",
+      "b",
+      "c",
+      "d/e",
+    ]);
+  });
+
   test("plain() produces a plain object version of a tree", async () => {
     const tree = new ObjectTree({
       a: 1,