@weborigami/async-tree 0.0.35

package/test/operations/mergeDeep.test.js

@@ -0,0 +1,38 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as Tree from "../../src/Tree.js";
+import mergeDeep from "../../src/operations/mergeDeep.js";
+
+describe("mergeDeep", () => {
+  test("can merge deep", async () => {
+    const fixture = mergeDeep(
+      Tree.from({
+        a: {
+          b: 1,
+          c: {
+            d: 2,
+          },
+        },
+      }),
+      Tree.from({
+        a: {
+          b: 0, // Will be obscured by `b` above
+          c: {
+            e: 3,
+          },
+          f: 4,
+        },
+      })
+    );
+    assert.deepEqual(await Tree.plain(fixture), {
+      a: {
+        b: 1,
+        c: {
+          d: 2,
+          e: 3,
+        },
+        f: 4,
+      },
+    });
+  });
+});

package/test/transforms/cachedKeyMaps.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/ObjectTree.js";
+import cachedKeyMaps from "../../src/transforms/cachedKeyMaps.js";
+
+describe("cachedKeyMaps", () => {
+  test("maps keys with caching", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+
+    let callCount = 0;
+    const underscoreKeys = async (sourceKey, tree) => {
+      callCount++;
+      return `_${sourceKey}`;
+    };
+
+    const { inverseKeyMap, keyMap } = cachedKeyMaps(underscoreKeys);
+
+    assert.equal(await inverseKeyMap("_a", tree), "a"); // Cache miss
+    assert.equal(callCount, 1);
+    assert.equal(await inverseKeyMap("_a", tree), "a");
+    assert.equal(callCount, 1);
+    assert.equal(await inverseKeyMap("_b", tree), "b"); // Cache miss
+    assert.equal(callCount, 2);
+
+    assert.equal(await keyMap("a", tree), "_a");
+    assert.equal(await keyMap("a", tree), "_a");
+    assert.equal(await keyMap("b", tree), "_b");
+    assert.equal(callCount, 2);
+
+    // `c` isn't in tree, so we should get undefined.
+    assert.equal(await inverseKeyMap("_c", tree), undefined);
+    // But key mapping is still possible.
+    assert.equal(await keyMap("c", tree), "_c");
+    // And now we have a cache hit.
+    assert.equal(await inverseKeyMap("_c", tree), "c");
+    assert.equal(callCount, 3);
+  });
+});

package/test/transforms/groupBy.test.js

@@ -0,0 +1,29 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as Tree from "../../src/Tree.js";
+import groupBy from "../../src/transforms/groupBy.js";
+
+describe("groupBy transform", () => {
+  test("groups using a group key function", async () => {
+    const fonts = [
+      { name: "Aboreto", tags: ["Sans Serif"] },
+      { name: "Albert Sans", tags: ["Geometric", "Sans Serif"] },
+      { name: "Alegreya", tags: ["Serif"] },
+      { name: "Work Sans", tags: ["Grotesque", "Sans Serif"] },
+    ];
+    const tree = Tree.from(fonts);
+    const grouped = await groupBy((value, key, tree) => value.get("tags"))(
+      tree
+    );
+    assert.deepEqual(await Tree.plain(grouped), {
+      Geometric: [{ name: "Albert Sans", tags: ["Geometric", "Sans Serif"] }],
+      Grotesque: [{ name: "Work Sans", tags: ["Grotesque", "Sans Serif"] }],
+      "Sans Serif": [
+        { name: "Aboreto", tags: ["Sans Serif"] },
+        { name: "Albert Sans", tags: ["Geometric", "Sans Serif"] },
+        { name: "Work Sans", tags: ["Grotesque", "Sans Serif"] },
+      ],
+      Serif: [{ name: "Alegreya", tags: ["Serif"] }],
+    });
+  });
+});

package/test/transforms/keyMapsForExtensions.test.js

