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

package/dist/es/components/internal/Calendar/calendar/timeframe/frames/YearFrame.js

@@ -0,0 +1,197 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _currentDayTimestamp, _fromTimestamp, _toTimestamp, _numberOfBlocks, _selectionFromTimestamp, _selectionToTimestamp, _lineWidth, _getBlockTimestampOffsetFromOrigin, getBlockTimestampOffsetFromOrigin_fn, _getStartForTimestamp, getStartForTimestamp_fn, _updateSelectionTimestamps, updateSelectionTimestamps_fn;
+import TimeFrame from "./TimeFrame.js";
+import { computeTimestampOffset, getEdgesDistance } from "../../utils.js";
+import { YEAR_MONTHS } from "../../constants.js";
+import { isInfinite, struct, isBitSafeInteger, structFrom } from "../../../../../../utils/common/index.js";
+import { T as TimeFlag } from "../../../../../../../flags-41c36e13.mjs";
+import { isString } from "../../../../../../utils/validator-utils.js";
+import { immutableProxyHandlers } from "../../../../../../utils/common/constants.js";
+class YearFrame extends TimeFrame {
+  constructor() {
+    super();
+    __privateAdd(this, _getBlockTimestampOffsetFromOrigin);
+    __privateAdd(this, _getStartForTimestamp);
+    __privateAdd(this, _updateSelectionTimestamps);
+    __privateAdd(this, _currentDayTimestamp, void 0);
+    __privateAdd(this, _fromTimestamp, -Infinity);
+    __privateAdd(this, _toTimestamp, Infinity);
+    __privateAdd(this, _numberOfBlocks, Infinity);
+    __privateAdd(this, _selectionFromTimestamp, void 0);
+    __privateAdd(this, _selectionToTimestamp, void 0);
+    __privateAdd(this, _lineWidth, 4);
+    this.initialize();
+  }
+  get fromTimestamp() {
+    return __privateGet(this, _fromTimestamp);
+  }
+  get toTimestamp() {
+    return __privateGet(this, _toTimestamp);
+  }
+  get numberOfBlocks() {
+    return __privateGet(this, _numberOfBlocks);
+  }
+  get currentDayTimestamp() {
+    return __privateGet(this, _currentDayTimestamp);
+  }
+  get rowspan() {
+    return __privateGet(this, _lineWidth);
+  }
+  getCursorBlockOriginTimestampOffset(timestamp) {
+    return new Date(timestamp).getMonth();
+  }
+  getDayOfWeekAtIndex() {
+    return void 0;
+  }
+  getEdgeBlockOffsetsFromOrigin() {
+    return [__privateMethod(this, _getBlockTimestampOffsetFromOrigin, getBlockTimestampOffsetFromOrigin_fn).call(this, __privateGet(this, _fromTimestamp)), __privateMethod(this, _getBlockTimestampOffsetFromOrigin, getBlockTimestampOffsetFromOrigin_fn).call(this, __privateGet(this, _toTimestamp))];
+  }
+  getFormattedDataForBlockCell(time) {
+    const date = new Date(time);
+    return [date.toLocaleDateString(this.locale, { month: "short" }), date.toISOString().slice(0, 7)];
+  }
+  getFormattedDataForFrameBlock(time) {
+    const date = new Date(time);
+    return [date.toLocaleDateString(this.locale, { year: "numeric" }), date.toISOString().slice(0, 7)];
+  }
+  getFrameBlockAtIndex(index) {
+    const startIndex = index * YEAR_MONTHS;
+    const endIndex = startIndex + YEAR_MONTHS - 1;
+    const numberOfUnits = endIndex - startIndex + 1;
+    const sharedStruct = struct({
+      from: { value: startIndex },
+      to: { value: endIndex },
+      units: { value: numberOfUnits }
+    });
+    const proxyForIndexPropertyAccess = new Proxy(struct(), {
+      ...immutableProxyHandlers,
+      get: (target, property, receiver) => {
+        if (isString(property)) {
+          const offset = +property;
+          if (isBitSafeInteger(offset) && offset >= 0 && offset < numberOfUnits) {
+            const index2 = startIndex + offset;
+            const timestamp = this.getTimestampAtIndex(index2);
+            const lineIndex = index2 % __privateGet(this, _lineWidth);
+            let flags = TimeFlag.WITHIN_BLOCK;
+            if (index2 === startIndex)
+              flags |= TimeFlag.BLOCK_START;
+            else if (index2 === endIndex)
+              flags |= TimeFlag.BLOCK_END;
+            if (lineIndex === 0)
+              flags |= TimeFlag.LINE_START;
+            else if (lineIndex === __privateGet(this, _lineWidth) - 1)
+              flags |= TimeFlag.LINE_END;
+            if (index2 === this.cursor)
+              flags |= TimeFlag.CURSOR;
+            if (timestamp === this.currentDayTimestamp)
+              flags |= TimeFlag.CURRENT;
+            if (timestamp >= this.fromTimestamp && timestamp <= this.toTimestamp) {
+              if (timestamp === this.fromTimestamp)
+                flags |= TimeFlag.RANGE_START;
+              if (timestamp === this.toTimestamp)
+                flags |= TimeFlag.RANGE_END;
+              flags |= TimeFlag.WITHIN_RANGE;
+            }
+            if (timestamp >= __privateGet(this, _selectionFromTimestamp) && timestamp <= __privateGet(this, _selectionToTimestamp)) {
+              if (timestamp === __privateGet(this, _selectionFromTimestamp))
+                flags |= TimeFlag.SELECTION_START;
+              if (timestamp === __privateGet(this, _selectionToTimestamp))
+                flags |= TimeFlag.SELECTION_END;
+              flags |= TimeFlag.WITHIN_SELECTION;
+            }
+            return [timestamp, flags];
+          }
+        }
+        return Reflect.get(target, property, receiver);
+      }
+    });
+    return structFrom(proxyForIndexPropertyAccess, {
+      inner: { value: sharedStruct },
+      month: { value: 0 },
+      outer: { value: sharedStruct },
+      year: { value: this.origin + index }
+    });
+  }
+  getUnitsForFrameBlockAtIndex() {
+    return YEAR_MONTHS;
+  }
+  getUnitsOffsetForTimestamp(startTimestamp, timestamp) {
+    const offset = getEdgesDistance(startTimestamp, timestamp);
+    return timestamp < startTimestamp ? 0 - offset : offset;
+  }
+  reoriginate() {
+    const date = new Date(this.originTimestamp);
+    this.origin = date.getFullYear();
+    this.originTimestamp = date.setMonth(0, 1);
+  }
+  reslice() {
+    __privateMethod(this, _updateSelectionTimestamps, updateSelectionTimestamps_fn).call(this);
+    __privateSet(this, _fromTimestamp, __privateMethod(this, _getStartForTimestamp, getStartForTimestamp_fn).call(this, super.fromTimestamp));
+    __privateSet(this, _toTimestamp, __privateMethod(this, _getStartForTimestamp, getStartForTimestamp_fn).call(this, super.toTimestamp));
+    __privateSet(this, _numberOfBlocks, isInfinite(super.numberOfBlocks) ? super.numberOfBlocks : Math.ceil((new Date(super.fromTimestamp).getMonth() + super.numberOfBlocks) / YEAR_MONTHS));
+  }
+  shiftOrigin(offset) {
+    this.originTimestamp = new Date(this.originTimestamp).setFullYear(this.origin + offset);
+    this.reoriginate();
+  }
+  clearSelection() {
+    super.clearSelection();
+    __privateMethod(this, _updateSelectionTimestamps, updateSelectionTimestamps_fn).call(this);
+    this.refreshFrame(true);
+  }
+  getTimestampAtIndex(indexOffset) {
+    return new Date(this.originTimestamp).setMonth(indexOffset);
+  }
+  updateSelection(time, selection) {
+    super.updateSelection(time, selection);
+    __privateMethod(this, _updateSelectionTimestamps, updateSelectionTimestamps_fn).call(this);
+    this.refreshFrame(true);
+  }
+  withCurrentDayTimestamp(timestamp) {
+    __privateSet(this, _currentDayTimestamp, __privateMethod(this, _getStartForTimestamp, getStartForTimestamp_fn).call(this, timestamp));
+  }
+}
+_currentDayTimestamp = new WeakMap();
+_fromTimestamp = new WeakMap();
+_toTimestamp = new WeakMap();
+_numberOfBlocks = new WeakMap();
+_selectionFromTimestamp = new WeakMap();
+_selectionToTimestamp = new WeakMap();
+_lineWidth = new WeakMap();
+_getBlockTimestampOffsetFromOrigin = new WeakSet();
+getBlockTimestampOffsetFromOrigin_fn = function(timestamp) {
+  return isInfinite(timestamp) ? timestamp : new Date(timestamp).getFullYear() - this.origin;
+};
+_getStartForTimestamp = new WeakSet();
+getStartForTimestamp_fn = function(timestamp) {
+  return timestamp === void 0 || isInfinite(timestamp) ? timestamp : new Date(timestamp - computeTimestampOffset(timestamp)).setDate(1);
+};
+_updateSelectionTimestamps = new WeakSet();
+updateSelectionTimestamps_fn = function() {
+  __privateSet(this, _selectionFromTimestamp, __privateMethod(this, _getStartForTimestamp, getStartForTimestamp_fn).call(this, this.selectionStart));
+  __privateSet(this, _selectionToTimestamp, __privateMethod(this, _getStartForTimestamp, getStartForTimestamp_fn).call(this, this.selectionEnd));
+};
+export {
+  YearFrame as default
+};

