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

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

@@ -1,178 +1,277 @@
-var Z = Object.defineProperty;
-var $ = (r, s, t) => s in r ? Z(r, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[s] = t;
-var P = (r, s, t) => ($(r, typeof s != "symbol" ? s + "" : s, t), t), b = (r, s, t) => {
-  if (!s.has(r))
-    throw TypeError("Cannot " + t);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
 };
-var i = (r, s, t) => (b(r, s, "read from private field"), t ? t.call(r) : s.get(r)), n = (r, s, t) => {
-  if (s.has(r))
+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");
-  s instanceof WeakSet ? s.add(r) : s.set(r, t);
-}, m = (r, s, t, e) => (b(r, s, "write to private field"), e ? e.call(r, t) : s.set(r, t), t);
-var h = (r, s, t) => (b(r, s, "access private method"), t);
-import tt from "./TimeFrame.js";
-import { getWeekendDays as z } from "../common/utils.js";
-import { getEdgesDistance as X, computeTimestampOffset as et, getMonthDays as j } from "../../utils.js";
-import { DAY_OF_WEEK_FORMATS as it, MAXIMUM_MONTH_UNITS as q, DAY_MS as st } from "../../constants.js";
-import rt from "../common/flags.js";
-import { isInfinite as nt, enumerable as U, struct as F, isBitSafeInteger as ot, structFrom as at } from "../../../../../../utils/common/index.js";
-import { isString as mt } from "../../../../../../utils/validator-utils.js";
-import { TimeFlag as o } from "../../types.js";
-import { immutableProxyHandlers as ht } from "../../../../../../utils/common/constants.js";
-var u, T, d, N, y, I, B, A, W, _, k, S, E, M, K, l, D, O, C;
-class It extends tt {
+  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 _daysInWeek, _daysOfWeekCached, _daysOfWeekend, _currentDayTimestamp, _fromTimestamp, _toTimestamp, _numberOfBlocks, _originMonthStartDate, _originMonthStartOffset, _originMonthStartTimestamp, _originYear, _selectionFromTimestamp, _selectionToTimestamp, _getBlockTimestampOffsetFromOrigin, getBlockTimestampOffsetFromOrigin_fn, _getStartForTimestamp, getStartForTimestamp_fn, _updateSelectionTimestamps, updateSelectionTimestamps_fn;
+import TimeFrame from "./TimeFrame.js";
+import { getWeekendDays } from "../common/utils.js";
+import { getEdgesDistance, computeTimestampOffset, getMonthDays } from "../../utils.js";
+import { DAY_OF_WEEK_FORMATS, MAXIMUM_MONTH_UNITS, DAY_MS } from "../../constants.js";
+import { T as TimeFlag, c as createFlagsRecord } from "../../../../../../../flags-41c36e13.mjs";
+import { isInfinite, enumerable, struct, isBitSafeInteger, structFrom } from "../../../../../../utils/common/index.js";
+import { isString } from "../../../../../../utils/validator-utils.js";
+import { immutableProxyHandlers } from "../../../../../../utils/common/constants.js";
+class MonthFrame extends TimeFrame {
   constructor() {
     super();
-    n(this, M);
-    n(this, l);
-    n(this, O);
-    n(this, u, 7);
-    n(this, T, []);
-    n(this, d, z(this.firstWeekDay));
-    n(this, N, void 0);
-    n(this, y, -1 / 0);
-    n(this, I, 1 / 0);
-    n(this, B, 1 / 0);
-    n(this, A, void 0);
-    n(this, W, void 0);
-    n(this, _, void 0);
-    n(this, k, void 0);
-    n(this, S, void 0);
-    n(this, E, void 0);
-    P(this, "daysInWeek", i(this, u));
+    __privateAdd(this, _getBlockTimestampOffsetFromOrigin);
+    __privateAdd(this, _getStartForTimestamp);
+    __privateAdd(this, _updateSelectionTimestamps);
+    __privateAdd(this, _daysInWeek, void 0);
+    __privateAdd(this, _daysOfWeekCached, void 0);
+    __privateAdd(this, _daysOfWeekend, void 0);
+    __privateAdd(this, _currentDayTimestamp, void 0);
+    __privateAdd(this, _fromTimestamp, void 0);
+    __privateAdd(this, _toTimestamp, void 0);
+    __privateAdd(this, _numberOfBlocks, void 0);
+    __privateAdd(this, _originMonthStartDate, void 0);
+    __privateAdd(this, _originMonthStartOffset, void 0);
+    __privateAdd(this, _originMonthStartTimestamp, void 0);
+    __privateAdd(this, _originYear, void 0);
+    __privateAdd(this, _selectionFromTimestamp, void 0);
+    __privateAdd(this, _selectionToTimestamp, void 0);
+    __privateSet(this, _daysInWeek, 7);
+    __privateSet(this, _daysOfWeekCached, []);
+    __privateSet(this, _daysOfWeekend, getWeekendDays(this.firstWeekDay));
+    __privateSet(this, _fromTimestamp, -Infinity);
+    __privateSet(this, _toTimestamp, Infinity);
+    __privateSet(this, _numberOfBlocks, Infinity);
+    this.daysInWeek = __privateGet(this, _daysInWeek);
     this.initialize();
   }
   get fromTimestamp() {
-    return i(this, y);
+    return __privateGet(this, _fromTimestamp);
   }
   get toTimestamp() {
-    return i(this, I);
+    return __privateGet(this, _toTimestamp);
   }
   get numberOfBlocks() {
-    return i(this, B);
+    return __privateGet(this, _numberOfBlocks);
   }
   get currentDayTimestamp() {
-    return i(this, N);
+    return __privateGet(this, _currentDayTimestamp);
   }
   get dynamicBlockHeight() {
     return super.dynamicBlockHeight;
   }
-  set dynamicBlockHeight(t) {
-    const e = this.dynamicBlockHeight;
-    super.dynamicBlockHeight = t, this.dynamicBlockHeight !== e && this.refreshFrame(!0);
+  set dynamicBlockHeight(bool) {
+    const current = this.dynamicBlockHeight;
+    super.dynamicBlockHeight = bool;
+    if (this.dynamicBlockHeight !== current)
+      this.refreshFrame(true);
   }
   get rowspan() {
-    return i(this, u);
+    return __privateGet(this, _daysInWeek);
   }
   get firstWeekDay() {
     return super.firstWeekDay;
   }
-  set firstWeekDay(t) {
-    const e = this.firstWeekDay;
-    super.firstWeekDay = t, this.firstWeekDay !== e && (i(this, T).length = 0, m(this, d, z(this.firstWeekDay)), this.reoriginate(), this.refreshFrame());
-  }
-  getCursorBlockOriginTimestampOffset(t) {
-    return new Date(t).getDate() - 1;
-  }
-  getDayOfWeekAtIndex(t) {
-    if (!i(this, T)[t]) {
-      const e = new Date(this.getTimestampAtIndex(t));
-      let p = 0;
-      i(this, d).includes(t) && (p |= o.WEEKEND), t === 0 ? p |= o.LINE_START : t === 6 && (p |= o.LINE_END);
-      const R = {};
-      for (const f of it)
-        R[f] = U(
-          e.toLocaleDateString(this.locale, { weekday: f })
+  set firstWeekDay(day) {
+    const current = this.firstWeekDay;
+    super.firstWeekDay = day;
+    if (this.firstWeekDay === current)
+      return;
+    __privateGet(this, _daysOfWeekCached).length = 0;
+    __privateSet(this, _daysOfWeekend, getWeekendDays(this.firstWeekDay));
+    this.reoriginate();
+    this.refreshFrame();
+  }
+  getCursorBlockOriginTimestampOffset(timestamp) {
+    return new Date(timestamp).getDate() - 1;
+  }
+  getDayOfWeekAtIndex(index) {
+    if (!__privateGet(this, _daysOfWeekCached)[index]) {
+      const date = new Date(this.getTimestampAtIndex(index));
+      let flags = 0;
+      if (__privateGet(this, _daysOfWeekend).includes(index))
+        flags |= TimeFlag.WEEKEND;
+      if (index === 0)
+        flags |= TimeFlag.LINE_START;
+      else if (index === 6)
+        flags |= TimeFlag.LINE_END;
+      const labelDescriptors = {};
+      for (const format of DAY_OF_WEEK_FORMATS) {
+        labelDescriptors[format] = enumerable(
+          date.toLocaleDateString(this.locale, { weekday: format })
         );
-      i(this, T)[t] = F({
-        flags: U(rt(p)),
-        labels: U(F(R))
+      }
+      __privateGet(this, _daysOfWeekCached)[index] = struct({
+        flags: enumerable(createFlagsRecord(flags)),
+        labels: enumerable(struct(labelDescriptors))
       });
     }
-    return i(this, T)[t];
+    return __privateGet(this, _daysOfWeekCached)[index];
   }
   getEdgeBlockOffsetsFromOrigin() {
-    return [h(this, M, K).call(this, i(this, y)), h(this, M, K).call(this, i(this, I))];
-  }
-  getFormattedDataForBlockCell(t) {
-    const e = new Date(t).toISOString();
-    return [Number(e.slice(8, 10)).toLocaleString(this.locale), e.slice(0, 10)];
-  }
-  getFormattedDataForFrameBlock(t) {
-    const e = new Date(t);
-    return [e.toLocaleDateString(this.locale, { month: "long", year: "numeric" }), e.toISOString().slice(0, 7)];
-  }
-  getFrameBlockAtIndex(t) {
-    const [e, p, R] = j(this.origin, i(this, k), t), f = t > 0 ? this.getFrameBlockAtIndex(t - 1).inner.to + 1 : i(this, W), H = f + e - 1, L = Math.floor(f / 7) * 7, Y = this.dynamicBlockHeight ? Math.ceil((H + 1) / 7) * 7 : L + q, G = this.dynamicBlockHeight ? Y - L : q, J = new Proxy(F(), {
-      ...ht,
-      get: (Q, v, V) => {
-        if (mt(v)) {
-          const w = +v;
-          if (ot(w) && w >= 0 && w < G) {
-            const g = L + w, c = this.getTimestampAtIndex(g), x = g % i(this, u);
-            let a = c === this.currentDayTimestamp ? o.CURRENT : 0;
-            return g === this.cursor && (a |= o.CURSOR), i(this, d).includes(x) && (a |= o.WEEKEND), x === 0 ? a |= o.LINE_START : x === i(this, u) - 1 && (a |= o.LINE_END), g >= f && g <= H && (g === f ? a |= o.BLOCK_START : g === H && (a |= o.BLOCK_END), a |= o.WITHIN_BLOCK), c >= this.fromTimestamp && c <= this.toTimestamp && (c === this.fromTimestamp && (a |= o.RANGE_START), c === this.toTimestamp && (a |= o.RANGE_END), a |= o.WITHIN_RANGE), c >= i(this, S) && c <= i(this, E) && (c === i(this, S) && (a |= o.SELECTION_START), c === i(this, E) && (a |= o.SELECTION_END), a |= o.WITHIN_SELECTION), [c, a];
+    return [__privateMethod(this, _getBlockTimestampOffsetFromOrigin, getBlockTimestampOffsetFromOrigin_fn).call(this, __privateGet(this, _fromTimestamp)), __privateMethod(this, _getBlockTimestampOffsetFromOrigin, getBlockTimestampOffsetFromOrigin_fn).call(this, __privateGet(this, _toTimestamp))];
+  }
+  getFormattedDataForBlockCell(time) {
+    const ISOString = new Date(time).toISOString();
+    return [Number(ISOString.slice(8, 10)).toLocaleString(this.locale), ISOString.slice(0, 10)];
+  }
+  getFormattedDataForFrameBlock(time) {
+    const date = new Date(time);
+    return [date.toLocaleDateString(this.locale, { month: "long", year: "numeric" }), date.toISOString().slice(0, 7)];
+  }
+  getFrameBlockAtIndex(index) {
+    const [monthDays, month, year] = getMonthDays(this.origin, __privateGet(this, _originYear), index);
+    const innerStartIndex = index > 0 ? this.getFrameBlockAtIndex(index - 1).inner.to + 1 : __privateGet(this, _originMonthStartOffset);
+    const innerEndIndex = innerStartIndex + monthDays - 1;
+    const outerStartIndex = Math.floor(innerStartIndex / 7) * 7;
+    const outerEndAfterIndex = this.dynamicBlockHeight ? Math.ceil((innerEndIndex + 1) / 7) * 7 : outerStartIndex + MAXIMUM_MONTH_UNITS;
+    const numberOfUnits = this.dynamicBlockHeight ? outerEndAfterIndex - outerStartIndex : MAXIMUM_MONTH_UNITS;
+    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 = outerStartIndex + offset;
+            const timestamp = this.getTimestampAtIndex(index2);
+            const weekDay = index2 % __privateGet(this, _daysInWeek);
+            let flags = timestamp === this.currentDayTimestamp ? TimeFlag.CURRENT : 0;
+            if (index2 === this.cursor)
+              flags |= TimeFlag.CURSOR;
+            if (__privateGet(this, _daysOfWeekend).includes(weekDay))
+              flags |= TimeFlag.WEEKEND;
+            if (weekDay === 0)
+              flags |= TimeFlag.LINE_START;
+            else if (weekDay === __privateGet(this, _daysInWeek) - 1)
+              flags |= TimeFlag.LINE_END;
+            if (index2 >= innerStartIndex && index2 <= innerEndIndex) {
+              if (index2 === innerStartIndex)
+                flags |= TimeFlag.BLOCK_START;
+              else if (index2 === innerEndIndex)
+                flags |= TimeFlag.BLOCK_END;
+              flags |= TimeFlag.WITHIN_BLOCK;
+            }
+            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(Q, v, V);
+        return Reflect.get(target, property, receiver);
       }
     });
-    return at(J, {
+    return structFrom(proxyForIndexPropertyAccess, {
       inner: {
-        value: F({
-          from: { value: f },
-          to: { value: H },
-          units: { value: e }
+        value: struct({
+          from: { value: innerStartIndex },
+          to: { value: innerEndIndex },
+          units: { value: monthDays }
         })
       },
-      month: { value: p },
+      month: { value: month },
       outer: {
-        value: F({
-          from: { value: L },
-          to: { value: Y - 1 },
-          units: { value: G }
+        value: struct({
+          from: { value: outerStartIndex },
+          to: { value: outerEndAfterIndex - 1 },
+          units: { value: numberOfUnits }
         })
       },
-      year: { value: R }
+      year: { value: year }
     });
   }
-  getUnitsForFrameBlockAtIndex(t) {
-    return j(this.origin, i(this, k), t)[0];
+  getUnitsForFrameBlockAtIndex(index) {
+    return getMonthDays(this.origin, __privateGet(this, _originYear), index)[0];
   }
-  getUnitsOffsetForTimestamp(t, e) {
-    return Math.round((e - t) / st);
+  getUnitsOffsetForTimestamp(startTimestamp, timestamp) {
+    return Math.round((timestamp - startTimestamp) / DAY_MS);
   }
   reoriginate() {
-    const t = new Date(this.originTimestamp), e = (8 - (t.getDate() - t.getDay() + this.firstWeekDay) % 7) % 7;
-    this.origin = t.getMonth(), m(this, k, t.getFullYear()), this.originTimestamp = t.setDate(1), m(this, W, e), m(this, _, t.setDate(1 - e)), m(this, A, t.getDate());
+    const date = new Date(this.originTimestamp);
+    const firstDayOffset = (8 - (date.getDate() - date.getDay() + this.firstWeekDay) % 7) % 7;
+    this.origin = date.getMonth();
+    __privateSet(this, _originYear, date.getFullYear());
+    this.originTimestamp = date.setDate(1);
+    __privateSet(this, _originMonthStartOffset, firstDayOffset);
+    __privateSet(this, _originMonthStartTimestamp, date.setDate(1 - firstDayOffset));
+    __privateSet(this, _originMonthStartDate, date.getDate());
   }
   reslice() {
-    h(this, O, C).call(this), m(this, y, h(this, l, D).call(this, super.fromTimestamp)), m(this, I, h(this, l, D).call(this, super.toTimestamp)), m(this, B, X(super.fromTimestamp, super.toTimestamp) + 1);
+    __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, getEdgesDistance(super.fromTimestamp, super.toTimestamp) + 1);
   }
-  shiftOrigin(t) {
-    this.originTimestamp = new Date(this.originTimestamp).setMonth(this.origin + t), this.reoriginate();
+  shiftOrigin(offset) {
+    this.originTimestamp = new Date(this.originTimestamp).setMonth(this.origin + offset);
+    this.reoriginate();
   }
   clearSelection() {
-    super.clearSelection(), h(this, O, C).call(this), this.refreshFrame(!0);
+    super.clearSelection();
+    __privateMethod(this, _updateSelectionTimestamps, updateSelectionTimestamps_fn).call(this);
+    this.refreshFrame(true);
   }
-  getTimestampAtIndex(t) {
-    return new Date(i(this, _)).setDate(i(this, A) + t);
+  getTimestampAtIndex(indexOffset) {
+    return new Date(__privateGet(this, _originMonthStartTimestamp)).setDate(__privateGet(this, _originMonthStartDate) + indexOffset);
   }
-  updateSelection(t, e) {
-    super.updateSelection(t, e), h(this, O, C).call(this), this.refreshFrame(!0);
+  updateSelection(time, selection) {
+    super.updateSelection(time, selection);
+    __privateMethod(this, _updateSelectionTimestamps, updateSelectionTimestamps_fn).call(this);
+    this.refreshFrame(true);
   }
-  withCurrentDayTimestamp(t) {
-    m(this, N, h(this, l, D).call(this, t));
+  withCurrentDayTimestamp(timestamp) {
+    __privateSet(this, _currentDayTimestamp, __privateMethod(this, _getStartForTimestamp, getStartForTimestamp_fn).call(this, timestamp));
   }
 }
-u = new WeakMap(), T = new WeakMap(), d = new WeakMap(), N = new WeakMap(), y = new WeakMap(), I = new WeakMap(), B = new WeakMap(), A = new WeakMap(), W = new WeakMap(), _ = new WeakMap(), k = new WeakMap(), S = new WeakMap(), E = new WeakMap(), M = new WeakSet(), K = function(t) {
-  const e = X(t, this.originTimestamp);
-  return t < this.originTimestamp ? 0 - e : e;
-}, l = new WeakSet(), D = function(t) {
-  return t === void 0 || nt(t) ? t : t - et(t);
-}, O = new WeakSet(), C = function() {
-  m(this, S, h(this, l, D).call(this, this.selectionStart)), m(this, E, h(this, l, D).call(this, this.selectionEnd));
+_daysInWeek = new WeakMap();
+_daysOfWeekCached = new WeakMap();
+_daysOfWeekend = new WeakMap();
+_currentDayTimestamp = new WeakMap();
+_fromTimestamp = new WeakMap();
+_toTimestamp = new WeakMap();
+_numberOfBlocks = new WeakMap();
+_originMonthStartDate = new WeakMap();
+_originMonthStartOffset = new WeakMap();
+_originMonthStartTimestamp = new WeakMap();
+_originYear = new WeakMap();
+_selectionFromTimestamp = new WeakMap();
+_selectionToTimestamp = new WeakMap();
+_getBlockTimestampOffsetFromOrigin = new WeakSet();
+getBlockTimestampOffsetFromOrigin_fn = function(timestamp) {
+  const offset = getEdgesDistance(timestamp, this.originTimestamp);
+  return timestamp < this.originTimestamp ? 0 - offset : offset;
+};
+_getStartForTimestamp = new WeakSet();
+getStartForTimestamp_fn = function(timestamp) {
+  return timestamp === void 0 || isInfinite(timestamp) ? timestamp : timestamp - computeTimestampOffset(timestamp);
+};
+_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 {
-  It as default
+  MonthFrame as default
 };