@@ -0,0 +1,70 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/ObjectTree.js";
+import * as Tree from "../../src/Tree.js";
+import keyMapsForExtensions from "../../src/transforms/keyMapsForExtensions.js";
+import map from "../../src/transforms/map.js";
+
+describe("keyMapsForExtensions", () => {
+  test("returns key functions that pass a matching key through", async () => {
+    const { inverseKeyMap, keyMap } = keyMapsForExtensions({
+      sourceExtension: "txt",
+    });
+    assert.equal(await inverseKeyMap("file.txt"), "file.txt");
+    assert.equal(await keyMap("file.txt"), "file.txt");
+    assert.equal(await inverseKeyMap("file.foo"), undefined);
+    assert.equal(await keyMap("file.foo"), undefined);
+  });
+
+  test("returns key functions that can map extensions", async () => {
+    const { inverseKeyMap, keyMap } = keyMapsForExtensions({
+      resultExtension: "html",
+      sourceExtension: "md",
+    });
+    assert.equal(await inverseKeyMap("file.html"), "file.md");
+    assert.equal(await keyMap("file.md"), "file.html");
+    assert.equal(await inverseKeyMap("file.foo"), undefined);
+    assert.equal(await keyMap("file.foo"), undefined);
+  });
+
+  test("works with map to handle keys that end in a given resultExtension", async () => {
+    const files = new ObjectTree({
+      "file1.txt": "will be mapped",
+      file2: "won't be mapped",
+      "file3.foo": "won't be mapped",
+    });
+    const { inverseKeyMap, keyMap } = keyMapsForExtensions({
+      sourceExtension: "txt",
+    });
+    const transform = map({
+      inverseKeyMap,
+      keyMap,
+      valueMap: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+    });
+    const fixture = transform(files);
+    assert.deepEqual(await Tree.plain(fixture), {
+      "file1.txt": "WILL BE MAPPED",
+    });
+  });
+
+  test("works with map to change a key's resultExtension", async () => {
+    const files = new ObjectTree({
+      "file1.txt": "will be mapped",
+      file2: "won't be mapped",
+      "file3.foo": "won't be mapped",
+    });
+    const { inverseKeyMap, keyMap } = keyMapsForExtensions({
+      resultExtension: "upper",
+      sourceExtension: "txt",
+    });
+    const transform = map({
+      inverseKeyMap,
+      keyMap,
+      valueMap: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+    });
+    const fixture = transform(files);
+    assert.deepEqual(await Tree.plain(fixture), {
+      "file1.upper": "WILL BE MAPPED",
+    });
+  });
+});

package/test/transforms/map.test.js

@@ -0,0 +1,174 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/ObjectTree.js";
+import * as Tree from "../../src/Tree.js";
+import map from "../../src/transforms/map.js";
+
+describe("map", () => {
+  test("returns identity graph if no keyMap or valueMap", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+    const mapped = map({})(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      a: "letter a",
+      b: "letter b",
+    });
+  });
+
+  test("maps values", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+      c: undefined, // Won't be mapped
+    });
+    const uppercaseValues = map({
+      valueMap: (sourceValue, sourceKey, innerTree) => {
+        assert(sourceKey === "a" || sourceKey === "b");
+        assert.equal(innerTree, tree);
+        return sourceValue.toUpperCase();
+      },
+    });
+    const mapped = uppercaseValues(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      a: "LETTER A",
+      b: "LETTER B",
+      c: undefined,
+    });
+  });
+
+  test("interprets a single function argument as the value function", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+    const uppercaseValues = map((sourceValue, sourceKey, innerTree) => {
+      assert(sourceKey === "a" || sourceKey === "b");
+      assert.equal(innerTree, tree);
+      return sourceValue.toUpperCase();
+    });
+    const mapped = uppercaseValues(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      a: "LETTER A",
+      b: "LETTER B",
+    });
+  });
+
+  test("maps keys using keyMap and inverseKeyMap", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+    const doubleKeys = map({
+      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+    });
+    const mapped = doubleKeys(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      _a: "letter a",
+      _b: "letter b",
+    });
+  });
+
+  test("maps keys and values", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      b: "letter b",
+    });
+    const doubleKeysUppercaseValues = map({
+      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+      valueMap: async (sourceValue, sourceKey, tree) =>
+        sourceValue.toUpperCase(),
+    });
+    const mapped = doubleKeysUppercaseValues(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      _a: "LETTER A",
+      _b: "LETTER B",
+    });
+  });
+
+  test("a shallow map is applied to async subtrees too", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      more: {
+        b: "letter b",
+      },
+    });
+    const doubleKeys = map({
+      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+      valueMap: async (sourceValue, sourceKey, tree) => sourceKey,
+    });
+    const mapped = doubleKeys(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      _a: "a",
+      _more: "more",
+    });
+  });
+
+  test("deep maps values", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      more: {
+        b: "letter b",
+      },
+    });
+    const uppercaseValues = map({
+      deep: true,
+      valueMap: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+    });
+    const mapped = uppercaseValues(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      a: "LETTER A",
+      more: {
+        b: "LETTER B",
+      },
+    });
+  });
+
+  test("deep maps leaf keys", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      more: {
+        b: "letter b",
+      },
+    });
+    const doubleKeys = map({
+      deep: true,
+      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+    });
+    const mapped = doubleKeys(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      _a: "letter a",
+      more: {
+        _b: "letter b",
+      },
+    });
+  });
+
+  test("deep maps leaf keys and values", async () => {
+    const tree = new ObjectTree({
+      a: "letter a",
+      more: {
+        b: "letter b",
+      },
+    });
+    const doubleKeysUppercaseValues = map({
+      deep: true,
+      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+      valueMap: async (sourceValue, sourceKey, tree) =>
+        sourceValue.toUpperCase(),
+    });
+    const mapped = doubleKeysUppercaseValues(tree);
+    assert.deepEqual(await Tree.plain(mapped), {
+      _a: "LETTER A",
+      more: {
+        _b: "LETTER B",
+      },
+    });
+  });
+});

