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

package/main.js

@@ -5,6 +5,7 @@ export { default as FileTree } from "./src/FileTree.js";
 export { default as FunctionTree } from "./src/FunctionTree.js";
 export { default as MapTree } from "./src/MapTree.js";
 // Skip BrowserFileTree.js, which is browser-only.
+export { default as calendarTree } from "./src/calendarTree.js";
 export { default as DeepMapTree } from "./src/DeepMapTree.js";
 export { default as ExplorableSiteTree } from "./src/ExplorableSiteTree.js";
 export { DeepObjectTree, ObjectTree, Tree } from "./src/internal.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.71-beta.1",
+  "version": "0.0.71",
   "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.71-beta.1"
+    "@weborigami/types": "0.0.71"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/SiteTree.js

@@ -87,17 +87,15 @@ export default class SiteTree {
     const { type, subtype } = match.groups;
     if (type === "text") {
       return true;
-    } else if (type === "application") {
-      return (
-        subtype === "json" ||
-        subtype.endsWith("+json") ||
-        subtype.endsWith(".json") ||
-        subtype === "xml" ||
-        subtype.endsWith("+xml") ||
-        subtype.endsWith(".xml")
-      );
     }
-    return false;
+    return (
+      subtype === "json" ||
+      subtype.endsWith("+json") ||
+      subtype.endsWith(".json") ||
+      subtype === "xml" ||
+      subtype.endsWith("+xml") ||
+      subtype.endsWith(".xml")
+    );
   }
 
   get path() {

package/src/calendarTree.js

@@ -1,3 +1,5 @@
+import * as trailingSlash from "./trailingSlash.js";
+
 /**
  * Return a tree of years, months, and days from a start date to an end date.
  *
@@ -10,68 +12,163 @@
  *
  * 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
+ * @typedef {string|undefined} CalendarOptionsDate
+ * @typedef {( year: string, month: string, day: string ) => any} CalendarOptionsFn
+ * @param {{ end?: CalendarOptionsDate, start?: CalendarOptionsDate, value: CalendarOptionsFn }} options
  */
-export default function calendarTree(start, end) {
-  const startParts = start?.split("-") ?? [];
-  const endParts = end?.split("-") ?? [];
+export default function calendarTree(options) {
+  const start = dateParts(options.start);
+  const end = dateParts(options.end);
+  const valueFn = options.value;
 
+  // Fill in the missing parts of the start and end dates.
   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;
+  if (start.day === undefined) {
+    start.day = start.year ? 1 : today.getDate();
+  }
+  if (start.month === undefined) {
+    start.month = start.year ? 1 : today.getMonth() + 1;
+  }
+  if (start.year === undefined) {
+    start.year = today.getFullYear();
+  }
+
+  if (end.day === undefined) {
+    end.day = end.month
+      ? daysInMonth(end.year, end.month)
+      : end.year
+      ? 31 // Last day of December
+      : today.getDate();
+  }
+  if (end.month === undefined) {
+    end.month = end.year ? 12 : today.getMonth() + 1;
   }
+  if (end.year === undefined) {
+    end.year = today.getFullYear();
+  }
+
+  return yearsTree(start, end, valueFn);
+}
 
-  return years;
+function dateParts(date) {
+  let year;
+  let month;
+  let day;
+  if (typeof date === "string") {
+    const parts = date.split("-");
+    year = parts[0] ? parseInt(parts[0]) : undefined;
+    month = parts[1] ? parseInt(parts[1]) : undefined;
+    day = parts[2] ? parseInt(parts[2]) : undefined;
+  }
+  return { year, month, day };
+}
+
+function daysForMonthTree(year, month, start, end, valueFn) {
+  return {
+    async get(day) {
+      day = parseInt(trailingSlash.remove(day));
+      return this.inRange(day)
+        ? valueFn(year.toString(), twoDigits(month), twoDigits(day))
+        : undefined;
+    },
+
+    inRange(day) {
+      if (year === start.year && year === end.year) {
+        if (month === start.month && month === end.month) {
+          return day >= start.day && day <= end.day;
+        } else if (month === start.month) {
+          return day >= start.day;
+        } else if (month === end.month) {
+          return day <= end.day;
+        } else {
+          return true;
+        }
+      } else if (year === start.year) {
+        if (month === start.month) {
+          return day >= start.day;
+        } else {
+          return month > start.month;
+        }
+      } else if (year === end.year) {
+        if (month === end.month) {
+          return day <= end.day;
+        } else {
+          return month < end.month;
+        }
+      } else {
+        return true;
+      }
+    },
+
+    async keys() {
+      const days = Array.from(
+        { length: daysInMonth(year, month) },
+        (_, i) => i + 1
+      );
+      return days
+        .filter((day) => this.inRange(day))
+        .map((day) => twoDigits(day));
+    },
+  };
 }
 
 function daysInMonth(year, month) {
   return new Date(year, month, 0).getDate();
 }
+
+function monthsForYearTree(year, start, end, valueFn) {
+  return {
+    async get(month) {
+      month = parseInt(trailingSlash.remove(month));
+      return this.inRange(month)
+        ? daysForMonthTree(year, month, start, end, valueFn)
+        : undefined;
+    },
+
+    inRange(month) {
+      if (year === start.year && year === end.year) {
+        return month >= start.month && month <= end.month;
+      } else if (year === start.year) {
+        return month >= start.month;
+      } else if (year === end.year) {
+        return month <= end.month;
+      } else {
+        return true;
+      }
+    },
+
+    async keys() {
+      const months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+      return months
+        .filter((month) => this.inRange(month))
+        .map((month) => twoDigits(month));
+    },
+  };
+}
+
+function twoDigits(number) {
+  return number.toString().padStart(2, "0");
+}
+
+function yearsTree(start, end, valueFn) {
+  return {
+    async get(year) {
+      year = parseInt(trailingSlash.remove(year));
+      return this.inRange(year)
+        ? monthsForYearTree(year, start, end, valueFn)
+        : undefined;
+    },
+
+    inRange(year) {
+      return year >= start.year && year <= end.year;
+    },
+
+    async keys() {
+      return Array.from(
+        { length: end.year - start.year + 1 },
+        (_, i) => start.year + i
+      );
+    },
+  };
+}

package/test/calendarTree.test.js

@@ -5,7 +5,9 @@ import { toPlainValue } from "../src/utilities.js";
 
 describe("calendarTree", () => {
   test("without a start or end, returns a tree for today", async () => {
-    const tree = calendarTree();
+    const tree = calendarTree({
+      value: (year, month, day) => `${year}-${month}-${day}`,
+    });
     const plain = await toPlainValue(tree);
     const today = new Date();
     const year = today.getFullYear();
@@ -14,96 +16,104 @@ describe("calendarTree", () => {
     assert.deepEqual(plain, {
       [year]: {
         [month]: {
-          [day]: null,
+          [day]: `${year}-${month}-${day}`,
         },
       },
     });
   });
 
   test("returns a tree for a month range", async () => {
-    const tree = calendarTree("2025-01", "2025-02");
+    const tree = calendarTree({
+      start: "2025-01",
+      end: "2025-02",
+      value: (year, month, day) => `${year}-${month}-${day}`,
+    });
     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,
+          "01": "2025-01-01",
+          "02": "2025-01-02",
+          "03": "2025-01-03",
+          "04": "2025-01-04",
+          "05": "2025-01-05",
+          "06": "2025-01-06",
+          "07": "2025-01-07",
+          "08": "2025-01-08",
+          "09": "2025-01-09",
+          10: "2025-01-10",
+          11: "2025-01-11",
+          12: "2025-01-12",
+          13: "2025-01-13",
+          14: "2025-01-14",
+          15: "2025-01-15",
+          16: "2025-01-16",
+          17: "2025-01-17",
+          18: "2025-01-18",
+          19: "2025-01-19",
+          20: "2025-01-20",
+          21: "2025-01-21",
+          22: "2025-01-22",
+          23: "2025-01-23",
+          24: "2025-01-24",
+          25: "2025-01-25",
+          26: "2025-01-26",
+          27: "2025-01-27",
+          28: "2025-01-28",
+          29: "2025-01-29",
+          30: "2025-01-30",
+          31: "2025-01-31",
         },
         "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,
+          "01": "2025-02-01",
+          "02": "2025-02-02",
+          "03": "2025-02-03",
+          "04": "2025-02-04",
+          "05": "2025-02-05",
+          "06": "2025-02-06",
+          "07": "2025-02-07",
+          "08": "2025-02-08",
+          "09": "2025-02-09",
+          10: "2025-02-10",
+          11: "2025-02-11",
+          12: "2025-02-12",
+          13: "2025-02-13",
+          14: "2025-02-14",
+          15: "2025-02-15",
+          16: "2025-02-16",
+          17: "2025-02-17",
+          18: "2025-02-18",
+          19: "2025-02-19",
+          20: "2025-02-20",
+          21: "2025-02-21",
+          22: "2025-02-22",
+          23: "2025-02-23",
+          24: "2025-02-24",
+          25: "2025-02-25",
+          26: "2025-02-26",
+          27: "2025-02-27",
+          28: "2025-02-28",
         },
       },
     });
   });
 
   test("returns a tree for a day range", async () => {
-    const tree = calendarTree("2025-02-27", "2025-03-02");
+    const tree = calendarTree({
+      start: "2025-02-27",
+      end: "2025-03-02",
+      value: (year, month, day) => `${year}-${month}-${day}`,
+    });
     const plain = await toPlainValue(tree);
     assert.deepEqual(plain, {
       2025: {
         "02": {
-          27: null,
-          28: null,
+          27: "2025-02-27",
+          28: "2025-02-28",
         },
         "03": {
-          "01": null,
-          "02": null,
+          "01": "2025-03-01",
+          "02": "2025-03-02",
         },
       },
     });