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

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

@@ -1,60 +1,94 @@
-import { toString as T, enumerable as c, struct as g, hasOwnProperty as f, isBitSafeInteger as l, clamp as u, isFunction as O } from "../../../../../utils/common/index.js";
-import { systemToTimezone as z, timezoneToSystem as h } from "../../../../../core/Localization/datetime/restamper/utils.js";
-import { EMPTY_OBJECT as d } from "../../../../../utils/common/constants.js";
-const P = (t) => T(t).slice(8, -1) === "Object" ? t : d, w = (t, e = !0) => ({
-  enumerable: e !== !1,
-  get: t
-}), j = (t) => Object.freeze({
-  systemToTimezone: c((e) => z(t, e)),
-  timezoneToSystem: c((e) => h(t, e)),
-  timezoneOffset: c((e) => t(e).offset)
-}), F = (t, e, s = t) => {
-  const a = (n, r) => {
-    let o = n;
-    n == null ? o = s : l(n) || (o = r ?? s);
-    const i = u(t, o, e);
-    return i === o ? i : r ?? s;
+import { toString, enumerable, struct, isFunction, hasOwnProperty, isBitSafeInteger, clamp } from "../../../../../utils/common/index.js";
+import "../../../../../core/Localization/datetime/restamper/restamper.js";
+import "../../../../../core/Localization/datetime/restamper/constants.js";
+import { systemToTimezone, timezoneToSystem } from "../../../../../core/Localization/datetime/restamper/utils.js";
+import { EMPTY_OBJECT } from "../../../../../utils/common/constants.js";
+const asPlainObject = (value) => toString(value).slice(8, -1) === "Object" ? value : EMPTY_OBJECT;
+const getter = (get, enumerable2 = true) => ({
+  enumerable: enumerable2 !== false,
+  get
+});
+const createRangeTimestampsConfigRestampingContext = (restamper) => Object.freeze({
+  systemToTimezone: enumerable((time) => systemToTimezone(restamper, time)),
+  timezoneToSystem: enumerable((time) => timezoneToSystem(restamper, time)),
+  timezoneOffset: enumerable((time) => restamper(time).offset)
+});
+const getRangeTimestampsContextIntegerPropertyFactory = (minInteger, maxInteger, defaultInteger = minInteger) => {
+  const _getNormalizedValue = (value, fallbackValue) => {
+    let normalizedValue = value;
+    if (value == void 0)
+      normalizedValue = defaultInteger;
+    else if (!isBitSafeInteger(value))
+      normalizedValue = fallbackValue ?? defaultInteger;
+    const clampedValue = clamp(minInteger, normalizedValue, maxInteger);
+    return clampedValue === normalizedValue ? clampedValue : fallbackValue ?? defaultInteger;
   };
-  return (n) => {
-    const r = w(() => o);
-    let o = a(n);
-    return g({
-      value: r,
-      descriptor: c({
-        ...r,
-        set(i) {
-          const p = o;
-          o = a(i, o), p !== o && (this.now = this.now);
+  return (initialValue) => {
+    const valueGetter = getter(() => normalizedValue);
+    let normalizedValue = _getNormalizedValue(initialValue);
+    return struct({
+      value: valueGetter,
+      descriptor: enumerable({
+        ...valueGetter,
+        set(value) {
+          const currentValue = normalizedValue;
+          normalizedValue = _getNormalizedValue(value, normalizedValue);
+          if (currentValue !== normalizedValue)
+            this.now = this.now;
         }
       })
     });
   };
-}, M = (t, e) => (s) => O(s) ? s.call(t, e) : s, N = (t) => !f(t, "offsets"), S = (t) => f(t, "from"), V = ({ now: t }) => t, b = (() => {
-  const t = /* @__PURE__ */ new Map();
-  return (e) => {
-    let s = t.get(e);
-    return s === void 0 && (s = Object.freeze([0, 0, e, 0, 0, 0, -1]), t.set(e, s)), s;
+};
+const getRangeTimestampsConfigParameterUnwrapper = (config, context) => (value) => isFunction(value) ? value.call(config, context) : value;
+const isRangeTimestampsConfigWithoutOffsets = (config) => !hasOwnProperty(config, "offsets");
+const isRangeTimestampsConfigWithFromOffsets = (config) => hasOwnProperty(config, "from");
+const nowTimestamp = ({ now }) => now;
+const offsetsForNDays = (() => {
+  const _cache = /* @__PURE__ */ new Map();
+  return (numberOfDays) => {
+    let offsets = _cache.get(numberOfDays);
+    if (offsets === void 0) {
+      offsets = Object.freeze([0, 0, numberOfDays, 0, 0, 0, -1]);
+      _cache.set(numberOfDays, offsets);
+    }
+    return offsets;
   };
-})(), x = (t) => {
+})();
+const parseRangeTimestamp = (timestamp) => {
   try {
-    const e = t instanceof Date || +t === t ? t : void 0, s = new Date(e).getTime();
-    return isNaN(s) ? void 0 : s;
+    const normalizedTimestamp = timestamp instanceof Date || +timestamp === timestamp ? timestamp : void 0;
+    const parsedTimestamp = new Date(normalizedTimestamp).getTime();
+    return isNaN(parsedTimestamp) ? void 0 : parsedTimestamp;
   } catch {
   }
-}, m = (t) => t.setHours(0, 0, 0, 0), _ = (t) => (m(t), t.setDate(1)), B = (t) => (m(t), t.setMonth(0, 1)), D = (t, e = t) => 0 + (-e % 7 + (t - 7)) % 7;
+};
+const startOfDay = (date) => date.setHours(0, 0, 0, 0);
+const startOfMonth = (date) => {
+  startOfDay(date);
+  return date.setDate(1);
+};
+const startOfYear = (date) => {
+  startOfDay(date);
+  return date.setMonth(0, 1);
+};
+const startOfWeekOffset = (firstWeekDay, weekDay = firstWeekDay) => {
+  const offset = (-weekDay % 7 + (firstWeekDay - 7)) % 7;
+  return 0 + offset;
+};
 export {
-  P as asPlainObject,
-  j as createRangeTimestampsConfigRestampingContext,
-  M as getRangeTimestampsConfigParameterUnwrapper,
-  F as getRangeTimestampsContextIntegerPropertyFactory,
-  w as getter,
-  S as isRangeTimestampsConfigWithFromOffsets,
-  N as isRangeTimestampsConfigWithoutOffsets,
-  V as nowTimestamp,
-  b as offsetsForNDays,
-  x as parseRangeTimestamp,
-  m as startOfDay,
-  _ as startOfMonth,
-  D as startOfWeekOffset,
-  B as startOfYear
+  asPlainObject,
+  createRangeTimestampsConfigRestampingContext,
+  getRangeTimestampsConfigParameterUnwrapper,
+  getRangeTimestampsContextIntegerPropertyFactory,
+  getter,
+  isRangeTimestampsConfigWithFromOffsets,
+  isRangeTimestampsConfigWithoutOffsets,
+  nowTimestamp,
+  offsetsForNDays,
+  parseRangeTimestamp,
+  startOfDay,
+  startOfMonth,
+  startOfWeekOffset,
+  startOfYear
 };

package/dist/es/components/internal/Calendar/calendar/timeslice/TimeSlice.js

@@ -1,63 +1,86 @@
-var c = (i, t, s) => {
-  if (!t.has(i))
-    throw TypeError("Cannot " + s);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
 };
-var e = (i, t, s) => (c(i, t, "read from private field"), s ? s.call(i) : t.get(i)), n = (i, t, s) => {
-  if (t.has(i))
+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");
-  t instanceof WeakSet ? t.add(i) : t.set(i, s);
-}, f = (i, t, s, T) => (c(i, t, "write to private field"), T ? T.call(i, s) : t.set(i, s), s);
-var u = (i, t, s, T) => ({
-  set _(O) {
-    f(i, t, O, s);
+  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 __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
   },
   get _() {
-    return e(i, t, T);
+    return __privateGet(obj, member, getter);
   }
 });
-import { RANGE_FROM as l, RANGE_TO as d } from "../constants.js";
-import { computeTimestampOffset as o, getEdgesDistance as g } from "../utils.js";
-var p, h, m, a, r;
-class N {
-  constructor(...t) {
-    n(this, p, 1 / 0);
-    n(this, h, 1 / 0);
-    n(this, m, -1 / 0);
-    n(this, a, 0);
-    n(this, r, 0);
-    if (t.length >= 2) {
-      let s = new Date(t[0]).getTime();
-      if (typeof t[1] != "symbol")
-        f(this, m, s || e(this, m)), f(this, h, new Date(t[1]).getTime() || e(this, h)), e(this, h) < e(this, m) && ([u(this, h)._, u(this, m)._] = [e(this, m), e(this, h)]), f(this, r, o(e(this, m))), f(this, a, o(e(this, h))), f(this, p, g(e(this, m), e(this, h)) + 1);
-      else if (!isNaN(s))
-        switch (t[1]) {
-          case d:
-            f(this, h, s), f(this, a, o(e(this, h)));
+var _numberOfMonths, _endTimestamp, _startTimestamp, _endTimestampOffset, _startTimestampOffset;
+import { RANGE_FROM, RANGE_TO } from "../constants.js";
+import { computeTimestampOffset, getEdgesDistance } from "../utils.js";
+class __TimeSlice__ {
+  constructor(...args) {
+    __privateAdd(this, _numberOfMonths, Infinity);
+    __privateAdd(this, _endTimestamp, Infinity);
+    __privateAdd(this, _startTimestamp, -Infinity);
+    __privateAdd(this, _endTimestampOffset, 0);
+    __privateAdd(this, _startTimestampOffset, 0);
+    if (args.length >= 2) {
+      let timestamp = new Date(args[0]).getTime();
+      if (typeof args[1] !== "symbol") {
+        __privateSet(this, _startTimestamp, timestamp || __privateGet(this, _startTimestamp));
+        __privateSet(this, _endTimestamp, new Date(args[1]).getTime() || __privateGet(this, _endTimestamp));
+        if (__privateGet(this, _endTimestamp) < __privateGet(this, _startTimestamp)) {
+          [__privateWrapper(this, _endTimestamp)._, __privateWrapper(this, _startTimestamp)._] = [__privateGet(this, _startTimestamp), __privateGet(this, _endTimestamp)];
+        }
+        __privateSet(this, _startTimestampOffset, computeTimestampOffset(__privateGet(this, _startTimestamp)));
+        __privateSet(this, _endTimestampOffset, computeTimestampOffset(__privateGet(this, _endTimestamp)));
+        __privateSet(this, _numberOfMonths, getEdgesDistance(__privateGet(this, _startTimestamp), __privateGet(this, _endTimestamp)) + 1);
+      } else if (!isNaN(timestamp)) {
+        switch (args[1]) {
+          case RANGE_TO:
+            __privateSet(this, _endTimestamp, timestamp);
+            __privateSet(this, _endTimestampOffset, computeTimestampOffset(__privateGet(this, _endTimestamp)));
             break;
-          case l:
+          case RANGE_FROM:
           default:
-            f(this, m, s), f(this, r, o(e(this, m)));
+            __privateSet(this, _startTimestamp, timestamp);
+            __privateSet(this, _startTimestampOffset, computeTimestampOffset(__privateGet(this, _startTimestamp)));
             break;
         }
+      }
     }
   }
   get numberOfMonths() {
-    return e(this, p);
+    return __privateGet(this, _numberOfMonths);
   }
   get endTimestamp() {
-    return e(this, h);
+    return __privateGet(this, _endTimestamp);
   }
   get endTimestampOffset() {
-    return e(this, a);
+    return __privateGet(this, _endTimestampOffset);
   }
   get startTimestamp() {
-    return e(this, m);
+    return __privateGet(this, _startTimestamp);
   }
   get startTimestampOffset() {
-    return e(this, r);
+    return __privateGet(this, _startTimestampOffset);
   }
 }
-p = new WeakMap(), h = new WeakMap(), m = new WeakMap(), a = new WeakMap(), r = new WeakMap();
+_numberOfMonths = new WeakMap();
+_endTimestamp = new WeakMap();
+_startTimestamp = new WeakMap();
+_endTimestampOffset = new WeakMap();
+_startTimestampOffset = new WeakMap();
 export {
-  N as default
+  __TimeSlice__ as default
 };

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

@@ -1,23 +1,27 @@
-import m from "./TimeSlice.js";
-import { RANGE_FROM as n, RANGE_TO as a } from "../constants.js";
-import { struct as s } from "../../../../../utils/common/index.js";
-const o = (...e) => {
-  const t = new m(...e);
-  return s({
-    from: { value: t.startTimestamp },
-    to: { value: t.endTimestamp },
+import __TimeSlice__ from "./TimeSlice.js";
+import { RANGE_FROM, RANGE_TO } from "../constants.js";
+import { struct } from "../../../../../utils/common/index.js";
+const factory = (...args) => {
+  const slice = new __TimeSlice__(...args);
+  return struct({
+    from: { value: slice.startTimestamp },
+    to: { value: slice.endTimestamp },
     offsets: {
-      value: s({
-        from: { value: t.startTimestampOffset },
-        to: { value: t.endTimestampOffset }
+      value: struct({
+        from: { value: slice.startTimestampOffset },
+        to: { value: slice.endTimestampOffset }
       })
     },
-    span: { value: t.numberOfMonths }
+    span: { value: slice.numberOfMonths }
   });
-}, r = o(), l = () => o(Date.now(), n), u = () => o(Date.now(), a), p = (...e) => e.length === 0 ? r : o(...e);
+};
+const UNBOUNDED_SLICE = factory();
+const sinceNow = () => factory(Date.now(), RANGE_FROM);
+const untilNow = () => factory(Date.now(), RANGE_TO);
+const timeslice = (...args) => args.length === 0 ? UNBOUNDED_SLICE : factory(...args);
 export {
-  r as UNBOUNDED_SLICE,
-  p as default,
-  l as sinceNow,
-  u as untilNow
+  UNBOUNDED_SLICE,
+  timeslice as default,
+  sinceNow,
+  untilNow
 };

package/dist/es/components/internal/Calendar/calendar/utils.js

@@ -1,19 +1,26 @@
-import { isInfinite as c, mod as g } from "../../../../utils/common/index.js";
-const f = (t) => c(t) ? 0 : t - new Date(t).setHours(0, 0, 0, 0), h = (t) => t === void 0 ? t : new Date(t), d = (t, n) => {
-  if (c(t) || c(n))
-    return 1 / 0;
-  const e = new Date(t), o = new Date(n);
-  return Math.abs(o.getMonth() - e.getMonth() + (o.getFullYear() - e.getFullYear()) * 12);
-}, M = (() => {
-  const t = [31, [29, 28], 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-  return (n, e, o = 0) => {
-    const a = n + o, r = g(a, 12), s = e + Math.floor(a / 12);
-    return [r === 1 ? t[1][(s % 100 ? s % 4 : s % 400) && 1] : t[r], r, s];
+import { isInfinite, mod } from "../../../../utils/common/index.js";
+const computeTimestampOffset = (timestamp) => isInfinite(timestamp) ? 0 : timestamp - new Date(timestamp).setHours(0, 0, 0, 0);
+const getDateObjectFromTimestamp = (timestamp) => timestamp === void 0 ? timestamp : new Date(timestamp);
+const getEdgesDistance = (fromTime, toTime) => {
+  if (isInfinite(fromTime) || isInfinite(toTime))
+    return Infinity;
+  const from = new Date(fromTime);
+  const to = new Date(toTime);
+  return Math.abs(to.getMonth() - from.getMonth() + (to.getFullYear() - from.getFullYear()) * 12);
+};
+const getMonthDays = (() => {
+  const DAYS = [31, [29, 28], 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return (month, year, offset = 0) => {
+    const nextMonth = month + offset;
+    const monthIndex = mod(nextMonth, 12);
+    const nextYear = year + Math.floor(nextMonth / 12);
+    const days = monthIndex === 1 ? DAYS[1][(nextYear % 100 ? nextYear % 4 : nextYear % 400) && 1] : DAYS[monthIndex];
+    return [days, monthIndex, nextYear];
   };
 })();
 export {
-  f as computeTimestampOffset,
-  h as getDateObjectFromTimestamp,
-  d as getEdgesDistance,
-  M as getMonthDays
+  computeTimestampOffset,
+  getDateObjectFromTimestamp,
+  getEdgesDistance,
+  getMonthDays
 };

package/dist/es/components/internal/Calendar/clock/clock.js

@@ -1,27 +1,45 @@
-import f from "../../../../utils/watchable/index.js";
-import { struct as h } from "../../../../utils/common/index.js";
-const g = (() => {
-  let t = null, a;
-  const s = (n, i, u) => {
-    const o = document.timeline.currentTime ?? performance.now(), l = (r) => {
-      const p = r - o, w = Math.round(p / n) * n, b = o + w + n - performance.now();
-      setTimeout(() => requestAnimationFrame(d), b);
-    }, d = (r) => {
-      i.aborted || (l(r), u());
+import watchable from "../../../../utils/watchable/index.js";
+import { struct } from "../../../../utils/common/index.js";
+const clock = (() => {
+  let timestamp = null;
+  let controller;
+  const animationInterval = (ms, signal, callback) => {
+    const start = document.timeline.currentTime ?? performance.now();
+    const scheduleFrame = (time) => {
+      const elapsed = time - start;
+      const roundedElapsed = Math.round(elapsed / ms) * ms;
+      const targetNext = start + roundedElapsed + ms;
+      const delay = targetNext - performance.now();
+      setTimeout(() => requestAnimationFrame(frame), delay);
     };
-    l(o);
-  }, m = () => {
-    t = Date.now(), e.notify();
-  }, c = () => t ?? Date.now(), e = f({ timestamp: c });
-  return e.callback.resume = () => {
-    a = new AbortController(), t = Date.now(), s(1e3, a.signal, m);
-  }, e.callback.idle = () => {
-    a.abort(), t = null;
-  }, h({
-    timestamp: { get: c },
-    watch: { value: e.watch }
+    const frame = (time) => {
+      if (signal.aborted)
+        return;
+      scheduleFrame(time);
+      callback();
+    };
+    scheduleFrame(start);
+  };
+  const animationIntervalCallback = () => {
+    timestamp = Date.now();
+    watchable$1.notify();
+  };
+  const getTimestamp = () => timestamp ?? Date.now();
+  const watchable$1 = watchable({ timestamp: getTimestamp });
+  watchable$1.callback.resume = () => {
+    controller = new AbortController();
+    timestamp = Date.now();
+    animationInterval(1e3, controller.signal, animationIntervalCallback);
+  };
+  watchable$1.callback.idle = () => {
+    controller.abort();
+    timestamp = null;
+  };
+  return struct({
+    timestamp: { get: getTimestamp },
+    watch: { value: watchable$1.watch }
   });
-})(), D = g;
+})();
 export {
-  D as default
+  clock as default
 };

package/dist/es/components/internal/Calendar/clock/clock.test.js

@@ -0,0 +1,43 @@
+import { initialize, DATES } from "./testing/fixtures.js";
+import clock from "./clock.js";
+import { d as describe, t as test, v as vi, g as globalExpect } from "../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("clock", () => {
+  const { watchFn } = initialize();
+  test("should have latest timestamp when not being watched", () => {
+    DATES.forEach((date) => {
+      vi.setSystemTime(date);
+      globalExpect(clock.timestamp).toBe(Date.now());
+    });
+  });
+  test("should use latest timestamp at timed intervals when being watched", () => {
+    const unwatch = clock.watch(watchFn);
+    let currentTimestamp = Date.now();
+    let watchFnCalls = 0;
+    globalExpect(clock.timestamp).toBe(currentTimestamp);
+    globalExpect(watchFn).toBeCalledTimes(++watchFnCalls);
+    globalExpect(watchFn).toHaveBeenLastCalledWith({ timestamp: currentTimestamp });
+    DATES.forEach((date) => {
+      vi.runOnlyPendingTimers();
+      vi.setSystemTime(date);
+      globalExpect(clock.timestamp).not.toBe(Date.now());
+      globalExpect(clock.timestamp).toBe(currentTimestamp);
+      globalExpect(watchFn).toBeCalledTimes(watchFnCalls);
+      vi.advanceTimersToNextTimer();
+      currentTimestamp = Date.now();
+      globalExpect(clock.timestamp).toBe(currentTimestamp);
+      globalExpect(watchFn).toBeCalledTimes(++watchFnCalls);
+      globalExpect(watchFn).toHaveBeenLastCalledWith({ timestamp: currentTimestamp });
+    });
+    unwatch();
+    DATES.forEach((date) => {
+      vi.runOnlyPendingTimers();
+      vi.setSystemTime(date);
+      globalExpect(clock.timestamp).toBe(currentTimestamp = Date.now());
+      globalExpect(watchFn).toBeCalledTimes(watchFnCalls);
+      vi.advanceTimersToNextTimer();
+      currentTimestamp = Date.now();
+      globalExpect(clock.timestamp).toBe(currentTimestamp);
+      globalExpect(watchFn).toBeCalledTimes(watchFnCalls);
+    });
+  });
+});

package/dist/es/components/internal/Calendar/clock/index.js

@@ -0,0 +1,7 @@
+import { default as default2, default as default3 } from "./clock.js";
+import { default as default4 } from "./today.js";
+export {
+  default2 as clock,
+  default3 as default,
+  default4 as today
+};

package/dist/es/components/internal/Calendar/clock/testing/fixtures.js

@@ -0,0 +1,60 @@
+import { v as vi, b as beforeEach, a as beforeAll, c as afterAll } from "../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+const DATES = [
+  /* @__PURE__ */ new Date("Feb 29, 2000, 11:30 PM GMT"),
+  /* @__PURE__ */ new Date("Apr 15, 2022, 1:30 PM GMT"),
+  /* @__PURE__ */ new Date("Dec 31, 2023, 5:30 PM GMT"),
+  /* @__PURE__ */ new Date("Jan 1, 2025, 3:30 AM GMT")
+];
+const TIMEZONES = /* @__PURE__ */ new Map([
+  [
+    "America/Toronto",
+    [
+      /* @__PURE__ */ new Date("Feb 29, 2000, 5:00 AM GMT"),
+      /* @__PURE__ */ new Date("Apr 15, 2022, 4:00 AM GMT"),
+      /* @__PURE__ */ new Date("Dec 31, 2023, 5:00 AM GMT"),
+      /* @__PURE__ */ new Date("Dec 31, 2024, 5:00 AM GMT")
+    ]
+  ],
+  [
+    "Asia/Tokyo",
+    [
+      /* @__PURE__ */ new Date("Feb 29, 2000, 3:00 PM GMT"),
+      /* @__PURE__ */ new Date("Apr 14, 2022, 3:00 PM GMT"),
+      /* @__PURE__ */ new Date("Dec 31, 2023, 3:00 PM GMT"),
+      /* @__PURE__ */ new Date("Dec 31, 2024, 3:00 PM GMT")
+    ]
+  ]
+]);
+const startOfDay = (date = Date.now()) => new Date(date).setHours(0, 0, 0, 0);
+const startOfNextDay = (startDateOfDay = startOfDay()) => {
+  const startDate = new Date(startDateOfDay);
+  return startDate.setDate(startDate.getDate() + 1);
+};
+const initialize = () => {
+  const watchFn = vi.fn();
+  beforeEach(() => {
+    watchFn.mockRestore();
+    vi.setSystemTime(0);
+  });
+  beforeAll(() => {
+    vi.useFakeTimers();
+    vi.stubGlobal(
+      "document",
+      Object.assign({}, document, {
+        timeline: { currentTime: void 0 }
+      })
+    );
+  });
+  afterAll(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+  return { watchFn };
+};
+export {
+  DATES,
+  TIMEZONES,
+  initialize,
+  startOfDay,
+  startOfNextDay
+};