init component

node_modules/buetify/lib/components/form/datepicker/BDatepicker.d.ts

@@ -0,0 +1,557 @@
+import '../../pagination/pagination.sass';
+import '../../dropdown/dropdown.sass';
+import './datepicker.sass';
+import { DateEvent, EventIndicator, MonthNumber } from './shared';
+import { WeekdayNumber } from './utils';
+import { FunctionN } from 'fp-ts/lib/function';
+import { PropType, VNode, ComponentOptions, FunctionalComponent, ExtractPropTypes } from 'vue';
+declare type Component = ComponentOptions | FunctionalComponent;
+export declare type DatepickerPosition = 'is-top-right' | 'is-top-left' | 'is-bottom-left';
+export interface DatepickerIcons {
+    next: Component;
+    previous: Component;
+    calendar: Component;
+}
+export declare function getDatepickerIcons(icons: Partial<DatepickerIcons>): DatepickerIcons;
+declare const BDatepickerPropsDefinition: {
+    modelValue: {
+        type: PropType<Date | Date[]>;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<FunctionN<[Date | Date[]], void>>;
+        required: true;
+    };
+    year: {
+        type: NumberConstructor;
+        default: number;
+    };
+    'onUpdate:year': {
+        type: PropType<FunctionN<[number], void>>;
+        required: boolean;
+    };
+    month: {
+        type: PropType<MonthNumber>;
+        default: MonthNumber;
+    };
+    'onUpdate:month': {
+        type: PropType<FunctionN<[MonthNumber], void>>;
+        required: boolean;
+    };
+    dayNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    monthNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    firstDayOfWeek: {
+        type: PropType<WeekdayNumber>;
+        default: 0;
+    };
+    events: {
+        type: PropType<DateEvent[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    minDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    maxDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    unselectableDates: {
+        type: PropType<Date[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    unselectableDaysOfWeek: {
+        type: PropType<number[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    selectableDates: {
+        type: PropType<Date[]>;
+    };
+    showWeekNumber: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    isMultiple: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    placeholder: {
+        type: PropType<string>;
+    };
+    useMobileNative: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    position: {
+        type: PropType<import("../../dropdown/BDropdown").DropdownPosition>;
+    };
+    indicators: {
+        type: PropType<EventIndicator>;
+        default: "bars";
+    };
+    yearsRange: {
+        type: PropType<[number, number]>;
+        default: import("fp-ts/lib/function").Lazy<readonly [-5, 3]>;
+    };
+    closeOnSelect: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isReadonly: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    useNativeValidation: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    icons: {
+        type: PropType<DatepickerIcons>;
+        default: import("fp-ts/lib/function").Lazy<DatepickerIcons>;
+    };
+    isFocused: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    onFocus: {
+        type: PropType<(e?: Event | undefined) => void>;
+        required: false;
+    };
+    onBlur: {
+        type: PropType<(e?: Event | undefined) => void>;
+        required: false;
+    };
+    focusOnMount: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    disableIfReadonly: {
+        type: PropType<boolean>;
+        required: boolean;
+        default: boolean;
+    };
+    isValid: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    'onUpdate:isValid': {
+        type: PropType<FunctionN<[boolean], void>>;
+        default: import("fp-ts/lib/function").Lazy<() => void>;
+    };
+    variant: {
+        type: PropType<import("../../..").ColorVariant>;
+        default: "";
+    };
+    type: {
+        type: PropType<string>;
+    };
+    autocomplete: {
+        type: PropType<string>;
+    };
+    size: {
+        type: PropType<import("../../..").SizeVariant>;
+        default: import("../../..").SizeVariant;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isExpanded: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isLoading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isRounded: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    maxlength: {
+        type: PropType<string | number>;
+    };
+    icon: null;
+    usePasswordReveal: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    id: PropType<string>;
+    isHoverable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isInline: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isMobileModal: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    menuTag: {
+        type: PropType<string>;
+        default: string;
+    };
+    transition: {
+        type: PropType<import("../../..").Transition>;
+        default: import("fp-ts/lib/function").Lazy<import("../../..").Transition>;
+    };
+    onToggle: {
+        type: PropType<FunctionN<[boolean], void>>;
+        required: false;
+    };
+    onSetOn: {
+        type: PropType<import("fp-ts/lib/IO").IO<void>>;
+        required: false;
+    };
+    onSetOff: {
+        type: PropType<import("fp-ts/lib/IO").IO<void>>;
+        required: false;
+    };
+    hasPopup: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    themeMap: {
+        type: PropType<import("../../..").ThemeColorMap>;
+        required: boolean;
+        default: import("fp-ts/lib/function").Lazy<import("../../..").ThemeColorMap>;
+    };
+    isThemeable: {
+        type: PropType<boolean>;
+        required: boolean;
+        default: boolean;
+    };
+};
+export declare type BDatepickerProps = ExtractPropTypes<typeof BDatepickerPropsDefinition>;
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<Date | Date[]>;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<FunctionN<[Date | Date[]], void>>;
+        required: true;
+    };
+    year: {
+        type: NumberConstructor;
+        default: number;
+    };
+    'onUpdate:year': {
+        type: PropType<FunctionN<[number], void>>;
+        required: boolean;
+    };
+    month: {
+        type: PropType<MonthNumber>;
+        default: MonthNumber;
+    };
+    'onUpdate:month': {
+        type: PropType<FunctionN<[MonthNumber], void>>;
+        required: boolean;
+    };
+    dayNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    monthNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    firstDayOfWeek: {
+        type: PropType<WeekdayNumber>;
+        default: 0;
+    };
+    events: {
+        type: PropType<DateEvent[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    minDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    maxDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    unselectableDates: {
+        type: PropType<Date[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    unselectableDaysOfWeek: {
+        type: PropType<number[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    selectableDates: {
+        type: PropType<Date[]>;
+    };
+    showWeekNumber: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    isMultiple: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    placeholder: {
+        type: PropType<string>;
+    };
+    useMobileNative: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    position: {
+        type: PropType<import("../../dropdown/BDropdown").DropdownPosition>;
+    };
+    indicators: {
+        type: PropType<EventIndicator>;
+        default: "bars";
+    };
+    yearsRange: {
+        type: PropType<[number, number]>;
+        default: import("fp-ts/lib/function").Lazy<readonly [-5, 3]>;
+    };
+    closeOnSelect: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isReadonly: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    useNativeValidation: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    icons: {
+        type: PropType<DatepickerIcons>;
+        default: import("fp-ts/lib/function").Lazy<DatepickerIcons>;
+    };
+    isFocused: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    onFocus: {
+        type: PropType<(e?: Event | undefined) => void>;
+        required: false;
+    };
+    onBlur: {
+        type: PropType<(e?: Event | undefined) => void>;
+        required: false;
+    };
+    focusOnMount: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    disableIfReadonly: {
+        type: PropType<boolean>;
+        required: boolean;
+        default: boolean;
+    };
+    isValid: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    'onUpdate:isValid': {
+        type: PropType<FunctionN<[boolean], void>>;
+        default: import("fp-ts/lib/function").Lazy<() => void>;
+    };
+    variant: {
+        type: PropType<import("../../..").ColorVariant>;
+        default: "";
+    };
+    type: {
+        type: PropType<string>;
+    };
+    autocomplete: {
+        type: PropType<string>;
+    };
+    size: {
+        type: PropType<import("../../..").SizeVariant>;
+        default: import("../../..").SizeVariant;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isExpanded: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isLoading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isRounded: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    maxlength: {
+        type: PropType<string | number>;
+    };
+    icon: null;
+    usePasswordReveal: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    id: PropType<string>;
+    isHoverable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isInline: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isMobileModal: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    menuTag: {
+        type: PropType<string>;
+        default: string;
+    };
+    transition: {
+        type: PropType<import("../../..").Transition>;
+        default: import("fp-ts/lib/function").Lazy<import("../../..").Transition>;
+    };
+    onToggle: {
+        type: PropType<FunctionN<[boolean], void>>;
+        required: false;
+    };
+    onSetOn: {
+        type: PropType<import("fp-ts/lib/IO").IO<void>>;
+        required: false;
+    };
+    onSetOff: {
+        type: PropType<import("fp-ts/lib/IO").IO<void>>;
+        required: false;
+    };
+    hasPopup: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    themeMap: {
+        type: PropType<import("../../..").ThemeColorMap>;
+        required: boolean;
+        default: import("fp-ts/lib/function").Lazy<import("../../..").ThemeColorMap>;
+    };
+    isThemeable: {
+        type: PropType<boolean>;
+        required: boolean;
+        default: boolean;
+    };
+}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    isThemeable: boolean;
+    themeMap: import("../../..").ThemeColorMap;
+    hasPopup: boolean;
+    transition: import("../../..").Transition;
+    variant: import("../../..").ColorVariant;
+    size: import("../../..").SizeVariant;
+    icons: DatepickerIcons;
+    isExpanded: boolean;
+    isRounded: boolean;
+    isLoading: boolean;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isHoverable: boolean;
+    isInline: boolean;
+    isMobileModal: boolean;
+    menuTag: string;
+    focusOnMount: boolean;
+    "onUpdate:modelValue": FunctionN<[Date | Date[]], void>;
+    isReadonly: boolean;
+    disableIfReadonly: boolean;
+    useNativeValidation: boolean;
+    isValid: boolean;
+    "onUpdate:isValid": FunctionN<[boolean], void>;
+    isRequired: boolean;
+    usePasswordReveal: boolean;
+    closeOnSelect: boolean;
+    isMultiple: boolean;
+    events: DateEvent[];
+    indicators: EventIndicator;
+    showWeekNumber: boolean;
+    month: MonthNumber;
+    unselectableDates: Date[];
+    unselectableDaysOfWeek: number[];
+    year: number;
+    dayNames: string[];
+    monthNames: string[];
+    firstDayOfWeek: WeekdayNumber;
+    useMobileNative: boolean;
+    yearsRange: [number, number];
+} & {
+    onToggle?: FunctionN<[boolean], void> | undefined;
+    onSetOn?: import("fp-ts/lib/IO").IO<void> | undefined;
+    onSetOff?: import("fp-ts/lib/IO").IO<void> | undefined;
+    icon?: any;
+    type?: string | undefined;
+    position?: "is-top-right" | "is-top-left" | "is-bottom-left" | undefined;
+    id?: string | undefined;
+    onFocus?: ((e?: Event | undefined) => void) | undefined;
+    onBlur?: ((e?: Event | undefined) => void) | undefined;
+    modelValue?: Date | Date[] | undefined;
+    autocomplete?: string | undefined;
+    placeholder?: string | undefined;
+    maxlength?: string | number | undefined;
+    minDate?: Date | undefined;
+    maxDate?: Date | undefined;
+    selectableDates?: Date[] | undefined;
+    "onUpdate:year"?: FunctionN<[number], void> | undefined;
+    "onUpdate:month"?: FunctionN<[MonthNumber], void> | undefined;
+}>, {
+    isThemeable: boolean;
+    themeMap: import("../../..").ThemeColorMap;
+    hasPopup: boolean;
+    transition: import("../../..").Transition;
+    variant: import("../../..").ColorVariant;
+    size: import("../../..").SizeVariant;
+    icons: DatepickerIcons;
+    isExpanded: boolean;
+    isRounded: boolean;
+    isLoading: boolean;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isHoverable: boolean;
+    isInline: boolean;
+    isMobileModal: boolean;
+    menuTag: string;
+    focusOnMount: boolean;
+    isReadonly: boolean;
+    disableIfReadonly: boolean;
+    useNativeValidation: boolean;
+    isValid: boolean;
+    "onUpdate:isValid": FunctionN<[boolean], void>;
+    isRequired: boolean;
+    usePasswordReveal: boolean;
+    closeOnSelect: boolean;
+    isMultiple: boolean;
+    events: DateEvent[];
+    indicators: EventIndicator;
+    showWeekNumber: boolean;
+    month: MonthNumber;
+    unselectableDates: Date[];
+    unselectableDaysOfWeek: number[];
+    year: number;
+    dayNames: string[];
+    monthNames: string[];
+    firstDayOfWeek: WeekdayNumber;
+    useMobileNative: boolean;
+    yearsRange: [number, number];
+}>;
+export default _default;

node_modules/buetify/lib/components/form/datepicker/BDatepicker.js

@@ -0,0 +1,541 @@
+import "../../../../src/components/pagination/pagination.sass";
+import "../../../../src/components/dropdown/dropdown.sass";
+import "../../../../src/components/form/datepicker/datepicker.sass";
+import { useDisable, UseDisablePropsDefinition } from '../../../composables/disable';
+import { useEqRef } from '../../../composables/eqRef';
+import { useFieldData } from '../../../composables/fieldData';
+import { getUseInputPropsDefinition } from '../../../composables/input/useInput';
+import { useProxy } from '../../../composables/proxy/useProxy';
+import { DEFAULT_DAY_NAMES, DEFAULT_MONTH_NAMES } from './shared';
+import { addDays, eqSerialDate, isDate } from './utils';
+import { BInput } from '../input/BInput';
+import { isArrowDownEvent, isArrowLeftEvent, isArrowRightEvent, isArrowUpEvent, isEnterEvent, isEscEvent, isSpaceEvent } from '../../../utils/eventHelpers';
+import { head, isNonEmpty, range } from 'fp-ts/lib/Array';
+import { constant } from 'fp-ts/lib/function';
+import { alt, chain, fromNullable, getEq, isNone, isSome, some } from 'fp-ts/lib/Option';
+import { pipe } from 'fp-ts/lib/pipeable';
+import BDropdown, { BDropdownPropsDefinition } from '../../dropdown/BDropdown';
+import BDatepickerTable from './BDatepickerTable';
+import BField from '../field/BField';
+import { BSelect } from '../select/BSelect';
+import { computed, onUnmounted, onMounted, defineAsyncComponent, defineComponent, h, shallowRef, watch, toRef } from 'vue';
+import { constEmptyArray, isString, toggleListItem } from '../../../utils/helpers';
+const DEFAULT_DATEPICKER_ICONS = {
+  previous: defineAsyncComponent(() => import('../../icons/angleLeft')),
+  next: defineAsyncComponent(() => import('../../icons/angleRight')),
+  calendar: defineAsyncComponent(() => import('../../icons/calendar'))
+};
+export function getDatepickerIcons(icons) {
+  return { ...DEFAULT_DATEPICKER_ICONS,
+    ...icons
+  };
+}
+const BDatepickerPropsDefinition = { ...BDropdownPropsDefinition,
+  ...UseDisablePropsDefinition,
+  ...getUseInputPropsDefinition(),
+  modelValue: {
+    type: [Array, Date]
+  },
+  'onUpdate:modelValue': {
+    type: Function,
+    required: true
+  },
+  year: {
+    type: Number,
+    default: new Date().getFullYear()
+  },
+  'onUpdate:year': {
+    type: Function,
+    required: false
+  },
+  month: {
+    type: Number,
+    default: new Date().getMonth()
+  },
+  'onUpdate:month': {
+    type: Function,
+    required: false
+  },
+  dayNames: {
+    type: Array,
+    default: constant(DEFAULT_DAY_NAMES)
+  },
+  monthNames: {
+    type: Array,
+    default: constant(DEFAULT_MONTH_NAMES)
+  },
+  firstDayOfWeek: {
+    type: Number,
+    default: 0
+  },
+  events: {
+    type: Array,
+    default: constEmptyArray
+  },
+  minDate: {
+    type: Date,
+    required: false
+  },
+  maxDate: {
+    type: Date,
+    required: false
+  },
+  isDisabled: {
+    type: Boolean,
+    default: false
+  },
+  unselectableDates: {
+    type: Array,
+    default: constEmptyArray
+  },
+  unselectableDaysOfWeek: {
+    type: Array,
+    default: constEmptyArray
+  },
+  selectableDates: {
+    type: Object
+  },
+  showWeekNumber: {
+    type: Boolean,
+    default: false
+  },
+  isMultiple: {
+    type: Boolean,
+    default: false
+  },
+  placeholder: {
+    type: String
+  },
+  useMobileNative: {
+    type: Boolean,
+    default: false
+  },
+  position: {
+    type: String
+  },
+  indicators: {
+    type: String,
+    default: 'bars'
+  },
+  yearsRange: {
+    type: Array,
+    default: constant([-5, 3])
+  },
+  closeOnSelect: {
+    type: Boolean,
+    default: true
+  },
+  isReadonly: {
+    type: Boolean,
+    default: true
+  },
+  useNativeValidation: {
+    type: Boolean,
+    default: false
+  },
+  // openOnFocus: {
+  //   type: Boolean as PropType<boolean>,
+  //   default: true
+  // },
+  icons: {
+    type: Object,
+    default: constant(DEFAULT_DATEPICKER_ICONS)
+  }
+};
+
+function useNative(props) {
+  return props.useMobileNative && !props.isInline;
+}
+
+const useFormattedDate = Intl.DateTimeFormat('default', {
+  year: 'numeric',
+  month: 'numeric',
+  day: 'numeric'
+}).format;
+
+function useFormattedModelValue(modelValue) {
+  return Array.isArray(modelValue) ? modelValue.map(useFormattedDate).join(', ') : modelValue ? useFormattedDate(modelValue) : null;
+}
+
+function parseInputString(str) {
+  const splits = str.split(',').map(s => s.trim());
+  return splits.map(s => new Date(s)).filter(d => isDate(d) && !isNaN(d.getTime()));
+}
+
+function generateInput(props, context, data) {
+  const isMobile = useNative(props);
+  return h(BInput, {
+    max: props.maxDate ? useFormattedDate(props.maxDate) : null,
+    min: props.minDate ? useFormattedDate(props.minDate) : null,
+    autocomplete: 'off',
+    type: isMobile ? 'date' : 'text',
+    modelValue: useFormattedModelValue(data.modelValue.value),
+    'onUpdate:modelValue': val => {
+      data.modelValue.value = parseInputString(val);
+    },
+    placeholder: props.placeholder,
+    size: props.size,
+    icon: props.icons.calendar,
+    isRounded: props.isRounded,
+    isDisabled: props.isDisabled,
+    isReadonly: props.isReadonly,
+    isLoading: props.isLoading,
+    useNativeValidation: props.useNativeValidation // onFocus: () => {
+    //   if (!isMobile && props.openOnFocus && toggle) {
+    //     if (toggle.isOff.value) {
+    //       console.log('focus-set-on')
+    //       toggle.setOn();
+    //       Date.now()
+    //     }
+    //   }
+    // }
+
+  });
+}
+
+function generateButton(props, data, isNext) {
+  return h('button', {
+    class: isNext ? 'pagination-next datepicker-next' : 'pagination-previous datepicker-previous',
+    disabled: data.isDisabled,
+    onClick: isNext ? data.nextMonth : data.previousMonth,
+    onKeydown: e => {
+      if (isEnterEvent(e) || isSpaceEvent(e)) {
+        e.preventDefault();
+        isNext ? data.nextMonth() : data.previousMonth();
+      }
+    }
+  }, [h(isNext ? props.icons.next : props.icons.previous, {
+    variant: 'is-link',
+    isThemeable: false
+  })]);
+}
+
+function generateYearSelect(props, data) {
+  return h(BSelect, {
+    items: data.years,
+    modelValue: data.year.value,
+    isDisabled: data.isDisabled,
+    size: props.size,
+    'onUpdate:modelValue': data.setYear
+  });
+}
+
+function generateMonthSelect(props, data) {
+  return h(BSelect, {
+    items: data.months,
+    isDisabled: data.isDisabled,
+    size: props.size,
+    modelValue: data.month.value,
+    'onUpdate:modelValue': data.setMonth
+  });
+}
+
+function generateSelects(props, data) {
+  return h('div', {
+    class: 'pagination-list'
+  }, [h(BField, {
+    class: 'is-marginless'
+  }, () => [generateMonthSelect(props, data), generateYearSelect(props, data)])]);
+}
+
+function generateDefaultHeaderContents(props, data) {
+  return h('div', {
+    class: ['pagination field is-centered', props.size]
+  }, [generateButton(props, data, false), generateSelects(props, data), generateButton(props, data, true)]);
+}
+
+function generateHeader(props, context, data) {
+  return h('header', {
+    class: 'datepicker-header'
+  }, context.slots.header ? context.slots.header(data) : [generateDefaultHeaderContents(props, data)]);
+}
+
+function generateDatepickerTable(props, context, data) {
+  return h(BDatepickerTable, {
+    modelValue: data.modelValue.value,
+    'onUpdate:modelValue': val => {
+      data.modelValue.value = val;
+    },
+    focusedDate: data.focusedDate.value,
+    'onUpdate:focusedDate': val => {
+      data.focusedDate.value = val;
+    },
+    dayNames: props.dayNames,
+    monthNames: props.monthNames,
+    firstDayOfWeek: props.firstDayOfWeek,
+    minDate: props.minDate,
+    maxDate: props.maxDate,
+    month: data.month.value,
+    year: data.year.value,
+    isDisabled: data.isDisabled,
+    unselectableDates: props.unselectableDates,
+    unselectableDaysOfWeek: props.unselectableDaysOfWeek,
+    selectableDates: props.selectableDates,
+    events: props.events,
+    indicators: props.indicators,
+    showWeekNumber: props.showWeekNumber
+  });
+}
+
+function generateFooter(context) {
+  return h('footer', {
+    class: 'datepicker-footer'
+  }, context.slots.footer && context.slots.footer());
+}
+
+function generateCalendar(props, context, data) {
+  return h('section', {
+    class: 'datepicker-content',
+    'aria-label': 'Datepicker calendar'
+  }, [generateDatepickerTable(props, context, data)]);
+}
+
+function generateDatepickerBody(props, context, data) {
+  const nodes = [generateHeader(props, context, data), generateCalendar(props, context, data)];
+
+  if (context.slots.footer) {
+    nodes.push(generateFooter(context));
+  }
+
+  return h('div', nodes);
+}
+
+function generateDropdown(props, context, data, dropdown) {
+  return h(BDropdown, {
+    ref: dropdown,
+    position: props.position,
+    isDisabled: props.isDisabled,
+    isInline: props.isInline
+  }, {
+    trigger: () => {
+      return generateInput(props, context, data);
+    },
+    default: () => generateDatepickerBody(props, context, data)
+  });
+}
+
+function getMonths(props, focusedMonth) {
+  return props.monthNames.map((month, index) => ({
+    value: index,
+    text: month,
+    isDisabled: false,
+    isSelected: focusedMonth === index
+  }));
+}
+
+function getYears(props, focusedYear) {
+  const currentYear = new Date().getFullYear();
+  return range(props.yearsRange[0], props.yearsRange[1]).map(inc => currentYear + inc).map(year => ({
+    value: year,
+    text: year.toString(),
+    isDisabled: false,
+    isSelected: focusedYear === year
+  }));
+}
+
+function getSetPreviousMonth(props, month, year) {
+  return e => {
+    if (e) {
+      e.preventDefault();
+    }
+
+    if (!props.isDisabled) {
+      if (month.value > 0) {
+        month.value = month.value - 1;
+      } else {
+        month.value = 11;
+        year.value = year.value - 1;
+      }
+    }
+  };
+}
+
+function getSetNextMonth(props, month, year) {
+  return e => {
+    if (e) {
+      e.preventDefault();
+    }
+
+    if (!props.isDisabled) {
+      const mv = month.value;
+
+      if (mv < 11) {
+        month.value = mv + 1;
+      } else {
+        month.value = 0;
+        year.value = year.value + 1;
+      }
+    }
+  };
+}
+
+function getSetMonth(monthRef) {
+  return month => {
+    if (isString(month)) {
+      const newVal = fromNullable(parseInt(month, 10));
+
+      if (isSome(newVal)) {
+        monthRef.value = newVal.value;
+      }
+    } else {
+      monthRef.value = month;
+    }
+  };
+}
+
+function getSetYear(yearRef) {
+  return year => {
+    if (isString(year)) {
+      const newVal = fromNullable(parseInt(year, 10));
+
+      if (isSome(newVal)) {
+        yearRef.value = newVal.value;
+      }
+    } else {
+      yearRef.value = year;
+    }
+  };
+}
+
+const toggleSerialDate = toggleListItem(eqSerialDate);
+export default defineComponent({
+  name: 'b-datepicker',
+  props: BDatepickerPropsDefinition,
+
+  setup(props, context) {
+    const fieldData = useFieldData();
+    const isDisabled = useDisable(props);
+    const dropdown = shallowRef(null);
+    const internalValue = shallowRef(props.modelValue);
+    watch(() => props.modelValue, newVal => {
+      internalValue.value = newVal;
+    });
+    const modelValue = computed({
+      get() {
+        return internalValue.value;
+      },
+
+      set(val) {
+        if (!val) {
+          return;
+        }
+
+        if (Array.isArray(val) && props.isMultiple || isDate(val)) {
+          props['onUpdate:modelValue'](val);
+          internalValue.value = val;
+        } else if (props.isMultiple && isDate(val)) {
+          const newVal = toggleSerialDate(val, internalValue.value == undefined ? [] : Array.isArray(internalValue.value) ? internalValue.value : [internalValue.value]);
+          props['onUpdate:modelValue'](newVal);
+          internalValue.value = newVal;
+        } else if (Array.isArray(val) && isNonEmpty(val)) {
+          props['onUpdate:modelValue'](val[0]);
+          internalValue.value = val[0];
+        }
+
+        if (props.closeOnSelect) {
+          dropdown.value && dropdown.value.toggle.setOff();
+        }
+      }
+
+    });
+    const focusedDate = useEqRef(getEq(eqSerialDate))(pipe(fromNullable(props.modelValue), chain(v => Array.isArray(v) ? head(v) : some(v)), alt(() => some(new Date()))));
+    const {
+      value: month
+    } = useProxy(toRef(props, 'month'), toRef(props, 'onUpdate:month'));
+    const {
+      value: year
+    } = useProxy(toRef(props, 'year'), toRef(props, 'onUpdate:year'));
+    const nextMonth = getSetNextMonth(props, month, year);
+    const previousMonth = getSetPreviousMonth(props, month, year);
+    const setMonth = getSetMonth(month);
+    const setYear = getSetYear(year);
+
+    function onKeydown(e) {
+      if (dropdown.value === undefined || dropdown.value?.$el === undefined || !dropdown.value.$el.contains(e.target)) {
+        return;
+      }
+
+      if (isEscEvent(e)) {
+        dropdown.value && dropdown.value.toggle.setOff();
+        return;
+      }
+
+      const fd = pipe(focusedDate.value, alt(() => pipe(fromNullable(modelValue.value), chain(v => Array.isArray(v) ? head(v) : some(v)))));
+
+      if (isNone(fd)) {
+        return;
+      }
+
+      if (isEnterEvent(e) || isSpaceEvent(e)) {
+        e.preventDefault();
+        modelValue.value = fd.value;
+      } else if (isArrowUpEvent(e)) {
+        e.preventDefault();
+        focusedDate.value = some(addDays(fd.value, -7));
+      } else if (isArrowRightEvent(e)) {
+        e.preventDefault();
+        focusedDate.value = some(addDays(fd.value, 1));
+      } else if (isArrowDownEvent(e)) {
+        e.preventDefault();
+        focusedDate.value = some(addDays(fd.value, 7));
+      } else if (isArrowLeftEvent(e)) {
+        e.preventDefault();
+        focusedDate.value = some(addDays(fd.value, -1));
+      }
+    }
+
+    onMounted(() => {
+      if (typeof window !== 'undefined') {
+        document.addEventListener('keyup', onKeydown);
+      }
+    });
+    onUnmounted(() => {
+      if (typeof window !== 'undefined') {
+        document.removeEventListener('keyup', onKeydown);
+      }
+    });
+    watch(focusedDate, fd => {
+      const m = month.value;
+      const y = year.value;
+
+      if (isSome(fd)) {
+        const fdValue = fd.value;
+        const nMonth = fdValue.getMonth();
+
+        if (nMonth !== m) {
+          month.value = nMonth;
+        }
+
+        const nYear = fdValue.getFullYear();
+
+        if (nYear !== y) {
+          year.value = nYear;
+        }
+      }
+    }, {
+      immediate: true
+    });
+    return () => {
+      const data = {
+        modelValue,
+        month,
+        year,
+        isDisabled: isDisabled.value,
+        focusedDate: focusedDate,
+        nextMonth,
+        previousMonth,
+        setMonth,
+        setYear,
+        months: getMonths(props, month.value),
+        years: getYears(props, year.value)
+      };
+      return h('article', {
+        class: ['b-datepicker control', props.size, {
+          'is-expanded': props.isExpanded || fieldData.attrs.isExpanded.value
+        }]
+      }, [useNative(props) ? generateInput(props, context, data) : generateDropdown(props, context, data, dropdown)]);
+    };
+  }
+
+});
+//# sourceMappingURL=BDatepicker.js.map

node_modules/buetify/lib/components/form/datepicker/BDatepickerTable.d.ts

@@ -0,0 +1,183 @@
+import './datepicker.sass';
+import { DateEvent, MonthNumber } from './shared';
+import { WeekdayNumber } from './utils';
+import { FunctionN } from 'fp-ts/lib/function';
+import { Option } from 'fp-ts/lib/Option';
+import { PropType, VNode, ExtractPropTypes } from 'vue';
+export declare const BDatepickerTablePropsDefinition: {
+    modelValue: {
+        type: PropType<Date | Date[]>;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<FunctionN<[Date | Date[]], void>>;
+        required: true;
+    };
+    focusedDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    'onUpdate:focusedDate': {
+        type: PropType<FunctionN<[Option<Date>], unknown>>;
+        required: true;
+    };
+    month: {
+        type: PropType<MonthNumber>;
+        required: true;
+    };
+    year: {
+        type: NumberConstructor;
+        required: true;
+    };
+    dayNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    monthNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    firstDayOfWeek: {
+        type: PropType<WeekdayNumber>;
+        default: 0;
+    };
+    events: {
+        type: PropType<DateEvent[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    indicators: {
+        type: PropType<import("./shared").EventIndicator>;
+        required: true;
+    };
+    minDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    maxDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    unselectableDates: {
+        type: PropType<Date[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    unselectableDaysOfWeek: {
+        type: PropType<number[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    selectableDates: {
+        type: PropType<Date[]>;
+    };
+    showWeekNumber: {
+        type: PropType<boolean>;
+        default: false;
+    };
+};
+export declare type BDatepickerTableProps = ExtractPropTypes<typeof BDatepickerTablePropsDefinition>;
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<Date | Date[]>;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<FunctionN<[Date | Date[]], void>>;
+        required: true;
+    };
+    focusedDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    'onUpdate:focusedDate': {
+        type: PropType<FunctionN<[Option<Date>], unknown>>;
+        required: true;
+    };
+    month: {
+        type: PropType<MonthNumber>;
+        required: true;
+    };
+    year: {
+        type: NumberConstructor;
+        required: true;
+    };
+    dayNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    monthNames: {
+        type: PropType<string[]>;
+        default: import("fp-ts/lib/function").Lazy<string[]>;
+    };
+    firstDayOfWeek: {
+        type: PropType<WeekdayNumber>;
+        default: 0;
+    };
+    events: {
+        type: PropType<DateEvent[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    indicators: {
+        type: PropType<import("./shared").EventIndicator>;
+        required: true;
+    };
+    minDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    maxDate: {
+        type: PropType<Date>;
+        required: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    unselectableDates: {
+        type: PropType<Date[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    unselectableDaysOfWeek: {
+        type: PropType<number[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    selectableDates: {
+        type: PropType<Date[]>;
+    };
+    showWeekNumber: {
+        type: PropType<boolean>;
+        default: false;
+    };
+}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    isDisabled: boolean;
+    "onUpdate:modelValue": FunctionN<[Date | Date[]], void>;
+    events: DateEvent[];
+    focusedDate: Option<Date>;
+    "onUpdate:focusedDate": FunctionN<[Option<Date>], unknown>;
+    indicators: import("./shared").EventIndicator;
+    showWeekNumber: boolean;
+    month: MonthNumber;
+    unselectableDates: Date[];
+    unselectableDaysOfWeek: number[];
+    year: number;
+    dayNames: string[];
+    monthNames: string[];
+    firstDayOfWeek: WeekdayNumber;
+} & {
+    modelValue?: Date | Date[] | undefined;
+    minDate?: Date | undefined;
+    maxDate?: Date | undefined;
+    selectableDates?: Date[] | undefined;
+}>, {
+    isDisabled: boolean;
+    events: DateEvent[];
+    showWeekNumber: boolean;
+    unselectableDates: Date[];
+    unselectableDaysOfWeek: number[];
+    dayNames: string[];
+    monthNames: string[];
+    firstDayOfWeek: WeekdayNumber;
+}>;
+export default _default;

node_modules/buetify/lib/components/form/datepicker/BDatepickerTable.js

@@ -0,0 +1,186 @@
+import "../../../../src/components/form/datepicker/datepicker.sass";
+import { DEFAULT_DAY_NAMES, DEFAULT_MONTH_NAMES } from './shared';
+import { addDays, getDatesInWeek, getEndOfMonth, getEndOfWeek, getStartOfMonth, getStartOfWeek, isDate, isOnOrAfterDate, isOnOrBeforeDate, isWithinWeek } from './utils';
+import { constEmptyArray } from '../../../utils/helpers';
+import { isEmpty, rotate } from 'fp-ts/lib/Array';
+import { constant } from 'fp-ts/lib/function';
+import { fromNullable, isNone, none } from 'fp-ts/lib/Option';
+import { defineComponent, h, computed } from 'vue';
+import BDatepickerTableRow from './BDatepickerTableRow';
+export const BDatepickerTablePropsDefinition = {
+  modelValue: {
+    type: [Array, Date]
+  },
+  'onUpdate:modelValue': {
+    type: Function,
+    required: true
+  },
+  focusedDate: {
+    type: Object,
+    required: true
+  },
+  'onUpdate:focusedDate': {
+    type: Function,
+    required: true
+  },
+  month: {
+    type: Number,
+    required: true
+  },
+  year: {
+    type: Number,
+    required: true
+  },
+  dayNames: {
+    type: Array,
+    default: constant(DEFAULT_DAY_NAMES)
+  },
+  monthNames: {
+    type: Array,
+    default: constant(DEFAULT_MONTH_NAMES)
+  },
+  firstDayOfWeek: {
+    type: Number,
+    default: 0
+  },
+  events: {
+    type: Array,
+    default: constEmptyArray
+  },
+  indicators: {
+    type: String,
+    required: true
+  },
+  minDate: {
+    type: Date,
+    required: false
+  },
+  maxDate: {
+    type: Date,
+    required: false
+  },
+  isDisabled: {
+    type: Boolean,
+    default: false
+  },
+  unselectableDates: {
+    type: Array,
+    default: constEmptyArray
+  },
+  unselectableDaysOfWeek: {
+    type: Array,
+    default: constEmptyArray
+  },
+  selectableDates: {
+    type: Object
+  },
+  showWeekNumber: {
+    type: Boolean,
+    default: false
+  }
+};
+
+function getWeeksWithinMonth(props) {
+  const startOfMonth = getStartOfMonth(new Date(props.year, props.month + 1, 0));
+  const endOfCalendar = getEndOfWeek(getEndOfMonth(startOfMonth), props.firstDayOfWeek);
+  const weeks = [];
+  let date = getStartOfWeek(startOfMonth, props.firstDayOfWeek);
+
+  while (isOnOrBeforeDate(date, endOfCalendar)) {
+    weeks.push(getDatesInWeek(date, props.firstDayOfWeek));
+    date = addDays(date, 7);
+  }
+
+  return weeks;
+}
+
+function getEventsWithinWeek(props, week) {
+  return props.events.filter(event => {
+    const eventDate = isDate(event) ? event : event.date;
+    return isWithinWeek(week[0], eventDate, props.firstDayOfWeek);
+  });
+}
+
+function getWeeks(props) {
+  return getWeeksWithinMonth(props).map((week, weekNumber) => ({
+    week,
+    weekNumber,
+    events: getEventsWithinWeek(props, week)
+  }));
+}
+
+function generateTableHeader(dayNames) {
+  return h('thead', {
+    class: 'datepicker-header'
+  }, [h('tr', dayNames.map(day => h('th', {
+    key: day,
+    class: 'datepicker-cell'
+  }, day)))]);
+}
+
+function getGenerateTableRow(props, focusedDate) {
+  return function generateTableRow(weekData) {
+    return h(BDatepickerTableRow, {
+      key: weekData.weekNumber,
+      modelValue: props.modelValue,
+      'onUpdate:modelValue': props['onUpdate:modelValue'],
+      focusedDate: focusedDate.value,
+      'onUpdate:focusedDate': val => {
+        focusedDate.value = val;
+      },
+      week: weekData.week,
+      weekNumber: weekData.weekNumber,
+      month: props.month,
+      minDate: fromNullable(props.minDate),
+      maxDate: fromNullable(props.maxDate),
+      unselectableDates: props.unselectableDates,
+      unselectableDaysOfWeek: props.unselectableDaysOfWeek,
+      selectableDates: fromNullable(props.selectableDates),
+      events: weekData.events,
+      indicators: props.indicators
+    });
+  };
+}
+
+function generateTableBody(props, focusedDate) {
+  return h('tbody', {
+    class: ['datepicker-body', {
+      'has-events': !isEmpty(props.events)
+    }]
+  }, getWeeks(props).map(getGenerateTableRow(props, focusedDate)));
+}
+
+export default defineComponent({
+  name: 'b-datepicker-table',
+  props: BDatepickerTablePropsDefinition,
+
+  setup(props) {
+    const focusedDate = computed({
+      get() {
+        return props.focusedDate;
+      },
+
+      set(date) {
+        if (isNone(date)) {
+          props['onUpdate:focusedDate'](date);
+        } else if (props.minDate && props.maxDate) {
+          props['onUpdate:focusedDate'](isOnOrAfterDate(date.value, props.minDate) && isOnOrBeforeDate(date.value, props.maxDate) ? date : none);
+        } else if (props.minDate) {
+          props['onUpdate:focusedDate'](isOnOrAfterDate(date.value, props.minDate) ? date : none);
+        } else if (props.maxDate) {
+          props['onUpdate:focusedDate'](isOnOrBeforeDate(date.value, props.maxDate) ? date : none);
+        } else {
+          props['onUpdate:focusedDate'](date);
+        }
+      }
+
+    });
+    return () => {
+      return h('table', {
+        class: 'datepicker-table'
+      }, [generateTableHeader(rotate(-props.firstDayOfWeek)(props.dayNames)), generateTableBody(props, focusedDate)]);
+    };
+  }
+
+});
+//# sourceMappingURL=BDatepickerTable.js.map

node_modules/buetify/lib/components/form/datepicker/BDatepickerTableCell.d.ts

@@ -0,0 +1,41 @@
+import './datepicker.sass';
+import { FunctionN } from 'fp-ts/lib/function';
+import { DateCell, EventIndicator } from './shared';
+import { Option } from 'fp-ts/lib/Option';
+import { PropType, VNode } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<Date | Date[]>;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<FunctionN<[Date | Date[]], void>>;
+        required: true;
+    };
+    focusedDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    'onUpdate:focusedDate': {
+        type: PropType<FunctionN<[Option<Date>], void>>;
+        required: true;
+    };
+    indicators: {
+        type: PropType<EventIndicator>;
+        required: true;
+    };
+    cell: {
+        type: PropType<DateCell>;
+        required: true;
+    };
+}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    "onUpdate:modelValue": FunctionN<[Date | Date[]], void>;
+    focusedDate: Option<Date>;
+    "onUpdate:focusedDate": FunctionN<[Option<Date>], void>;
+    indicators: EventIndicator;
+    cell: DateCell;
+} & {
+    modelValue?: Date | Date[] | undefined;
+}>, {}>;
+export default _default;

node_modules/buetify/lib/components/form/datepicker/BDatepickerTableCell.js

@@ -0,0 +1,84 @@
+import "../../../../src/components/form/datepicker/datepicker.sass";
+import { toggleListItem } from '../../../utils/helpers';
+import { eqSerialDate, isSameDay } from './utils';
+import { exists, getEq, some } from 'fp-ts/lib/Option';
+import { pipe } from 'fp-ts/lib/pipeable';
+import { defineComponent, shallowRef, h, watch, onMounted } from 'vue';
+
+function generateEvents(events) {
+  return h('div', {
+    class: 'events'
+  }, events.map((event, index) => h('div', {
+    key: index,
+    class: ['event', event.variant]
+  })));
+}
+
+const toggleSerialDate = toggleListItem(eqSerialDate);
+const eqOptionSerialDate = getEq(eqSerialDate);
+export default defineComponent({
+  name: 'b-datepicker-table-cell',
+  props: {
+    modelValue: {
+      type: [Date, Array]
+    },
+    'onUpdate:modelValue': {
+      type: Function,
+      required: true
+    },
+    focusedDate: {
+      type: Object,
+      required: true
+    },
+    'onUpdate:focusedDate': {
+      type: Function,
+      required: true
+    },
+    indicators: {
+      type: String,
+      required: true
+    },
+    cell: {
+      type: Object,
+      required: true
+    }
+  },
+
+  setup(props) {
+    const buttonRef = shallowRef(null);
+
+    function onClick(e) {
+      e && e.preventDefault();
+      const currentValue = props.modelValue;
+      props['onUpdate:modelValue'](Array.isArray(currentValue) ? toggleSerialDate(props.cell.date, currentValue) : props.cell.date);
+    }
+
+    const onFocus = () => {
+      props['onUpdate:focusedDate'](some(props.cell.date));
+    };
+
+    onMounted(() => watch(() => props.focusedDate, (newVal, oldVal) => {
+      if ((oldVal && !eqOptionSerialDate.equals(newVal, oldVal) || oldVal === undefined) && buttonRef.value && pipe(newVal, exists(d => isSameDay(d, props.cell.date))) && document.activeElement !== buttonRef.value) {
+        buttonRef.value.focus({
+          preventScroll: true
+        });
+      }
+    }, {
+      immediate: true
+    }));
+    return () => {
+      return h('td', [h('button', {
+        ref: buttonRef,
+        class: ['datepicker-cell', props.cell.classes, props.indicators],
+        disabled: props.cell.isDisabled,
+        tabindex: props.cell.isDisabled || props.cell.isSelected ? -1 : 0,
+        'aria-label': props.cell.ariaLabel,
+        onClick,
+        onFocus,
+        onMouseenter: onFocus
+      }, [props.cell.date.getDate(), props.cell.hasEvents ? generateEvents(props.cell.events) : undefined])]);
+    };
+  }
+
+});
+//# sourceMappingURL=BDatepickerTableCell.js.map

node_modules/buetify/lib/components/form/datepicker/BDatepickerTableRow.d.ts

@@ -0,0 +1,164 @@
+import './datepicker.sass';
+import { DateEvent } from './shared';
+import { FunctionN } from 'fp-ts/lib/function';
+import { Option } from 'fp-ts/lib/Option';
+import { PropType, VNode, ExtractPropTypes } from 'vue';
+export declare const BDatepickerTableRowPropsDefinition: {
+    modelValue: {
+        type: PropType<Date | Date[]>;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<FunctionN<[Date | Date[]], void>>;
+        required: true;
+    };
+    focusedDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    'onUpdate:focusedDate': {
+        type: PropType<FunctionN<[Option<Date>], unknown>>;
+        required: true;
+    };
+    showWeekNumber: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    weekNumber: {
+        type: PropType<number>;
+        required: true;
+    };
+    week: {
+        type: PropType<Date[]>;
+        required: true;
+    };
+    month: {
+        type: PropType<number>;
+        required: true;
+    };
+    minDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    maxDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    isDisabled: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    unselectableDates: {
+        type: PropType<Date[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    unselectableDaysOfWeek: {
+        type: PropType<number[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    selectableDates: {
+        type: PropType<Option<Date[]>>;
+        default: import("fp-ts/lib/function").Lazy<Option<never>>;
+    };
+    events: {
+        type: PropType<DateEvent[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    indicators: {
+        type: PropType<import("./shared").EventIndicator>;
+        required: true;
+    };
+};
+export declare type BDatePickerTableRowProps = ExtractPropTypes<typeof BDatepickerTableRowPropsDefinition>;
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<Date | Date[]>;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<FunctionN<[Date | Date[]], void>>;
+        required: true;
+    };
+    focusedDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    'onUpdate:focusedDate': {
+        type: PropType<FunctionN<[Option<Date>], unknown>>;
+        required: true;
+    };
+    showWeekNumber: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    weekNumber: {
+        type: PropType<number>;
+        required: true;
+    };
+    week: {
+        type: PropType<Date[]>;
+        required: true;
+    };
+    month: {
+        type: PropType<number>;
+        required: true;
+    };
+    minDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    maxDate: {
+        type: PropType<Option<Date>>;
+        required: true;
+    };
+    isDisabled: {
+        type: PropType<boolean>;
+        default: false;
+    };
+    unselectableDates: {
+        type: PropType<Date[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    unselectableDaysOfWeek: {
+        type: PropType<number[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    selectableDates: {
+        type: PropType<Option<Date[]>>;
+        default: import("fp-ts/lib/function").Lazy<Option<never>>;
+    };
+    events: {
+        type: PropType<DateEvent[]>;
+        default: import("fp-ts/lib/function").Lazy<never[]>;
+    };
+    indicators: {
+        type: PropType<import("./shared").EventIndicator>;
+        required: true;
+    };
+}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    isDisabled: boolean;
+    "onUpdate:modelValue": FunctionN<[Date | Date[]], void>;
+    events: DateEvent[];
+    focusedDate: Option<Date>;
+    "onUpdate:focusedDate": FunctionN<[Option<Date>], unknown>;
+    indicators: import("./shared").EventIndicator;
+    showWeekNumber: boolean;
+    weekNumber: number;
+    week: Date[];
+    month: number;
+    minDate: Option<Date>;
+    maxDate: Option<Date>;
+    unselectableDates: Date[];
+    unselectableDaysOfWeek: number[];
+    selectableDates: Option<Date[]>;
+} & {
+    modelValue?: Date | Date[] | undefined;
+}>, {
+    isDisabled: boolean;
+    events: DateEvent[];
+    showWeekNumber: boolean;
+    unselectableDates: Date[];
+    unselectableDaysOfWeek: number[];
+    selectableDates: Option<Date[]>;
+}>;
+export default _default;

node_modules/buetify/lib/components/form/datepicker/BDatepickerTableRow.js

@@ -0,0 +1,202 @@
+import "../../../../src/components/form/datepicker/datepicker.sass";
+import BDatepickerTableCell from './BDatepickerTableCell';
+import { elemSerialDate, isDate, isOnOrAfterDate, isOnOrBeforeDate, isSameDay } from './utils';
+import { constEmptyArray, constNone } from '../../../utils/helpers';
+import { isNonEmpty } from 'fp-ts/lib/Array';
+import { constTrue, identity } from 'fp-ts/lib/function';
+import { fold } from 'fp-ts/lib/Option';
+import { pipe } from 'fp-ts/lib/pipeable';
+import { defineComponent, computed, h } from 'vue';
+export const BDatepickerTableRowPropsDefinition = {
+  modelValue: {
+    type: [Date, Array]
+  },
+  'onUpdate:modelValue': {
+    type: Function,
+    required: true
+  },
+  focusedDate: {
+    type: Object,
+    required: true
+  },
+  'onUpdate:focusedDate': {
+    type: Function,
+    required: true
+  },
+  showWeekNumber: {
+    type: Boolean,
+    default: false
+  },
+  weekNumber: {
+    type: Number,
+    required: true
+  },
+  week: {
+    type: Array,
+    required: true
+  },
+  month: {
+    type: Number,
+    required: true
+  },
+  minDate: {
+    type: Object,
+    required: true
+  },
+  maxDate: {
+    type: Object,
+    required: true
+  },
+  isDisabled: {
+    type: Boolean,
+    default: false
+  },
+  unselectableDates: {
+    type: Array,
+    default: constEmptyArray
+  },
+  unselectableDaysOfWeek: {
+    type: Array,
+    default: constEmptyArray
+  },
+  selectableDates: {
+    type: Object,
+    default: constNone
+  },
+  events: {
+    type: Array,
+    default: constEmptyArray
+  },
+  indicators: {
+    type: String,
+    required: true
+  }
+};
+
+function getIsAfterMinDate(props) {
+  return function isAfterMinDate(date) {
+    return pipe(props.minDate, fold(constTrue, d => isOnOrAfterDate(date, d)));
+  };
+}
+
+function getIsBeforeMaxDate(props) {
+  return function isBeforeMaxDate(date) {
+    return pipe(props.maxDate, fold(constTrue, d => isOnOrBeforeDate(date, d)));
+  };
+}
+
+function getIsWithinMonth(props) {
+  return function isWithinMonth(date) {
+    return date.getMonth() === props.month;
+  };
+}
+
+function getIsEnabled(props) {
+  return function isEnabled(date) {
+    return !elemSerialDate(date, props.unselectableDates) && pipe(props.selectableDates, fold(constTrue, dates => elemSerialDate(date, dates)));
+  };
+}
+
+function getIsOnSelectableDayOfWeek(props) {
+  return function isOnSelectableDayOfWeek(date) {
+    return !props.unselectableDaysOfWeek.includes(date.getDay());
+  };
+}
+
+function getDatePredicates(props) {
+  const isAfterMinDate = getIsAfterMinDate(props);
+  const isBeforeMaxDate = getIsBeforeMaxDate(props);
+  const isWithinMonth = getIsWithinMonth(props);
+  const isEnabled = getIsEnabled(props);
+  const isOnSelectableDayOfWeek = getIsOnSelectableDayOfWeek(props);
+
+  function isSelectedDate(date) {
+    return Array.isArray(props.modelValue) ? props.modelValue.some(d => isSameDay(d, date)) : props.modelValue ? isSameDay(props.modelValue, date) : false;
+  }
+
+  function isSelectableDate(date) {
+    return [isAfterMinDate(date), isBeforeMaxDate(date), isWithinMonth(date), isEnabled(date), isOnSelectableDayOfWeek(date)].every(identity);
+  }
+
+  return {
+    isAfterMinDate,
+    isBeforeMaxDate,
+    isWithinMonth,
+    isEnabled,
+    isOnSelectableDayOfWeek,
+    isSelectableDate,
+    isSelectedDate
+  };
+}
+
+function getDateClassesGenerator(props, predicates) {
+  const today = new Date();
+  return function getDateClasses(date, hasEvents = false) {
+    if (isDate(date)) {
+      const isSelectable = predicates.isSelectableDate(date);
+      return {
+        'is-selected': predicates.isSelectedDate(date),
+        'is-today': isSameDay(date, today),
+        'is-selectable': isSelectable && !props.isDisabled,
+        'is-unselectable': !isSelectable || props.isDisabled,
+        'has-event': hasEvents
+      };
+    } else {
+      return {};
+    }
+  };
+}
+
+function generateWeekNumber(weekNumber) {
+  return h('td', [`${weekNumber}`]);
+}
+
+function getGenerateCell(props) {
+  return function generateCell(cell) {
+    return h(BDatepickerTableCell, {
+      key: cell.date.toLocaleDateString(),
+      cell,
+      modelValue: props.modelValue,
+      'onUpdate:modelValue': props['onUpdate:modelValue'],
+      focusedDate: props.focusedDate,
+      'onUpdate:focusedDate': props['onUpdate:focusedDate'],
+      indicators: props.indicators
+    });
+  };
+}
+
+export default defineComponent({
+  name: 'b-datepicker-table-row',
+  props: BDatepickerTableRowPropsDefinition,
+
+  setup(props) {
+    const formattedEvents = computed(() => props.events.map(event => isDate(event) ? {
+      date: event,
+      variant: 'is-primary'
+    } : event));
+    const predicates = getDatePredicates(props);
+    const getDateClasses = getDateClassesGenerator(props, predicates);
+    const cells = computed(() => props.week.map(date => {
+      const events = formattedEvents.value.filter(event => isSameDay(date, event.date));
+      const hasEvents = isNonEmpty(events);
+      return {
+        date,
+        events,
+        hasEvents,
+        isSelected: predicates.isSelectedDate(date),
+        isDisabled: props.isDisabled || !predicates.isSelectableDate(date),
+        number: date.getDate(),
+        ariaLabel: date.toLocaleDateString(),
+        classes: getDateClasses(date, hasEvents)
+      };
+    }));
+    const generateCell = getGenerateCell(props);
+    return () => {
+      return h('tr', {
+        class: 'datepicker-row'
+      }, props.showWeekNumber ? [generateWeekNumber(props.weekNumber), ...cells.value.map(generateCell)] : cells.value.map(generateCell));
+    };
+  }
+
+});
+//# sourceMappingURL=BDatepickerTableRow.js.map

node_modules/buetify/lib/components/form/datepicker/index.d.ts

@@ -0,0 +1,3 @@
+import BDatepicker from './BDatepicker';
+export default BDatepicker;
+export { BDatepicker };

node_modules/buetify/lib/components/form/datepicker/index.js

@@ -0,0 +1,4 @@
+import BDatepicker from './BDatepicker';
+export default BDatepicker;
+export { BDatepicker };
+//# sourceMappingURL=index.js.map

node_modules/buetify/lib/components/form/datepicker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/form/datepicker/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAP,MAAwB,eAAxB;AAEA,eAAe,WAAf;AAEA,SAAS,WAAT","sourcesContent":["import BDatepicker from './BDatepicker';\n\nexport default BDatepicker;\n\nexport { BDatepicker };\n"],"sourceRoot":"","file":"index.js"}

node_modules/buetify/lib/components/form/datepicker/shared.d.ts

@@ -0,0 +1,20 @@
+import { ColorVariant } from '../../../types/ColorVariants';
+export declare type DateEvent = Date | DetailedDateEvent;
+export interface DetailedDateEvent {
+    date: Date;
+    variant: ColorVariant;
+}
+export declare type EventIndicator = 'dots' | 'bars';
+export declare const DEFAULT_DAY_NAMES: string[];
+export declare const DEFAULT_MONTH_NAMES: string[];
+export declare type MonthNumber = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+export interface DateCell {
+    date: Date;
+    number: number;
+    ariaLabel: string;
+    isDisabled: boolean;
+    isSelected: boolean;
+    events: DetailedDateEvent[];
+    hasEvents: boolean;
+    classes: object;
+}

node_modules/buetify/lib/components/form/datepicker/shared.js

@@ -0,0 +1,3 @@
+export const DEFAULT_DAY_NAMES = ['Su', 'M', 'Tu', 'W', 'Th', 'F', 'S'];
+export const DEFAULT_MONTH_NAMES = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+//# sourceMappingURL=shared.js.map

node_modules/buetify/lib/components/form/datepicker/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/form/datepicker/shared.ts"],"names":[],"mappings":"AAWA,OAAO,MAAM,iBAAiB,GAAG,CAAC,IAAD,EAAO,GAAP,EAAY,IAAZ,EAAkB,GAAlB,EAAuB,IAAvB,EAA6B,GAA7B,EAAkC,GAAlC,CAA1B;AAEP,OAAO,MAAM,mBAAmB,GAAG,CACjC,SADiC,EAEjC,UAFiC,EAGjC,OAHiC,EAIjC,OAJiC,EAKjC,KALiC,EAMjC,MANiC,EAOjC,MAPiC,EAQjC,QARiC,EASjC,WATiC,EAUjC,SAViC,EAWjC,UAXiC,EAYjC,UAZiC,CAA5B","sourcesContent":["import { ColorVariant } from '../../../types/ColorVariants';\n\nexport type DateEvent = Date | DetailedDateEvent;\n\nexport interface DetailedDateEvent {\n  date: Date;\n  variant: ColorVariant;\n}\n\nexport type EventIndicator = 'dots' | 'bars';\n\nexport const DEFAULT_DAY_NAMES = ['Su', 'M', 'Tu', 'W', 'Th', 'F', 'S'];\n\nexport const DEFAULT_MONTH_NAMES = [\n  'January',\n  'February',\n  'March',\n  'April',\n  'May',\n  'June',\n  'July',\n  'August',\n  'September',\n  'October',\n  'November',\n  'December'\n];\n\nexport type MonthNumber = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;\n\nexport interface DateCell {\n  date: Date;\n  number: number;\n  ariaLabel: string;\n  isDisabled: boolean;\n  isSelected: boolean;\n  events: DetailedDateEvent[];\n  hasEvents: boolean;\n  classes: object;\n}\n"],"sourceRoot":"","file":"shared.js"}

node_modules/buetify/lib/components/form/datepicker/utils.d.ts

@@ -0,0 +1,27 @@
+import { Eq } from 'fp-ts/lib/Eq';
+import { Ord } from 'fp-ts/lib/Ord';
+export declare function isDate(value: unknown): value is Date;
+export declare function getStartOfDay(date: Date): Date;
+export declare function getEndOfDay(date: Date): Date;
+export declare function isSameDay(x: Date, y: Date): boolean;
+export declare function isBeforeDay(date: Date, isBefore: Date): boolean;
+export declare function isAfterDay(date: Date, isAfter: Date): boolean;
+export declare function isSameMonth(x: Date, y: Date): boolean;
+export declare const eqSerialDate: Eq<Date>;
+export declare const ordSerialDate: Ord<Date>;
+export declare const isOnOrAfterDate: (x: Date, y: Date) => boolean;
+export declare const isOnOrBeforeDate: (x: Date, y: Date) => boolean;
+export declare const elemSerialDate: {
+    (a: Date): (as: Date[]) => boolean;
+    (a: Date, as: Date[]): boolean;
+};
+export declare type WeekdayNumber = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export declare function getStartOfMonth(date: Date): Date;
+export declare function getEndOfMonth(date: Date): Date;
+export declare function getStartOfWeek(date: Date, weekStartsOn?: WeekdayNumber): Date;
+export declare function getEndOfWeek(date: Date, weekStartsOn?: WeekdayNumber): Date;
+export declare function isWithinWeek(date: Date, secondDate: Date, weekStartsOn?: WeekdayNumber): boolean;
+export declare function getDaysInMonth(date: Date): number;
+export declare function addDays(date: Date, days: number): Date;
+export declare function getDatesInWeek(date: Date, weekStartsOn?: WeekdayNumber): Date[];
+export declare function addMonths(date: Date, months: number): Date;

node_modules/buetify/lib/components/form/datepicker/utils.js

@@ -0,0 +1,108 @@
+import { elem } from 'fp-ts/lib/Array';
+import { fromEquals } from 'fp-ts/lib/Eq';
+import { fromCompare, geq, leq } from 'fp-ts/lib/Ord';
+export function isDate(value) {
+  // from date-fns
+  return value instanceof Date || typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]';
+}
+export function getStartOfDay(date) {
+  const clone = new Date(date.getTime());
+  clone.setHours(0, 0, 0, 0);
+  return clone;
+}
+export function getEndOfDay(date) {
+  const clone = new Date(date.getTime());
+  clone.setHours(23, 59, 59, 999);
+  return clone;
+}
+export function isSameDay(x, y) {
+  return getStartOfDay(x).getTime() === getStartOfDay(y).getTime();
+}
+export function isBeforeDay(date, isBefore) {
+  return date.getTime() < getStartOfDay(isBefore).getTime();
+}
+export function isAfterDay(date, isAfter) {
+  return date.getTime() > getEndOfDay(isAfter).getTime();
+}
+
+function compareSerialDate(x, y) {
+  return isBeforeDay(x, y) ? -1 : isAfterDay(x, y) ? 1 : 0;
+}
+
+export function isSameMonth(x, y) {
+  return x.getFullYear() === y.getFullYear() && x.getMonth() === y.getMonth();
+}
+export const eqSerialDate = fromEquals(isSameDay);
+export const ordSerialDate = fromCompare(compareSerialDate);
+export const isOnOrAfterDate = geq(ordSerialDate);
+export const isOnOrBeforeDate = leq(ordSerialDate);
+export const elemSerialDate = elem(ordSerialDate);
+export function getStartOfMonth(date) {
+  const clone = new Date(date.getTime());
+  clone.setDate(1);
+  clone.setHours(0, 0, 0, 0);
+  return clone;
+}
+export function getEndOfMonth(date) {
+  const clone = new Date(date.getTime());
+  const month = clone.getMonth();
+  clone.setFullYear(clone.getFullYear(), month + 1, 0);
+  clone.setHours(23, 59, 59, 999);
+  return clone;
+}
+export function getStartOfWeek(date, weekStartsOn = 0) {
+  const clone = new Date(date.getTime());
+  const day = clone.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  clone.setDate(clone.getDate() - diff);
+  clone.setHours(0, 0, 0, 0);
+  return clone;
+}
+export function getEndOfWeek(date, weekStartsOn = 0) {
+  const clone = new Date(date.getTime());
+  const day = clone.getDay();
+  const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
+  clone.setDate(clone.getDate() + diff);
+  clone.setHours(23, 59, 59, 999);
+  return clone;
+}
+export function isWithinWeek(date, secondDate, weekStartsOn = 0) {
+  return isOnOrAfterDate(date, getStartOfWeek(secondDate, weekStartsOn)) && isOnOrBeforeDate(date, getEndOfWeek(secondDate, weekStartsOn));
+}
+export function getDaysInMonth(date) {
+  const clone = new Date(date.getTime());
+  const year = clone.getFullYear();
+  const monthIndex = clone.getMonth();
+  const lastDayOfMonth = new Date(0);
+  lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);
+  lastDayOfMonth.setHours(0, 0, 0, 0);
+  return lastDayOfMonth.getDate();
+}
+export function addDays(date, days) {
+  const clone = new Date(date.getTime());
+  clone.setDate(clone.getDate() + days);
+  return clone;
+}
+export function getDatesInWeek(date, weekStartsOn = 0) {
+  const dates = [];
+  let day = getStartOfWeek(date, weekStartsOn);
+  const end = getEndOfWeek(date, weekStartsOn);
+
+  while (isOnOrBeforeDate(day, end)) {
+    dates.push(day);
+    day = addDays(day, 1);
+  }
+
+  return dates;
+}
+export function addMonths(date, months) {
+  const clone = new Date(date.getTime());
+  const newMonth = clone.getMonth() + months;
+  const dateWithDesiredMonth = new Date(0);
+  dateWithDesiredMonth.setFullYear(clone.getFullYear(), newMonth, 1);
+  dateWithDesiredMonth.setHours(0, 0, 0, 0);
+  const daysInMonth = getDaysInMonth(dateWithDesiredMonth);
+  clone.setMonth(newMonth, Math.min(daysInMonth, clone.getDate()));
+  return clone;
+}
+//# sourceMappingURL=utils.js.map