@adyen/adyen-platform-experience-web 0.1.2 → 1.0.0-beta

package/dist/es/components/internal/Calendar/calendar/timerange/presets/lastNDays.test.js

@@ -0,0 +1,69 @@
+import { getDateRangeContext, TIMEZONE_TESTS_TIMESTAMPS } from "./testing/fixtures.js";
+import { asTimestamp } from "./testing/helpers.js";
+import lastNDays, { DEFAULT_NUM_DAYS } from "./lastNDays.js";
+import { d as describe, t as test, g as globalExpect, v as vi } from "../../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("last {n} days", () => {
+  test("should use normalized (clamped) numberOfDays integer", () => {
+    const ABOVE_MAX_VALUES = [10240, 720, 366];
+    const BELOW_MIN_VALUES = [-5120, -256, -1, -0, 0];
+    const DECIMAL_VALUES = [-3564.456, -37.3671, -1.5, 0.4775, 23.5783, 38858.343];
+    const INVALID_VALUES = [NaN, Infinity, -Infinity, () => {
+    }, {}, [43]];
+    (/* @__PURE__ */ new Map([
+      [ABOVE_MAX_VALUES, DEFAULT_NUM_DAYS],
+      [BELOW_MIN_VALUES, DEFAULT_NUM_DAYS],
+      [DECIMAL_VALUES, DEFAULT_NUM_DAYS],
+      [INVALID_VALUES, DEFAULT_NUM_DAYS]
+    ])).forEach((numberOfDays2, values) => {
+      values.forEach((N) => {
+        globalExpect(getDateRangeContext(() => lastNDays(N)).numberOfDays).toBe(numberOfDays2);
+      });
+    });
+  });
+  const lastNDaysTimestamps = getDateRangeContext(lastNDays);
+  const numberOfDays = [
+    /* default */
+    void 0,
+    3,
+    7,
+    10,
+    25,
+    100
+  ];
+  test.each(numberOfDays)(`should be {N} days before now day (N => %i)`, (numberOfDaysParam) => {
+    lastNDaysTimestamps.numberOfDays = numberOfDaysParam;
+    const { numberOfDays: numberOfDays2, fromDate, now } = lastNDaysTimestamps;
+    const date = new Date(fromDate);
+    const withinLastNDays = vi.fn();
+    while (date.getTime() <= now) {
+      withinLastNDays();
+      date.setDate(date.getDate() + 1);
+    }
+    globalExpect(withinLastNDays).toHaveBeenCalledTimes(numberOfDays2);
+  });
+  test.each(numberOfDays)(`should have precise timestamps (N => %i)`, (numberOfDaysParam) => {
+    lastNDaysTimestamps.numberOfDays = numberOfDaysParam;
+    const { from, fromDate, now, to } = lastNDaysTimestamps;
+    const dateBefore = new Date(from - 1);
+    globalExpect(to).toBe(now);
+    globalExpect(dateBefore.getDay()).toBe((fromDate.getDay() + 6) % 7);
+  });
+  test("should have precise timestamps for timezone (N => 7)", () => {
+    const range = getDateRangeContext(() => lastNDays(7));
+    const { now: initialNow, timezone: initialTimezone } = range;
+    const TIMEZONES = /* @__PURE__ */ new Map([
+      ["America/Toronto", asTimestamp(["Apr 9, 2022, 12:00 AM GMT-4", "Dec 25, 2023, 12:00 AM GMT-5", "Dec 25, 2023, 12:00 AM GMT-5"])],
+      ["Asia/Tokyo", asTimestamp(["Apr 9, 2022, 12:00 AM GMT+9", "Dec 26, 2023, 12:00 AM GMT+9", "Dec 26, 2023, 12:00 AM GMT+9"])]
+    ]);
+    TIMEZONES.forEach((timestamps, timezone) => {
+      range.timezone = timezone;
+      TIMEZONE_TESTS_TIMESTAMPS.forEach((timestamp, index) => {
+        range.now = timestamp;
+        globalExpect(range.from).toBe(timestamps[index]);
+        globalExpect(range.to).toBe(timestamp);
+      });
+      range.now = initialNow;
+      range.timezone = initialTimezone;
+    });
+  });
+});

package/dist/es/components/internal/Calendar/calendar/timerange/presets/lastWeek.js

