@weborigami/async-tree 0.0.45 → 0.0.47

package/test/transforms/map.test.js

@@ -1,18 +1,16 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../../src/DeepObjectTree.js";
 import FunctionTree from "../../src/FunctionTree.js";
-import ObjectTree from "../../src/ObjectTree.js";
-import * as Tree from "../../src/Tree.js";
+import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import map from "../../src/transforms/map.js";
 
 describe("map", () => {
-  test("returns identity graph if no keyMap or valueMap", async () => {
-    const tree = new ObjectTree({
+  test("returns identity graph if no key or value", async () => {
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
-    const mapped = map({})(tree);
+    };
+    const mapped = map()(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       a: "letter a",
       b: "letter b",
@@ -26,7 +24,7 @@ describe("map", () => {
       c: undefined, // Won't be mapped
     });
     const uppercaseValues = map({
-      valueMap: (sourceValue, sourceKey, innerTree) => {
+      value: (sourceValue, sourceKey, innerTree) => {
         assert(sourceKey === "a" || sourceKey === "b");
         assert.equal(innerTree, tree);
         return sourceValue.toUpperCase();
@@ -41,13 +39,12 @@ describe("map", () => {
   });
 
   test("interprets a single function argument as the value function", async () => {
-    const tree = new ObjectTree({
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
-    const uppercaseValues = map((sourceValue, sourceKey, innerTree) => {
+    };
+    const uppercaseValues = map((sourceValue, sourceKey, tree) => {
       assert(sourceKey === "a" || sourceKey === "b");
-      assert.equal(innerTree, tree);
       return sourceValue.toUpperCase();
     });
     const mapped = uppercaseValues(tree);
@@ -57,14 +54,14 @@ describe("map", () => {
     });
   });
 
-  test("maps keys using keyMap and inverseKeyMap", async () => {
-    const tree = new ObjectTree({
+  test("maps keys using key and inverseKey", async () => {
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
+    };
     const doubleKeys = map({
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
     });
     const mapped = doubleKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -74,15 +71,14 @@ describe("map", () => {
   });
 
   test("maps keys and values", async () => {
-    const tree = new ObjectTree({
+    const tree = {
       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(),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const mapped = doubleKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -92,16 +88,16 @@ describe("map", () => {
   });
 
   test("a shallow map is applied to async subtrees too", async () => {
-    const tree = new ObjectTree({
+    const tree = {
       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,
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      value: async (sourceValue, sourceKey, tree) => sourceKey,
     });
     const mapped = doubleKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -110,14 +106,14 @@ describe("map", () => {
     });
   });
 
-  test("valueMap can provide a default keyMap and inverseKeyMap", async () => {
+  test("value can provide a default key and inverse key functions", async () => {
     const uppercase = (s) => s.toUpperCase();
-    uppercase.keyMap = (sourceKey) => `_${sourceKey}`;
-    uppercase.inverseKeyMap = (resultKey) => resultKey.slice(1);
-    const tree = new ObjectTree({
+    uppercase.key = (sourceKey) => `_${sourceKey}`;
+    uppercase.inverseKey = (resultKey) => resultKey.slice(1);
+    const tree = {
       a: "letter a",
       b: "letter b",
-    });
+    };
     const mapped = map(uppercase)(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       _a: "LETTER A",
@@ -134,7 +130,7 @@ describe("map", () => {
     });
     const uppercaseValues = map({
       deep: true,
-      valueMap: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
+      value: (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const mapped = uppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -154,8 +150,8 @@ describe("map", () => {
     });
     const doubleKeys = map({
       deep: true,
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
     });
     const mapped = doubleKeys(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -175,10 +171,9 @@ describe("map", () => {
     });
     const doubleKeysUppercaseValues = map({
       deep: true,
-      keyMap: async (sourceKey, tree) => `_${sourceKey}`,
-      inverseKeyMap: async (resultKey, tree) => resultKey.slice(1),
-      valueMap: async (sourceValue, sourceKey, tree) =>
-        sourceValue.toUpperCase(),
+      key: async (sourceKey, tree) => `_${sourceKey}`,
+      inverseKey: async (resultKey, tree) => resultKey.slice(1),
+      value: async (sourceValue, sourceKey, tree) => sourceValue.toUpperCase(),
     });
     const mapped = doubleKeysUppercaseValues(tree);
     assert.deepEqual(await Tree.plain(mapped), {
@@ -196,7 +191,7 @@ describe("map", () => {
     }, ["a", "b", "c"]);
     const mapped = map({
       needsSourceValue: false,
-      valueMap: () => "X",
+      value: () => "X",
     })(tree);
     assert.deepEqual(await Tree.plain(mapped), {
       a: "X",

package/test/transforms/regExpKeys.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectTree from "../../src/DeepObjectTree.js";
-import * as Tree from "../../src/Tree.js";
+import { DeepObjectTree, Tree } from "../../src/internal.js";
 import regExpKeys from "../../src/transforms/regExpKeys.js";
 
 describe("regExpKeys", () => {

package/test/transforms/sort.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import sort from "../../src/transforms/sort.js";
 
 describe("sort transform", () => {

package/test/transforms/sortBy.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import sortBy from "../../src/transforms/sortBy.js";
 
 describe("sortBy transform", () => {

package/test/transforms/sortNatural.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import * as Tree from "../../src/Tree.js";
+import { Tree } from "../../src/internal.js";
 import sortNatural from "../../src/transforms/sortNatural.js";
 
 describe("sortNatural transform", () => {