@weborigami/async-tree 0.0.73 → 0.1.0

package/src/operations/map.js

@@ -1,14 +1,129 @@
-import mapFn from "../transforms/mapFn.js";
+import { Tree } from "../internal.js";
+import * as trailingSlash from "../trailingSlash.js";
 
 /**
  * Transform the keys and/or values of a tree.
  *
  * @typedef {import("../../index.ts").KeyFn} KeyFn
+ * @typedef {import("../../index.ts").TreeMapOptions} MapOptions
  * @typedef {import("../../index.ts").ValueKeyFn} ValueKeyFn
  *
  * @param {import("../../index.ts").Treelike} treelike
- * @param {ValueKeyFn|{ deep?: boolean, description?: string, needsSourceValue?: boolean, inverseKey?: KeyFn, key?: KeyFn, value?: ValueKeyFn }} options
+ * @param {MapOptions|ValueKeyFn} options
  */
 export default function map(treelike, options = {}) {
-  return mapFn(options)(treelike);
+  let deep;
+  let description;
+  let inverseKeyFn;
+  let keyFn;
+  let needsSourceValue;
+  let valueFn;
+
+  if (!treelike) {
+    const error = new TypeError(`map: The tree to map isn't defined.`);
+    /** @type {any} */ (error).position = 0;
+    throw error;
+  }
+
+  if (typeof options === "function") {
+    // Take the single function argument as the valueFn
+    valueFn = options;
+  } else {
+    deep = options.deep;
+    description = options.description;
+    inverseKeyFn = options.inverseKey;
+    keyFn = options.key;
+    needsSourceValue = options.needsSourceValue;
+    valueFn = options.value;
+  }
+
+  deep ??= false;
+  description ??= "key/value map";
+  // @ts-ignore
+  inverseKeyFn ??= valueFn?.inverseKey;
+  // @ts-ignore
+  keyFn ??= valueFn?.key;
+  needsSourceValue ??= true;
+
+  if ((keyFn && !inverseKeyFn) || (!keyFn && inverseKeyFn)) {
+    throw new TypeError(
+      `map: You must specify both key and inverseKey functions, or neither.`
+    );
+  }
+
+  /**
+   * @param {import("@weborigami/types").AsyncTree} tree
+   */
+  function mapFn(tree) {
+    // The transformed tree is actually an extension of the original tree's
+    // prototype chain. This allows the transformed tree to inherit any
+    // properties/methods. For example, the `parent` of the transformed tree is
+    // the original tree's parent.
+    const transformed = Object.create(tree);
+
+    transformed.description = description;
+
+    if (keyFn || valueFn) {
+      transformed.get = async (resultKey) => {
+        // Step 1: Map the result key to the source key.
+        const sourceKey = (await inverseKeyFn?.(resultKey, tree)) ?? resultKey;
+
+        if (sourceKey === undefined) {
+          // No source key means no value.
+          return undefined;
+        }
+
+        // Step 2: Get the source value.
+        let sourceValue;
+        if (needsSourceValue) {
+          // Normal case: get the value from the source tree.
+          sourceValue = await tree.get(sourceKey);
+        } else if (deep && trailingSlash.has(sourceKey)) {
+          // Only get the source value if it's expected to be a subtree.
+          sourceValue = tree;
+        }
+
+        // Step 3: Map the source value to the result value.
+        let resultValue;
+        if (needsSourceValue && sourceValue === undefined) {
+          // No source value means no result value.
+          resultValue = undefined;
+        } else if (deep && Tree.isAsyncTree(sourceValue)) {
+          // Map a subtree.
+          resultValue = mapFn(sourceValue);
+        } else if (valueFn) {
+          // Map a single value.
+          resultValue = await valueFn(sourceValue, sourceKey, tree);
+        } else {
+          // Return source value as is.
+          resultValue = sourceValue;
+        }
+
+        return resultValue;
+      };
+    }
+
+    if (keyFn) {
+      transformed.keys = async () => {
+        // Apply the keyFn to source keys for leaf values (not subtrees).
+        const sourceKeys = Array.from(await tree.keys());
+        const mapped = await Promise.all(
+          sourceKeys.map(async (sourceKey) =>
+            // Deep maps leave source keys for subtrees alone
+            deep && trailingSlash.has(sourceKey)
+              ? sourceKey
+              : await keyFn(sourceKey, tree)
+          )
+        );
+        // Filter out any cases where the keyFn returned undefined.
+        const resultKeys = mapped.filter((key) => key !== undefined);
+        return resultKeys;
+      };
+    }
+
+    return transformed;
+  }
+
+  const tree = Tree.from(treelike, { deep });
+  return mapFn(tree);
 }