@@ -1,5 +1,5 @@
-import e from "./shared/offsetWeek.js";
-const t = e(1), s = t;
+import offsetWeek from "./shared/offsetWeek.js";
+const lastWeek = offsetWeek(1);
 export {
-  s as default
+  lastWeek as default
 };

package/dist/es/components/internal/Calendar/calendar/timerange/presets/lastWeek.test.js

@@ -0,0 +1,108 @@
+import { getDateRangeContext, TIMEZONE_TESTS_TIMESTAMPS } from "./testing/fixtures.js";
+import { asTimestamp } from "./testing/helpers.js";
+import lastWeek from "./lastWeek.js";
+import { d as describe, t as test, g as globalExpect, v as vi } from "../../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("last week", () => {
+  const lastWeekTimestamps = getDateRangeContext(lastWeek);
+  const firstWeekDays = [
+    /* default */
+    void 0,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6
+  ];
+  test.each(firstWeekDays)(`should be previous week (firstWeekDay => %i)`, (firstWeekDayParam) => {
+    lastWeekTimestamps.firstWeekDay = firstWeekDayParam;
+    const { firstWeekDay, fromDate, nowDate, to, toDate } = lastWeekTimestamps;
+    const fromMonth = fromDate.getMonth();
+    const fromYear = fromDate.getFullYear();
+    const nowMonth = nowDate.getMonth();
+    const nowYear = nowDate.getFullYear();
+    const toMonth = toDate.getMonth();
+    const toYear = toDate.getFullYear();
+    const dateOfToday = nowDate.getDate();
+    const firstDayOfLastWeek = fromDate.getDate();
+    const lastDayOfLastWeek = toDate.getDate();
+    globalExpect(fromDate.getDay()).toBe(firstWeekDay);
+    globalExpect(toDate.getDay()).toBe((firstWeekDay + 6) % 7);
+    if (firstDayOfLastWeek < dateOfToday) {
+      globalExpect(fromMonth).toBe(toMonth);
+      globalExpect(fromYear).toBe(toYear);
+      globalExpect(fromMonth).toBe(nowMonth);
+      globalExpect(fromYear).toBe(nowYear);
+    } else {
+      if (nowMonth === 0) {
+        globalExpect(fromMonth).toBe(11);
+        globalExpect(fromYear).toBe(nowYear - 1);
+      } else {
+        globalExpect(fromMonth).toBe(nowMonth - 1);
+        globalExpect(fromYear).toBe(nowYear);
+      }
+      if (lastDayOfLastWeek < dateOfToday) {
+        globalExpect(nowMonth).toBe(toMonth);
+        globalExpect(nowYear).toBe(toYear);
+      } else {
+        globalExpect(fromMonth).toBe(toMonth);
+        globalExpect(fromYear).toBe(toYear);
+      }
+    }
+    const date = new Date(fromDate);
+    const nowDateStartTimestamp = new Date(nowDate).setHours(0, 0, 0, 0);
+    const dayInLastWeek = vi.fn();
+    const daySinceLastWeek = vi.fn();
+    let timestamp = date.getTime();
+    while (timestamp < nowDateStartTimestamp) {
+      daySinceLastWeek();
+      if (timestamp < to)
+        dayInLastWeek();
+      timestamp = date.setDate(date.getDate() + 1);
+    }
+    globalExpect(dayInLastWeek).toHaveBeenCalledTimes(7);
+    globalExpect(daySinceLastWeek.mock.calls.length).toBeGreaterThanOrEqual(7);
+  });
+  test.each(firstWeekDays)(`should have precise timestamps (firstWeekDay => %i)`, (firstWeekDayParam) => {
+    lastWeekTimestamps.firstWeekDay = firstWeekDayParam;
+    const { firstWeekDay, from, to } = lastWeekTimestamps;
+    const dateAfter = new Date(to + 1);
+    const dateBefore = new Date(from - 1);
+    globalExpect(dateAfter.getDay()).toBe(firstWeekDay);
+    globalExpect(dateBefore.getDay()).toBe((firstWeekDay + 6) % 7);
+  });
+  test("should have precise timestamps for timezone (firstWeekDay => 1)", () => {
+    const range = getDateRangeContext(() => lastWeek(1));
+    const { now: initialNow, timezone: initialTimezone } = range;
+    const TIMEZONES = /* @__PURE__ */ new Map([
+      [
+        "America/Toronto",
+        [
+          asTimestamp(["Apr 4, 2022, 12:00 AM GMT-4", "Apr 10, 2022, 23:59:59.999 GMT-4"]),
+          asTimestamp(["Dec 18, 2023, 12:00 AM GMT-5", "Dec 24, 2023, 23:59:59.999 GMT-5"]),
+          asTimestamp(["Dec 18, 2023, 12:00 AM GMT-5", "Dec 24, 2023, 23:59:59.999 GMT-5"])
+        ]
+      ],
+      [
+        "Asia/Tokyo",
+        [
+          asTimestamp(["Apr 4, 2022, 12:00 AM GMT+9", "Apr 10, 2022, 23:59:59.999 GMT+9"]),
+          asTimestamp(["Dec 25, 2023, 12:00 AM GMT+9", "Dec 31, 2023, 23:59:59.999 GMT+9"]),
+          asTimestamp(["Dec 25, 2023, 12:00 AM GMT+9", "Dec 31, 2023, 23:59:59.999 GMT+9"])
+        ]
+      ]
+    ]);
+    TIMEZONES.forEach((timestamps, timezone) => {
+      range.timezone = timezone;
+      TIMEZONE_TESTS_TIMESTAMPS.forEach((timestamp, index) => {
+        const [fromTimestamp, toTimestamp] = timestamps[index];
+        range.now = timestamp;
+        globalExpect(range.from).toBe(fromTimestamp);
+        globalExpect(range.to).toBe(toTimestamp);
+      });
+      range.now = initialNow;
+      range.timezone = initialTimezone;
+    });
+  });
+});

