@weborigami/async-tree 0.6.13 → 0.6.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.6.13",
+  "version": "0.6.14",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",

package/src/Tree.js

@@ -10,7 +10,9 @@ export { default as child } from "./operations/child.js";
 export { default as clear } from "./operations/clear.js";
 export { default as concat } from "./operations/concat.js";
 export { default as constant } from "./operations/constant.js";
+export { default as deepArrays } from "./operations/deepArrays.js";
 export { default as deepEntries } from "./operations/deepEntries.js";
+export { default as deepEntriesIterator } from "./operations/deepEntriesIterator.js";
 export { default as deepMap } from "./operations/deepMap.js";
 export { default as deepMerge } from "./operations/deepMerge.js";
 export { default as deepReverse } from "./operations/deepReverse.js";

package/src/operations/addNextPrevious.js

@@ -51,6 +51,8 @@ export default async function addNextPrevious(maplike) {
       yield* sourceKeys;
     },
 
+    source,
+
     trailingSlashKeys: /** @type {any} */ (source).trailingSlashKeys,
   });
 }

package/src/operations/concat.js

@@ -1,11 +1,15 @@
-import { isUnpackable, SyncMap, Tree } from "@weborigami/async-tree";
-// import assignPropertyDescriptors from "./assignPropertyDescriptors.js";
+import SyncMap from "../drivers/SyncMap.js";
+import * as trailingSlash from "../trailingSlash.js";
+import isUnpackable from "../utilities/isUnpackable.js";
+import entries from "./entries.js";
 
 /**
  * Concatenate the given trees. This is similar to a merge, but numeric keys
  * will be renumbered starting with 0 and incrementing by 1.
  *
- * @typedef {import("@weborigami/async-tree").Maplike} Maplike
+ * If the final result is array-like, returns an array, otherwise returns a map.
+ *
+ * @typedef {import("../../index.ts").Maplike} Maplike
  *
  * @param {(Maplike|null)[]} trees
  */
