@weborigami/async-tree 0.5.3 → 0.5.5

package/test/operations/values.test.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import values from "../../src/operations/values.js";
+
+describe("values", () => {
+  test("returns the tree's values as an array", async () => {
+    const fixture = {
+      "Alice.md": "Hello, **Alice**.",
+      "Bob.md": "Hello, **Bob**.",
+      "Carol.md": "Hello, **Carol**.",
+    };
+    assert.deepEqual(await values(fixture), [
+      "Hello, **Alice**.",
+      "Hello, **Bob**.",
+      "Hello, **Carol**.",
+    ]);
+  });
+});

package/test/operations/withKeys.test.js

@@ -0,0 +1,21 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { Tree } from "../../src/internal.js";
+import withKeys from "../../src/operations/withKeys.js";
+
+describe("withKeys", () => {
+  test("applies the indicated keys", async () => {
+    const result = await withKeys(
+      {
+        a: 1,
+        b: 2,
+        c: 3,
+      },
+      ["a", "c"]
+    );
+    assert.deepEqual(await Tree.plain(result), {
+      a: 1,
+      c: 3,
+    });
+  });
+});

package/test/utilities/box.test.js

@@ -0,0 +1,26 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import box from "../../src/utilities/box.js";
+
+describe("box", () => {
+  test("returns a boxed value", () => {
+    const string = "string";
+    const stringObject = box(string);
+    assert(stringObject instanceof String);
+    assert.equal(stringObject, string);
+
+    const number = 1;
+    const numberObject = box(number);
+    assert(numberObject instanceof Number);
+    assert.equal(numberObject, number);
+
+    const boolean = true;
+    const booleanObject = box(boolean);
+    assert(booleanObject instanceof Boolean);
+    assert.equal(booleanObject, boolean);
+
+    const object = {};
+    const boxedObject = box(object);
+    assert.equal(boxedObject, object);
+  });
+});

package/test/utilities/getRealmObjectPrototype.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import getRealmObjectPrototype from "../../src/utilities/getRealmObjectPrototype.js";
+
+describe("getRealmObjectPrototype", () => {
+  test("returns the object's root prototype", () => {
+    const object = {};
+    const proto = getRealmObjectPrototype(object);
+    assert.equal(proto, Object.prototype);
+  });
+});

package/test/utilities/isPlainObject.test.js

@@ -0,0 +1,13 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import isPlainObject from "../../src/utilities/isPlainObject.js";
+
+describe("isPlainObject", () => {
+  test("returns true if the object is a plain object", () => {
+    assert.equal(isPlainObject({}), true);
+    assert.equal(isPlainObject(new Object()), true);
+    assert.equal(isPlainObject(Object.create(null)), true);
+    class Foo {}
+    assert.equal(isPlainObject(new Foo()), false);
+  });
+});

package/test/utilities/keysFromPath.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import keysFromPath from "../../src/utilities/keysFromPath.js";
+
+describe("keysFromPath", () => {
+  test("returns the keys from a slash-separated path", () => {
+    assert.deepEqual(keysFromPath(""), []);
+    assert.deepEqual(keysFromPath("/"), []);
+    assert.deepEqual(keysFromPath("a/b/c"), ["a/", "b/", "c"]);
+    assert.deepEqual(keysFromPath("a/b/c/"), ["a/", "b/", "c/"]);
+    assert.deepEqual(keysFromPath("/foo/"), ["foo/"]);
+    assert.deepEqual(keysFromPath("a///b"), ["a/", "b"]);
+  });
+});

package/test/utilities/naturalOrder.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import naturalOrder from "../../src/utilities/naturalOrder.js";
+
+describe("naturalOrder", () => {
+  test("compares strings in natural order", () => {
+    const strings = ["file10", "file1", "file9"];
+    strings.sort(naturalOrder);
+    assert.deepEqual(strings, ["file1", "file9", "file10"]);
+  });
+});

package/test/utilities/pathFromKeys.test.js

@@ -0,0 +1,12 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import pathFromKeys from "../../src/utilities/pathFromKeys.js";
+
+describe("pathFromKeys", () => {
+  test("returns a slash-separated path from keys", () => {
+    assert.equal(pathFromKeys([]), "");
+    assert.equal(pathFromKeys(["a", "b", "c"]), "a/b/c");
+    assert.equal(pathFromKeys(["a/", "b/", "c"]), "a/b/c");
+    assert.equal(pathFromKeys(["a/", "b/", "c/"]), "a/b/c/");
+  });
+});

package/test/utilities/setParent.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import * as symbols from "../../src/symbols.js";
+import setParent from "../../src/utilities/setParent.js";
+
+describe("setParent", () => {
+  test("sets a child's parent", () => {
+    const parent = new ObjectTree({});
+
+    // Set [symbols.parent] on a plain object.
+    const object = {};
+    setParent(object, parent);
+    assert.equal(object[symbols.parent], parent);
+
+    // Leave [symbols.parent] alone if it's already set.
+    const childWithParent = {
+      [symbols.parent]: "parent",
+    };
+    setParent(childWithParent, parent);
+    assert.equal(childWithParent[symbols.parent], "parent");
+
+    // Set `parent` on a tree.
+    const tree = new ObjectTree({});
+    setParent(tree, parent);
+    assert.equal(tree.parent, parent);
+
+    // Leave `parent` alone if it's already set.
+    const treeWithParent = new ObjectTree({});
+    treeWithParent.parent = "parent";
+    setParent(treeWithParent, parent);
+    assert.equal(treeWithParent.parent, "parent");
+  });
+});

