@weborigami/async-tree 0.0.64-beta.1 → 0.0.64

package/index.ts

@@ -25,7 +25,7 @@ export type PlainObject = {
   [key: string]: any;
 };
 
-export type ReduceFn = (values: any[], keys: any[]) => Promise<any>;
+export type ReduceFn = (values: any[], keys: any[], tree: AsyncTree) => Promise<any>;
 
 export type StringLike = string | HasString;
 

package/package.json

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

package/src/FunctionTree.js

@@ -27,11 +27,11 @@ export default class FunctionTree {
       this.fn.length <= 1
         ? // Function takes no arguments, one argument, or a variable number of
           // arguments: invoke it.
-          await this.fn.call(null, key)
+          await this.fn.call(this.parent, key)
         : // Bind the key to the first parameter. Subsequent get calls will
           // eventually bind all parameters until only one remains. At that point,
           // the above condition will apply and the function will be invoked.
-          Reflect.construct(this.constructor, [this.fn.bind(null, key)]);
+          Reflect.construct(this.constructor, [this.fn.bind(this.parent, key)]);
     setParent(value, this);
     return value;
   }

package/src/Tree.d.ts

@@ -14,7 +14,7 @@ export function isTraversable(obj: any): boolean;
 export function isTreelike(obj: any): obj is Treelike;
 export function map(tree: Treelike, valueFn: ValueKeyFn): AsyncTree;
 export function mapReduce(tree: Treelike, mapFn: ValueKeyFn | null, reduceFn: ReduceFn): Promise<any>;
-export function paths(tree: Treelike, base: string): string[];
+export function paths(tree: Treelike, base?: string): string[];
 export function plain(tree: Treelike): Promise<PlainObject>;
 export function remove(AsyncTree: AsyncMutableTree, key: any): Promise<boolean>;
 export function toFunction(tree: Treelike): Function;

package/src/Tree.js

