@coreui/vue-pro 4.1.4 → 4.3.0-beta.1

package/src/components/date-range-picker/CDateRangePicker.ts

@@ -0,0 +1,635 @@
+import { defineComponent, h, onMounted, PropType, ref, watch } from 'vue'
+
+import { CButton } from '../button'
+import { CCalendar } from '../calendar'
+import { CFormInput, CInputGroup, CInputGroupText } from '../form'
+import { CPicker } from '../picker'
+import { CTimePicker } from '../time-picker'
+
+import { isValidDate } from '../../utils/calendar'
+
+import { Color } from '../props'
+
+const CDateRangePicker = defineComponent({
+  name: 'CDateRangePicker',
+  props: {
+    /**
+     * The number of calendars that render on desktop devices.
+     */
+    calendars: {
+      type: Number,
+      default: 2,
+    },
+    /**
+     * Default date of the component
+     */
+    calendarDate: {
+      type: [Date, String],
+    },
+    /**
+     * Toggle visibility or set the content of cancel button.
+     */
+    cancelButton: {
+      type: [Boolean, String],
+      default: 'Cancel',
+    },
+    /**
+     * Sets the color context of the cancel button to one of CoreUI’s themed colors.
+     *
+     * @values 'primary', 'secondary', 'success', 'danger', 'warning', 'info', 'dark', 'light'
+     */
+    cancelButtonColor: {
+      ...Color,
+      default: 'primary',
+    },
+    /**
+     * Size the cancel button small or large.
+     *
+     * @values 'sm', 'lg'
+     */
+    cancelButtonSize: {
+      type: String,
+      default: 'sm',
+      validator: (value: string) => {
+        return ['sm', 'lg'].includes(value)
+      },
+    },
+    /**
+     * Set the cancel button variant to an outlined button or a ghost button.
+     *
+     * @values 'ghost', 'outline'
+     */
+    cancelButtonVariant: {
+      type: String,
+      default: 'ghost',
+      validator: (value: string) => {
+        return ['ghost', 'outline'].includes(value)
+      },
+    },
+    /**
+     * Toggle visibility of the cleaner button.
+     */
+    cleaner: {
+      type: Boolean,
+      default: true,
+    },
+    /**
+     * Toggle visibility or set the content of confirm button.
+     */
+    confirmButton: {
+      type: [Boolean, String],
+      default: 'OK',
+    },
+    /**
+     * Sets the color context of the confirm button to one of CoreUI’s themed colors.
+     *
+     * @values 'primary', 'secondary', 'success', 'danger', 'warning', 'info', 'dark', 'light'
+     */
+    confirmButtonColor: {
+      ...Color,
+      default: 'primary',
+    },
+    /**
+     * Size the confirm button small or large.
+     *
+     * @values 'sm', 'lg'
+     */
+    confirmButtonSize: {
+      type: String,
+      default: 'sm',
+      validator: (value: string) => {
+        return ['sm', 'lg'].includes(value)
+      },
+    },
+    /**
+     * Set the confirm button variant to an outlined button or a ghost button.
+     *
+     * @values 'ghost', 'outline'
+     */
+    confirmButtonVariant: {
+      type: String,
+      validator: (value: string) => {
+        return ['ghost', 'outline'].includes(value)
+      },
+    },
+    /**
+     * Toggle the disabled state for the component.
+     */
+    disabled: Boolean,
+    /**
+     * Specify the list of dates that cannot be selected.
+     */
+    disabledDates: {
+      type: Array as PropType<Date[] | Date[][]>,
+    },
+    /**
+     * Initial selected to date (range).
+     */
+    endDate: {
+      type: [Date, String],
+      required: false,
+    },
+    /**
+     * Sets the day of start week.
+     * - 0 - Sunday,
+     * - 1 - Monday,
+     * - 2 - Tuesday,
+     * - 3 - Wednesday,
+     * - 4 - Thursday,
+     * - 5 - Friday,
+     * - 6 - Saturday,
+     * - 7 - Sunday
+     */
+    firstDayOfWeek: {
+      type: Number,
+      default: 1,
+    },
+    /**
+     * Toggle visibility of footer element or set the content of footer.
+     */
+    footer: Boolean,
+    /**
+     * Toggle visibility or set the content of the input indicator.
+     */
+    indicator: {
+      type: Boolean,
+      default: true,
+    },
+    /**
+     * Toggle the readonly state for the component.
+     */
+    inputReadOnly: Boolean,
+    /**
+     * Sets the default locale for components. If not set, it is inherited from the navigator.language.
+     */
+    locale: {
+      type: String,
+      default: 'default',
+    },
+    /**
+     * Max selectable date.
+     */
+    maxDate: {
+      type: [Date, String],
+    },
+    /**
+     * Min selectable date.
+     */
+    minDate: {
+      type: [Date, String],
+    },
+    /**
+     * Show arrows navigation.
+     */
+    navigation: {
+      type: Boolean,
+      default: true,
+    },
+    /**
+     * Specifies a short hint that is visible in the input.
+     */
+    placeholder: {
+      type: [String, Array] as PropType<String | String[]>,
+      default: () => ['Start date', 'End date'],
+    },
+    /**
+     * @ignore
+     */
+    range: {
+      type: Boolean,
+      default: true,
+    },
+    /**
+     * Predefined date ranges the user can select from.
+     */
+    ranges: Object,
+    /**
+     * Toggle select mode between start and end date.
+     */
+    selectEndDate: Boolean,
+    /**
+     * Default icon or character character that separates two dates.
+     */
+    separator: {
+      type: Boolean,
+      default: true,
+    },
+    /**
+     * Size the component small or large.
+     *
+     * @values 'sm', 'lg'
+     */
+    size: {
+      type: String,
+      required: false,
+      validator: (value: string) => {
+        return ['sm', 'lg'].includes(value)
+      },
+    },
+    /**
+     * Initial selected date.
+     */
+    startDate: {
+      type: [Date, String],
+    },
+    /**
+     * Provide an additional time selection by adding select boxes to choose times.
+     */
+    timepicker: Boolean,
+    /**
+     * Set length or format of day name.
+     *
+     * @type  number | 'long' | 'narrow' | 'short'
+     */
+    weekdayFormat: {
+      type: [Number, String],
+      default: 2,
+      validator: (value: string | number) => {
+        if (typeof value === 'string') {
+          return ['long', 'narrow', 'short'].includes(value)
+        }
+        if (typeof value === 'number') {
+          return true
+        }
+        return false
+      },
+    },
+  },
+  emit: [
+    /**
+     * Callback fired when the end date changed.
+     */
+    'end-date-change',
+    /**
+     * Callback fired when the component requests to be hidden.
+     */
+    'hide',
+    /**
+     * Callback fired when the component requests to be shown.
+     */
+    'show',
+    /**
+     * Callback fired when the start date changed.
+     */
+    'start-date-change',
+  ],
+  setup(props, { slots, emit }) {
+    const calendarDate = ref<Date>(
+      props.calendarDate
+        ? new Date(props.calendarDate)
+        : props.startDate
+        ? new Date(props.startDate)
+        : props.endDate
+        ? new Date(props.endDate)
+        : new Date(),
+    )
+    const inputStartHoverValue = ref<Date | null>(null)
+    const inputEndHoverValue = ref<Date | null>(null)
+    const startDate = ref<Date | null>(props.startDate ? new Date(props.startDate) : null)
+    const endDate = ref<Date | null>(props.endDate ? new Date(props.endDate) : null)
+    const initialStartDate = ref<Date | null>(startDate.value ? new Date(startDate.value) : null)
+    const initialEndDate = ref<Date | null>(endDate.value ? new Date(endDate.value) : null)
+    const selectEndDate = ref(false)
+
+    const isMobile = ref(false)
+
+    onMounted(() => {
+      isMobile.value = window.innerWidth < 768
+    })
+
+    watch(
+      () => props.startDate,
+      () => {
+        if (props.startDate) {
+          calendarDate.value = new Date(props.startDate)
+        }
+      },
+    )
+
+    watch(
+      () => props.endDate,
+      () => {
+        if (props.endDate) {
+          calendarDate.value = new Date(props.endDate)
+        }
+      },
+    )
+
+    const setInputValue = (date: Date | null, timepicker?: boolean) => {
+      if (date) {
+        return timepicker
+          ? date.toLocaleString(props.locale)
+          : date.toLocaleDateString(props.locale)
+      }
+
+      return ''
+    }
+
+    const handleCalendarCellHover = (date: Date | null) => {
+      if (selectEndDate.value) {
+        inputEndHoverValue.value = date === null ? null : date
+        return
+      }
+      inputStartHoverValue.value = date === null ? null : date
+    }
+
+    const handleCalendarDateChange = (date: Date, difference?: number) => {
+      if (difference) {
+        calendarDate.value = new Date(date.getFullYear(), date.getMonth() - difference, 1)
+        return
+      }
+
+      calendarDate.value = date
+    }
+
+    const handleStartDateChange = (date: Date) => {
+      startDate.value = date
+      inputStartHoverValue.value = null
+      if (props.range) {
+        selectEndDate.value = true
+      }
+
+      emit('start-date-change', date)
+    }
+
+    const handleEndDateChange = (date: Date) => {
+      endDate.value = date
+      inputEndHoverValue.value = null
+      if (props.range) {
+        selectEndDate.value = false
+      }
+
+      emit('end-date-change', date)
+    }
+
+    const handleClear = (event: Event) => {
+      event.stopPropagation()
+      startDate.value = null
+      endDate.value = null
+      inputStartHoverValue.value = null
+      inputEndHoverValue.value = null
+    }
+
+    const InputGroup = () =>
+      h(
+        CInputGroup,
+        {
+          class: 'picker-input-group',
+          size: props.size,
+        },
+        () => [
+          h(CFormInput, {
+            class: {
+              hover: inputStartHoverValue.value,
+            },
+            disabled: props.disabled,
+            onClick: () => {
+              selectEndDate.value = false
+            },
+            onInput: (event) => {
+              if (isValidDate(event.target.value)) {
+                calendarDate.value = new Date(event.target.value)
+                startDate.value = new Date(event.target.value)
+              }
+            },
+            placeholder: Array.isArray(props.placeholder)
+              ? props.placeholder[0]
+              : props.placeholder,
+            readonly: props.inputReadOnly,
+            value: inputStartHoverValue.value
+              ? setInputValue(inputStartHoverValue.value, props.timepicker)
+              : setInputValue(startDate.value, props.timepicker),
+          }),
+          props.range &&
+            props.separator !== false &&
+            h(CInputGroupText, {}, () =>
+              slots.separator
+                ? slots.separator()
+                : h('span', { class: 'picker-input-group-icon date-picker-arrow-icon' }),
+            ),
+          props.range &&
+            h(CFormInput, {
+              class: {
+                hover: inputEndHoverValue.value,
+              },
+              disabled: props.disabled,
+              onClick: () => {
+                selectEndDate.value = true
+              },
+              onInput: (event) => {
+                if (isValidDate(event.target.value)) {
+                  calendarDate.value = new Date(event.target.value)
+                  endDate.value = new Date(event.target.value)
+                }
+              },
+              placeholder: props.placeholder[1],
+              readonly: props.inputReadOnly,
+              value: inputEndHoverValue.value
+                ? setInputValue(inputEndHoverValue.value, props.timepicker)
+                : setInputValue(endDate.value, props.timepicker),
+            }),
+          (props.indicator || props.cleaner) &&
+            h(CInputGroupText, {}, () => [
+              props.indicator &&
+                h(
+                  'span',
+                  {
+                    class: 'picker-input-group-indicator',
+                  },
+                  slots.indicator
+                    ? slots.indicator()
+                    : h('span', { class: 'picker-input-group-icon date-picker-input-icon' }),
+                ),
+              props.cleaner &&
+                h(
+                  'span',
+                  {
+                    class: 'picker-input-group-cleaner',
+                    onClick: (event: Event) => handleClear(event),
+                    role: 'button',
+                  },
+                  slots.cleaner
+                    ? slots.cleaner()
+                    : h('span', { class: 'picker-input-group-icon date-picker-cleaner-icon' }),
+                ),
+            ]),
+        ],
+      )
+
+    return () =>
+      h(
+        CPicker,
+        {
+          cancelButton: props.cancelButton,
+          cancelButtonColor: props.cancelButtonColor,
+          cancelButtonSize: props.cancelButtonSize,
+          cancelButtonVariant: props.cancelButtonVariant,
+          class: 'date-picker',
+          confirmButton: props.confirmButton,
+          confirmButtonColor: props.confirmButtonColor,
+          confirmButtonSize: props.confirmButtonSize,
+          confirmButtonVariant: props.confirmButtonVariant,
+          disabled: props.disabled,
+          footer: props.footer || props.timepicker,
+          onCancel: () => {
+            startDate.value = initialStartDate.value
+            endDate.value = initialEndDate.value
+          },
+          onHide: () => {
+            emit('hide')
+          },
+          onShow: () => {
+            if (startDate.value) {
+              initialStartDate.value = new Date(startDate.value)
+            }
+
+            if (endDate.value) {
+              initialEndDate.value = new Date(endDate.value)
+            }
+
+            emit('show')
+          },
+        },
+        {
+          ...(slots.cancelButton && {
+            cancelButton: () => slots.cancelButton && slots.cancelButton(),
+          }),
+          ...(slots.confirmButton && {
+            confirmButton: () => slots.confirmButton && slots.confirmButton(),
+          }),
+          toggler: () => InputGroup(),
+          default: () =>
+            h(
+              'div',
+              {
+                class: 'date-picker-body',
+              },
+              [
+                props.ranges &&
+                  h(
+                    'div',
+                    { class: 'date-picker-ranges' },
+                    Object.keys(props.ranges).map((key: string) =>
+                      h(
+                        CButton,
+                        {
+                          color: 'secondary',
+                          onClick: () => {
+                            if (props.ranges) {
+                              startDate.value = props.ranges[key][0]
+                              endDate.value = props.ranges[key][1]
+                            }
+                          },
+                          variant: 'ghost',
+                        },
+                        () => key,
+                      ),
+                    ),
+                  ),
+                h(
+                  'div',
+                  { class: 'date-picker-calendars' },
+                  [...Array(isMobile.value ? 1 : props.calendars)].map((_, index) =>
+                    h('div', { class: 'date-picker-calendar' }, [
+                      h(
+                        CCalendar,
+                        {
+                          calendarDate: new Date(
+                            calendarDate.value.getFullYear(),
+                            calendarDate.value.getMonth() + index,
+                            1,
+                          ),
+                          disabledDates: props.disabledDates,
+                          ...(endDate.value && { endDate: endDate.value }),
+                          firstDayOfWeek: props.firstDayOfWeek,
+                          locale: props.locale,
+                          maxDate: props.maxDate,
+                          minDate: props.minDate,
+                          navigation: props.navigation,
+                          range: true,
+                          selectEndDate: selectEndDate.value,
+                          ...(startDate.value && { startDate: startDate.value }),
+                          onCalendarCellHover: (date: Date | null) => handleCalendarCellHover(date),
+                          onCalendarDateChange: (date: Date) =>
+                            handleCalendarDateChange(date, index),
+                          onStartDateChange: (date: Date) => handleStartDateChange(date),
+                          onEndDateChange: (date: Date) => handleEndDateChange(date),
+                        },
+                        {
+                          /**
+                           * @slot Location for next icon.
+                           */
+                          ...(slots.navNextIcon && {
+                            navNextIcon: () => slots.navNextIcon && slots.navNextIcon(),
+                          }),
+                          /**
+                           * @slot Location for next double icon.
+                           */
+                          ...(slots.navNextDoubleIcon && {
+                            navNextDoubleIcon: () =>
+                              slots.navNextDoubleIcon && slots.navNextDoubleIcon(),
+                          }),
+                          /**
+                           * @slot Location for previous icon.
+                           */
+                          ...(slots.navPrevIcon && {
+                            navPrevIcon: () => slots.navPrevIcon && slots.navPrevIcon(),
+                          }),
+                          /**
+                           * @slot Location for double previous icon.
+                           */
+                          ...(slots.navPrevDoubleIcon && {
+                            navPrevDoubleIcon: () =>
+                              slots.navPrevDoubleIcon && slots.navPrevDoubleIcon(),
+                          }),
+                        },
+                      ),
+                      !isMobile.value &&
+                        props.timepicker &&
+                        (index === 0 || props.calendars - index === 1) &&
+                        h(CTimePicker, {
+                          container: 'inline',
+                          disabled:
+                            index === 0
+                              ? startDate.value === null
+                                ? true
+                                : false
+                              : endDate.value === null
+                              ? true
+                              : false,
+                          locale: props.locale,
+                          onChange: (_: any, __: any, date: Date) =>
+                            index === 0 ? handleStartDateChange(date) : handleEndDateChange(date),
+                          time: index === 0 ? startDate.value : endDate.value,
+                          variant: 'select',
+                        }),
+                      isMobile.value &&
+                        props.timepicker && [
+                          h(CTimePicker, {
+                            container: 'inline',
+                            disabled: startDate.value === null ? true : false,
+                            locale: props.locale,
+                            onChange: (_: any, __: any, date: Date) => handleStartDateChange(date),
+                            time: startDate.value,
+                            variant: 'select',
+                          }),
+                          h(CTimePicker, {
+                            container: 'inline',
+                            disabled: endDate.value === null ? true : false,
+                            locale: props.locale,
+                            onChange: (_: any, __: any, date: Date) => handleEndDateChange(date),
+                            time: endDate.value,
+                            variant: 'select',
+                          }),
+                        ],
+                    ]),
+                  ),
+                ),
+              ],
+            ),
+        },
+      )
+  },
+})
+
+export { CDateRangePicker }

package/src/components/date-range-picker/index.ts

@@ -0,0 +1,10 @@
+import { App } from 'vue'
+import { CDateRangePicker } from './CDateRangePicker'
+
+const CDateRangePickerPlugin = {
+  install: (app: App): void => {
+    app.component(CDateRangePicker.name, CDateRangePicker)
+  },
+}
+
+export { CDateRangePickerPlugin, CDateRangePicker }