package/src/operations/sort.js

@@ -1,4 +1,4 @@
-import sortFn from "../transforms/sortFn.js";
+import { Tree } from "../internal.js";
 
 /**
  * Return a new tree with the original's keys sorted. A comparison function can
@@ -14,5 +14,48 @@ import sortFn from "../transforms/sortFn.js";
  * @param {SortOptions} [options]
  */
 export default function sort(treelike, options) {
-  return sortFn(options)(treelike);
+  if (!treelike) {
+    const error = new TypeError(`sort: The tree to sort isn't defined.`);
+    /** @type {any} */ (error).position = 0;
+    throw error;
+  }
+
+  const sortKey = options?.sortKey;
+  let compare = options?.compare;
+
+  const tree = Tree.from(treelike);
+  const transformed = Object.create(tree);
+  transformed.keys = async () => {
+    const keys = Array.from(await tree.keys());
+
+    if (sortKey) {
+      // Invoke the async sortKey function to get sort keys.
+      // Create { key, sortKey } tuples.
+      const tuples = await Promise.all(
+        keys.map(async (key) => {
+          const sort = await sortKey(key, tree);
+          if (sort === undefined) {
+            throw new Error(
+              `sortKey function returned undefined for key ${key}`
+            );
+          }
+          return { key, sort };
+        })
+      );
+
+      // Wrap the comparison function so it applies to sort keys.
+      const defaultCompare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+      const originalCompare = compare ?? defaultCompare;
+      // Sort by the sort key.
+      tuples.sort((a, b) => originalCompare(a.sort, b.sort));
+      // Map back to the original keys.
+      const sorted = tuples.map((pair) => pair.key);
+      return sorted;
+    } else {
+      // Use original keys as sort keys.
+      // If compare is undefined, this uses default sort order.
+      return keys.slice().sort(compare);
+    }
+  };
+  return transformed;
 }

package/src/operations/take.js

@@ -1,4 +1,4 @@
-import takeFn from "../transforms/takeFn.js";
+import { Tree } from "../internal.js";
 
 /**
  * Returns a new tree with the number of keys limited to the indicated count.
@@ -7,5 +7,22 @@ import takeFn from "../transforms/takeFn.js";
  * @param {number} count
  */
 export default function take(treelike, count) {
-  return takeFn(count)(treelike);
+  if (!treelike) {
+    const error = new TypeError(`take: The tree to take from isn't defined.`);
+    /** @type {any} */ (error).position = 0;
+    throw error;
+  }
+
+  const tree = Tree.from(treelike);
+
+  return {
+    async keys() {
+      const keys = Array.from(await tree.keys());
+      return keys.slice(0, count);
+    },
+
+    async get(key) {
+      return tree.get(key);
+    },
+  };
 }

package/src/symbols.js

@@ -1 +1,2 @@
+export const deep = Symbol("deep");
 export const parent = Symbol("parent");

package/test/Tree.test.js

@@ -1,7 +1,8 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import MapTree from "../src/MapTree.js";
+import MapTree from "../src/drivers/MapTree.js";
 import { DeepObjectTree, ObjectTree, Tree } from "../src/internal.js";