package/test/transforms/regExpKeys.test.js

@@ -0,0 +1,25 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as Tree from "../../src/Tree.js";
+import regExpKeys from "../../src/transforms/regExpKeys.js";
+
+describe("regExpKeys", () => {
+  test("matches keys using regular expressions", async () => {
+    const fixture = await regExpKeys(
+      Tree.from({
+        a: true,
+        "b.*": true,
+        c: {
+          d: true,
+          "e*": true,
+        },
+      })
+    );
+    assert(await Tree.traverse(fixture, "a"));
+    assert(!(await Tree.traverse(fixture, "alice")));
+    assert(await Tree.traverse(fixture, "bob"));
+    assert(await Tree.traverse(fixture, "brenda"));
+    assert(await Tree.traverse(fixture, "c", "d"));
+    assert(await Tree.traverse(fixture, "c", "eee"));
+  });
+});

package/test/transforms/sort.test.js

@@ -0,0 +1,30 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as Tree from "../../src/Tree.js";
+import sort from "../../src/transforms/sort.js";
+
+describe("sort transform", () => {
+  test("sorts keys", async () => {
+    const tree = Tree.from({
+      b: 2,
+      c: 3,
+      a: 1,
+    });
+    const sortTransform = sort();
+    const sorted = await sortTransform(tree);
+    assert.deepEqual(Array.from(await sorted.keys()), ["a", "b", "c"]);
+  });
+
+  test("sorts keys using a comparison function", async () => {
+    const tree = Tree.from({
+      b: 2,
+      c: 3,
+      a: 1,
+    });
+    // Reverse order
+    const compareFn = (a, b) => (a > b ? -1 : a < b ? 1 : 0);
+    const sortTransform = sort(compareFn);
+    const sorted = await sortTransform(tree);
+    assert.deepEqual(Array.from(await sorted.keys()), ["c", "b", "a"]);
+  });
+});

package/test/transforms/sortBy.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as Tree from "../../src/Tree.js";
+import sortBy from "../../src/transforms/sortBy.js";
+
+describe("sortBy transform", () => {
+  test("sorts keys using a provided sort key function", async () => {
+    const tree = Tree.from({
+      Alice: { age: 48 },
+      Bob: { age: 36 },
+      Carol: { age: 42 },
+    });
+    const sorted = await sortBy((key, tree) => Tree.traverse(tree, key, "age"))(
+      tree
+    );
+    assert.deepEqual(Array.from(await sorted.keys()), [
+      "Bob",
+      "Carol",
+      "Alice",
+    ]);
+  });
+});

package/test/transforms/sortNatural.test.js

@@ -0,0 +1,21 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as Tree from "../../src/Tree.js";
+import sortNatural from "../../src/transforms/sortNatural.js";
+
+describe("sortNatural transform", () => {
+  test("sorts keys", async () => {
+    const tree = Tree.from({
+      file10: null,
+      file1: null,
+      file9: null,
+    });
+    const sortTransform = sortNatural();
+    const sorted = await sortTransform(tree);
+    assert.deepEqual(Array.from(await sorted.keys()), [
+      "file1",
+      "file9",
+      "file10",
+    ]);
+  });
+});

package/test/utilities.test.js

@@ -0,0 +1,24 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import * as utilities from "../src/utilities.js";
+
+describe("utilities", () => {
+  test("getRealmObjectPrototype returns the object's root prototype", () => {
+    const object = {};
+    const proto = utilities.getRealmObjectPrototype(object);
+    assert.equal(proto, Object.prototype);
+  });
+
+  test("isPlainObject returns true if the object is a plain object", () => {
+    assert.equal(utilities.isPlainObject({}), true);
+    assert.equal(utilities.isPlainObject(new Object()), true);
+    assert.equal(utilities.isPlainObject(Object.create(null)), true);
+    class Foo {}
+    assert.equal(utilities.isPlainObject(new Foo()), false);
+  });
+
+  test("keysFromPath() returns the keys from a slash-separated path", () => {
+    assert.deepEqual(utilities.keysFromPath("a/b/c"), ["a", "b", "c"]);
+    assert.deepEqual(utilities.keysFromPath("foo/"), ["foo", ""]);
+  });
+});