package/test/utilities/toFunction.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ObjectTree from "../../src/drivers/ObjectTree.js";
+import toFunction from "../../src/utilities/toFunction.js";
+
+describe("toFunction", () => {
+  test("returns a plain function as is", () => {
+    const fn = () => {};
+    assert.equal(toFunction(fn), fn);
+  });
+
+  test("returns a tree's getter as a function", async () => {
+    const tree = new ObjectTree({
+      a: 1,
+    });
+    const fn = toFunction(tree);
+    // @ts-ignore
+    assert.equal(await fn("a"), 1);
+  });
+
+  test("can use a packed object's `unpack` as a function", async () => {
+    const obj = new String();
+    /** @type {any} */ (obj).unpack = () => () => "result";
+    const fn = toFunction(obj);
+    // @ts-ignore
+    assert.equal(await fn(), "result");
+  });
+
+  test("returns null for something that's not a function", () => {
+    // @ts-ignore
+    const result = toFunction("this is not a function");
+    assert.equal(result, null);
+  });
+});

package/test/utilities/toPlainValue.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import toPlainValue from "../../src/utilities/toPlainValue.js";
+
+describe("toPlainValue", () => {
+  test("returns the plainest representation of an object", async () => {
+    class User {
+      constructor(name) {
+        this.name = name;
+      }
+    }
+
+    assert.equal(await toPlainValue(1), 1);
+    assert.equal(await toPlainValue("string"), "string");
+    assert.deepEqual(await toPlainValue({ a: 1 }), { a: 1 });
+    assert.equal(
+      await toPlainValue(new TextEncoder().encode("bytes")),
+      "bytes"
+    );
+    // ArrayBuffer with non-printable characters should be returned as base64
+    assert.equal(await toPlainValue(new Uint8Array([1, 2, 3]).buffer), "AQID");
+    assert.equal(await toPlainValue(async () => "result"), "result");
+    assert.deepEqual(await toPlainValue(new User("Alice")), {
+      name: "Alice",
+    });
+  });
+});

package/test/utilities/toString.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import toString from "../../src/utilities/toString.js";
+
+describe("toString", () => {
+  test("returns the value of an object's `toString` method", () => {
+    const object = {
+      toString: () => "text",
+    };
+    assert.equal(toString(object), "text");
+  });
+
+  test("returns null for an object with no useful `toString`", () => {
+    const object = {};
+    assert.equal(toString(object), null);
+  });
+
+  test("decodes an ArrayBuffer as UTF-8", () => {
+    const arrayBuffer = new TextEncoder().encode("text").buffer;
+    assert.equal(toString(arrayBuffer), "text");
+  });
+});

package/src/Tree.d.ts

@@ -1,24 +0,0 @@
-import type { AsyncMutableTree, AsyncTree } from "@weborigami/types";
-import { PlainObject, ReduceFn, Treelike, TreeMapOptions, ValueKeyFn } from "../index.ts";
-
-export function assign(target: Treelike, source: Treelike): Promise<AsyncTree>;
-export function clear(AsyncTree: AsyncMutableTree): Promise<void>;
-export function entries(AsyncTree: AsyncTree): Promise<IterableIterator<any>>;
-export function forEach(AsyncTree: AsyncTree, callbackfn: (value: any, key: any) => Promise<void>): Promise<void>;
-export function from(obj: any, options?: { deep?: boolean, parent?: AsyncTree|null }): AsyncTree;
-export function has(AsyncTree: AsyncTree, key: any): Promise<boolean>;
-export function isAsyncMutableTree(obj: any): obj is AsyncMutableTree;
-export function isAsyncTree(obj: any): obj is AsyncTree;
-export function isTraversable(obj: any): boolean;
-export function isTreelike(obj: any): obj is Treelike;
-export function map(tree: Treelike, options: TreeMapOptions|ValueKeyFn): AsyncTree;
-export function mapReduce(tree: Treelike, mapFn: ValueKeyFn | null, reduceFn: ReduceFn): Promise<any>;
-export function paths(tree: Treelike, options?: { assumeSlashes?: boolean, base?: string }): string[];
-export function plain(tree: Treelike): Promise<PlainObject>;
-export function root(tree: Treelike): AsyncTree;
-export function remove(AsyncTree: AsyncMutableTree, key: any): Promise<boolean>;
-export function toFunction(tree: Treelike): Function;
-export function traverse(tree: Treelike, ...keys: any[]): Promise<any>;
-export function traverseOrThrow(tree: Treelike, ...keys: any[]): Promise<any>;
-export function traversePath(tree: Treelike, path: string): Promise<any>;
-export function values(tree: Treelike): Promise<IterableIterator<any>>;

package/src/utilities.d.ts

@@ -1,21 +0,0 @@
-import { AsyncTree } from "@weborigami/types";
-import { Packed, PlainObject, StringLike } from "../index.ts";
-
-export function assertIsTreelike(object: any, operation: string, position?: number): void;
-export function box(value: any): any;
-export function castArrayLike(keys: any[], values: any[]): any;
-export function getParent(object: any, options?: any): AsyncTree|null;
-export function getRealmObjectPrototype(object: any): any;
-export const hiddenFileNames: string[];
-export function isPacked(obj: any): obj is Packed;
-export function isPlainObject(obj: any): obj is PlainObject;
-export function isPrimitive(obj: any): boolean;
-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|null): void;
-export function toPlainValue(object: any): Promise<any>;
-export function toString(object: any): string;