@adyen/bento-vue3 1.75.0 → 1.76.0

package/dist/chunks/date-range-picker.B6UKl1_N.js

@@ -0,0 +1,1114 @@
+import { reactive as Ee, defineComponent as tt, ref as F, computed as S, onMounted as at, toRaw as he, resolveComponent as De, createElementBlock as Me, openBlock as A, createElementVNode as H, createCommentVNode as B, renderSlot as qe, createBlock as V, createVNode as W, withCtx as Q, createTextVNode as se, normalizeClass as Oe, toRef as we, watch as ke, withDirectives as pt, unref as b, withKeys as $e, toDisplayString as bt, createSlots as It } from "vue";
+import { B as Rt } from "./divider.DnKNNyWB.js";
+import { h as St, B as Et } from "./button-actions.BQ3AFQqt.js";
+import { B as nt, d as wt } from "./typography.yBEME_Gu.js";
+import { e as P, a as Pe, g as _e } from "./differenceInMonths.C8FyCrav.js";
+import { g as fe } from "./generate-uid.NJ8tVoha.js";
+import { u as Fe } from "./index.pdBj0KQU.js";
+import { e as C, g as rt, h as Ye, i as q, j as kt, k as Le, l as ht, s as je, m as Mt, n as ve, o as Ke, b as te, u as Ot, f as me } from "./calendar.Tm7Cvpwu.js";
+import { f as Ge, v as _t, D as h } from "./date-format.B8RU7D42.js";
+import { t as z, c as Ft, n as Ct } from "./getTimezoneOffsetInMilliseconds.BW7U6PxE.js";
+import { u as At } from "./use-form-layout-loading.D3lALhtC.js";
+import { B as Ut } from "./directive.Cbdox5VL.js";
+import { D as Nt } from "./dropdown-default-textbox.MkU0tMf1.js";
+import { B as Bt } from "./input-field.A-dEZZfC.js";
+import { B as qt } from "./dropdown.DG_EnV8g.js";
+import { B as $t } from "./segmented-control.BCHGDSrf.js";
+import { d as Ie } from "./debounce.DUTu11PS.js";
+import { u as Pt } from "./use-has-slot.B7eQSabc.js";
+import { c as Yt } from "./constructNow.CHWWeLPc.js";
+import { _ as lt } from "./_plugin-vue_export-helper.CHgC5LLL.js";
+import { F as Lt, E as He } from "./field-label.C97CrBI_.js";
+import { B as jt } from "./button-actions.types.BptAXjD8.js";
+import "../assets/date-range-picker.css";
+function oe(e) {
+  if (e == null)
+    return C(/* @__PURE__ */ new Date());
+  const [a, i, r] = e.split("-").map((d) => parseInt(d, 10));
+  return new Date(a, i - 1, r);
+}
+function st(e, a, i) {
+  return rt(e, a * 3, i);
+}
+function Kt(e, a, i) {
+  return st(e, -1, i);
+}
+const Gt = ({
+  firstDayOfWeek: e,
+  min: a,
+  max: i
+}) => ({ getGranularCalendarLimits: (d) => {
+  if (!a && !i)
+    return { min: null, max: null };
+  let m = a ? C(a) : null, D = i ? P(i) : null;
+  if ((d == null ? void 0 : d.type) === "weekly") {
+    if (d.earliest)
+      m = C(d.earliest);
+    else if (m) {
+      const y = Ye(m, { weekStartsOn: e });
+      q(m, y) || (m = C(kt(Le(m, { weekStartsOn: e }), 1)));
+    }
+    if (d.latest)
+      D = P(d.latest);
+    else if (D) {
+      const y = Le(D, { weekStartsOn: e });
+      q(D, y) || (D = P(ht(Ye(D, { weekStartsOn: e }), 1)));
+    }
+  }
+  if ((d == null ? void 0 : d.type) === "monthly") {
+    if (d.earliest)
+      m = C(d.earliest);
+    else if (m) {
+      const y = je(m);
+      q(m, y) || (m = je(rt(m, 1)));
+    }
+    if (d.latest)
+      D = P(d.latest);
+    else if (D) {
+      const y = Pe(D);
+      q(D, y) || (D = Pe(Mt(D, 1)));
+    }
+  }
+  if ((d == null ? void 0 : d.type) === "quarterly") {
+    if (d.earliest)
+      m = ve(d.earliest);
+    else if (m) {
+      const y = ve(m);
+      q(m, y) || (m = ve(st(m, 1)));
+    }
+    if (d.latest)
+      D = P(d.latest);
+    else if (D) {
+      const y = Ke(D);
+      q(D, y) || (D = Ke(Kt(D)));
+    }
+  }
+  return { min: m, max: D };
+} }), Ht = () => {
+  const e = Ee({
+    daily: null,
+    weekly: null,
+    monthly: null,
+    quarterly: null
+  });
+  return {
+    savedRanges: e,
+    saveRange: (r, d) => {
+      e[r] = d;
+    },
+    resetSavedRanges: () => {
+      e.daily = null, e.weekly = null, e.monthly = null, e.quarterly = null;
+    }
+  };
+};
+var g = /* @__PURE__ */ ((e) => (e.CUSTOM_RANGE = "custom-range", e.INPUT = "input", e.ERROR = "error", e.FORM_DATE = "form-date", e.START_DATE_SELECTED = "start-date-selected", e))(g || {});
+const Qt = /[\d]/, Vt = /^\d{2}$/, Wt = /^\d{2}:\d{2}$/, zt = (e) => {
+  const { selectionStart: a } = e.target, i = ["Backspace", "Tab", "ArrowLeft", "ArrowRight"], r = Qt.test(e.key) || i.includes(e.key), d = [1, 2, 4, 5].includes(a) && e.key === ":";
+  !r && !d && e.preventDefault();
+}, Qe = (e) => {
+  if (!e)
+    return e;
+  let a = e;
+  if (a.length === 1 && parseInt(e, 10) > 2)
+    return `0${a}:`;
+  const [i, r] = a.slice(-2);
+  return [2, 5].includes(a.length) && r === ":" && (a = `${a.slice(0, a.length - 2)}0${i}`), (Vt.test(a) || Wt.test(a)) && (a += ":"), a;
+};
+function Jt(e, a, i) {
+  const r = z(e, i == null ? void 0 : i.in);
+  return r.setHours(a), r;
+}
+function Xt(e, a, i) {
+  const r = z(e, i == null ? void 0 : i.in);
+  return r.setMinutes(a), r;
+}
+function Zt(e, a, i) {
+  const r = z(e, i == null ? void 0 : i.in);
+  return r.setSeconds(a), r;
+}
+function Ve(e, a) {
+  const i = z(e, a == null ? void 0 : a.in);
+  return i.setMilliseconds(0), i;
+}
+function We(e, a) {
+  return +Ve(e) == +Ve(a);
+}
+function Re(e, a) {
+  return +z(e) == +z(a);
+}
+function xt(e, a) {
+  return q(
+    Ft(e, e),
+    Yt(e)
+  );
+}
+function ze(e, a, i) {
+  const r = z(e, i == null ? void 0 : i.in);
+  return r.setMilliseconds(a), r;
+}
+const Je = {
+  "en-US": {
+    customRange: "Custom range",
+    daily: "Daily",
+    dateFrom: "Date from",
+    dateTo: "Date to",
+    lastMonth: "Last month",
+    lastSevenDays: "Last 7 days",
+    lastThreeMonths: "Last three months",
+    monthly: "Monthly",
+    quarterly: "Quarterly",
+    timeFrom: "Time from",
+    timeTo: "Time to",
+    weekly: "Weekly"
+  },
+  "ja-JP": {
+    customRange: "カスタム範囲を選択",
+    daily: "毎日",
+    lastMonth: "先月",
+    lastSevenDays: "過去7日間",
+    monthly: "毎月",
+    weekly: "毎週"
+  },
+  "pt-BR": {
+    customRange: "Selecione um intervalo personalizado",
+    daily: "Diário",
+    lastMonth: "Último mês",
+    lastSevenDays: "Últimos 7 dias",
+    monthly: "Mensal",
+    weekly: "Semanal"
+  }
+}, Xe = 300, Ze = "customRange", ea = tt({
+  i18n: { messages: Je },
+  name: "date-range-picker-calendar",
+  components: {
+    BentoDropdown: qt,
+    BentoInputField: Bt,
+    BentoSegmentedControl: $t,
+    BentoTypography: nt,
+    Calendar: te
+  },
+  props: {
+    /**
+     * Allows user to enter time values in the form
+     */
+    allowTimeInput: { type: Boolean, default: !1 },
+    /**
+     * Ranges form persistance data
+     */
+    dateFormData: {
+      type: Object,
+      default: () => ({ startDate: void 0, endDate: void 0, startTime: void 0, endTime: void 0 })
+    },
+    /**
+     * Allows you to set the first day of the week. 0 is sunday, 1 is monday, 6 is saturday
+     */
+    firstDayOfWeek: te.props.firstDayOfWeek,
+    /**
+     * A list of available granularities.
+     * If present, the date picker will display a segmented control to change granularity.
+     */
+    granularities: {
+      type: Array,
+      default: null
+    },
+    /**
+     * Indicate if a date should be disabled or not
+     */
+    isDateDisabled: te.props.isDateDisabled,
+    /**
+     * Set a maximum number of dates to be selectable by the range.
+     */
+    maxRange: te.props.maxRange,
+    /**
+     * Sets a minimum limit for selectable dates - dates before `min` will not be selectable
+     */
+    min: te.props.min,
+    /**
+     * Sets a maximum limit for selectable dates - dates after `max` will not be selectable
+     */
+    max: te.props.max,
+    /**
+     * Number of months rendered on pane
+     */
+    numberOfMonths: te.props.numberOfMonths,
+    /**
+     * Displays the end date's month when the calendar is opened. Defaults to false i.e. the start date's month is displayed.
+     */
+    showEndDateOnOpen: { type: Boolean, default: !1 },
+    /**
+     * Enables the custom range selector.
+     * If provided, must be an array that sets the custom range dropdown items. Items are of the structure:
+     * `label` - label of custom range item.
+     * `value` - a unique key of the custom range item.
+     * `data` - an object `{ startDate: Date; endDate: Date }` to set the date picker range to upon selecting.
+     */
+    quickSelectRanges: {
+      type: Array,
+      default: void 0
+    },
+    /**
+     * Selected date
+     */
+    value: { type: Object, default: void 0 },
+    /**
+     * The type of calendar to display. Defaults to showing days.
+     */
+    variant: te.props.variant
+  },
+  emits: [
+    g.CUSTOM_RANGE,
+    g.INPUT,
+    g.ERROR,
+    g.FORM_DATE,
+    g.START_DATE_SELECTED
+  ],
+  setup(e, { emit: a, slots: i }) {
+    var Ae, Ue, Ne, Be;
+    const { locale: r, t: d } = Fe({ messages: Je }), m = _e(), D = F({}), y = S(() => e.variant === "month" ? "monthly" : "daily"), n = Ee({
+      startDate: (Ae = e.value) == null ? void 0 : Ae.startDate,
+      endDate: (Ue = e.value) == null ? void 0 : Ue.endDate,
+      range: (Ne = e.value) == null ? void 0 : Ne.range,
+      ...e.granularities ? {
+        granularity: ((Be = e.value) == null ? void 0 : Be.granularity) || y.value
+      } : {}
+    });
+    function T(t) {
+      return t ? new Date(
+        t.getUTCFullYear(),
+        t.getUTCMonth(),
+        t.getUTCDate(),
+        t.getUTCHours(),
+        t.getUTCMinutes(),
+        t.getUTCSeconds()
+      ) : null;
+    }
+    const I = S(() => {
+      var t, s;
+      return (
+        // eslint-disable-next-line consistent-return
+        ((s = (t = e == null ? void 0 : e.quickSelectRanges) == null ? void 0 : t.find(({ value: c, data: u }) => {
+          var k;
+          if (!u.endDate) {
+            if (u.isRelativeToNow) {
+              const O = (k = D.value) == null ? void 0 : k[c];
+              return O ? Re(
+                T(O.startDate),
+                T(n.startDate)
+              ) && Re(
+                T(O.endDate),
+                T(n.endDate)
+              ) : (
+                // If not stored calculated dates, fall back to comparing the quick select item's value
+                // with the internal range's stored range identifier.
+                c === n.range
+              );
+            }
+            return Re(
+              T(u.startDate),
+              T(n.startDate)
+            ) && Re(
+              T(n.endDate),
+              T(P(n.endDate))
+            ) && xt(T(n.endDate)) && (e.granularities ? u.granularity === n.granularity : !0);
+          }
+          if (e.allowTimeInput)
+            return We(
+              T(u.startDate),
+              T(n.startDate)
+            ) && We(
+              T(u.endDate),
+              T(n.endDate)
+            ) && (e.granularities ? u.granularity === n.granularity : !0);
+          if (u.endDate)
+            return q(u.startDate, n.startDate) && q(u.endDate, n.endDate) && (e.granularities ? u.granularity === n.granularity : !0);
+        })) == null ? void 0 : s.value) ?? Ze
+      );
+    }), Y = S(() => ({
+      "b-date-range-picker-calendar__form-input-wrapper": e.allowTimeInput
+    })), ye = S(() => [
+      { label: d("customRange"), value: Ze },
+      ...e.quickSelectRanges ? e.quickSelectRanges : []
+    ]), J = S(
+      () => {
+        var t;
+        return ((t = e.granularities) == null ? void 0 : t.find(({ type: s }) => s === n.granularity)) || null;
+      }
+    ), w = S(
+      () => {
+        var t;
+        return ((t = e.granularities) == null ? void 0 : t.map(({ type: s, disabled: c }) => ({
+          label: d(s),
+          value: s,
+          disabled: c
+        }))) ?? [];
+      }
+    ), { getGranularCalendarLimits: X } = Gt(e), f = S(
+      () => e.granularities ? X(J.value) : { min: e.min ? C(e.min) : null, max: e.max ? P(e.max) : null }
+    ), {
+      adjustDateForQuarterly: ie,
+      adjustDateForMonthly: M,
+      adjustDateForWeekly: ae,
+      adjustStartDateInputForWeekly: Z,
+      adjustEndDateInputForWeekly: ue,
+      adjustStartDateInputForMonthly: x,
+      adjustEndDateInputForMonthly: p,
+      adjustStartDateInputForQuarterly: de,
+      adjustEndDateInputForQuarterly: L
+    } = Ot(e.firstDayOfWeek), { savedRanges: $, saveRange: ne, resetSavedRanges: _ } = Ht(), v = (t) => {
+      var s;
+      return t ? me(t, h.NUMERIC_DATE_YEAR_FIRST, {
+        locale: m[(s = r.value) == null ? void 0 : s.substring(0, 2)] || m.enUS
+      }) : "";
+    }, E = (t) => {
+      var s;
+      return t ? me(t, h.HOUR_MINUTE_SECONDS, {
+        locale: m[(s = r.value) == null ? void 0 : s.substring(0, 2)] || m.enUS
+      }) : "";
+    }, j = F(!1), re = F(!1), K = F(!1), G = F(!1), o = Ee({
+      startDate: e.dateFormData.startDate,
+      endDate: e.dateFormData.endDate,
+      startTime: e.dateFormData.startTime,
+      endTime: e.dateFormData.endTime
+    }), Te = (t, s) => {
+      let c = new Date(t);
+      const [u, k, O] = s.split(":");
+      return c = Jt(c, parseInt(u, 10)), c = Xt(c, parseInt(k, 10)), c = Zt(c, parseInt(O, 10)), c;
+    }, ge = (t) => /^(?:[01]\d|2[01234]):(?:[012345]\d):(?:[012345]\d)$/.test(t), ce = (t, s) => {
+      const c = () => {
+        if (s && R(s)) {
+          const u = Te(new Date(s), t);
+          if (e.min && u < ze(e.min, 0) || e.max && u > ze(e.max, 0))
+            return !1;
+        }
+        return !0;
+      };
+      return ge(t) && c();
+    }, U = (t, s) => !s || !ge(s) || e.variant === "month" ? t : Te(new Date(t), s), l = (t) => {
+      o.startTime = E(
+        e.min && e.allowTimeInput && q(e.min, t.startDate) ? e.min : C(t.startDate)
+      ), o.endTime = E(
+        e.max && e.allowTimeInput && q(e.max, t.endDate) ? e.max : P(t.endDate)
+      ), n.startDate = U(t.startDate, o.startTime), n.endDate = U(t.endDate, o.endTime), n.range = null, e.granularities && _(), a(g.INPUT, {
+        ...n,
+        range: I.value
+      });
+    }, R = (t) => {
+      const s = (u) => e.min && C(u) < C(e.min) || e.max && C(u) > C(e.max) ? !1 : e.isDateDisabled ? !e.isDateDisabled(C(u)) : !0;
+      return /^\d{4}-(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])$/.test(t) && s(new Date(t));
+    };
+    at(() => {
+      j.value = !!(e.dateFormData.startDate && !R(e.dateFormData.startDate)), e.allowTimeInput ? K.value = !!(e.dateFormData.startTime && !ce(e.dateFormData.startTime, e.dateFormData.startDate)) : K.value = !1, re.value = !!(e.dateFormData.endDate && !R(e.dateFormData.endDate)), e.allowTimeInput ? G.value = !!(e.dateFormData.endTime && !ce(e.dateFormData.endTime, e.dateFormData.endDate)) : G.value = !1;
+    });
+    const le = (t) => {
+      var s;
+      o.startDate = v(t), o.startTime ? K.value && (o.startTime = (s = e.dateFormData) == null ? void 0 : s.startTime) : o.startTime = E(t), j.value = !1, K.value = !1, a(g.START_DATE_SELECTED, t);
+    }, ee = (t) => {
+      var s;
+      o.endDate = v(t), o.endTime ? G.value && (o.endTime = (s = e.dateFormData) == null ? void 0 : s.endTime) : o.endTime = E(P(t)), re.value = !1, G.value = !1;
+    }, N = (t) => {
+      const s = e.value[t];
+      if (s)
+        return s;
+      if (e.dateFormData[t] && R(e.dateFormData[t]))
+        return new Date(e.dateFormData[t]);
+    }, pe = Ie((t) => {
+      var s;
+      if (R(t)) {
+        let c = t;
+        switch (j.value = !1, (s = J.value) == null ? void 0 : s.type) {
+          case "weekly":
+            c = Z(
+              t,
+              v,
+              f.value.min,
+              f.value.max
+            ), o.startDate = c;
+            break;
+          case "monthly":
+            c = x(
+              t,
+              v,
+              f.value.min,
+              f.value.max
+            ), o.startDate = c;
+            break;
+          case "quarterly":
+            c = de(
+              t,
+              v,
+              f.value.min,
+              f.value.max
+            ), o.startDate = c;
+            break;
+        }
+        const u = oe(c);
+        n.startDate = U(u, o.startTime), n.endDate = U(
+          oe(o.endDate),
+          o.endTime
+        ), R(o.endDate) && (n.endDate = U(
+          oe(o.endDate),
+          o.endTime
+        ));
+        const k = N("endDate");
+        n.range = null, a(g.FORM_DATE, {
+          startDate: u,
+          endDate: k
+        }), a(g.INPUT, {
+          ...n,
+          range: I.value
+        });
+      } else
+        j.value = !0, a(g.ERROR, { ...o });
+    }, Xe), ot = (t) => {
+      o.startDate = Ge(t), pe(o.startDate);
+    }, it = Ie((t) => {
+      var s;
+      if (R(t)) {
+        let c = t;
+        switch (re.value = !1, (s = J.value) == null ? void 0 : s.type) {
+          case "weekly":
+            c = ue(
+              t,
+              v,
+              f.value.min,
+              f.value.max
+            ), o.endDate = c;
+            break;
+          case "monthly":
+            c = p(
+              t,
+              v,
+              f.value.min,
+              f.value.max
+            ), o.endDate = c;
+            break;
+          case "quarterly":
+            c = L(
+              t,
+              v,
+              f.value.min,
+              f.value.max
+            ), o.endDate = c;
+            break;
+        }
+        const u = oe(c);
+        n.endDate = U(u, o.endTime), R(o.startDate) && (n.startDate = U(
+          oe(o.startDate),
+          o.startTime
+        ));
+        const k = N("startDate");
+        n.range = null, a(g.FORM_DATE, {
+          startDate: k,
+          endDate: u
+        }), a(g.INPUT, {
+          ...n,
+          range: I.value
+        });
+      } else
+        re.value = !0, a(g.ERROR, { ...o });
+    }, Xe), ut = (t) => {
+      o.endDate = Ge(t), it(o.endDate);
+    }, dt = (t) => {
+      _t(t);
+    }, ct = Ie((t) => {
+      if (ce(t, e.dateFormData.startDate)) {
+        K.value = !1, n.startDate = U(n.startDate, t);
+        const s = N("endDate");
+        a(g.FORM_DATE, {
+          startDate: n.startDate,
+          endDate: s,
+          startTime: t,
+          endTime: o.endTime ?? e.dateFormData.endTime
+        }), a(g.INPUT, {
+          ...n,
+          range: I.value
+        });
+      } else
+        K.value = !0, a(g.ERROR, { ...o });
+    }), mt = Ie((t) => {
+      ce(t, e.dateFormData.endDate) ? (G.value = !1, n.endDate = U(n.endDate, t), a(g.FORM_DATE, {
+        startDate: n.startDate,
+        endDate: n.endDate,
+        startTime: o.startTime ?? e.dateFormData.startTime,
+        endTime: t
+      }), a(g.INPUT, {
+        ...n,
+        range: I.value
+      })) : (G.value = !0, a(g.ERROR, { ...o }));
+    }), Dt = (t) => {
+      o.startTime = Qe(t), ct(o.startTime);
+    }, ft = (t) => {
+      o.endTime = Qe(t), mt(o.endTime);
+    }, vt = (t) => {
+      zt(t);
+    }, be = (t, s, c, u) => {
+      n.startDate = t, n.endDate = s, c && (n.granularity = c), u && (n.range = u);
+    }, yt = (t) => {
+      var c;
+      const s = (c = e.quickSelectRanges) == null ? void 0 : c.find(({ value: u }) => u === t);
+      if (s) {
+        _();
+        const u = s.data, k = u.endDate || (u.isRelativeToNow ? new Date(Date.now()) : P(new Date(Date.now()))), O = u.isRelativeToNow && u.timeDifference ? new Date(k.getTime() - u.timeDifference) : u.startDate;
+        o.endDate = v(k), o.startDate = v(O), be(O, k, null, t), e.granularities && (n.granularity = u.granularity || y.value), o.startTime = E(O), o.endTime = E(k), n.startDate = O, n.endDate = k, u.isRelativeToNow && (D.value = {
+          ...D.value,
+          [t]: {
+            startDate: O,
+            endDate: k
+          }
+        }), a(g.CUSTOM_RANGE, {
+          ...s.data,
+          startDate: O,
+          endDate: k,
+          range: s.value
+        });
+      }
+    }, Tt = {
+      weekly: ae,
+      monthly: M,
+      quarterly: ie
+    }, gt = (t) => {
+      const s = n.granularity;
+      if (n.granularity = t, s && ne(s, structuredClone(he(n))), n.startDate && n.endDate) {
+        switch (t) {
+          case "quarterly":
+          case "monthly":
+          case "weekly": {
+            if ($[t]) {
+              be($[t].startDate, $[t].endDate, t);
+              break;
+            }
+            const { startDate: c, endDate: u } = Tt[t](
+              n.startDate,
+              n.endDate,
+              f.value.min,
+              f.value.max
+            );
+            be(c, u, t);
+            break;
+          }
+          case "daily":
+            $.daily && be($.daily.startDate, $.daily.endDate, t);
+            break;
+        }
+        o.startDate = v(n.startDate), o.endDate = v(n.endDate), a(g.INPUT, {
+          ...n,
+          range: I.value
+        });
+      }
+    };
+    return {
+      // Values
+      internalRangeDate: n,
+      dateTextInput: o,
+      endDateError: re,
+      endTimeError: G,
+      granularityItems: w,
+      selectedGranularity: J,
+      computedMinMax: f,
+      selectedRangeSelectorValue: I,
+      startDateError: j,
+      startTimeError: K,
+      quickSelectRangeDefaultItems: ye,
+      formInputWrapperConditionalClasses: Y,
+      // Methods
+      hasSlot: Pt(i),
+      t: d,
+      // Events
+      onDateInput: l,
+      onDateInputKeyDown: dt,
+      onEndDateInput: ut,
+      onEndDateSelected: ee,
+      onEndTimeInput: ft,
+      onGranularityInput: gt,
+      onRangeSelectorInput: yt,
+      onStartDateInput: ot,
+      onStartDateSelected: le,
+      onStartTimeInput: Dt,
+      onTimeInputKeyDown: vt
+    };
+  }
+}), ta = { class: "b-date-range-picker-calendar" }, aa = { class: "b-date-range-picker-calendar__form-container" }, na = { class: "b-date-range-picker-calendar__form" }, ra = { key: 0 }, la = { class: "b-date-range-picker-calendar__calendars-container" };
+function sa(e, a, i, r, d, m) {
+  const D = De("bento-dropdown"), y = De("bento-segmented-control"), n = De("bento-typography"), T = De("bento-input-field"), I = De("calendar");
+  return A(), Me("div", ta, [
+    H("div", aa, [
+      H("div", na, [
+        e.hasSlot("title") ? qe(e.$slots, "title", { key: 0 }, void 0, !0) : B("", !0),
+        e.quickSelectRanges ? (A(), V(D, {
+          key: 1,
+          "aria-label": e.t("customRange"),
+          items: e.quickSelectRangeDefaultItems,
+          value: e.selectedRangeSelectorValue,
+          onInput: e.onRangeSelectorInput
+        }, null, 8, ["aria-label", "items", "value", "onInput"])) : B("", !0),
+        e.granularities ? (A(), V(y, {
+          key: 2,
+          items: e.granularityItems,
+          "model-value": e.internalRangeDate.granularity,
+          "full-width": "",
+          "onUpdate:modelValue": e.onGranularityInput
+        }, null, 8, ["items", "model-value", "onUpdate:modelValue"])) : B("", !0),
+        H("div", null, [
+          W(n, {
+            stronger: "",
+            el: "span",
+            class: "b-date-range-picker-calendar__label"
+          }, {
+            default: Q(() => a[0] || (a[0] = [
+              se(" From ")
+            ])),
+            _: 1
+          }),
+          H("div", {
+            class: Oe(e.formInputWrapperConditionalClasses)
+          }, [
+            W(T, {
+              "aria-label": e.t("dateFrom"),
+              value: e.dateTextInput.startDate,
+              error: e.startDateError,
+              class: "b-date-range-picker-calendar__form-input",
+              onInput: e.onStartDateInput,
+              onKeydown: e.onDateInputKeyDown
+            }, {
+              description: Q(() => a[1] || (a[1] = [
+                se("YYYY-MM-DD")
+              ])),
+              _: 1
+            }, 8, ["aria-label", "value", "error", "onInput", "onKeydown"]),
+            e.allowTimeInput ? (A(), V(T, {
+              key: 0,
+              "aria-label": e.t("timeFrom"),
+              value: e.dateTextInput.startTime,
+              error: e.startTimeError,
+              class: "b-date-range-picker-calendar__form-input",
+              onInput: e.onStartTimeInput,
+              onKeydown: e.onTimeInputKeyDown
+            }, {
+              description: Q(() => a[2] || (a[2] = [
+                se("HH:MM:SS")
+              ])),
+              _: 1
+            }, 8, ["aria-label", "value", "error", "onInput", "onKeydown"])) : B("", !0)
+          ], 2)
+        ]),
+        H("div", null, [
+          W(n, {
+            stronger: "",
+            el: "span",
+            class: "b-date-range-picker-calendar__label"
+          }, {
+            default: Q(() => a[3] || (a[3] = [
+              se(" To ")
+            ])),
+            _: 1
+          }),
+          H("div", {
+            class: Oe(e.formInputWrapperConditionalClasses)
+          }, [
+            W(T, {
+              class: "b-date-range-picker-calendar__form-input",
+              "aria-label": e.t("dateTo"),
+              value: e.dateTextInput.endDate,
+              error: e.endDateError,
+              onInput: e.onEndDateInput,
+              onKeydown: e.onDateInputKeyDown
+            }, {
+              description: Q(() => a[4] || (a[4] = [
+                se("YYYY-MM-DD")
+              ])),
+              _: 1
+            }, 8, ["aria-label", "value", "error", "onInput", "onKeydown"]),
+            e.allowTimeInput ? (A(), V(T, {
+              key: 0,
+              "aria-label": e.t("timeTo"),
+              value: e.dateTextInput.endTime,
+              error: e.endTimeError,
+              class: "b-date-range-picker-calendar__form-input",
+              onInput: e.onEndTimeInput,
+              onKeydown: e.onTimeInputKeyDown
+            }, {
+              description: Q(() => a[5] || (a[5] = [
+                se("HH:MM:SS")
+              ])),
+              _: 1
+            }, 8, ["aria-label", "value", "error", "onInput", "onKeydown"])) : B("", !0)
+          ], 2)
+        ])
+      ]),
+      e.hasSlot("actions") ? (A(), Me("div", ra, [
+        qe(e.$slots, "actions", {}, void 0, !0)
+      ])) : B("", !0)
+    ]),
+    H("div", la, [
+      W(I, {
+        value: e.internalRangeDate,
+        "first-day-of-week": e.firstDayOfWeek,
+        "is-date-disabled": e.isDateDisabled,
+        "max-range": e.maxRange,
+        min: e.computedMinMax.min,
+        max: e.computedMinMax.max,
+        "number-of-months": e.numberOfMonths,
+        "show-end-date-on-open": e.showEndDateOnOpen,
+        granularity: e.selectedGranularity,
+        variant: e.variant,
+        "is-range": "",
+        onInput: e.onDateInput,
+        onStartDateSelected: e.onStartDateSelected,
+        onEndDateSelected: e.onEndDateSelected
+      }, null, 8, ["value", "first-day-of-week", "is-date-disabled", "max-range", "min", "max", "number-of-months", "show-end-date-on-open", "granularity", "variant", "onInput", "onStartDateSelected", "onEndDateSelected"])
+    ])
+  ]);
+}
+const oa = /* @__PURE__ */ lt(ea, [["render", sa], ["__scopeId", "data-v-225b979c"]]);
+function xe(e, a) {
+  const i = z(e, a == null ? void 0 : a.in);
+  return Math.trunc(i.getMonth() / 3) + 1;
+}
+function et(e, a) {
+  return z(e, a == null ? void 0 : a.in).getFullYear();
+}
+function ia(e, a, i) {
+  const [r, d] = Ct(
+    i == null ? void 0 : i.in,
+    e,
+    a
+  );
+  return +ve(r) == +ve(d);
+}
+const Ce = {
+  "en-US": {
+    apply: "Apply",
+    cancel: "Cancel",
+    dateRangePicker: "Date range picker {name}",
+    provideDateInAFormat: "Provide date in a YYYY-MM-DD format",
+    quarter: "Q{quarter} {year}",
+    selectDate: "Select a date",
+    selectDateRange: "Select a date range",
+    selectedDateIsNotAvailable: "Selected date is not available"
+  },
+  "ja-JP": {
+    apply: "適用",
+    cancel: "キャンセル",
+    selectDate: "日付を選択"
+  },
+  "pt-BR": {
+    apply: "Aplicar",
+    cancel: "Cancelar",
+    selectDate: "Selecione uma data"
+  }
+}, ua = ({
+  datePickerValue: e,
+  isDateIncorrect: a,
+  quickSelectRanges: i,
+  isMonthVariant: r,
+  withTimeInput: d,
+  placeholder: m
+}) => {
+  var w, X, f, ie;
+  const { locale: D, t: y } = Fe({ messages: Ce }), n = _e(), T = (M) => !!M && !isNaN(M.getTime()), I = (M, ae) => {
+    var Z;
+    return T(M) ? me(M, ae, {
+      locale: n[(Z = D.value) == null ? void 0 : Z.substring(0, 2)] || n.enUS
+    }) : void 0;
+  }, Y = Ee({
+    startDate: I((w = e.value) == null ? void 0 : w.startDate, h.NUMERIC_DATE_YEAR_FIRST),
+    endDate: I((X = e.value) == null ? void 0 : X.endDate, h.NUMERIC_DATE_YEAR_FIRST),
+    startTime: I((f = e.value) == null ? void 0 : f.startDate, h.HOUR_MINUTE_SECONDS),
+    endTime: I((ie = e.value) == null ? void 0 : ie.endDate, h.HOUR_MINUTE_SECONDS)
+  });
+  return {
+    // Values
+    dateDisplayValue: S(() => {
+      var ne;
+      if (a.value)
+        return `${Y.startDate || ""} - ${Y.endDate || ""}`;
+      if (!e.value || !e.value.startDate && !e.value.endDate)
+        return (m == null ? void 0 : m.value) || y("selectDateRange");
+      if ((ne = i.value) != null && ne.length) {
+        const _ = i.value.find(({ value: v }) => {
+          var E;
+          return v === ((E = e.value) == null ? void 0 : E.range);
+        });
+        if (_)
+          return _.label;
+      }
+      if (e.value.granularity === "quarterly") {
+        const { startDate: _, endDate: v } = e.value, E = y("quarter", { quarter: xe(_), year: et(_) });
+        if (ia(_, v))
+          return E;
+        const j = y("quarter", { quarter: xe(v), year: et(v) });
+        return `${E} - ${j}`;
+      }
+      const { startDate: M, endDate: ae, startTime: Z, endTime: ue } = Y, x = r != null && r.value ? h.LONG_MONTH_YEAR : h.FULL_DATE_MONTH_FIRST, p = I(oe(M), x), de = I(oe(ae), x);
+      if (!d.value)
+        return `${p} - ${de}`;
+      const L = [p, Z].filter(Boolean).join(", "), $ = [de, ue].filter(Boolean).join(", ");
+      return `${L} - ${$}`;
+    }),
+    textInputDisplayValue: Y,
+    // Methods
+    formatTextInputDisplayValue: () => ""
+  };
+};
+var Se = /* @__PURE__ */ ((e) => (e.INPUT = "input", e))(Se || {});
+const da = { class: "b-date-range-picker" }, ca = { class: "b-date-range-picker__footer" }, ma = {
+  i18n: { messages: Ce },
+  name: "bento-date-range-picker"
+}, Da = /* @__PURE__ */ tt({
+  ...ma,
+  props: {
+    allowTimeInput: { type: Boolean },
+    firstDayOfWeek: { default: 1 },
+    granularities: {},
+    isDateDisabled: { type: Function, default: void 0 },
+    showEndDateOnOpen: { type: Boolean, default: !1 },
+    quickSelectRanges: { default: void 0 },
+    maxRange: { default: null },
+    min: { default: null },
+    max: { default: null },
+    numberOfMonths: { default: void 0 },
+    value: { default: null },
+    variant: { default: void 0 },
+    hasActions: { type: Boolean, default: !1 },
+    description: { default: void 0 },
+    disabled: { type: Boolean, default: !1 },
+    errorMessage: { default: null },
+    label: { default: void 0 },
+    optional: { type: Boolean, default: !1 },
+    placeholder: { default: null },
+    readonly: { type: Boolean, default: !1 },
+    required: { type: Boolean, default: !1 },
+    tooltipText: { default: null }
+  },
+  emits: [Se.INPUT],
+  setup(e, { emit: a }) {
+    const i = a, r = e, { locale: d, t: m } = Fe({ messages: Ce }), D = _e(), y = fe("bento-date-range-picker-container"), n = fe("bento-date-range-picker-label"), T = fe("bento-date-range-picker-description"), I = fe("bento-date-range-picker-error"), Y = fe("bento-date-range-picker-date-error"), ye = S(() => r.label || m("dateRangePicker", { name: y })), J = S(() => (r == null ? void 0 : r.quickSelectRanges) && r.quickSelectRanges.map((l) => {
+      const R = l.data.endDate ? void 0 : new Date(Date.now()).getTime() - l.data.startDate.getTime();
+      return {
+        ...l,
+        data: {
+          ...l.data,
+          // Adding timeDifference to calculate an up-to-date endDate on range selection
+          timeDifference: R
+        }
+      };
+    })), w = F(!1), X = F(null), f = F(!1), { isReadOnly: ie } = At(we(r, "readonly"));
+    ke(
+      () => r.disabled,
+      () => {
+        r.disabled && f.value && (f.value = !1);
+      }
+    );
+    const M = S(() => r.hasActions ? !E.value && w.value : w.value), ae = S(() => ({
+      "b-date-range-picker__description--error": !!r.errorMessage || M.value
+    })), Z = S(() => r.variant === "month"), ue = S(() => r.allowTimeInput && r.variant !== "month"), { dateDisplayValue: x, textInputDisplayValue: p } = ua({
+      datePickerValue: we(r, "value"),
+      isDateIncorrect: w,
+      quickSelectRanges: J,
+      isMonthVariant: Z,
+      withTimeInput: ue,
+      placeholder: we(r, "placeholder")
+    }), de = S(
+      () => `${r.description ? T : ""} ${r.errorMessage ? I : ""} ${w.value ? Y : ""}`.trim() || null
+    ), L = () => {
+      f.value = !1;
+    }, $ = () => {
+      f.value = !0;
+    }, ne = F(x.value), _ = F(
+      // textInputDisplayValue is a reactive object
+      structuredClone(he(p))
+    ), v = F(r.value), E = F(!0), j = S(
+      () => r.hasActions ? _.value : p
+    ), re = S(
+      () => r.hasActions ? ne.value : x.value
+    );
+    at(() => {
+      if (r.hasActions || wt(
+        'BentoDateRangePicker "hasActions" property',
+        `Set the BentoDateRangePicker "hasActions" property true which will display the "Apply" and "Cancel" buttons.
+                        This will be the default behavior in the v2 and "hasActions" will be removed.`,
+        "2.0.0"
+      ), r.granularities && r.variant !== "month" && r.granularities.find(({ type: l }) => l === "quarterly"))
+        throw new Error('Quarterly granularity is only supported by BentoDateRangePicker with variant: "month"');
+    }), ke(
+      () => r.value,
+      () => {
+        ne.value = x.value, _.value = structuredClone(he(p));
+      }
+    );
+    const K = S(() => [
+      {
+        title: m("apply"),
+        event: () => {
+          i(Se.INPUT, v.value), L(), E.value = !0;
+        },
+        disabled: E.value
+      },
+      {
+        title: m("cancel"),
+        event: L
+      }
+    ]);
+    ke(v, (l) => {
+      if (r.hasActions) {
+        E.value = w.value;
+        return;
+      }
+      i(Se.INPUT, l);
+    });
+    const G = (l) => {
+      w.value = !1;
+      const R = (le, ee) => {
+        var N;
+        return le ? me(le, ee, {
+          locale: D[(N = d.value) == null ? void 0 : N.substring(0, 2)] || D.enUS
+        }) : void 0;
+      };
+      p.startDate = R(l.startDate, h.NUMERIC_DATE_YEAR_FIRST), p.endDate = R(l.endDate, h.NUMERIC_DATE_YEAR_FIRST), p.startTime = R(l.startDate, h.HOUR_MINUTE_SECONDS), p.endTime = R(l.endDate, h.HOUR_MINUTE_SECONDS), v.value = l;
+    }, o = async () => {
+      w.value && (w.value = !1), v.value = null;
+    }, Te = () => {
+      if (!f.value) {
+        f.value = !0;
+        return;
+      }
+      w.value || (f.value = !1);
+    }, ge = (l) => {
+      w.value = !1, l.startTime && (p.startTime = l.startTime), l.endTime && (p.endTime = l.endTime);
+    }, ce = (l) => {
+      w.value = !0, p.startDate = l.startDate, p.endDate = l.endDate, v.value = { startDate: null, endDate: null };
+    }, U = (l) => {
+      if (l) {
+        const R = (ee, N) => {
+          var pe;
+          return ee ? me(ee, N, {
+            locale: D[(pe = d.value) == null ? void 0 : pe.substring(0, 2)] || D.enUS
+          }) : void 0;
+        }, le = (ee) => {
+          var N;
+          return me(ee, h.NUMERIC_DATE_YEAR_FIRST, {
+            locale: D[(N = d.value) == null ? void 0 : N.substring(0, 2)] || D.enUS
+          });
+        };
+        p.startDate = le(l.startDate), p.endDate = le(l.endDate), p.startTime = R(
+          l.startDate,
+          h.HOUR_MINUTE_SECONDS
+        ), p.endTime = R(l.endDate, h.HOUR_MINUTE_SECONDS), v.value = l;
+      }
+    };
+    return (l, R) => pt((A(), Me("div", da, [
+      l.label ? (A(), V(b(Lt), {
+        key: 0,
+        id: b(n),
+        label: l.label,
+        "tooltip-text": l.tooltipText,
+        optional: l.optional,
+        required: l.required
+      }, null, 8, ["id", "label", "tooltip-text", "optional", "required"])) : B("", !0),
+      H("div", {
+        onKeydown: $e(Te, ["enter"])
+      }, [
+        W(b(Nt), {
+          ref_key: "inputContainerRef",
+          ref: X,
+          "always-combobox-is-input": "",
+          ariaControls: b(y),
+          ariaExpanded: f.value,
+          "aria-labelledby": l.label ? b(n) : null,
+          "aria-describedby": de.value,
+          disabled: l.disabled,
+          "is-invalid": !!l.errorMessage || M.value,
+          open: f.value,
+          "display-value": re.value,
+          readonly: b(ie),
+          onOpen: $,
+          onClear: o,
+          onClose: L
+        }, null, 8, ["ariaControls", "ariaExpanded", "aria-labelledby", "aria-describedby", "disabled", "is-invalid", "open", "display-value", "readonly"])
+      ], 32),
+      M.value ? (A(), V(b(He), {
+        key: 1,
+        id: b(Y),
+        "error-message": b(m)("provideDateInAFormat"),
+        class: "b-date-range-picker__error-message"
+      }, null, 8, ["id", "error-message"])) : B("", !0),
+      l.errorMessage ? (A(), V(b(He), {
+        key: 2,
+        id: b(I),
+        "error-message": l.errorMessage,
+        class: "b-date-range-picker__error-message"
+      }, null, 8, ["id", "error-message"])) : B("", !0),
+      l.description ? (A(), V(b(nt), {
+        key: 3,
+        id: b(T),
+        class: Oe(["b-date-range-picker__description", ae.value]),
+        el: "span"
+      }, {
+        default: Q(() => [
+          se(bt(l.description), 1)
+        ]),
+        _: 1
+      }, 8, ["id", "class"])) : B("", !0),
+      X.value ? (A(), V(b(St), {
+        key: 4,
+        id: b(y),
+        class: "b-date-range-picker__container",
+        open: f.value,
+        "target-element": X.value,
+        "aria-label": ye.value,
+        position: "bottom-start",
+        "without-space": "",
+        "fit-content": "",
+        "trap-all": "",
+        onKeydown: $e(L, ["esc", "native"])
+      }, {
+        default: Q(() => [
+          W(b(oa), {
+            "allow-time-input": ue.value,
+            "quick-select-ranges": J.value,
+            value: l.value,
+            "first-day-of-week": l.firstDayOfWeek,
+            granularities: l.granularities,
+            "is-date-disabled": l.isDateDisabled,
+            "max-range": l.maxRange,
+            min: l.min,
+            max: l.max,
+            "number-of-months": l.numberOfMonths,
+            "show-end-date-on-open": l.showEndDateOnOpen,
+            "date-form-data": j.value,
+            variant: l.variant,
+            onCustomRange: U,
+            onInput: G,
+            onError: ce,
+            onFormDate: ge
+          }, It({ _: 2 }, [
+            l.hasActions ? {
+              name: "actions",
+              fn: Q(() => [
+                W(b(Rt)),
+                H("div", ca, [
+                  W(b(Et), {
+                    actions: K.value,
+                    layout: b(jt).SPACE_BETWEEN
+                  }, null, 8, ["actions", "layout"])
+                ])
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["allow-time-input", "quick-select-ranges", "value", "first-day-of-week", "granularities", "is-date-disabled", "max-range", "min", "max", "number-of-months", "show-end-date-on-open", "date-form-data", "variant"])
+        ]),
+        _: 1
+      }, 8, ["id", "open", "target-element", "aria-label"])) : B("", !0)
+    ])), [
+      [b(Ut), L]
+    ]);
+  }
+}), Ba = /* @__PURE__ */ lt(Da, [["__scopeId", "data-v-09f3b2b1"]]);
+export {
+  Ba as B,
+  oa as D,
+  Se as a,
+  xt as b,
+  Re as i
+};
+//# sourceMappingURL=date-range-picker.B6UKl1_N.js.map