@ironsource/shared-ui 1.4.2-test.4 → 1.4.2-test.5

package/src/components/checkbox/icons/unchecked.vue.js

@@ -0,0 +1,30 @@
+import { openBlock, createElementBlock, createElementVNode } from 'vue';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Unchecked.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+const _hoisted_1 = {
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2 = /*#__PURE__*/createElementVNode("rect", {
+  x: "1",
+  y: "1",
+  width: "14",
+  height: "14",
+  rx: "3",
+  stroke: "currentColor",
+  "stroke-width": "2"
+}, null, -1);
+const _hoisted_3 = [
+  _hoisted_2
+];
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+var Unchecked = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render]]);
+
+export { Unchecked as default };

package/src/components/checkbox/index.vue.js

@@ -0,0 +1,6 @@
+import Checkbox from './Checkbox.vue.js';
+export { default as Checkbox } from './Checkbox.vue.js';
+
+const CheckboxTypes = () => [Checkbox];
+
+export { CheckboxTypes };

package/src/components/chip/Chip.vue.js

@@ -0,0 +1,64 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, renderSlot, createCommentVNode, createElementVNode, toDisplayString, createVNode, unref } from 'vue';
+import Icon from '../icon/Icon.vue.js';
+/* empty css                                                      */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Chip.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = ["disabled"];
+const _hoisted_2 = {
+  key: 0,
+  class: "icon icon--start"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "prefix"
+};
+const _hoisted_4 = {
+  key: 1,
+  class: "icon icon--end"
+};
+const _sfc_main = defineComponent({
+  __name: "Chip",
+  props: {
+    selected: { type: Boolean, default: false },
+    clearable: { type: Boolean, default: false },
+    prefix: { default: null },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["cleared"],
+  setup(__props, { emit }) {
+    const cleared = (event) => {
+      event.stopPropagation();
+      emit("cleared");
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        class: normalizeClass(["chip-container", { selected: _ctx.selected, disabled: _ctx.disabled }]),
+        disabled: _ctx.disabled
+      }, [
+        _ctx.$slots["icon-start"] ? (openBlock(), createElementBlock("span", _hoisted_2, [
+          renderSlot(_ctx.$slots, "icon-start", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        createElementVNode("span", null, [
+          !!_ctx.prefix ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(_ctx.prefix) + ":", 1)) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _ctx.$slots["icon-end"] ? (openBlock(), createElementBlock("span", _hoisted_4, [
+          renderSlot(_ctx.$slots, "icon-end", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        _ctx.clearable ? (openBlock(), createElementBlock("button", {
+          key: 2,
+          class: "clear-icon",
+          onClick: cleared
+        }, [
+          createVNode(unref(Icon), {
+            name: "close",
+            "font-size": "sm"
+          })
+        ])) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+var Chip = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-68f9a601"]]);
+
+export { Chip as default };

package/src/components/chip/index.vue.js

@@ -0,0 +1,6 @@
+import Chip from './Chip.vue.js';
+export { default as Chip } from './Chip.vue.js';
+
+const ChipTypes = () => [Chip];
+
+export { ChipTypes };

package/src/components/cssBaseline/CssBaseline.vue.js

@@ -0,0 +1,12 @@
+import { renderSlot } from 'vue';
+/* empty css                                                             *//* empty css                                                 */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../CssBaseline.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+function _sfc_render(_ctx, _cache) {
+  return renderSlot(_ctx.$slots, "default", {}, undefined, true)
+}
+var CssBaseline = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render],['__scopeId',"data-v-dbb761f8"]]);
+
+export { CssBaseline as default };

package/src/components/cssBaseline/index.vue.js

@@ -0,0 +1,6 @@
+import CssBaseline from './CssBaseline.vue.js';
+export { default as CssBaseline } from './CssBaseline.vue.js';
+
+const CssBaselineTypes = () => [CssBaseline];
+
+export { CssBaselineTypes };

package/src/components/datePicker/DatePicker.vue.js

@@ -0,0 +1,125 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, createElementVNode, unref, renderSlot, withDirectives, vModelText, normalizeClass, createVNode, createCommentVNode } from 'vue';
+import { onClickOutside } from '@vueuse/core';
+import { useToggle } from '../../composables/useToggle.vue.js';
+import DatePickerMonth from './DatePickerMonth.vue.js';
+import { isValid, format, parse, isFuture } from 'date-fns';
+/* empty css                                                            */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../DatePicker.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = ["id"];
+const _hoisted_2 = ["placeholder"];
+const _sfc_main = defineComponent({
+  __name: "DatePicker",
+  props: {
+    uniqueId: { default: Date.now() },
+    modelValue: { default: null },
+    allowFutureDates: { type: Boolean, default: false },
+    dateFormat: { default: "yyyy-MM-d" },
+    placeholder: { default: "" }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const datePicker = ref(null);
+    const popup = ref(null);
+    const input = ref(null);
+    const buttonRef = ref(null);
+    const [isOpen, toggle] = useToggle({ initialValue: false });
+    const close = () => {
+      toggle(false);
+    };
+    const handleInput = (event) => {
+      const value = event.target.value;
+      if (!isOpen) {
+        emit("update:modelValue", value);
+        return;
+      }
+      const parsedDate = parse(value, props.dateFormat, new Date());
+      if (!value.trim()) {
+        updateValue(null);
+      }
+      if (!isValid(parsedDate)) {
+        return;
+      }
+      if (!props.allowFutureDates && isFuture(parsedDate)) {
+        return;
+      }
+      updateValue(parsedDate);
+    };
+    const updateValue = (value) => {
+      close();
+      emit("update:modelValue", value);
+    };
+    const componentId = computed(() => {
+      return `datePicker${props.uniqueId || Math.random().toString().substring(2, 7)}`;
+    });
+    const formattedValue = computed(() => {
+      const date = new Date(props.modelValue);
+      return isValid(props.modelValue) ? format(date, props.dateFormat) : props.modelValue;
+    });
+    const nearTheEdge = computed(() => {
+      if (!datePicker.value || !isOpen)
+        return false;
+      const rect = datePicker.value.getBoundingClientRect();
+      const popupWidth = 232;
+      return window.innerWidth - (rect.x + popupWidth) < 0;
+    });
+    const valueAsDate = computed(() => {
+      if (!props.modelValue)
+        return null;
+      const parsedDate = new Date(props.modelValue);
+      return isValid(parsedDate) ? parsedDate : null;
+    });
+    onClickOutside(
+      popup,
+      () => {
+        close();
+      },
+      { ignore: [datePicker] }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        id: componentId.value,
+        ref_key: "datePicker",
+        ref: datePicker,
+        class: "date-picker"
+      }, [
+        createElementVNode("div", {
+          ref_key: "buttonRef",
+          ref: buttonRef,
+          onClick: _cache[2] || (_cache[2] = ($event) => unref(toggle)())
+        }, [
+          renderSlot(_ctx.$slots, "default", { formattedDate: formattedValue.value }, () => [
+            withDirectives(createElementVNode("input", {
+              ref_key: "input",
+              ref: input,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => formattedValue.value = $event),
+              type: "text",
+              class: "input",
+              placeholder: _ctx.placeholder,
+              onInput: _cache[1] || (_cache[1] = ($event) => handleInput($event))
+            }, null, 40, _hoisted_2), [
+              [vModelText, formattedValue.value]
+            ])
+          ], true)
+        ], 512),
+        unref(isOpen) ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          ref_key: "popup",
+          ref: popup,
+          class: normalizeClass(["date-picker-popup", { "align-right": nearTheEdge.value }])
+        }, [
+          createVNode(DatePickerMonth, {
+            id: componentId.value + "-month",
+            "model-value": valueAsDate.value,
+            "allow-future-dates": _ctx.allowFutureDates,
+            "onUpdate:modelValue": updateValue
+          }, null, 8, ["id", "model-value", "allow-future-dates"])
+        ], 2)) : createCommentVNode("", true)
+      ], 8, _hoisted_1);
+    };
+  }
+});
+var DatePicker = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1f4328e0"]]);
+
+export { DatePicker as default };

package/src/components/datePicker/DatePickerMonth.vue.js

@@ -0,0 +1,99 @@
+import { defineComponent, ref, watch, onMounted, computed, openBlock, createBlock, unref } from 'vue';
+import CalendarMonth from '../dateRange/CalendarMonth.vue.js';
+import dateServices from '../dateRange/DateServices.vue.js';
+import { navigateNext } from '../dateRange/consts.vue.js';
+import { startOfMonth, differenceInMonths, addMonths, subMonths } from 'date-fns';
+/* empty css                                                                 */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../DatePickerMonth.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "DatePickerMonth",
+  props: {
+    uniqueId: { default: Date.now() },
+    modelValue: { default: null },
+    includeToday: { type: Boolean, default: true },
+    allowFutureDates: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const getMonthDataFromDate = (date) => {
+      const month = date.getMonth();
+      const year = date.getFullYear();
+      return dateServices.createMonth(
+        month,
+        year,
+        props.includeToday,
+        !props.allowFutureDates
+      );
+    };
+    let monthData = ref(getMonthDataFromDate(dateServices.getCurrentTimeUTC()));
+    const resetMonth = () => {
+      const date = props.modelValue || dateServices.getCurrentTimeUTC();
+      monthData.value = getMonthDataFromDate(date);
+    };
+    const handleNavigation = (direction) => {
+      const date = new Date(monthData.value.year, monthData.value.month);
+      const newDate = direction === navigateNext ? addMonths(date, 1) : subMonths(date, 1);
+      monthData.value = getMonthDataFromDate(newDate);
+    };
+    watch(
+      () => props.modelValue,
+      () => {
+        resetMonth();
+      }
+    );
+    watch(
+      () => props.allowFutureDates,
+      () => {
+        monthData.value = getMonthDataFromDate(
+          new Date(monthData.value.year, monthData.value.month)
+        );
+      }
+    );
+    const getRangeFromDate = (date) => {
+      const d = date || null;
+      return {
+        fromStart: d,
+        fromEnd: d,
+        toStart: d,
+        toEnd: d
+      };
+    };
+    onMounted(() => {
+      resetMonth();
+    });
+    const navigation = computed(() => {
+      if (props.allowFutureDates)
+        return "all";
+      const current = startOfMonth(dateServices.getCurrentTimeUTC());
+      differenceInMonths(monthData.value.year, monthData.value.month);
+      const date = new Date(monthData.value.year, monthData.value.month);
+      return differenceInMonths(date, current) >= 0 ? "previous" : "all";
+    });
+    const selectedRange = computed(() => getRangeFromDate(props.modelValue));
+    const handleSelection = (day) => {
+      if (day.isFuture)
+        return;
+      emit("update:modelValue", day.date);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(CalendarMonth, {
+        id: _ctx.uniqueId,
+        type: "month",
+        class: "date-picker-month",
+        range: selectedRange.value,
+        navigation: navigation.value,
+        year: unref(monthData).year,
+        days: unref(monthData).days,
+        weeks: unref(monthData).weeks,
+        month: unref(monthData).month,
+        onSelectionChanged: handleSelection,
+        onNavigation: handleNavigation
+      }, null, 8, ["id", "range", "navigation", "year", "days", "weeks", "month"]);
+    };
+  }
+});
+var DatePickerMonth = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-7dbe885c"]]);
+
+export { DatePickerMonth as default };

package/src/components/datePicker/index.vue.js

@@ -0,0 +1,6 @@
+import DatePicker from './DatePicker.vue.js';
+export { default as DatePicker } from './DatePicker.vue.js';
+
+const DatePickerTypes = () => [DatePicker];
+
+export { DatePickerTypes };

package/src/components/dateRange/CalendarMonth.vue.js

@@ -0,0 +1,319 @@
+import { defineComponent, ref, computed, watch, onMounted, openBlock, createElementBlock, createElementVNode, unref, createBlock, withCtx, createVNode, createCommentVNode, createTextVNode, toDisplayString, Fragment, renderList, normalizeClass } from 'vue';
+import dateServices from './DateServices.vue.js';
+import { navigatePrev, navigateNext } from './consts.vue.js';
+import Heading from '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import '../button/Button.vue.js';
+import IconButton from '../button/IconButton.vue.js';
+import '../button/ScrollButton.vue.js';
+import { isBefore, isAfter, isSameDay } from 'date-fns';
+import AngleLeft from '../icon/icons/AngleLeft.vue.js';
+import AngleRight from '../icon/icons/AngleRight.vue.js';
+import Icon from '../icon/Icon.vue.js';
+/* empty css                                                               */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../CalendarMonth.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = ["id"];
+const _hoisted_2 = { class: "month-header" };
+const _hoisted_3 = { class: "days-header" };
+const _hoisted_4 = { class: "days-wrapper" };
+const _sfc_main = defineComponent({
+  __name: "CalendarMonth",
+  props: {
+    year: {},
+    days: {},
+    weeks: {},
+    month: {},
+    navigation: {},
+    range: {},
+    type: {},
+    id: { default: Date.now() },
+    allowedDays: { default: null },
+    maxAllowedDate: { default: null }
+  },
+  emits: ["selectionChanged", "navigation"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const months = [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ];
+    const dayNames = ["S", "M", "T", "W", "T", "F", "S"];
+    const selectedDays = ref([]);
+    const selectedDaysMap = ref({});
+    const inBetweenMap = ref({});
+    const monthName = computed(() => months[props.month]);
+    const selectDay = (day) => {
+      if (day.value === 0) {
+        return;
+      }
+      emit("selectionChanged", day, props.month, props.year);
+    };
+    const navigate = (navigation) => {
+      emit("navigation", navigation);
+    };
+    const isMonthInRange = () => {
+      if (!props.range.fromStart || !props.range.toEnd) {
+        return false;
+      }
+      const fromMonth = props.range.fromStart.getMonth();
+      const fromYear = props.range.fromStart.getFullYear();
+      const toMonth = props.range.toEnd.getMonth();
+      const toYear = props.range.toEnd.getFullYear();
+      if (props.year < fromYear || props.year > toYear) {
+        return false;
+      }
+      return !(props.year === fromYear && props.month < fromMonth || props.year === toYear && props.month > toMonth);
+    };
+    const getFirstDayInRangeForMonth = (date, month) => {
+      if (date.getMonth() < month.month && date.getFullYear() === month.year || date.getFullYear() < month.year) {
+        return 1;
+      }
+      if (date.getMonth() === month.month && date.getFullYear() === month.year) {
+        return date.getDate();
+      }
+      return dateServices.daysInMonth(month.month, month.year);
+    };
+    const getLastDayInRangeForMonth = (date, month) => {
+      if (date.getMonth() > month.month && date.getFullYear() === month.year || date.getFullYear() > month.year) {
+        return dateServices.daysInMonth(month.month, month.year);
+      }
+      if (date.getMonth() === month.month && date.getFullYear() === month.year) {
+        return date.getDate();
+      }
+      return 1;
+    };
+    const getMinDateInMonth = () => {
+      if (props.allowedDays) {
+        const today = dateServices.getCurrentTimeUTC();
+        today.setDate(today.getDate() - props.allowedDays + 1);
+        let minDate = today;
+        switch (props.type) {
+          case "week":
+            minDate = dateServices.getFirstDayOfWeek(today);
+            break;
+          case "month":
+            minDate.setDate(1);
+            break;
+        }
+        minDate.setHours(0, 0, 0, 0);
+        return minDate;
+      }
+      return null;
+    };
+    const refreshDisabledDays = () => {
+      const minDate = getMinDateInMonth();
+      const maxDate = props.maxAllowedDate;
+      Object.keys(props.days).forEach((dayKey) => {
+        const day = props.days[dayKey];
+        if (minDate && isBefore(day.date, minDate) || maxDate && isAfter(day.date, maxDate)) {
+          day.disabled = true;
+        } else {
+          delete day.disabled;
+        }
+      });
+    };
+    const setSelectionInMonth = (date, day, lowerLimit, upperLimit) => {
+      if (props.year === date.getFullYear() && props.month === date.getMonth() && day >= lowerLimit && day <= upperLimit) {
+        selectedDaysMap.value[day] = true;
+      }
+    };
+    const updateSelection = () => {
+      for (let i = 0; i < selectedDays.value.length; i++) {
+        const day = selectedDays.value[i];
+        delete selectedDaysMap.value[day.value];
+        delete inBetweenMap.value[day.value];
+      }
+      selectedDays.value = [];
+      if (isMonthInRange()) {
+        const thisMonth = { month: props.month, year: props.year };
+        const selectionFromStart = getFirstDayInRangeForMonth(
+          props.range.fromStart,
+          thisMonth
+        );
+        const selectionFromEnd = getLastDayInRangeForMonth(
+          props.range.fromEnd,
+          thisMonth
+        );
+        const selectionToStart = getFirstDayInRangeForMonth(
+          props.range.toStart,
+          thisMonth
+        );
+        const selectionToEnd = getLastDayInRangeForMonth(
+          props.range.toEnd,
+          thisMonth
+        );
+        for (let j = selectionFromStart; j <= selectionToEnd; j++) {
+          inBetweenMap.value[j] = true;
+          setSelectionInMonth(
+            props.range.fromStart,
+            j,
+            selectionFromStart,
+            selectionFromEnd
+          );
+          setSelectionInMonth(
+            props.range.fromEnd,
+            j,
+            selectionFromStart,
+            selectionFromEnd
+          );
+          setSelectionInMonth(
+            props.range.toStart,
+            j,
+            selectionToStart,
+            selectionToEnd
+          );
+          setSelectionInMonth(
+            props.range.toEnd,
+            j,
+            selectionToStart,
+            selectionToEnd
+          );
+          selectedDays.value.push(props.days[j]);
+        }
+      }
+    };
+    const isStartDay = (day) => {
+      if (day.value === 0)
+        return false;
+      return isSameDay(day.date, props.range.fromStart);
+    };
+    const isEndDay = (day) => {
+      if (day.value === 0)
+        return false;
+      return isSameDay(day.date, props.range.toEnd);
+    };
+    watch(
+      () => props.month,
+      () => {
+        updateSelection();
+      }
+    );
+    watch(
+      () => props.range,
+      (newVal, oldVal) => {
+        if (newVal && newVal !== oldVal) {
+          updateSelection();
+        }
+      }
+    );
+    watch(
+      () => props.maxAllowedDate,
+      () => {
+        refreshDisabledDays();
+      }
+    );
+    onMounted(() => {
+      refreshDisabledDays();
+      updateSelection();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        id: "datepickerCalendar" + _ctx.id,
+        class: "calendar-month"
+      }, [
+        createElementVNode("span", {
+          onClick: _cache[0] || (_cache[0] = ($event) => navigate(unref(navigatePrev)))
+        }, [
+          _ctx.navigation === unref(navigatePrev) || _ctx.navigation === "all" ? (openBlock(), createBlock(unref(IconButton), {
+            key: 0,
+            variant: "borderless",
+            size: "md",
+            class: "previous"
+          }, {
+            default: withCtx(() => [
+              createVNode(Icon, null, {
+                default: withCtx(() => [
+                  createVNode(AngleLeft)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        createElementVNode("span", {
+          onClick: _cache[1] || (_cache[1] = ($event) => navigate(unref(navigateNext)))
+        }, [
+          _ctx.navigation === unref(navigateNext) || _ctx.navigation === "all" ? (openBlock(), createBlock(unref(IconButton), {
+            key: 0,
+            class: "next",
+            variant: "borderless",
+            size: "md"
+          }, {
+            default: withCtx(() => [
+              createVNode(Icon, null, {
+                default: withCtx(() => [
+                  createVNode(AngleRight)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        createElementVNode("div", _hoisted_2, [
+          createVNode(Heading, { level: "6" }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(monthName.value) + " " + toDisplayString(_ctx.year), 1)
+            ]),
+            _: 1
+          }),
+          createElementVNode("div", _hoisted_3, [
+            (openBlock(), createElementBlock(Fragment, null, renderList(dayNames, (weekDay, index) => {
+              return createVNode(unref(Text), {
+                key: index,
+                size: "xs"
+              }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(weekDay), 1)
+                ]),
+                _: 2
+              }, 1024);
+            }), 64))
+          ])
+        ]),
+        createElementVNode("div", _hoisted_4, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.weeks, (week, weekIndex) => {
+            return openBlock(), createElementBlock("div", { key: weekIndex }, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(week, (day, dayIndex) => {
+                return openBlock(), createBlock(unref(Text), {
+                  key: dayIndex,
+                  class: normalizeClass(["day", {
+                    "selected-day": selectedDaysMap.value[day.value],
+                    "selected-day-between": inBetweenMap.value[day.value],
+                    today: day.isToday,
+                    "disabled-day": day.isFuture || day.disabled,
+                    "non-day": day.value === 0,
+                    "start-day": isStartDay(day),
+                    "end-day": isEndDay(day)
+                  }]),
+                  size: "sm",
+                  onClick: ($event) => day.disabled || day.isFuture || selectDay(day)
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(day.value), 1)
+                  ]),
+                  _: 2
+                }, 1032, ["class", "onClick"]);
+              }), 128))
+            ]);
+          }), 128))
+        ])
+      ], 8, _hoisted_1);
+    };
+  }
+});
+var CalendarMonth = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b6b53aec"]]);
+
+export { CalendarMonth as default };