@weborigami/async-tree 0.6.14 → 0.6.15

package/package.json

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

package/src/Tree.js

@@ -20,6 +20,7 @@ export { default as deepTake } from "./operations/deepTake.js";
 export { default as deepText } from "./operations/deepText.js";
 export { default as deepValues } from "./operations/deepValues.js";
 export { default as deepValuesIterator } from "./operations/deepValuesIterator.js";
+export { default as deflatePaths } from "./operations/deflatePaths.js";
 export { default as delete } from "./operations/delete.js";
 export { default as entries } from "./operations/entries.js";
 export { default as filter } from "./operations/filter.js";
@@ -32,6 +33,7 @@ export { default as group } from "./operations/group.js";
 export { default as groupBy } from "./operations/groupBy.js";
 export { default as has } from "./operations/has.js";
 export { default as indent } from "./operations/indent.js";
+export { default as inflatePaths } from "./operations/inflatePaths.js";
 export { default as inners } from "./operations/inners.js";
 export { default as invokeFunctions } from "./operations/invokeFunctions.js";
 export { default as isAsyncMutableTree } from "./operations/isAsyncMutableTree.js";

package/src/drivers/SetMap.js

@@ -1,13 +1,16 @@
 import SyncMap from "./SyncMap.js";
 
 /**
- * A map of Set objects.
+ * A standard `Set` represented as a `Map`. The keys are integer indices; the
+ * values are the set's values.
  */
 export default class SetMap extends SyncMap {
   /**
    * @param {Set} set
    */
   constructor(set) {
-    super(set.entries());
+    // Treat the set as an array-like map
+    const entries = Array.from(set).map((value, index) => [index, value]);
+    super(entries);
   }
 }

package/src/operations/deflatePaths.js

@@ -0,0 +1,38 @@
+import SyncMap from "../drivers/SyncMap.js";
+import * as trailingSlash from "../trailingSlash.js";
+import * as args from "../utilities/args.js";
+import isMap from "./isMap.js";
+
+/**
+ * Given a tree, return a flat mapping of string paths to values.
+ *
+ * If a `basePath` is provided, it will be prepended to all paths in the result.
+ *
+ * @typedef {import("../../index.ts").Maplike} Maplike
+ *
+ * @param {Maplike} maplike
+ * @param {string} [basePath]
+ */
+export default async function deflatePaths(maplike, basePath = "") {
+  const tree = await args.map(maplike, "Tree.deflatePaths", { deep: true });
+  const result = new SyncMap();
+  for await (let [key, value] of tree) {
+    const normalizedKey = trailingSlash.remove(key);
+    let path = basePath;
+    if (path && !path.endsWith("/")) {
+      path += "/";
+    }
+    path += normalizedKey;
+    value = await value;
+    if (isMap(value)) {
+      const subResult = await deflatePaths(value, path);
+      for await (let [subPath, subValue] of subResult) {
+        subValue = await subValue;
+        result.set(subPath, subValue);
+      }
+    } else {
+      result.set(path, value);
+    }
+  }
+  return result;
+}

package/src/operations/inflatePaths.js

@@ -0,0 +1,27 @@
+import SyncMap from "../drivers/SyncMap.js";
+import * as args from "../utilities/args.js";
+import keysFromPath from "../utilities/keysFromPath.js";
+
+/**
+ * Given a mapping of string paths to values, return the described tree.
+ */
+export default async function inflatePaths(maplike) {
+  const map = await args.map(maplike, "Tree.inflatePaths", { deep: true });
+
+  const result = new SyncMap();
+  for await (const [path, value] of map) {
+    const keys = keysFromPath(path);
+    setValue(result, keys, value);
+  }
+  return result;
+}
+
+// Add the value to the tree at the given path of keys
+function setValue(map, keys, value) {
+  let node = map;
+  for (const key of keys.slice(0, -1)) {
+    // Create a new node if one doesn't exist yet
+    node = node.getOrInsertComputed(key, () => new SyncMap());
+  }
+  node.set(keys[keys.length - 1], value);
+}

package/test/drivers/SetMap.test.js

@@ -6,20 +6,20 @@ describe("SetMap", () => {
   test("can get the keys of the map", async () => {
     const set = new Set(["a", "b", "c"]);
     const fixture = new SetMap(set);
-    assert.deepEqual(Array.from(await fixture.keys()), ["a", "b", "c"]);
+    assert.deepEqual(Array.from(await fixture.keys()), [0, 1, 2]);
   });
 
   test("can get the value for a key", async () => {
     const set = new Set(["a", "b", "c"]);
     const fixture = new SetMap(set);
-    const a = await fixture.get("a");
+    const a = await fixture.get(0);
     assert.equal(a, "a");
   });
 
   test("getting an unsupported key returns undefined", async () => {
     const set = new Set(["a", "b", "c"]);
     const fixture = new SetMap(set);
-    assert.equal(await fixture.get("d"), undefined);
+    assert.equal(await fixture.get(3), undefined);
   });
 
   test("getting a null/undefined key throws an exception", async () => {

package/test/operations/deflatePaths.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import deflatePaths from "../../src/operations/deflatePaths.js";
+
+describe("deflatePaths", () => {
+  test("flattens a tree into a map of string paths to values", async () => {
+    const maplike = {
+      foo: {
+        bar: {
+          "baz.json": 123,
+          "qux.json": 456,
+        },
+        "quux.json": 789,
+      },
+    };
+    const result = await deflatePaths(maplike);
+    assert.deepStrictEqual(Object.fromEntries(result), {
+      "foo/bar/baz.json": 123,
+      "foo/bar/qux.json": 456,
+      "foo/quux.json": 789,
+    });
+  });
+});

package/test/operations/inflatePaths.test.js

@@ -0,0 +1,24 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import inflatePaths from "../../src/operations/inflatePaths.js";
+import plain from "../../src/operations/plain.js";
+
+describe("inflatePaths", () => {
+  test("given a flat mapping of paths to values, returns the described tree", async () => {
+    const maplike = {
+      "foo/bar/baz.json": 123,
+      "foo/bar/qux.json": 456,
+      "foo/quux.json": 789,
+    };
+    const result = await inflatePaths(maplike);
+    assert.deepStrictEqual(await plain(result), {
+      foo: {
+        bar: {
+          "baz.json": 123,
+          "qux.json": 456,
+        },
+        "quux.json": 789,
+      },
+    });
+  });
+});