@weborigami/async-tree 0.5.2 → 0.5.4

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
   "browser": "./browser.js",
   "types": "./index.ts",
   "dependencies": {
-    "@weborigami/types": "0.5.2"
+    "@weborigami/types": "0.5.4"
   },
   "devDependencies": {
     "@types/node": "24.3.0",

package/src/Tree.js

@@ -337,10 +337,21 @@ export async function paths(treelike, options = {}) {
 /**
  * Converts an asynchronous tree into a synchronous plain JavaScript object.
  *
- * The result's keys will be the tree's keys cast to strings. Any tree value
- * that is itself a tree will be similarly converted to a plain object.
+ * The result's keys will be the tree's keys cast to strings. Any trailing
+ * slashes in keys will be removed.
  *
- * Any trailing slashes in keys will be removed.
+ * Any tree value that is itself a tree will be recursively converted to a plain
+ * object.
+ *
+ * If the tree is array-like (its keys are integers and fill the range
+ * 0..length-1), then the result will be an array. The order of the keys will
+ * determine the order of the values in the array -- but the numeric value of
+ * the keys will be ignored.
+ *
+ * For example, a tree like `{ 1: "b", 0: "a", 2: "c" }` is array-like because
+ * its keys are all integers and fill the range 0..2. The result will be the
+ * array `["b", "a", "c" ]` because the tree has the keys in that order. The
+ * specific values of the keys (0, 1, and 2) are ignored.
  *
  * @param {Treelike} treelike
  * @returns {Promise<PlainObject|Array>}

package/src/operations/map.js

@@ -171,6 +171,12 @@ function validateOptions(options) {
     }
   }
 
+  if (!valueFn && !keyFn) {
+    throw new TypeError(
+      `map: You must specify a value function or a key function`
+    );
+  }
+
   deep ??= false;
   description ??= "key/value map";
   needsSourceValue ??= true;

package/src/utilities.js

@@ -55,36 +55,40 @@ export function box(value) {
 /**
  * Create an array or plain object from the given keys and values.
  *
- * If the given plain object has only sequential integer keys, return the
- * values as an array. Otherwise, create a plain object with the keys and
- * values.
+ * If the given plain object has only integer keys, and the set of integers is
+ * complete from 0 to length-1, assume the values are a result of array
+ * transformations and the values are the desired result; return them as is.
+ * Otherwise, create a plain object with the keys and values.
  *
  * @param {any[]} keys
  * @param {any[]} values
  */
 export function castArrayLike(keys, values) {
-  let isArrayLike = false;
+  if (keys.length === 0) {
+    // Empty keys/values means an empty object, not an empty array
+    return {};
+  }
 
-  // Need at least one key to count as an array
-  if (keys.length > 0) {
-    // Assume it's an array
-    isArrayLike = true;
-    // Then check if all the keys are sequential integers
-    let expectedIndex = 0;
-    for (const key of keys) {
-      const index = Number(key);
-      if (key === "" || isNaN(index) || index !== expectedIndex) {
-        // Not array-like
-        isArrayLike = false;
-        break;
-      }
-      expectedIndex++;
+  let onlyNumericKeys = true;
+  const numberSeen = new Array(keys.length);
+  for (const key of keys) {
+    const n = Number(key);
+    if (isNaN(n) || !Number.isInteger(n) || n < 0 || n >= keys.length) {
+      onlyNumericKeys = false;
+      break;
+    } else {
+      numberSeen[n] = true;
     }
   }
 
-  return isArrayLike
-    ? values
-    : Object.fromEntries(keys.map((key, i) => [key, values[i]]));
+  // If any number from 0..length-1 is missing, we can't treat this as an array
+  const allNumbersSeen = onlyNumericKeys && numberSeen.every((v) => v);
+  if (allNumbersSeen) {
+    return values;
+  } else {
+    // Return a plain object with the (key, value) pairs
+    return Object.fromEntries(keys.map((key, i) => [key, values[i]]));
+  }
 }
 
 /**
@@ -328,6 +332,22 @@ export function setParent(child, parent) {
   }
 }
 
+function toBase64(object) {
+  if (typeof Buffer !== "undefined") {
+    // Node.js environment
+    return Buffer.from(object).toString("base64");
+  } else {
+    // Browser environment
+    let binary = "";
+    const bytes = new Uint8Array(object);
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+}
+
 /**
  * Convert the given input to the plainest possible JavaScript value. This
  * helper is intended for functions that want to accept an argument from the ori
@@ -390,22 +410,6 @@ export async function toPlainValue(input) {
   }
 }
 
-function toBase64(object) {
-  if (typeof Buffer !== "undefined") {
-    // Node.js environment
-    return Buffer.from(object).toString("base64");
-  } else {
-    // Browser environment
-    let binary = "";
-    const bytes = new Uint8Array(object);
-    const len = bytes.byteLength;
-    for (let i = 0; i < len; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-}
-
 /**
  * Return a string form of the object, handling cases not generally handled by
  * the standard JavaScript `toString()` method:

package/test/operations/map.test.js

@@ -6,15 +6,13 @@ import map from "../../src/operations/map.js";
 import * as trailingSlash from "../../src/trailingSlash.js";
 
 describe("map", () => {
-  test("returns identity graph if no key or value function is supplied", async () => {
+  test("throws if no key or value function is supplied", async () => {
     const tree = {
       a: "letter a",
       b: "letter b",
     };
-    const mapped = map(tree, {});
-    assert.deepEqual(await Tree.plain(mapped), {
-      a: "letter a",
-      b: "letter b",
+    assert.throws(() => {
+      map(tree, {});
     });
   });
 

package/test/operations/paginate.test.js

@@ -13,7 +13,8 @@ describe("paginate", () => {
       e: 5,
     };
     const paginated = await paginate.call(null, treelike, 2);
-    assert.deepEqual(await Tree.plain(paginated), {
+    const plain = await Tree.plain(paginated);
+    assert.deepEqual(await plain, {
       1: {
         items: { a: 1, b: 2 },
         nextPage: 2,