@ironsource/shared-ui 2.0.0-rc.1 → 2.0.0-rc.2

package/components/chip/v4/ChipV4.vue.js

@@ -1,76 +0,0 @@
-import { defineComponent, resolveComponent, openBlock, createElementBlock, normalizeClass, unref, renderSlot, createCommentVNode, createElementVNode, toDisplayString, createVNode, withCtx, createTextVNode } from 'vue';
-import Icon from '../../icon/Icon.vue.js';
-import { ChipTestIdModifiers } from '../../../testids/index.vue.js';
-/* empty css                                                        */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
-
-import "../../../ChipV4.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = ["disabled", "data-testid"];
-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 _hoisted_5 = ["data-testid"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "ChipV4",
-  props: {
-    selected: { type: Boolean, default: false },
-    clearable: { type: Boolean, default: false },
-    prefix: { default: null },
-    disabled: { type: Boolean, default: false },
-    testId: { default: "" }
-  },
-  emits: ["cleared"],
-  setup(__props, { emit }) {
-    const cleared = (event) => {
-      event.stopPropagation();
-      emit("cleared");
-    };
-    return (_ctx, _cache) => {
-      const _component_B = resolveComponent("B");
-      return openBlock(), createElementBlock("button", {
-        class: normalizeClass(["chip-container", { selected: __props.selected, disabled: __props.disabled }]),
-        disabled: __props.disabled,
-        "data-testid": `${__props.testId}-${unref(ChipTestIdModifiers).WRAPPER}`
-      }, [
-        _ctx.$slots["icon-start"] ? (openBlock(), createElementBlock("span", _hoisted_2, [
-          renderSlot(_ctx.$slots, "icon-start", {}, void 0, true)
-        ])) : createCommentVNode("", true),
-        createElementVNode("span", null, [
-          !!__props.prefix ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(__props.prefix) + ":", 1)) : createCommentVNode("", true),
-          renderSlot(_ctx.$slots, "default", {}, void 0, true),
-          createVNode(_component_B, null, {
-            default: withCtx(() => [
-              createTextVNode(" V4 ")
-            ]),
-            _: 1
-          })
-        ]),
-        _ctx.$slots["icon-end"] ? (openBlock(), createElementBlock("span", _hoisted_4, [
-          renderSlot(_ctx.$slots, "icon-end", {}, void 0, true)
-        ])) : createCommentVNode("", true),
-        __props.clearable ? (openBlock(), createElementBlock("button", {
-          key: 2,
-          class: "clear-icon",
-          "data-testid": `${__props.testId}-${unref(ChipTestIdModifiers).CLEAR}`,
-          onClick: cleared
-        }, [
-          createVNode(unref(Icon), {
-            name: "close-bold",
-            "font-size": "sm"
-          })
-        ], 8, _hoisted_5)) : createCommentVNode("", true)
-      ], 10, _hoisted_1);
-    };
-  }
-});
-var Chip = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-d3894364"]]);
-
-export { Chip as default };

package/components/cssBaseline/CssBaseline.vue.js

@@ -1,12 +0,0 @@
-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/components/datePicker/DatePicker.vue.js

@@ -1,130 +0,0 @@
-import { defineComponent, ref, computed, openBlock, createElementBlock, unref, createElementVNode, renderSlot, withDirectives, isRef, 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';
-import { DatePickerTestIdModifiers } from '../../testids/index.vue.js';
-/* 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", "data-testid"];
-const _hoisted_2 = ["placeholder", "data-testid"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "DatePicker",
-  props: {
-    uniqueId: { default: Date.now() },
-    modelValue: { default: null },
-    allowFutureDates: { type: Boolean, default: false },
-    dateFormat: { default: "yyyy-MM-d" },
-    placeholder: { default: "" },
-    testId: { 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: unref(componentId),
-        ref_key: "datePicker",
-        ref: datePicker,
-        class: "date-picker",
-        "data-testid": `${__props.testId}-${unref(DatePickerTestIdModifiers).WRAPPER}`
-      }, [
-        createElementVNode("div", {
-          ref_key: "buttonRef",
-          ref: buttonRef,
-          onClick: _cache[2] || (_cache[2] = ($event) => unref(toggle)())
-        }, [
-          renderSlot(_ctx.$slots, "default", { formattedDate: unref(formattedValue) }, () => [
-            withDirectives(createElementVNode("input", {
-              ref_key: "input",
-              ref: input,
-              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(formattedValue) ? formattedValue.value = $event : null),
-              type: "text",
-              class: "input",
-              placeholder: __props.placeholder,
-              "data-testid": `${__props.testId}-${unref(DatePickerTestIdModifiers).INPUT}`,
-              onInput: _cache[1] || (_cache[1] = ($event) => handleInput($event))
-            }, null, 40, _hoisted_2), [
-              [vModelText, unref(formattedValue)]
-            ])
-          ], true)
-        ], 512),
-        unref(isOpen) ? (openBlock(), createElementBlock("div", {
-          key: 0,
-          ref_key: "popup",
-          ref: popup,
-          class: normalizeClass(["date-picker-popup", { "align-right": unref(nearTheEdge) }])
-        }, [
-          createVNode(DatePickerMonth, {
-            id: unref(componentId) + "-month",
-            "model-value": unref(valueAsDate),
-            "allow-future-dates": __props.allowFutureDates,
-            "test-id": __props.testId,
-            "onUpdate:modelValue": updateValue
-          }, null, 8, ["id", "model-value", "allow-future-dates", "test-id"])
-        ], 2)) : createCommentVNode("", true)
-      ], 8, _hoisted_1);
-    };
-  }
-});
-var DatePicker = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-71f15c18"]]);
-
-export { DatePicker as default };

package/components/datePicker/DatePickerMonth.vue.js

@@ -1,101 +0,0 @@
-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 = /* @__PURE__ */ defineComponent({
-  __name: "DatePickerMonth",
-  props: {
-    uniqueId: { default: Date.now() },
-    modelValue: { default: null },
-    includeToday: { type: Boolean, default: true },
-    allowFutureDates: { type: Boolean, default: false },
-    testId: { default: "" }
-  },
-  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: __props.uniqueId,
-        type: "month",
-        class: "date-picker-month",
-        range: unref(selectedRange),
-        navigation: unref(navigation),
-        year: unref(monthData).year,
-        days: unref(monthData).days,
-        weeks: unref(monthData).weeks,
-        month: unref(monthData).month,
-        "test-id": __props.testId,
-        onSelectionChanged: handleSelection,
-        onNavigation: handleNavigation
-      }, null, 8, ["id", "range", "navigation", "year", "days", "weeks", "month", "test-id"]);
-    };
-  }
-});
-var DatePickerMonth = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-79208613"]]);
-
-export { DatePickerMonth as default };