package/dist/es/components/internal/Calendar/calendar/timerange/presets/shared/offsetMonth.js

@@ -1,18 +1,27 @@
-import { clamp as c } from "../../../../../../../utils/common/index.js";
-import i from "../../factory.js";
-import { startOfMonth as h, nowTimestamp as p } from "../../utils.js";
-const M = Object.freeze([0, 1, 0, 0, 0, 0, -1]), g = (f = 0) => {
-  const e = ~~c(0, f, 1 / 0) || 0;
-  return i({
-    from: ({ now: n, systemToTimezone: r, timezoneToSystem: m }) => {
-      const t = new Date(n), a = new Date(m(n)), o = t.getMonth() - a.getMonth();
-      let s = e;
-      return o && (s += o > 1 ? -1 : o < -1 ? 1 : o), h(t), t.setMonth(t.getMonth() - s), r(t);
+import { clamp } from "../../../../../../../utils/common/index.js";
+import createRangeTimestampsFactory from "../../factory.js";
+import { startOfMonth, nowTimestamp } from "../../utils.js";
+const ONE_MONTH_OFFSETS = Object.freeze([0, 1, 0, 0, 0, 0, -1]);
+const offsetMonth = (monthCount = 0) => {
+  const months = ~~clamp(0, monthCount, Infinity) || 0;
+  const restConfig = months ? { offsets: ONE_MONTH_OFFSETS } : { to: nowTimestamp };
+  return createRangeTimestampsFactory({
+    from: ({ now, systemToTimezone, timezoneToSystem }) => {
+      const date = new Date(now);
+      const restampedDate = new Date(timezoneToSystem(now));
+      const monthDiff = date.getMonth() - restampedDate.getMonth();
+      let monthOffset = months;
+      if (monthDiff) {
+        monthOffset += monthDiff > 1 ? -1 : monthDiff < -1 ? 1 : monthDiff;
+      }
+      startOfMonth(date);
+      date.setMonth(date.getMonth() - monthOffset);
+      return systemToTimezone(date);
     },
-    ...e ? { offsets: M } : { to: p }
+    ...restConfig
   });
-}, l = g;
+};
 export {
-  M as ONE_MONTH_OFFSETS,
-  l as default
+  ONE_MONTH_OFFSETS,
+  offsetMonth as default
 };

package/dist/es/components/internal/Calendar/calendar/timerange/presets/shared/offsetWeek.js

@@ -1,29 +1,37 @@
-import { clamp as p } from "../../../../../../../utils/common/index.js";
-import F from "../../factory.js";
-import { offsetsForNDays as W, startOfDay as d, startOfWeekOffset as k, getRangeTimestampsContextIntegerPropertyFactory as E, nowTimestamp as O } from "../../utils.js";
-const r = 1, T = W(7), _ = E(0, 6, r), u = (f = 0) => {
-  const s = ~~p(0, f, 1 / 0) || 0;
-  return (n = r) => {
-    const D = s ? { offsets: T } : { to: O }, o = _(n);
-    return F(
+import { clamp } from "../../../../../../../utils/common/index.js";
+import createRangeTimestampsFactory from "../../factory.js";
+import { offsetsForNDays, startOfDay, startOfWeekOffset, getRangeTimestampsContextIntegerPropertyFactory, nowTimestamp } from "../../utils.js";
+const DEFAULT_FIRST_WEEK_DAY = 1;
+const ONE_WEEK_OFFSETS = offsetsForNDays(7);
+const _getFirstWeekDayContext = getRangeTimestampsContextIntegerPropertyFactory(0, 6, DEFAULT_FIRST_WEEK_DAY);
+const offsetWeek = (weekCount = 0) => {
+  const weeks = ~~clamp(0, weekCount, Infinity) || 0;
+  return (firstWeekDay = DEFAULT_FIRST_WEEK_DAY) => {
+    const restConfig = weeks ? { offsets: ONE_WEEK_OFFSETS } : { to: nowTimestamp };
+    const firstWeekDayContext = _getFirstWeekDayContext(firstWeekDay);
+    return createRangeTimestampsFactory(
       {
-        from: ({ now: a, systemToTimezone: c, timezoneToSystem: i }) => {
-          const t = new Date(a), m = new Date(i(a)), e = t.getDay() - m.getDay();
-          if (d(t), e) {
-            const g = e > 1 ? -1 : e < -1 ? 1 : e;
-            t.setDate(t.getDate() - g);
+        from: ({ now, systemToTimezone, timezoneToSystem }) => {
+          const date = new Date(now);
+          const restampedDate = new Date(timezoneToSystem(now));
+          const dayDiff = date.getDay() - restampedDate.getDay();
+          startOfDay(date);
+          if (dayDiff) {
+            const dateDiff = dayDiff > 1 ? -1 : dayDiff < -1 ? 1 : dayDiff;
+            date.setDate(date.getDate() - dateDiff);
           }
-          const y = k(o.value, t.getDay()) - s * 7;
-          return t.setDate(t.getDate() + y), c(t);
+          const dateOffset = startOfWeekOffset(firstWeekDayContext.value, date.getDay()) - weeks * 7;
+          date.setDate(date.getDate() + dateOffset);
+          return systemToTimezone(date);
         },
-        ...D
+        ...restConfig
       },
-      { firstWeekDay: o.descriptor }
+      { firstWeekDay: firstWeekDayContext.descriptor }
     )();
   };
-}, w = u;
+};
 export {
-  r as DEFAULT_FIRST_WEEK_DAY,
-  T as ONE_WEEK_OFFSETS,
-  w as default
+  DEFAULT_FIRST_WEEK_DAY,
+  ONE_WEEK_OFFSETS,
+  offsetWeek as default
 };

package/dist/es/components/internal/Calendar/calendar/timerange/presets/testing/fixtures.js

@@ -0,0 +1,15 @@
+import { asTimestamp } from "./helpers.js";
+import { getter } from "../../utils.js";
+const getDateRangeContext = (factory) => {
+  const rangeContext = factory();
+  return Object.defineProperties(rangeContext, {
+    fromDate: getter(() => new Date(rangeContext.from)),
+    nowDate: getter(() => new Date(rangeContext.now)),
+    toDate: getter(() => new Date(rangeContext.to))
+  });
+};
+const TIMEZONE_TESTS_TIMESTAMPS = asTimestamp(["Apr 15, 2022, 1:30 PM GMT", "Dec 31, 2023, 5:30 PM GMT", "Jan 1, 2024, 3:30 AM GMT"]);
+export {
+  TIMEZONE_TESTS_TIMESTAMPS,
+  getDateRangeContext
+};

package/dist/es/components/internal/Calendar/calendar/timerange/presets/testing/helpers.js

@@ -0,0 +1,19 @@
+const asTimestamp = (dates) => dates.map((date) => new Date(date).getTime());
+const isLeapYear = (year) => (year % 100 ? year % 4 : year % 400) === 0;
+const getMonthDays = (month, year) => {
+  switch (month) {
+    case 3:
+    case 5:
+    case 8:
+    case 10:
+      return 30;
+    case 1:
+      return isLeapYear(year) ? 29 : 28;
+    default:
+      return 31;
+  }
+};
+export {
+  asTimestamp,
+  getMonthDays
+};

package/dist/es/components/internal/Calendar/calendar/timerange/presets/thisMonth.js

@@ -1,5 +1,5 @@
-import t from "./shared/offsetMonth.js";
-const o = t(0), h = o;
+import offsetMonth from "./shared/offsetMonth.js";
+const thisMonth = offsetMonth(0);
 export {
-  h as default
+  thisMonth as default
 };

package/dist/es/components/internal/Calendar/calendar/timerange/presets/thisMonth.test.js

@@ -0,0 +1,46 @@
+import { getDateRangeContext, TIMEZONE_TESTS_TIMESTAMPS } from "./testing/fixtures.js";
+import { asTimestamp } from "./testing/helpers.js";
+import thisMonth from "./thisMonth.js";
+import { d as describe, t as test, g as globalExpect } from "../../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("this month", () => {
+  test("should be current month", () => {
+    const { fromDate, nowDate, toDate } = getDateRangeContext(thisMonth);
+    const fromMonth = fromDate.getMonth();
+    const fromYear = fromDate.getFullYear();
+    const nowMonth = nowDate.getMonth();
+    const nowYear = nowDate.getFullYear();
+    const toMonth = toDate.getMonth();
+    const toYear = toDate.getFullYear();
+    globalExpect(fromYear).toBe(nowYear);
+    globalExpect(fromMonth).toBe(nowMonth);
+    globalExpect(fromYear).toBe(toYear);
+    globalExpect(fromMonth).toBe(toMonth);
+    globalExpect(fromDate.getDate()).toBe(1);
+    globalExpect(toDate.getDate()).toBe(nowDate.getDate());
+  });
+  test("should have precise timestamps", () => {
+    const { nowDate, from, now, to } = getDateRangeContext(thisMonth);
+    const nowMonth = nowDate.getMonth();
+    const monthBefore = new Date(from - 1).getMonth();
+    globalExpect(to).toBe(now);
+    nowMonth === 0 ? globalExpect(monthBefore).toBe(11) : globalExpect(monthBefore).toBe(nowMonth - 1);
+  });
+  test("should have precise timestamps for timezone", () => {
+    const range = getDateRangeContext(thisMonth);
+    const { now: initialNow, timezone: initialTimezone } = range;
+    const TIMEZONES = /* @__PURE__ */ new Map([
+      ["America/Toronto", asTimestamp(["Apr 1, 2022, 12:00 AM GMT-4", "Dec 1, 2023, 12:00 AM GMT-5", "Dec 1, 2023, 12:00 AM GMT-5"])],
+      ["Asia/Tokyo", asTimestamp(["Apr 1, 2022, 12:00 AM GMT+9", "Jan 1, 2024, 12:00 AM GMT+9", "Jan 1, 2024, 12:00 AM GMT+9"])]
+    ]);
+    TIMEZONES.forEach((fromTimestamps, timezone) => {
+      range.timezone = timezone;
+      TIMEZONE_TESTS_TIMESTAMPS.forEach((timestamp, index) => {
+        range.now = timestamp;
+        globalExpect(range.from).toBe(fromTimestamps[index]);
+        globalExpect(range.to).toBe(timestamp);
+      });
+      range.now = initialNow;
+      range.timezone = initialTimezone;
+    });
+  });
+});

package/dist/es/components/internal/Calendar/calendar/timerange/presets/thisWeek.js

@@ -1,5 +1,5 @@
-import e from "./shared/offsetWeek.js";
-const t = e(0), s = t;
+import offsetWeek from "./shared/offsetWeek.js";
+const thisWeek = offsetWeek(0);
 export {
-  s as default
+  thisWeek as default
 };

package/dist/es/components/internal/Calendar/calendar/timerange/presets/thisWeek.test.js

@@ -0,0 +1,85 @@
+import { getDateRangeContext, TIMEZONE_TESTS_TIMESTAMPS } from "./testing/fixtures.js";
+import { asTimestamp } from "./testing/helpers.js";
+import thisWeek from "./thisWeek.js";
+import { d as describe, t as test, g as globalExpect, v as vi } from "../../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("this week", () => {
+  const thisWeekTimestamps = getDateRangeContext(thisWeek);
+  const firstWeekDays = [
+    /* default */
+    void 0,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6
+  ];
+  test.each(firstWeekDays)(`should be this week (firstWeekDay => %i)`, (firstWeekDayParam) => {
+    thisWeekTimestamps.firstWeekDay = firstWeekDayParam;
+    const { firstWeekDay, fromDate, nowDate, to, toDate } = thisWeekTimestamps;
+    const fromMonth = fromDate.getMonth();
+    const fromYear = fromDate.getFullYear();
+    const nowMonth = nowDate.getMonth();
+    const nowYear = nowDate.getFullYear();
+    const toMonth = toDate.getMonth();
+    const toYear = toDate.getFullYear();
+    const dateOfToday = nowDate.getDate();
+    const firstDayOfThisWeek = fromDate.getDate();
+    globalExpect(fromDate.getDay()).toBe(firstWeekDay);
+    globalExpect(toDate.getDay()).toBe(nowDate.getDay());
+    if (firstDayOfThisWeek <= dateOfToday) {
+      globalExpect(fromMonth).toBe(toMonth);
+      globalExpect(fromYear).toBe(toYear);
+      globalExpect(fromMonth).toBe(nowMonth);
+      globalExpect(fromYear).toBe(nowYear);
+    } else {
+      if (nowMonth === 0) {
+        globalExpect(fromMonth).toBe(11);
+        globalExpect(fromYear).toBe(nowYear - 1);
+      } else {
+        globalExpect(fromMonth).toBe(nowMonth - 1);
+        globalExpect(fromYear).toBe(nowYear);
+      }
+    }
+    const date = new Date(fromDate);
+    const nowDateStartTimestamp = new Date(nowDate).setHours(0, 0, 0, 0);
+    const daysInWeek = (7 + (nowDate.getDay() - firstWeekDay) % 7) % 7;
+    const dayInThisWeek = vi.fn();
+    const daySinceThisWeek = vi.fn();
+    let timestamp = date.getTime();
+    while (timestamp < nowDateStartTimestamp) {
+      daySinceThisWeek();
+      if (timestamp < to)
+        dayInThisWeek();
+      timestamp = date.setDate(date.getDate() + 1);
+    }
+    globalExpect(dayInThisWeek).toHaveBeenCalledTimes(daysInWeek);
+    globalExpect(daySinceThisWeek.mock.calls.length).toBeGreaterThanOrEqual(daysInWeek);
+  });
+  test.each(firstWeekDays)(`should have precise timestamps (firstWeekDay => %i)`, (firstWeekDayParam) => {
+    thisWeekTimestamps.firstWeekDay = firstWeekDayParam;
+    const { firstWeekDay, from, now, to } = thisWeekTimestamps;
+    const dateBefore = new Date(from - 1);
+    globalExpect(to).toBe(now);
+    globalExpect(dateBefore.getDay()).toBe((firstWeekDay + 6) % 7);
+  });
+  test("should have precise timestamps for timezone (firstWeekDay => 1)", () => {
+    const range = getDateRangeContext(() => thisWeek(1));
+    const { now: initialNow, timezone: initialTimezone } = range;
+    const TIMEZONES = /* @__PURE__ */ new Map([
+      ["America/Toronto", asTimestamp(["Apr 11, 2022, 12:00 AM GMT-4", "Dec 25, 2023, 12:00 AM GMT-5", "Dec 25, 2023, 12:00 AM GMT-5"])],
+      ["Asia/Tokyo", asTimestamp(["Apr 11, 2022, 12:00 AM GMT+9", "Jan 1, 2024, 12:00 AM GMT+9", "Jan 1, 2024, 12:00 AM GMT+9"])]
+    ]);
+    TIMEZONES.forEach((timestamps, timezone) => {
+      range.timezone = timezone;
+      TIMEZONE_TESTS_TIMESTAMPS.forEach((timestamp, index) => {
+        range.now = timestamp;
+        globalExpect(range.from).toBe(timestamps[index]);
+        globalExpect(range.to).toBe(timestamp);
+      });
+      range.now = initialNow;
+      range.timezone = initialTimezone;
+    });
+  });
+});

package/dist/es/components/internal/Calendar/calendar/timerange/presets/yearToDate.js

@@ -1,12 +1,16 @@
-import m from "../factory.js";
-import { startOfYear as l, nowTimestamp as n } from "../utils.js";
-const c = m({
-  from: ({ now: t, systemToTimezone: a, timezoneToSystem: r }) => {
-    const e = new Date(t), o = new Date(r(t)), s = e.getFullYear() - o.getFullYear();
-    return l(e), e.setFullYear(e.getFullYear() - s), a(e);
+import createRangeTimestampsFactory from "../factory.js";
+import { startOfYear, nowTimestamp } from "../utils.js";
+const yearToDate = createRangeTimestampsFactory({
+  from: ({ now, systemToTimezone, timezoneToSystem }) => {
+    const date = new Date(now);
+    const restampedDate = new Date(timezoneToSystem(now));
+    const yearOffset = date.getFullYear() - restampedDate.getFullYear();
+    startOfYear(date);
+    date.setFullYear(date.getFullYear() - yearOffset);
+    return systemToTimezone(date);
   },
-  to: n
-}), u = c;
+  to: nowTimestamp
+});
 export {
-  u as default
+  yearToDate as default
 };

package/dist/es/components/internal/Calendar/calendar/timerange/presets/yearToDate.test.js

@@ -0,0 +1,49 @@
+import { getDateRangeContext, TIMEZONE_TESTS_TIMESTAMPS } from "./testing/fixtures.js";
+import { asTimestamp } from "./testing/helpers.js";
+import yearToDate from "./yearToDate.js";
+import { d as describe, t as test, g as globalExpect } from "../../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("year to date", () => {
+  test("should be current year", () => {
+    const { fromDate, nowDate, toDate } = getDateRangeContext(yearToDate);
+    const fromMonth = fromDate.getMonth();
+    const fromYear = fromDate.getFullYear();
+    const nowMonth = nowDate.getMonth();
+    const nowYear = nowDate.getFullYear();
+    const toMonth = toDate.getMonth();
+    const toYear = toDate.getFullYear();
+    globalExpect(fromYear).toBe(nowYear);
+    globalExpect(fromMonth).toBe(0);
+    globalExpect(toYear).toBe(nowYear);
+    globalExpect(toMonth).toBe(nowMonth);
+    globalExpect(fromDate.getDate()).toBe(1);
+    globalExpect(toDate.getDate()).toBe(nowDate.getDate());
+  });
+  test("should have precise timestamps", () => {
+    const { from, fromDate, now, to } = getDateRangeContext(yearToDate);
+    const dateBefore = new Date(from - 1);
+    const fromYear = fromDate.getFullYear();
+    const monthBefore = dateBefore.getMonth();
+    const yearBefore = dateBefore.getFullYear();
+    globalExpect(to).toBe(now);
+    globalExpect(monthBefore).toBe(11);
+    globalExpect(yearBefore).toBe(fromYear - 1);
+  });
+  test("should have precise timestamps for timezone", () => {
+    const range = getDateRangeContext(yearToDate);
+    const { now: initialNow, timezone: initialTimezone } = range;
+    const TIMEZONES = /* @__PURE__ */ new Map([
+      ["America/Toronto", asTimestamp(["Jan 1, 2022, 12:00 AM GMT-5", "Jan 1, 2023, 12:00 AM GMT-5", "Jan 1, 2023, 12:00 AM GMT-5"])],
+      ["Asia/Tokyo", asTimestamp(["Jan 1, 2022, 12:00 AM GMT+9", "Jan 1, 2024, 12:00 AM GMT+9", "Jan 1, 2024, 12:00 AM GMT+9"])]
+    ]);
+    TIMEZONES.forEach((fromTimestamps, timezone) => {
+      range.timezone = timezone;
+      TIMEZONE_TESTS_TIMESTAMPS.forEach((timestamp, index) => {
+        range.now = timestamp;
+        globalExpect(range.from).toBe(fromTimestamps[index]);
+        globalExpect(range.to).toBe(timestamp);
+      });
+      range.now = initialNow;
+      range.timezone = initialTimezone;
+    });
+  });
+});