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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.64-beta.2",
+  "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.2"
+    "@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/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/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 () => {