package/components/dateRange/CalendarMonth.vue.js

@@ -1,336 +0,0 @@
-import { defineComponent, ref, computed, watch, onMounted, openBlock, createElementBlock, unref, createElementVNode, 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 Icon from '../icon/Icon.vue.js';
-import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-/* empty css                                                                   */import IconButton from '../button/v3/IconButton.vue.js';
-import { CalendarMonthTestIdModifiers } from '../../testids/index.vue.js';
-/* empty css                                                                               */import 'floating-vue';
-/* empty css                                                      *//* empty css                                                                         */import { isBefore, isAfter, isSameDay } from 'date-fns';
-import AngleLeft from '../icon/icons/AngleLeft.vue.js';
-import AngleRight from '../icon/icons/AngleRight.vue.js';
-/* empty css                                                               */
-import "../../CalendarMonth.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = ["id", "data-testid"];
-const _hoisted_2 = ["data-testid"];
-const _hoisted_3 = ["data-testid"];
-const _hoisted_4 = ["data-testid"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "CalendarMonth",
-  props: {
-    year: null,
-    days: null,
-    weeks: null,
-    month: null,
-    navigation: null,
-    range: null,
-    type: null,
-    id: { default: Date.now() },
-    allowedDays: { default: null },
-    maxAllowedDate: { default: null },
-    testId: { default: "" }
-  },
-  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" + __props.id,
-        class: "calendar-month",
-        "data-testid": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).WRAPPER}`
-      }, [
-        createElementVNode("span", {
-          onClick: _cache[0] || (_cache[0] = ($event) => navigate(unref(navigatePrev)))
-        }, [
-          __props.navigation === unref(navigatePrev) || __props.navigation === "all" ? (openBlock(), createBlock(unref(IconButton), {
-            key: 0,
-            variant: "borderless",
-            size: "md",
-            class: "previous",
-            "data-testid": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).PREVIOUS}`
-          }, {
-            default: withCtx(() => [
-              createVNode(Icon, null, {
-                default: withCtx(() => [
-                  createVNode(AngleLeft)
-                ]),
-                _: 1
-              })
-            ]),
-            _: 1
-          }, 8, ["data-testid"])) : createCommentVNode("", true)
-        ]),
-        createElementVNode("span", {
-          onClick: _cache[1] || (_cache[1] = ($event) => navigate(unref(navigateNext)))
-        }, [
-          __props.navigation === unref(navigateNext) || __props.navigation === "all" ? (openBlock(), createBlock(unref(IconButton), {
-            key: 0,
-            class: "next",
-            variant: "borderless",
-            size: "md",
-            "data-testid": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).NEXT}`
-          }, {
-            default: withCtx(() => [
-              createVNode(Icon, null, {
-                default: withCtx(() => [
-                  createVNode(AngleRight)
-                ]),
-                _: 1
-              })
-            ]),
-            _: 1
-          }, 8, ["data-testid"])) : createCommentVNode("", true)
-        ]),
-        createElementVNode("div", {
-          class: "month-header",
-          "data-testid": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).MONTH_HEADER}`
-        }, [
-          createVNode(Heading, {
-            level: "6",
-            "test-id": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).MONTH_HEADER_TEXT}`
-          }, {
-            default: withCtx(() => [
-              createTextVNode(toDisplayString(unref(monthName)) + " " + toDisplayString(__props.year), 1)
-            ]),
-            _: 1
-          }, 8, ["test-id"]),
-          createElementVNode("div", {
-            class: "days-header",
-            "data-testid": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).DAYS_HEADER}`
-          }, [
-            (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))
-          ], 8, _hoisted_3)
-        ], 8, _hoisted_2),
-        createElementVNode("div", {
-          class: "days-wrapper",
-          "data-testid": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).DAYS_WRAPPER}`
-        }, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.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",
-                  "data-testid": `${__props.testId}-${unref(CalendarMonthTestIdModifiers).DAY}-${day.value}`,
-                  onClick: ($event) => day.disabled || day.isFuture || selectDay(day)
-                }, {
-                  default: withCtx(() => [
-                    createTextVNode(toDisplayString(day.value), 1)
-                  ]),
-                  _: 2
-                }, 1032, ["class", "data-testid", "onClick"]);
-              }), 128))
-            ]);
-          }), 128))
-        ], 8, _hoisted_4)
-      ], 8, _hoisted_1);
-    };
-  }
-});
-var CalendarMonth = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-11dadeb0"]]);
-
-export { CalendarMonth as default };