@@ -30,19 +34,18 @@ export default async function concat(...trees) {
   let onlyNumericKeys = true;
   const map = new SyncMap();
   for (const source of sources) {
-    const entries = await Tree.entries(source);
-    for (const [entryKey, entryValue] of entries) {
-      let key;
-      if (!isNaN(parseInt(entryKey))) {
+    const sourceEntries = await entries(source);
+    for (let [key, value] of sourceEntries) {
+      key = trailingSlash.remove(key);
+      if (typeof key === "number" || /^\d+$/.test(key)) {
         // Numeric key, renumber it.
         key = String(index);
         index++;
       } else {
         // Non-numeric key, keep it as is.
-        key = entryKey;
         onlyNumericKeys = false;
       }
-      map.set(key, entryValue);
+      map.set(key, value);
     }
   }
 

package/src/operations/deepArrays.js

@@ -0,0 +1,23 @@
+import * as args from "../utilities/args.js";
+import entries from "./entries.js";
+import isMap from "./isMap.js";
+
+/**
+ * Return the deep nested entries in the tree as arrays of [key, value] pairs.
+ *
+ * @typedef {import("../../index.ts").Maplike} Maplike
+ *
+ * @param {Maplike} maplike
+ */
+export default async function deepEntries(maplike) {
+  const tree = await args.map(maplike, "Tree.deepEntries");
+
+  const treeEntries = await entries(tree);
+  const result = await Promise.all(
+    treeEntries.map(async ([key, value]) => {
+      const resolvedValue = isMap(value) ? await deepEntries(value) : value;
+      return [key, resolvedValue];
+    }),
+  );
+  return result;
+}

package/src/operations/deepEntries.js

@@ -1,6 +1,5 @@
 import * as args from "../utilities/args.js";
-import entries from "./entries.js";
-import isMap from "./isMap.js";
+import deepEntriesIterator from "./deepEntriesIterator.js";
 
 /**
  * Return the deep nested entries in the tree as arrays of [key, value] pairs.
@@ -12,12 +11,10 @@ import isMap from "./isMap.js";
 export default async function deepEntries(maplike) {
   const tree = await args.map(maplike, "Tree.deepEntries");
 
-  const treeEntries = await entries(tree);
-  const result = await Promise.all(
-    treeEntries.map(async ([key, value]) => {
-      const resolvedValue = isMap(value) ? await deepEntries(value) : value;
-      return [key, resolvedValue];
-    }),
-  );
-  return result;
+  const iterator = deepEntriesIterator(tree, { depth: Infinity });
+  const entries = [];
+  for await (const entry of iterator) {
+    entries.push(entry);
+  }
+  return entries;
 }

package/src/operations/deepEntriesIterator.js

@@ -0,0 +1,45 @@
+import * as args from "../utilities/args.js";
+import isUnpackable from "../utilities/isUnpackable.js";
+import isMap from "./isMap.js";
+import isMaplike from "./isMaplike.js";
+/**
+ * Return an iterator that yields all entries in a tree, including nested trees.
+ *
+ * If the `expand` option is true, maplike values (but not functions) will be
+ * expanded into nested trees and their values will be yielded. Packed values
+ * will be unpacked before expanding.
+ *
+ * If the `depth` option is specified, the iterator will only descend to the
+ * specified depth. A depth of 0 will yield values only at the tree's top level.
+ *
+ * @param {import("../../index.ts").Maplike} maplike
+ * @param {{ depth?: number, expand?: boolean }} [options]
+ * @returns {AsyncGenerator<[any, any], void, undefined>}
+ */
+export default async function* deepEntriesIterator(maplike, options = {}) {
+  const tree = await args.map(maplike, "Tree.deepEntriesIterator", {
+    deep: !options.expand,
+  });
+
+  const depth = options.depth ?? Infinity;
+  const expand = options.expand ?? false;
+
+  for await (let [key, value] of tree.entries()) {
+    value = await value;
+
+    if (expand && isUnpackable(value)) {
+      value = await value.unpack();
+    }
+
+    // Recurse into child trees, but don't expand functions.
+    const recurse =
+      depth > 0 &&
+      (isMap(value) ||
+        (expand && typeof value !== "function" && isMaplike(value)));
+    if (recurse) {
+      yield* deepEntriesIterator(value, { depth: depth - 1, expand });
+    } else {
+      yield [key, value];
+    }
+  }
+}

package/src/operations/deepValuesIterator.js

@@ -11,7 +11,7 @@ import isMaplike from "./isMaplike.js";
  * will be unpacked before expanding.
  *
  * If the `depth` option is specified, the iterator will only descend to the
- * specified depth. A depth of 1 will yield values only at the tree's top level.
+ * specified depth. A depth of 0 will yield values only at the tree's top level.
  *
  * @param {import("../../index.ts").Maplike} maplike
  * @param {{ depth?: number, expand?: boolean }} [options]
@@ -34,7 +34,7 @@ export default async function* deepValuesIterator(maplike, options = {}) {
 
     // Recurse into child trees, but don't expand functions.
     const recurse =
-      depth > 1 &&
+      depth > 0 &&
       (isMap(value) ||
         (expand && typeof value !== "function" && isMaplike(value)));
     if (recurse) {

package/src/operations/flat.js

@@ -1,8 +1,15 @@
+import SyncMap from "../drivers/SyncMap.js";
+import * as trailingSlash from "../trailingSlash.js";
 import * as args from "../utilities/args.js";
-import deepValuesIterator from "./deepValuesIterator.js";
+import deepEntriesIterator from "./deepEntriesIterator.js";
 
 /**
- * Flatten the values in the tree to the given depth.
+ * Flatten the entries in the tree to the given depth. If the depth is omitted,
+ * the tree will be flattened one level.
+ *
+ * Numeric keys will be renumbered.
+ *
+ * If the final result is array-like, returns an array, otherwise returns a map.
  *
  * @typedef {import("../../index.ts").Maplike} Maplike
  *
@@ -11,11 +18,28 @@ import deepValuesIterator from "./deepValuesIterator.js";
  */
 export default async function flat(maplike, depth = 1) {
   const map = await args.map(maplike, "Tree.flat", { deep: true });
-  /** @type {any} */
-  const iterator = deepValuesIterator(map, { depth, expand: true });
-  const result = [];
-  for await (const key of iterator) {
-    result.push(key);
+
+  let index = 0;
+  let onlyNumericKeys = true;
+  const result = new SyncMap();
+  for await (let [key, value] of deepEntriesIterator(map, { depth })) {
+    key = trailingSlash.remove(key);
+    if (typeof key === "number" || /^\d+$/.test(key)) {
+      // Numeric key, renumber it.
+      key = String(index);
+      index++;
+    } else {
+      // Non-numeric key, keep it as is.
+      onlyNumericKeys = false;
+    }
+    result.set(key, value);
+  }
+
+  if (onlyNumericKeys) {
+    // All keys are numeric, return an array.
+    return [...result.values()];
+  } else {
+    // Some keys are non-numeric, return a map.
+    return result;
   }
-  return result;
 }

package/test/operations/assign.test.js

@@ -3,8 +3,8 @@ import { describe, test } from "node:test";
 import ObjectMap from "../../src/drivers/ObjectMap.js";
 import SyncMap from "../../src/drivers/SyncMap.js";
 import assign from "../../src/operations/assign.js";
+import deepArrays from "../../src/operations/deepArrays.js";
 import plain from "../../src/operations/plain.js";
-import { deepEntries } from "../../src/Tree.js";
 import SampleAsyncMap from "../SampleAsyncMap.js";
 
 describe("assign", () => {
@@ -26,7 +26,7 @@ describe("assign", () => {
     const result = await assign(target, source);
 
     assert.equal(result, target);
-    assert.deepEqual(await deepEntries(target), [
+    assert.deepEqual(await deepArrays(target), [
       ["a", 4],
       ["b", 2],
       [

package/test/operations/deepArrays.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import deepArrays from "../../src/operations/deepArrays.js";
+import SampleAsyncMap from "../SampleAsyncMap.js";
+
+describe("deepArrays", () => {
+  test("converts an async tree to an array of nested entries arrays", async () => {
+    const fixture = new SampleAsyncMap([
+      ["a", 1],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["c", 3],
+          ["d", 4],
+        ],
+      ],
+    ]);
+    const result = await deepArrays(fixture);
+    assert.deepStrictEqual(result, [
+      ["a", 1],
+      ["b", 2],
+      [
+        "more",
+        [
+          ["c", 3],
+          ["d", 4],
+        ],
+      ],
+    ]);
+  });
+});

package/test/operations/deepEntries.test.js

@@ -4,7 +4,7 @@ import deepEntries from "../../src/operations/deepEntries.js";
 import SampleAsyncMap from "../SampleAsyncMap.js";
 
 describe("deepEntries", () => {
-  test("converts an async tree to an array of nested entries arrays", async () => {
+  test("returns an entry of the deep tree entries", async () => {
     const fixture = new SampleAsyncMap([
       ["a", 1],
       ["b", 2],
@@ -20,13 +20,8 @@ describe("deepEntries", () => {
     assert.deepStrictEqual(result, [
       ["a", 1],
       ["b", 2],
-      [
-        "more",
-        [
-          ["c", 3],
-          ["d", 4],
-        ],
-      ],
+      ["c", 3],
+      ["d", 4],
     ]);
   });
 });

package/test/operations/deepEntriesIterator.test.js

@@ -0,0 +1,78 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import deepEntriesIterator from "../../src/operations/deepEntriesIterator.js";
+
+describe("deepEntriesIterator", () => {
+  test("returns an iterator of a tree's deep entries", async () => {
+    const tree = new ObjectMap({
+      a: 1,
+      b: 2,
+      more: {
+        c: 3,
+        d: 4,
+      },
+    });
+    const entries = [];
+    // The tree will be shallow, but we'll ask to expand the entries.
+    for await (const entry of deepEntriesIterator(tree, { expand: true })) {
+      entries.push(entry);
+    }
+    assert.deepEqual(entries, [
+      ["a", 1],
+      ["b", 2],
+      ["c", 3],
+      ["d", 4],
+    ]);
+  });
+
+  test("if depth is specified, only descends to specified depth", async () => {
+    const tree = new ObjectMap({
+      a: 1,
+      sub: {
+        b: 2,
+        more: {
+          c: 3,
+          deeper: {
+            d: 4,
+          },
+        },
+      },
+    });
+    const entries = [];
+    for await (const entry of deepEntriesIterator(tree, {
+      depth: 2,
+      expand: true,
+    })) {
+      entries.push(entry);
+    }
+    assert.deepEqual(entries, [
+      ["a", 1],
+      ["b", 2],
+      ["c", 3],
+      ["deeper", { d: 4 }],
+    ]);
+  });
+
+  test("can optionally unpack a packed value", async () => {
+    /** @type {any} */
+    const packed = new String("String that unpacks to data");
+    packed.unpack = async function () {
+      return {
+        message: "Hello",
+      };
+    };
+    const tree = {
+      a: 1,
+      packed,
+    };
+    const entries = [];
+    for await (const entry of deepEntriesIterator(tree, { expand: true })) {
+      entries.push(entry);
+    }
+    assert.deepEqual(entries, [
+      ["a", 1],
+      ["message", "Hello"],
+    ]);
+  });
+});

package/test/operations/deepValuesIterator.test.js

@@ -36,7 +36,7 @@ describe("deepValuesIterator", () => {
     });
     const values = [];
     for await (const value of deepValuesIterator(tree, {
-      depth: 3,
+      depth: 2,
       expand: true,
     })) {
       values.push(value);

package/test/operations/flat.test.js

@@ -5,7 +5,19 @@ import flat from "../../src/operations/flat.js";
 import plain from "../../src/operations/plain.js";
 
 describe("flat", () => {
-  test("flattens the tree's values into an array", async () => {
+  test("flattens an array one level by default", async () => {
+    const result = await flat([1, 2, [3], [[4, [5]]]], 1);
+    assert.deepEqual(await plain(result), [1, 2, 3, [4, [5]]]);
+  });
+
+  test("flattens deep arrays", async () => {
+    assert.deepEqual(
+      await flat([1, 2, [3], [[4, [5]]]], Infinity),
+      [1, 2, 3, 4, 5],
+    );
+  });
+
+  test("flattens an object one level by default", async () => {
     const fixture = {
       a: 1,
       sub: {
@@ -15,10 +27,17 @@ describe("flat", () => {
         },
       },
     };
-    assert.deepEqual(await flat(fixture, Infinity), [1, 2, 3]);
+    const result = await flat(fixture);
+    assert.deepEqual(await plain(result), {
+      a: 1,
+      b: 2,
+      more: {
+        c: 3,
+      },
+    });
   });
 
-  test("flattens one level by default", async () => {
+  test("flattens deep objects", async () => {
     const fixture = {
       a: 1,
       sub: {
@@ -28,14 +47,12 @@ describe("flat", () => {
         },
       },
     };
-    assert.deepEqual(await plain(await flat(fixture)), [
-      1,
-      { b: 2, more: { c: 3 } },
-    ]);
-  });
-
-  test("flattens arrays", async () => {
-    assert.deepEqual(await flat([1, 2, [3]], Infinity), [1, 2, 3]);
+    const result = await flat(fixture, Infinity);
+    assert.deepEqual(await plain(result), {
+      a: 1,
+      b: 2,
+      c: 3,
+    });
   });
 
   test("flattens maplike objects", async () => {
@@ -53,6 +70,13 @@ describe("flat", () => {
       ],
       Infinity,
     );
-    assert.deepEqual(result, [1, 2, 3, 4, 5, 6]);
+    assert.deepEqual(await plain(result), {
+      a: 1,
+      b: 2,
+      c: 3,
+      d: 4,
+      0: 5,
+      1: 6,
+    });
   });
 });