@@ -166,7 +166,14 @@ export async function has(tree, key) {
  * @returns {obj is AsyncTree}
  */
 export function isAsyncTree(obj) {
-  return obj && typeof obj.get === "function" && typeof obj.keys === "function";
+  return (
+    obj &&
+    typeof obj.get === "function" &&
+    typeof obj.keys === "function" &&
+    // JavaScript Map look like trees but can't be extended the same way, so we
+    // report false.
+    !(obj instanceof Map)
+  );
 }
 
 /**
@@ -231,8 +238,9 @@ export function isTraversable(object) {
 export function isTreelike(obj) {
   return (
     isAsyncTree(obj) ||
-    obj instanceof Function ||
     obj instanceof Array ||
+    obj instanceof Function ||
+    obj instanceof Map ||
     obj instanceof Set ||
     isPlainObject(obj)
   );
@@ -286,14 +294,14 @@ export async function mapReduce(treelike, valueFn, reduceFn) {
   const values = await Promise.all(promises);
 
   // Reduce the values to a single result.
-  return reduceFn(values, keys);
+  return reduceFn(values, keys, tree);
 }
 
 /**
  * Returns slash-separated paths for all values in the tree.
  *
  * @param {Treelike} treelike
- * @param {string} base
+ * @param {string?} base
  */
 export async function paths(treelike, base = "") {
   const tree = from(treelike);
@@ -310,6 +318,7 @@ export async function paths(treelike, base = "") {
   }
   return result;
 }
+
 /**
  * Converts an asynchronous tree into a synchronous plain JavaScript object.
  *
@@ -320,7 +329,11 @@ export async function paths(treelike, base = "") {
  * @returns {Promise<PlainObject|Array>}
  */
 export async function plain(treelike) {
-  return mapReduce(treelike, null, (values, keys) => {
+  return mapReduce(treelike, null, (values, keys, tree) => {
+    // Special case for an empty tree: if based on array, return array.
+    if (tree instanceof ObjectTree && keys.length === 0) {
+      return tree.object instanceof Array ? [] : {};
+    }
     const object = {};
     for (let i = 0; i < keys.length; i++) {
       object[keys[i]] = values[i];

package/src/calendarTree.js

@@ -0,0 +1,77 @@
+/**
+ * Return a tree of years, months, and days from a start date to an end date.
+ *
+ * Both the start and end date can be provided in "YYYY-MM-DD", "YYYY-MM", or
+ * "YYYY" format. If a start year is provided, but a month is not, then the
+ * first month of the year will be used; if a start month is provided, but a day
+ * is not, then the first day of that month will be used. Similar logic applies
+ * to the end date, using the last month of the year or the last day of the
+ * month.
+ *
+ * If a start date is omitted, today will be used, likewise for the end date.
+ *
+ * @param {string} [start] - Start date in "YYYY-MM-DD", "YYYY-MM", or "YYYY"
+ * format
+ * @param {string} [end] - End date in "YYYY-MM-DD", "YYYY-MM", or "YYYY" format
+ */
+export default function calendarTree(start, end) {
+  const startParts = start?.split("-") ?? [];
+  const endParts = end?.split("-") ?? [];
+
+  const today = new Date();
+
+  const startYear = startParts[0]
+    ? parseInt(startParts[0])
+    : today.getFullYear();
+  const startMonth = startParts[1]
+    ? parseInt(startParts[1])
+    : startParts[0]
+    ? 1
+    : today.getMonth() + 1;
+  const startDay = startParts[2]
+    ? parseInt(startParts[2])
+    : startParts[1]
+    ? 1
+    : today.getDate();
+
+  const endYear = endParts[0] ? parseInt(endParts[0]) : today.getFullYear();
+  const endMonth = endParts[1]
+    ? parseInt(endParts[1])
+    : endParts[0]
+    ? 12
+    : today.getMonth() + 1;
+  const endDay = endParts[2]
+    ? parseInt(endParts[2])
+    : endParts[1]
+    ? daysInMonth(endYear, endMonth)
+    : today.getDate();
+
+  let years = {};
+  for (let year = startYear; year <= endYear; year++) {
+    let months = new Map();
+    const firstMonth = year === startYear ? startMonth : 1;
+    const lastMonth = year === endYear ? endMonth : 12;
+    for (let month = firstMonth; month <= lastMonth; month++) {
+      const monthPadded = month.toString().padStart(2, "0");
+      let days = new Map();
+      const firstDay =
+        year === startYear && month === startMonth ? startDay : 1;
+      const lastDay =
+        year === endYear && month === endMonth
+          ? endDay
+          : daysInMonth(year, month);
+      for (let day = firstDay; day <= lastDay; day++) {
+        const dayPadded = day.toString().padStart(2, "0");
+        days.set(dayPadded, null);
+      }
+      months.set(monthPadded, days);
+    }
+    years[year] = months;
+  }
+
+  return years;
+}
+
+function daysInMonth(year, month) {
+  return new Date(year, month, 0).getDate();
+}

package/src/operations/cache.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, Tree } from "../internal.js";
+import { ObjectTree, Tree } from "../internal.js";
 
 /**
  * Caches values from a source tree in a second cache tree. Cache source tree
@@ -14,16 +14,30 @@ import { DeepObjectTree, Tree } from "../internal.js";
  * @typedef {import("../../index.ts").Treelike} Treelike
  *
  * @param {Treelike} sourceTreelike
- * @param {AsyncMutableTree} [cacheTree]
+ * @param {AsyncMutableTree} [cacheTreelike]
  * @param {Treelike} [filterTreelike]
  * @returns {AsyncTree & { description: string }}
  */
-export default function treeCache(sourceTreelike, cacheTree, filterTreelike) {
+export default function treeCache(
+  sourceTreelike,
+  cacheTreelike,
+  filterTreelike
+) {
   const source = Tree.from(sourceTreelike);
   const filter = filterTreelike ? Tree.from(filterTreelike) : undefined;
 
   /** @type {AsyncMutableTree} */
-  const cache = cacheTree ?? new DeepObjectTree({});
+  let cache;
+  if (cacheTreelike) {
+    // @ts-ignore
+    cache = Tree.from(cacheTreelike);
+    if (!Tree.isAsyncMutableTree(cache)) {
+      throw new Error("Cache tree must define a set() method.");
+    }
+  } else {
+    cache = new ObjectTree({});
+  }
+
   let keys;
   return {
     description: "cache",
@@ -47,8 +61,9 @@ export default function treeCache(sourceTreelike, cacheTree, filterTreelike) {
             // Construct merged tree for a tree result.
             if (cacheValue === undefined) {
               // Construct new container in cache
-              await cache.set(key, {});
-              cacheValue = await cache.get(key);
+              cacheValue = new ObjectTree({});
+              cacheValue.parent = this;
+              await cache.set(key, cacheValue);
             }
             value = treeCache(value, cacheValue, filterValue);
           } else {

package/test/MapTree.test.js

@@ -1,6 +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";
 
 describe("MapTree", () => {
   test("can get the keys of the tree", async () => {
@@ -18,7 +19,7 @@ describe("MapTree", () => {
     const map = new Map([["more", new Map([["a", 1]])]]);
     const fixture = new MapTree(map);
     const more = await fixture.get("more");
-    assert.equal(more.parent, fixture);
+    assert.equal(more[symbols.parent], fixture);
   });
 
   test("getting an unsupported key returns undefined", async () => {

package/test/Tree.test.js

@@ -261,6 +261,13 @@ describe("Tree", () => {
     assert.deepEqual(plain, original);
   });
 
+  test("plain() returns empty array or object for ObjectTree as necessary", async () => {
+    const tree = new ObjectTree({});
+    assert.deepEqual(await Tree.plain(tree), {});
+    const arrayTree = new ObjectTree([]);
+    assert.deepEqual(await Tree.plain(arrayTree), []);
+  });
+
   test("plain() awaits async properties", async () => {
     const object = {
       get name() {

package/test/calendarTree.test.js

@@ -0,0 +1,111 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { toPlainValue } from "../main.js";
+import calendarTree from "../src/calendarTree.js";
+
+describe("calendarTree", () => {
+  test("without a start or end, returns a tree for today", async () => {
+    const tree = calendarTree();
+    const plain = await toPlainValue(tree);
+    const today = new Date();
+    const year = today.getFullYear();
+    const month = (today.getMonth() + 1).toString().padStart(2, "0");
+    const day = today.getDate().toString().padStart(2, "0");
+    assert.deepEqual(plain, {
+      [year]: {
+        [month]: {
+          [day]: null,
+        },
+      },
+    });
+  });
+
+  test("returns a tree for a month range", async () => {
+    const tree = calendarTree("2025-01", "2025-02");
+    const plain = await toPlainValue(tree);
+    assert.deepEqual(plain, {
+      2025: {
+        "01": {
+          "01": null,
+          "02": null,
+          "03": null,
+          "04": null,
+          "05": null,
+          "06": null,
+          "07": null,
+          "08": null,
+          "09": null,
+          10: null,
+          11: null,
+          12: null,
+          13: null,
+          14: null,
+          15: null,
+          16: null,
+          17: null,
+          18: null,
+          19: null,
+          20: null,
+          21: null,
+          22: null,
+          23: null,
+          24: null,
+          25: null,
+          26: null,
+          27: null,
+          28: null,
+          29: null,
+          30: null,
+          31: null,
+        },
+        "02": {
+          "01": null,
+          "02": null,
+          "03": null,
+          "04": null,
+          "05": null,
+          "06": null,
+          "07": null,
+          "08": null,
+          "09": null,
+          10: null,
+          11: null,
+          12: null,
+          13: null,
+          14: null,
+          15: null,
+          16: null,
+          17: null,
+          18: null,
+          19: null,
+          20: null,
+          21: null,
+          22: null,
+          23: null,
+          24: null,
+          25: null,
+          26: null,
+          27: null,
+          28: null,
+        },
+      },
+    });
+  });
+
+  test("returns a tree for a day range", async () => {
+    const tree = calendarTree("2025-02-27", "2025-03-02");
+    const plain = await toPlainValue(tree);
+    assert.deepEqual(plain, {
+      2025: {
+        "02": {
+          27: null,
+          28: null,
+        },
+        "03": {
+          "01": null,
+          "02": null,
+        },
+      },
+    });
+  });
+});

package/test/operations/cache.test.js

@@ -1,13 +1,13 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { ObjectTree, Tree } from "../../src/internal.js";
+import { DeepObjectTree, ObjectTree, Tree } from "../../src/internal.js";
 import cache from "../../src/operations/cache.js";
 
 describe("cache", () => {
   test("caches reads of values from one tree into another", async () => {
     const objectCache = new ObjectTree({});
     const fixture = cache(
-      Tree.from({
+      new DeepObjectTree({
         a: 1,
         b: 2,
         c: 3,
@@ -18,7 +18,7 @@ describe("cache", () => {
       objectCache
     );
 
-    const keys = Array.from(await fixture.keys());
+    const keys = [...(await fixture.keys())];
     assert.deepEqual(keys, ["a", "b", "c", "more"]);
 
     assert.equal(await objectCache.get("a"), undefined);
@@ -28,6 +28,13 @@ describe("cache", () => {
     assert.equal(await objectCache.get("b"), undefined);
     assert.equal(await fixture.get("b"), 2);
     assert.equal(await objectCache.get("b"), 2);
+
+    assert.equal(await objectCache.get("more"), undefined);
+    const more = await fixture.get("more");
+    assert.deepEqual([...(await more.keys())], ["d"]);
+    assert.equal(await more.get("d"), 4);
+    const moreCache = await objectCache.get("more");
+    assert.equal(await moreCache.get("d"), 4);
   });
 
   test("if a cache filter is supplied, it only caches values whose keys match the filter", async () => {