@weborigami/async-tree 0.6.0 → 0.6.2

package/test/operations/regExpKeys.test.js

@@ -1,21 +1,24 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
 import regExpKeys from "../../src/operations/regExpKeys.js";
 import traverse from "../../src/operations/traverse.js";
 
 describe("regExpKeys", () => {
   test("matches keys using regular expressions", async () => {
     const fixture = await regExpKeys(
-      new DeepObjectMap({
-        "^a$": true,
-        "^b.*": true,
-        c: {
-          d: true,
-          "e*": true,
+      new ObjectMap(
+        {
+          "^a$": true,
+          "^b.*": true,
+          c: {
+            d: true,
+            "e*": true,
+          },
+          f: true,
         },
-        f: true,
-      })
+        { deep: true }
+      )
     );
     assert(await traverse(fixture, "a"));
     assert(!(await traverse(fixture, "alice")));

package/test/operations/root.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectMap from "../../src/drivers/ObjectMap.js";
+import root from "../../src/operations/root.js";
+import traverse from "../../src/operations/traverse.js";
+
+describe("root", () => {
+  test("returns root of a tree", async () => {
+    const tree = new ObjectMap(
+      {
+        a: {
+          b: {
+            c: {},
+          },
+        },
+      },
+      { deep: true }
+    );
+    const c = await traverse(tree, "a", "b", "c");
+    const r = await root(c);
+    assert.strictEqual(r, tree);
+  });
+});

package/test/operations/set.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import set from "../../src/operations/set.js";
+
+describe("set", () => {
+  test("sets a value", async () => {
+    const map = new Map();
+    await set(map, "key", "value");
+    assert.strictEqual(map.get("key"), "value");
+  });
+});

package/test/operations/traverse.test.js

@@ -39,4 +39,17 @@ describe("traverse", () => {
     });
     assert.equal(await traverse(tree, "a", "b", "c"), "Hello");
   });
+
+  test("unpacks last value if key ends in a slash", async () => {
+    const tree = new ObjectMap({
+      a: {
+        b: Object.assign(new String("packed"), {
+          unpack() {
+            return "unpacked";
+          },
+        }),
+      },
+    });
+    assert.equal(await traverse(tree, "a/", "b/"), "unpacked");
+  });
 });

package/test/utilities/castArrayLike.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import castArraylike from "../../src/utilities/castArraylike.js";
+
+describe("castArraylike", () => {
+  test("returns an object if any keys are not integers", () => {
+    const map = new /** @type {any} */ (Map)([
+      [0, "a"],
+      [1, "b"],
+      ["x", "c"],
+    ]);
+    const result = castArraylike(map);
+    assert.deepEqual(result, {
+      0: "a",
+      1: "b",
+      x: "c",
+    });
+  });
+
+  test("returns values as is if keys are numeric and 0..length-1", () => {
+    const map = new /** @type {any} */ (Map)([
+      [0, "a"],
+      [1, "b"],
+      [2, "c"],
+    ]);
+    const result = castArraylike(map);
+    assert.deepEqual(result, ["a", "b", "c"]);
+  });
+
+  test("order of keys doesn't matter as long as they're all present", () => {
+    const map = new /** @type {any} */ (Map)([
+      [1, "a"],
+      [0, "b"],
+      [2, "c"],
+    ]);
+    const result = castArraylike(map);
+    assert.deepEqual(result, ["a", "b", "c"]);
+  });
+
+  test("resorts object if numeric keys are missing", () => {
+    const map = new /** @type {any} */ (Map)([
+      [1, "a"],
+      [0, "b"],
+      [3, "c"],
+    ]);
+    const result = castArraylike(map);
+    assert.deepEqual(result, {
+      1: "a",
+      0: "b",
+      3: "c",
+    });
+  });
+});

package/src/drivers/DeepObjectMap.js

@@ -1,27 +0,0 @@
-import isMap from "../operations/isMap.js";
-import isPlainObject from "../utilities/isPlainObject.js";
-import ObjectMap from "./ObjectMap.js";
-
-export default class DeepObjectMap extends ObjectMap {
-  // Implement delete (and set) to keep the Map read-write
-  delete(key) {
-    return super.delete(key);
-  }
-
-  get(key) {
-    let value = super.get(key);
-    if (value instanceof Array || isPlainObject(value)) {
-      value = Reflect.construct(this.constructor, [value]);
-    }
-    return value;
-  }
-
-  isSubtree(value) {
-    return value instanceof Array || isPlainObject(value) || isMap(value);
-  }
-
-  // See delete()
-  set(key, value) {
-    return super.set(key, value);
-  }
-}

package/test/drivers/DeepObjectMap.test.js

@@ -1,36 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import DeepObjectMap from "../../src/drivers/DeepObjectMap.js";
-import plain from "../../src/operations/plain.js";
-
-describe("DeepObjectMap", () => {
-  test("returns a map for a value that's a plain sub-object or sub-array", async () => {
-    const map = createFixture();
-
-    const object = await map.get("object");
-    assert.equal(object instanceof DeepObjectMap, true);
-    assert.deepEqual(await plain(object), { b: 2 });
-    assert.equal(object.parent, map);
-
-    const array = await map.get("array");
-    assert.equal(array instanceof DeepObjectMap, true);
-    assert.deepEqual(await plain(array), [3]);
-    assert.equal(array.parent, map);
-  });
-
-  test("adds trailing slashes to keys for submaps including plain objects or arrays", async () => {
-    const map = createFixture();
-    const keys = Array.from(await map.keys());
-    assert.deepEqual(keys, ["a", "object/", "array/"]);
-  });
-});
-
-function createFixture() {
-  return new DeepObjectMap({
-    a: 1,
-    object: {
-      b: 2,
-    },
-    array: [3],
-  });
-}