package/dist/es/components/internal/Calendar/calendar/timeframe/index.js

@@ -0,0 +1,8 @@
+import { default as default2 } from "./frames/MonthFrame.js";
+import { default as default3 } from "./frames/TimeFrame.js";
+import { default as default4 } from "./frames/YearFrame.js";
+export {
+  default2 as MonthFrame,
+  default3 as TimeFrame,
+  default4 as YearFrame
+};

package/dist/es/components/internal/Calendar/calendar/timerange/factory.js

@@ -1,49 +1,72 @@
-import { struct as d } from "../../../../../utils/common/index.js";
-import { asPlainObject as R, createRangeTimestampsConfigRestampingContext as W, getter as c, parseRangeTimestamp as a, isRangeTimestampsConfigWithoutOffsets as Y, isRangeTimestampsConfigWithFromOffsets as b, getRangeTimestampsConfigParameterUnwrapper as E } from "./utils.js";
-import H from "../../../../../core/Localization/datetime/restamper/restamper.js";
-import { EMPTY_OBJECT as u } from "../../../../../utils/common/constants.js";
-const j = (C = u, D = u) => {
-  const s = R(C), h = R(D);
+import { struct } from "../../../../../utils/common/index.js";
+import restamper from "../../../../../core/Localization/datetime/restamper/restamper.js";
+import "../../../../../core/Localization/datetime/restamper/constants.js";
+import { asPlainObject, createRangeTimestampsConfigRestampingContext, getter, parseRangeTimestamp, isRangeTimestampsConfigWithoutOffsets, isRangeTimestampsConfigWithFromOffsets, getRangeTimestampsConfigParameterUnwrapper } from "./utils.js";
+import { EMPTY_OBJECT } from "../../../../../utils/common/constants.js";
+const createRangeTimestampsFactory = (config = EMPTY_OBJECT, additionalContext = EMPTY_OBJECT) => {
+  const _config = asPlainObject(config);
+  const _additionalContext = asPlainObject(additionalContext);
   return () => {
-    const m = H(), l = c(() => o), T = c(() => m.tz.current), f = d({
-      now: l,
-      timezone: T,
-      ...W(m)
-    }), i = E(s, f);
-    let { from: n, to: r, now: o } = u;
-    const g = (p) => {
-      o = a(p ?? Date.now()) ?? o;
-      t: {
-        if (Y(s)) {
-          n = a(i(s.from)) ?? o, r = a(i(s.to)) ?? o;
-          break t;
+    const _restamper = restamper();
+    const nowDescriptor = getter(() => NOW);
+    const tzDescriptor = getter(() => _restamper.tz.current);
+    const configContext = struct({
+      now: nowDescriptor,
+      timezone: tzDescriptor,
+      ...createRangeTimestampsConfigRestampingContext(_restamper)
+    });
+    const unwrap = getRangeTimestampsConfigParameterUnwrapper(_config, configContext);
+    let { from, to, now: NOW } = EMPTY_OBJECT;
+    const nowSetter = (timestamp) => {
+      NOW = parseRangeTimestamp(timestamp ?? Date.now()) ?? NOW;
+      parsing: {
+        if (isRangeTimestampsConfigWithoutOffsets(_config)) {
+          from = parseRangeTimestamp(unwrap(_config.from)) ?? NOW;
+          to = parseRangeTimestamp(unwrap(_config.to)) ?? NOW;
+          break parsing;
+        }
+        let date;
+        let direction;
+        let withRangeFrom;
+        if (withRangeFrom = isRangeTimestampsConfigWithFromOffsets(_config)) {
+          date = new Date(from = parseRangeTimestamp(unwrap(_config.from)) ?? NOW);
+          direction = 1;
+        } else {
+          date = new Date(to = parseRangeTimestamp(unwrap(_config.to)) ?? NOW);
+          direction = -1;
         }
-        let t, e, w;
-        (w = b(s)) ? (t = new Date(n = a(i(s.from)) ?? o), e = 1) : (t = new Date(r = a(i(s.to)) ?? o), e = -1), t = new Date(f.timezoneToSystem(t));
-        const [F = 0, O = 0, x = 0, M = 0, S = 0, _ = 0, P = 0] = i(s.offsets);
-        t.setFullYear(t.getFullYear() + F * e, t.getMonth() + O * e, t.getDate() + x * e), t.setHours(
-          t.getHours() + M * e,
-          t.getMinutes() + S * e,
-          t.getSeconds() + _ * e,
-          t.getMilliseconds() + P * e
+        date = new Date(configContext.timezoneToSystem(date));
+        const [years = 0, months = 0, days = 0, hours = 0, minutes = 0, seconds = 0, ms = 0] = unwrap(_config.offsets);
+        date.setFullYear(date.getFullYear() + years * direction, date.getMonth() + months * direction, date.getDate() + days * direction);
+        date.setHours(
+          date.getHours() + hours * direction,
+          date.getMinutes() + minutes * direction,
+          date.getSeconds() + seconds * direction,
+          date.getMilliseconds() + ms * direction
         );
-        const z = a(f.systemToTimezone(t)) ?? o;
-        w ? r = z : n = z;
+        const timestamp2 = parseRangeTimestamp(configContext.systemToTimezone(date)) ?? NOW;
+        withRangeFrom ? to = timestamp2 : from = timestamp2;
       }
-      n > r && ([n, r] = [r, n]);
-    }, y = (p) => {
-      const t = m.tz, e = t.current;
-      m.tz = p, t.current !== e && g(o);
+      if (from > to)
+        [from, to] = [to, from];
     };
-    return g(), d({
-      ...h,
-      from: c(() => n),
-      now: { ...l, set: g },
-      timezone: { ...T, set: y },
-      to: c(() => r)
+    const tzSetter = (timezone) => {
+      const tz = _restamper.tz;
+      const currentTimezone = tz.current;
+      _restamper.tz = timezone;
+      if (tz.current !== currentTimezone)
+        nowSetter(NOW);
+    };
+    nowSetter();
+    return struct({
+      ..._additionalContext,
+      from: getter(() => from),
+      now: { ...nowDescriptor, set: nowSetter },
+      timezone: { ...tzDescriptor, set: tzSetter },
+      to: getter(() => to)
     });
   };
-}, U = j;
+};
 export {
-  U as default
+  createRangeTimestampsFactory as default
 };

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

@@ -0,0 +1,139 @@
+import "../../../../../core/Localization/datetime/restamper/restamper.js";
+import { SYSTEM_TIMEZONE } from "../../../../../core/Localization/datetime/restamper/constants.js";
+import "../../../../../utils/common/index.js";
+import createRangeTimestampsFactory from "./factory.js";
+import { d as describe, t as test, g as globalExpect } from "../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("createRangeTimestampsFactory", () => {
+  const DATE_NOW = Date.now();
+  const NOW_DATE = new Date(DATE_NOW).getDate();
+  const DAY_OFFSETS = Object.freeze([0, 0, 1, 0, 0, 0, -1]);
+  const DAY_OFFSETS_INVERTED = Object.freeze(DAY_OFFSETS.map((x) => -x));
+  const DAY_START = new Date(DATE_NOW).setHours(0, 0, 0, 0);
+  const DAY_END = new Date(DAY_START).setDate(NOW_DATE + 1) - 1;
+  const ZONE_OFFSET = new Date(DATE_NOW).getTimezoneOffset();
+  (/* @__PURE__ */ new Map([
+    ["from and to timestamps", { from: DAY_START, to: DAY_END }],
+    ["from timestamp and offset", { from: DAY_START, offsets: DAY_OFFSETS }],
+    ["to timestamp and offset", { to: DAY_END, offsets: DAY_OFFSETS }]
+  ])).forEach((config, description) => {
+    test(`should return a range timestamps factory (config => ${description})`, () => {
+      const factory = createRangeTimestampsFactory(config);
+      const todayTimestamps = factory();
+      globalExpect(factory).toBeTypeOf("function");
+      globalExpect(factory).toHaveLength(0);
+      globalExpect(todayTimestamps).toHaveProperty("from");
+      globalExpect(todayTimestamps).toHaveProperty("now");
+      globalExpect(todayTimestamps).toHaveProperty("timezone");
+      globalExpect(todayTimestamps).toHaveProperty("to");
+      globalExpect(todayTimestamps.from).toBeTypeOf("number");
+      globalExpect(todayTimestamps.now).toBeTypeOf("number");
+      globalExpect(todayTimestamps.timezone).toBeTypeOf("string");
+      globalExpect(todayTimestamps.to).toBeTypeOf("number");
+      globalExpect(todayTimestamps.from).toBe(DAY_START);
+      globalExpect(todayTimestamps.to).toBe(DAY_END);
+      globalExpect(todayTimestamps.timezone).toBe(SYSTEM_TIMEZONE);
+      globalExpect(todayTimestamps.now).toBeCloseTo(DATE_NOW, -3);
+      globalExpect(todayTimestamps.now).not.toBe(DATE_NOW);
+      todayTimestamps.now = DATE_NOW;
+      globalExpect(todayTimestamps.now).toBe(DATE_NOW);
+      todayTimestamps.now = -Infinity;
+      globalExpect(todayTimestamps.now).toBe(DATE_NOW);
+      todayTimestamps.now = null;
+      globalExpect(todayTimestamps.now).not.toBe(DATE_NOW);
+      globalExpect(todayTimestamps.now).toBeCloseTo(Date.now(), -3);
+    });
+  });
+  (/* @__PURE__ */ new Map([
+    ["from and to timestamps", { from: DAY_END, to: DAY_START }],
+    ["from timestamp and offset", { from: DAY_END, offsets: DAY_OFFSETS_INVERTED }],
+    ["to timestamp and offset", { to: DAY_START, offsets: DAY_OFFSETS_INVERTED }]
+  ])).forEach((config, description) => {
+    test(`should correctly order inverted timestamps (config => ${description})`, () => {
+      const todayTimestamps = createRangeTimestampsFactory(config)();
+      globalExpect(todayTimestamps.from).toBe(DAY_START);
+      globalExpect(todayTimestamps.to).toBe(DAY_END);
+    });
+  });
+  test("should return a range timestamps factory with additional context properties", () => {
+    const FROM = "FROM";
+    const LABEL = "today";
+    const additionalContextPropDescriptors = {
+      from: { enumerable: true, value: FROM },
+      // will be discarded since it conflicts with the from timestamp property
+      label: { enumerable: true, value: LABEL },
+      offset: { enumerable: true, get: () => (/* @__PURE__ */ new Date()).getTimezoneOffset() }
+    };
+    const config = { from: DAY_START, to: DAY_END };
+    const factory = createRangeTimestampsFactory(config, additionalContextPropDescriptors);
+    const todayTimestamps = factory();
+    globalExpect(todayTimestamps).toHaveProperty("from");
+    globalExpect(todayTimestamps).toHaveProperty("now");
+    globalExpect(todayTimestamps).toHaveProperty("timezone");
+    globalExpect(todayTimestamps).toHaveProperty("to");
+    globalExpect(todayTimestamps).toHaveProperty("label");
+    globalExpect(todayTimestamps).toHaveProperty("offset");
+    globalExpect(todayTimestamps.from).toBeTypeOf("number");
+    globalExpect(todayTimestamps.now).toBeTypeOf("number");
+    globalExpect(todayTimestamps.timezone).toBeTypeOf("string");
+    globalExpect(todayTimestamps.to).toBeTypeOf("number");
+    globalExpect(todayTimestamps.label).toBeTypeOf(typeof LABEL);
+    globalExpect(todayTimestamps.offset).toBeTypeOf("number");
+    globalExpect(todayTimestamps.from).toBe(DAY_START);
+    globalExpect(todayTimestamps.from).not.toBe(FROM);
+    globalExpect(todayTimestamps.to).toBe(DAY_END);
+    globalExpect(todayTimestamps.timezone).toBe(SYSTEM_TIMEZONE);
+    globalExpect(todayTimestamps.label).toBe(LABEL);
+    globalExpect(todayTimestamps.offset).toBe(ZONE_OFFSET);
+  });
+  test("should use correct config context for callable config properties", () => {
+    const todayTimestamps = createRangeTimestampsFactory({
+      from: DAY_START,
+      to: ({ now, systemToTimezone, timezone, timezoneToSystem, timezoneOffset }) => {
+        globalExpect(now).toBeTypeOf("number");
+        globalExpect(timezone).toBeTypeOf("string");
+        globalExpect(systemToTimezone).toBeTypeOf("function");
+        globalExpect(timezoneToSystem).toBeTypeOf("function");
+        globalExpect(timezoneOffset).toBeTypeOf("function");
+        globalExpect(timezone).toBe(SYSTEM_TIMEZONE);
+        globalExpect(systemToTimezone(now)).toBeTypeOf("number");
+        globalExpect(timezoneToSystem(now)).toBeTypeOf("number");
+        globalExpect(timezoneOffset(now)).toBe(0);
+        return now;
+      }
+    })();
+    globalExpect(todayTimestamps.from).toBe(DAY_START);
+    globalExpect(todayTimestamps.to).toBe(todayTimestamps.now);
+    [
+      DATE_NOW,
+      -Infinity,
+      // invalid value (now will be unchanged)
+      null
+      // reset value (now will be Date.now())
+    ].forEach((NOW) => {
+      todayTimestamps.now = NOW;
+      globalExpect(todayTimestamps.from).toBe(DAY_START);
+      globalExpect(todayTimestamps.to).toBe(todayTimestamps.now);
+    });
+  });
+  test("should use config object as `this` binding where possible for callable config properties", () => {
+    const todayTimestamps = createRangeTimestampsFactory({
+      from(context) {
+        return new Date(this.to(context)).setHours(0, 0, 0, 0);
+      },
+      to: ({ now }) => now
+    })();
+    globalExpect(todayTimestamps.from).toBe(DAY_START);
+    globalExpect(todayTimestamps.to).toBe(todayTimestamps.now);
+    [
+      DATE_NOW,
+      -Infinity,
+      // invalid value (now will be unchanged)
+      null
+      // reset value (now will be Date.now())
+    ].forEach((NOW) => {
+      todayTimestamps.now = NOW;
+      globalExpect(todayTimestamps.from).toBe(DAY_START);
+      globalExpect(todayTimestamps.to).toBe(todayTimestamps.now);
+    });
+  });
+});

package/dist/es/components/internal/Calendar/calendar/timerange/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./factory.js";
+export {
+  default2 as default
+};

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

@@ -0,0 +1,14 @@
+import { default as default2 } from "./lastMonth.js";
+import { default as default3 } from "./lastNDays.js";
+import { default as default4 } from "./lastWeek.js";
+import { default as default5 } from "./thisMonth.js";
+import { default as default6 } from "./thisWeek.js";
+import { default as default7 } from "./yearToDate.js";
+export {
+  default2 as lastMonth,
+  default3 as lastNDays,
+  default4 as lastWeek,
+  default5 as thisMonth,
+  default6 as thisWeek,
+  default7 as yearToDate
+};

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

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

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

@@ -0,0 +1,69 @@
+import { getDateRangeContext, TIMEZONE_TESTS_TIMESTAMPS } from "./testing/fixtures.js";
+import { asTimestamp, getMonthDays } from "./testing/helpers.js";
+import lastMonth from "./lastMonth.js";
+import { d as describe, t as test, g as globalExpect } from "../../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("last month", () => {
+  test("should be previous month", () => {
+    const { fromDate, nowDate, toDate } = getDateRangeContext(lastMonth);
+    const fromMonth = fromDate.getMonth();
+    const fromYear = fromDate.getFullYear();
+    const fromMonthDays = getMonthDays(fromMonth, fromYear);
+    const nowMonth = nowDate.getMonth();
+    const nowYear = nowDate.getFullYear();
+    const toMonth = toDate.getMonth();
+    const toYear = toDate.getFullYear();
+    globalExpect(fromYear).toBe(toYear);
+    globalExpect(fromMonth).toBe(toMonth);
+    globalExpect(fromDate.getDate()).toBe(1);
+    globalExpect(toDate.getDate()).toBe(fromMonthDays);
+    if (nowMonth === 0) {
+      globalExpect(fromMonth).toBe(11);
+      globalExpect(fromYear).toBe(nowYear - 1);
+    } else {
+      globalExpect(fromMonth).toBe(nowMonth - 1);
+      globalExpect(fromYear).toBe(nowYear);
+    }
+  });
+  test("should have precise timestamps", () => {
+    const { fromDate, nowDate, from, to } = getDateRangeContext(lastMonth);
+    const nowMonth = nowDate.getMonth();
+    const fromMonth = fromDate.getMonth();
+    const monthAfter = new Date(to + 1).getMonth();
+    const monthBefore = new Date(from - 1).getMonth();
+    globalExpect(monthAfter).toBe(nowMonth);
+    fromMonth === 0 ? globalExpect(monthBefore).toBe(11) : globalExpect(monthBefore).toBe(fromMonth - 1);
+  });
+  test("should have precise timestamps for timezone", () => {
+    const range = getDateRangeContext(lastMonth);
+    const { now: initialNow, timezone: initialTimezone } = range;
+    const TIMEZONES = /* @__PURE__ */ new Map([
+      [
+        "America/Toronto",
+        [
+          asTimestamp(["Mar 1, 2022, 12:00 AM GMT-5", "Mar 31, 2022, 23:59:59.999 GMT-4"]),
+          asTimestamp(["Nov 1, 2023, 12:00 AM GMT-4", "Nov 30, 2023, 23:59:59.999 GMT-5"]),
+          asTimestamp(["Nov 1, 2023, 12:00 AM GMT-4", "Nov 30, 2023, 23:59:59.999 GMT-5"])
+        ]
+      ],
+      [
+        "Asia/Tokyo",
+        [
+          asTimestamp(["Mar 1, 2022, 12:00 AM GMT+9", "Mar 31, 2022, 23:59:59.999 GMT+9"]),
+          asTimestamp(["Dec 1, 2023, 12:00 AM GMT+9", "Dec 31, 2023, 23:59:59.999 GMT+9"]),
+          asTimestamp(["Dec 1, 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/lastNDays.js

@@ -1,22 +1,33 @@
-import c from "../factory.js";
-import { startOfDay as f, nowTimestamp as p, getRangeTimestampsContextIntegerPropertyFactory as y } from "../utils.js";
-const g = 365, i = 1, u = 1, N = y(i, g, u), _ = (r) => {
-  const a = N(r);
-  return c(
+import createRangeTimestampsFactory from "../factory.js";
+import { startOfDay, nowTimestamp, getRangeTimestampsContextIntegerPropertyFactory } from "../utils.js";
+const MAX_NUM_DAYS = 365;
+const MIN_NUM_DAYS = 1;
+const DEFAULT_NUM_DAYS = 1;
+const _getNumberOfDaysContext = getRangeTimestampsContextIntegerPropertyFactory(MIN_NUM_DAYS, MAX_NUM_DAYS, DEFAULT_NUM_DAYS);
+const lastNDays = (numberOfDays) => {
+  const numberOfDaysContext = _getNumberOfDaysContext(numberOfDays);
+  return createRangeTimestampsFactory(
     {
-      from: ({ now: s, systemToTimezone: n, timezoneToSystem: D }) => {
-        const t = new Date(s), m = new Date(D(s)), e = t.getDate() - m.getDate();
-        let o = a.value - 1;
-        return e && (o += e > 1 ? -1 : e < -1 ? 1 : e), f(t), t.setDate(t.getDate() - o), n(t);
+      from: ({ now, systemToTimezone, timezoneToSystem }) => {
+        const date = new Date(now);
+        const restampedDate = new Date(timezoneToSystem(now));
+        const dateDiff = date.getDate() - restampedDate.getDate();
+        let dateOffset = numberOfDaysContext.value - 1;
+        if (dateDiff) {
+          dateOffset += dateDiff > 1 ? -1 : dateDiff < -1 ? 1 : dateDiff;
+        }
+        startOfDay(date);
+        date.setDate(date.getDate() - dateOffset);
+        return systemToTimezone(date);
       },
-      to: p
+      to: nowTimestamp
     },
-    { numberOfDays: a.descriptor }
+    { numberOfDays: numberOfDaysContext.descriptor }
   )();
-}, A = _;
+};
 export {
-  u as DEFAULT_NUM_DAYS,
-  g as MAX_NUM_DAYS,
-  i as MIN_NUM_DAYS,
-  A as default
+  DEFAULT_NUM_DAYS,
+  MAX_NUM_DAYS,
+  MIN_NUM_DAYS,
+  lastNDays as default
 };