+import * as symbols from "../src/symbols.js";
 
 describe("Tree", () => {
   test("assign applies one tree to another", async () => {
@@ -108,6 +109,17 @@ describe("Tree", () => {
     assert(tree instanceof DeepObjectTree);
   });
 
+  test("from returns a deep object tree if object has [deep] symbol set", async () => {
+    const obj = {
+      sub: {
+        a: 1,
+      },
+    };
+    Object.defineProperty(obj, symbols.deep, { value: true });
+    const tree = Tree.from(obj);
+    assert(tree instanceof DeepObjectTree);
+  });
+
   test("from() creates a deferred tree if unpack() returns a promise", async () => {
     const obj = new String();
     /** @type {any} */ (obj).unpack = async () => ({
@@ -179,7 +191,10 @@ describe("Tree", () => {
         b: "Bob",
       },
     });
-    const mapped = Tree.map(tree, (value) => value.toUpperCase());
+    const mapped = Tree.map(tree, {
+      deep: true,
+      value: (value) => value.toUpperCase(),
+    });
     assert.deepEqual(await Tree.plain(mapped), {
       a: "ALICE",
       more: {
@@ -275,6 +290,14 @@ describe("Tree", () => {
     assert.deepEqual(await Tree.plain(object), { name: "Alice" });
   });
 
+  test("plain() coerces TypedArray values to strings", async () => {
+    const tree = new ObjectTree({
+      a: new TextEncoder().encode("Hello, world."),
+    });
+    const plain = await Tree.plain(tree);
+    assert.equal(plain.a, "Hello, world.");
+  });
+
   test("remove method removes a value", async () => {
     const fixture = createFixture();
     await Tree.remove(fixture, "Alice.md");

package/test/{BrowserFileTree.test.js → drivers/BrowserFileTree.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import BrowserFileTree from "../src/BrowserFileTree.js";
-import { Tree } from "../src/internal.js";
+import BrowserFileTree from "../../src/drivers/BrowserFileTree.js";
+import { Tree } from "../../src/internal.js";
 
 // Skip these tests if we're not in a browser.
 const isBrowser = typeof window !== "undefined";

package/test/{DeepMapTree.test.js → drivers/DeepMapTree.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeepMapTree from "../src/DeepMapTree.js";
-import { Tree } from "../src/internal.js";
+import DeepMapTree from "../../src/drivers/DeepMapTree.js";
+import { Tree } from "../../src/internal.js";
 
 describe("DeepMapTree", () => {
   test("returns a DeepMapTree for value that's a Map", async () => {

package/test/{DeepObjectTree.test.js → drivers/DeepObjectTree.test.js}

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { DeepObjectTree, Tree } from "../src/internal.js";
+import { DeepObjectTree, Tree } from "../../src/internal.js";
 
 describe("DeepObjectTree", () => {
   test("returns an ObjectTree for value that's a plain sub-object or sub-array", async () => {

package/test/{DeferredTree.test.js → drivers/DeferredTree.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import DeferredTree from "../src/DeferredTree.js";
-import { ObjectTree, Tree } from "../src/internal.js";
+import DeferredTree from "../../src/drivers/DeferredTree.js";
+import { ObjectTree, Tree } from "../../src/internal.js";
 
 describe("DeferredTree", () => {
   test("lazy-loads a treelike object", async () => {

package/test/{ExplorableSiteTree.test.js → drivers/ExplorableSiteTree.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { beforeEach, describe, mock, test } from "node:test";
-import ExplorableSiteTree from "../src/ExplorableSiteTree.js";
-import { Tree } from "../src/internal.js";
+import ExplorableSiteTree from "../../src/drivers/ExplorableSiteTree.js";
+import { Tree } from "../../src/internal.js";
 
 const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();
@@ -77,7 +77,10 @@ describe("ExplorableSiteTree", () => {
   test("can convert a site to a plain object", async () => {
     const fixture = new ExplorableSiteTree(mockHost);
     // Convert buffers to strings.
-    const strings = Tree.map(fixture, (value) => textDecoder.decode(value));
+    const strings = Tree.map(fixture, {
+      deep: true,
+      value: (value) => textDecoder.decode(value),
+    });
     assert.deepEqual(await Tree.plain(strings), {
       about: {
         "Alice.html": "Hello, Alice!",

package/test/{FileTree.test.js → drivers/FileTree.test.js}

@@ -3,8 +3,8 @@ import * as fs from "node:fs/promises";
 import path from "node:path";
 import { describe, test } from "node:test";
 import { fileURLToPath } from "node:url";
-import FileTree from "../src/FileTree.js";
-import { ObjectTree, Tree } from "../src/internal.js";
+import FileTree from "../../src/drivers/FileTree.js";
+import { ObjectTree, Tree } from "../../src/internal.js";
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const tempDirectory = path.join(dirname, "fixtures/temp");
@@ -132,9 +132,10 @@ describe("FileTree", async () => {
 
     // Read them back in.
     const actualFiles = await tempFiles.get("folder");
-    const strings = Tree.map(actualFiles, (buffer) =>
-      textDecoder.decode(buffer)
-    );
+    const strings = Tree.map(actualFiles, {
+      deep: true,
+      value: (buffer) => textDecoder.decode(buffer),
+    });
     const plain = await Tree.plain(strings);
     assert.deepEqual(plain, obj);
 

package/test/{FunctionTree.test.js → drivers/FunctionTree.test.js}

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import FunctionTree from "../src/FunctionTree.js";
+import FunctionTree from "../../src/drivers/FunctionTree.js";
 
 describe("FunctionTree", async () => {
   test("can get the keys of the tree", async () => {

package/test/{MapTree.test.js → drivers/MapTree.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import MapTree from "../src/MapTree.js";
-import * as symbols from "../src/symbols.js";
+import MapTree from "../../src/drivers/MapTree.js";
+import * as symbols from "../../src/symbols.js";
 
 describe("MapTree", () => {
   test("can get the keys of the tree", async () => {

package/test/{ObjectTree.test.js → drivers/ObjectTree.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { ObjectTree, Tree } from "../src/internal.js";
-import * as symbols from "../src/symbols.js";
+import { ObjectTree, Tree } from "../../src/internal.js";
+import * as symbols from "../../src/symbols.js";
 
 describe("ObjectTree", () => {
   test("can get the keys of the tree", async () => {

package/test/{SetTree.test.js → drivers/SetTree.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import SetTree from "../src/SetTree.js";
-import { ObjectTree } from "../src/internal.js";
+import SetTree from "../../src/drivers/SetTree.js";
+import { ObjectTree } from "../../src/internal.js";
 
 describe("SetTree", () => {
   test("can get the keys of the tree", async () => {

package/test/{SiteTree.test.js → drivers/SiteTree.test.js}

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { beforeEach, describe, mock, test } from "node:test";
-import SiteTree from "../src/SiteTree.js";
+import SiteTree from "../../src/drivers/SiteTree.js";
 
 const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();

package/test/{calendarTree.test.js → drivers/calendarTree.test.js}

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import calendarTree from "../src/calendarTree.js";
-import { toPlainValue } from "../src/utilities.js";
+import calendar from "../../src/drivers/calendarTree.js";
+import { toPlainValue } from "../../src/utilities.js";
 
 describe("calendarTree", () => {
   test("without a start or end, returns a tree for today", async () => {
-    const tree = calendarTree({
+    const tree = calendar({
       value: (year, month, day) => `${year}-${month}-${day}`,
     });
     const plain = await toPlainValue(tree);
@@ -23,7 +23,7 @@ describe("calendarTree", () => {
   });
 
   test("returns a tree for a month range", async () => {
-    const tree = calendarTree({
+    const tree = calendar({
       start: "2025-01",
       end: "2025-02",
       value: (year, month, day) => `${year}-${month}-${day}`,
@@ -99,7 +99,7 @@ describe("calendarTree", () => {
   });
 
   test("returns a tree for a day range", async () => {
-    const tree = calendarTree({
+    const tree = calendar({
       start: "2025-02-27",
       end: "2025-03-02",
       value: (year, month, day) => `${year}-${month}-${day}`,

package/test/extension.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { extname, match, replace } from "../src/extension.js";
+
+describe("extension", () => {
+  test("extname", () => {
+    assert.equal(extname(".\\"), "");
+    assert.equal(extname("..\\"), ".\\");
+    assert.equal(extname("file.ext\\"), ".ext\\");
+    assert.equal(extname("file.ext\\\\"), ".ext\\\\");
+    assert.equal(extname("file\\"), "");
+    assert.equal(extname("file\\\\"), "");
+    assert.equal(extname("file.\\"), ".\\");
+    assert.equal(extname("file.\\\\"), ".\\\\");
+  });
+
+  test("match", () => {
+    assert.equal(match("file.md", ".md"), "file");
+    assert.equal(match("file.md", ".txt"), null);
+    assert.equal(match("file.md/", ".md"), "file/");
+    assert.equal(match("file", ""), "file");
+    assert.equal(match("file", "/"), null);
+    assert.equal(match("file/", "/"), "file");
+  });
+
+  test("match can handle multi-part extensions", () => {
+    assert.equal(match("foo.ori.html", ".ori.html"), "foo");
+    assert.equal(match("foo.ori.html", ".html"), "foo.ori");
+    assert.equal(match("foo.ori.html", ".txt"), null);
+    assert.equal(match("foo.ori.html/", ".ori.html"), "foo/");
+  });
+
+  test("replace", () => {
+    assert.equal(replace("file.md", ".md", ".html"), "file.html");
+    assert.equal(replace("file.md", ".txt", ".html"), "file.md");
+    assert.equal(replace("file.md/", ".md", ".html"), "file.html/");
+    assert.equal(replace("folder/", "", ".html"), "folder.html");
+    assert.equal(replace("folder", "/", ".html"), "folder");
+    assert.equal(replace("folder/", "/", ".html"), "folder.html");
+  });
+});

package/test/{transforms → operations}/cachedKeyFunctions.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { DeepObjectTree, ObjectTree } from "../../src/internal.js";
-import cachedKeyFunctions from "../../src/transforms/cachedKeyFunctions.js";
+import cachedKeyFunctions from "../../src/operations/cachedKeyFunctions.js";
 
 describe("cachedKeyFunctions", () => {
   test("maps keys with caching", async () => {

package/test/operations/concat.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import FunctionTree from "../../src/FunctionTree.js";
+import FunctionTree from "../../src/drivers/FunctionTree.js";
 import { Tree } from "../../src/internal.js";
 import concat from "../../src/operations/concat.js";
 

package/test/{transforms → operations}/deepReverse.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { Tree } from "../../src/internal.js";
-import deepReverse from "../../src/transforms/deepReverse.js";
+import deepReverse from "../../src/operations/deepReverse.js";
 
 describe("deepReverse", () => {
   test("reverses keys at all levels of a tree", async () => {

package/test/operations/{deepTakeFn.test.js → deepTake.test.js}

@@ -1,9 +1,9 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { Tree } from "../../src/internal.js";
-import deepTakeFn from "../../src/operations/deepTakeFn.js";
+import deepTake from "../../src/operations/deepTake.js";
 
-describe("deepTakeFn", () => {
+describe("deepTake", () => {
   test("traverses deeply and returns a limited number of items", async () => {
     const tree = {
       a: 1,
@@ -16,7 +16,7 @@ describe("deepTakeFn", () => {
       },
       g: 5,
     };
-    const result = await deepTakeFn(4)(tree);
+    const result = await deepTake(tree, 4);
     assert.deepEqual(await Tree.plain(result), [1, 2, 3, 4]);
   });
 });

package/test/{transforms/groupFn.test.js → operations/group.test.js}

@@ -1,9 +1,9 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { Tree } from "../../src/internal.js";
-import groupFn from "../../src/operations/groupFn.js";
+import group from "../../src/operations/group.js";
 
-describe("groupFn transform", () => {
+describe("group transform", () => {
   test("groups an array using a group key function", async () => {
     const fonts = [
       { name: "Aboreto", tags: ["Sans Serif"] },
@@ -12,7 +12,7 @@ describe("groupFn transform", () => {
       { name: "Work Sans", tags: ["Grotesque", "Sans Serif"] },
     ];
     const tree = Tree.from(fonts);
-    const grouped = await groupFn((value, key, tree) => value.tags)(tree);
+    const grouped = await group(tree, (value, key, tree) => value.tags);
     assert.deepEqual(await Tree.plain(grouped), {
       Geometric: [{ name: "Albert Sans", tags: ["Geometric", "Sans Serif"] }],
       Grotesque: [{ name: "Work Sans", tags: ["Grotesque", "Sans Serif"] }],
@@ -33,7 +33,7 @@ describe("groupFn transform", () => {
       "Work Sans": { tags: ["Grotesque", "Sans Serif"] },
     };
     const tree = Tree.from(fonts);
-    const grouped = await groupFn((value, key, tree) => value.tags)(tree);
+    const grouped = await group(tree, (value, key, tree) => value.tags);
     assert.deepEqual(await Tree.plain(grouped), {
       Geometric: {
         "Albert Sans": { tags: ["Geometric", "Sans Serif"] },

package/test/{transforms → operations}/invokeFunctions.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { Tree } from "../../src/internal.js";
-import invokeFunctions from "../../src/transforms/invokeFunctions.js";
+import invokeFunctions from "../../src/operations/invokeFunctions.js";
 
 describe("invokeFunctions", () => {
   test("invokes function values, leaves other values as is", async () => {