@weborigami/async-tree 0.0.67-beta.2 → 0.0.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.67-beta.2",
+  "version": "0.0.69",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/types": "0.0.67-beta.2"
+    "@weborigami/types": "0.0.69"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/Tree.js

@@ -332,14 +332,9 @@ export async function plain(treelike) {
     if (tree instanceof ObjectTree && keys.length === 0) {
       return tree.object instanceof Array ? [] : {};
     }
-    const object = {};
-    for (let i = 0; i < keys.length; i++) {
-      // Normalize slashes in keys.
-      const key = trailingSlash.remove(keys[i]);
-      const value = values[i];
-      object[key] = value;
-    }
-    return castArrayLike(object);
+    // Normalize slashes in keys.
+    keys = keys.map(trailingSlash.remove);
+    return castArrayLike(keys, values);
   });
 }
 

package/src/utilities.d.ts

@@ -2,7 +2,7 @@ import { AsyncTree } from "@weborigami/types";
 import { Packed, PlainObject, StringLike } from "../index.ts";
 
 export function box(value: any): any;
-export function castArrayLike(object: any): any;
+export function castArrayLike(keys: any[], values: any[]): any;
 export function getRealmObjectPrototype(object: any): any;
 export const hiddenFileNames: string[];
 export function isPacked(obj: any): obj is Packed;
@@ -11,6 +11,7 @@ export function isStringLike(obj: any): obj is StringLike;
 export function isUnpackable(obj): obj is { unpack: () => any };
 export function keysFromPath(path: string): string[];
 export const naturalOrder: (a: string, b: string) => number;
+export function pathFromKeys(keys: string[]): string;
 export function pipeline(start: any, ...functions: Function[]): Promise<any>;
 export function setParent(child: any, parent: AsyncTree): void;
 export function toPlainValue(object: any): Promise<any>;

package/src/utilities.js

@@ -27,24 +27,38 @@ export function box(value) {
 }
 
 /**
- * If the given plain object has only sequential integer keys, return it as an
- * array. Otherwise return it as is.
+ * Create an array or plain object from the given keys and values.
  *
- * @param {any} object
+ * 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.
+ *
+ * @param {any[]} keys
+ * @param {any[]} values
  */
-export function castArrayLike(object) {
-  let hasKeys = false;
-  let expectedIndex = 0;
-  for (const key in object) {
-    hasKeys = true;
-    const index = Number(key);
-    if (key === "" || isNaN(index) || index !== expectedIndex) {
-      // Not an array-like object.
-      return object;
+export function castArrayLike(keys, values) {
+  let isArrayLike = false;
+
+  // 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++;
     }
-    expectedIndex++;
   }
-  return hasKeys ? Object.values(object) : object;
+
+  return isArrayLike
+    ? values
+    : Object.fromEntries(keys.map((key, i) => [key, values[i]]));
 }
 
 /**
@@ -196,6 +210,19 @@ export const naturalOrder = new Intl.Collator(undefined, {
   numeric: true,
 }).compare;
 
+/**
+ * Return a slash-separated path for the given keys.
+ *
+ * This takes care to avoid adding consecutive slashes if they keys themselves
+ * already have trailing slashes.
+ *
+ * @param {string[]} keys
+ */
+export function pathFromKeys(keys) {
+  const normalized = keys.map((key) => trailingSlash.remove(key));
+  return normalized.join("/");
+}
+
 /**
  * Apply a series of functions to a value, passing the result of each function
  * to the next one.

package/test/utilities.test.js

@@ -55,6 +55,12 @@ describe("utilities", () => {
     assert.deepEqual(strings, ["file1", "file9", "file10"]);
   });
 
+  test("pathFromKeys() returns a slash-separated path from keys", () => {
+    assert.equal(utilities.pathFromKeys([]), "");
+    assert.equal(utilities.pathFromKeys(["a", "b", "c"]), "a/b/c");
+    assert.equal(utilities.pathFromKeys(["a/", "b/", "c"]), "a/b/c");
+  });
+
   test("pipeline applies a series of functions to a value", async () => {
     const addOne = (n) => n + 1;
     const double = (n) => n * 2;