@dimailn/vuetify 2.7.2-alpha4 → 2.7.2-alpha41

package/src/components/VCalendar/util/props.ts

@@ -1,213 +1,211 @@
-
 import { validateTimestamp, parseDate, DAYS_IN_WEEK, validateTime } from './timestamp'
-import { PropType } from 'vue'
+import type { PropType } from 'vue'
 import { CalendarEvent, CalendarFormatter, CalendarTimestamp, CalendarEventOverlapMode, CalendarEventNameFunction, CalendarEventColorFunction, CalendarEventCategoryFunction, CalendarEventTimedFunction, CalendarCategoryTextFunction, CalendarCategory } from 'vuetify/types'
 import { CalendarEventOverlapModes } from '../modes'
-import { PropValidator } from 'vue/types/options'
 
 export default {
   base: {
     start: {
       type: [String, Number, Date],
       validate: validateTimestamp,
-      default: () => parseDate(new Date()).date,
+      default: () => parseDate(new Date()).date
     },
     end: {
       type: [String, Number, Date],
-      validate: validateTimestamp,
+      validate: validateTimestamp
     },
     weekdays: {
       type: [Array, String] as PropType<number[] | string>,
       default: () => [0, 1, 2, 3, 4, 5, 6],
-      validate: validateWeekdays,
+      validate: validateWeekdays
     },
     hideHeader: {
-      type: Boolean,
+      type: Boolean
     },
     shortWeekdays: {
       type: Boolean,
-      default: true,
+      default: true
     },
     weekdayFormat: {
       type: Function as PropType<CalendarFormatter>,
-      default: null,
+      default: null
     },
     dayFormat: {
       type: Function as PropType<CalendarFormatter>,
-      default: null,
-    },
+      default: null
+    }
   },
   intervals: {
     maxDays: {
       type: Number,
-      default: 7,
+      default: 7
     },
     shortIntervals: {
       type: Boolean,
-      default: true,
+      default: true
     },
     intervalHeight: {
       type: [Number, String],
       default: 48,
-      validate: validateNumber,
+      validate: validateNumber
     },
     intervalWidth: {
       type: [Number, String],
       default: 60,
-      validate: validateNumber,
+      validate: validateNumber
     },
     intervalMinutes: {
       type: [Number, String],
       default: 60,
-      validate: validateNumber,
+      validate: validateNumber
     },
     firstInterval: {
       type: [Number, String],
       default: 0,
-      validate: validateNumber,
+      validate: validateNumber
     },
     firstTime: {
       type: [Number, String, Object],
-      validate: validateTime,
+      validate: validateTime
     },
     intervalCount: {
       type: [Number, String],
       default: 24,
-      validate: validateNumber,
+      validate: validateNumber
     },
     intervalFormat: {
       type: Function as PropType<CalendarFormatter>,
-      default: null,
+      default: null
     },
     intervalStyle: {
       type: Function as PropType<(interval: CalendarTimestamp) => object>,
-      default: null,
+      default: null
     },
     showIntervalLabel: {
       type: Function as PropType<(interval: CalendarTimestamp) => boolean>,
-      default: null,
-    },
+      default: null
+    }
   },
   weeks: {
     localeFirstDayOfYear: {
       type: [String, Number],
-      default: 0,
+      default: 0
     },
     minWeeks: {
       validate: validateNumber,
-      default: 1,
+      default: 1
     },
     shortMonths: {
       type: Boolean,
-      default: true,
+      default: true
     },
     showMonthOnFirst: {
       type: Boolean,
-      default: true,
+      default: true
     },
     showWeek: Boolean,
     monthFormat: {
       type: Function as PropType<CalendarFormatter>,
-      default: null,
-    },
+      default: null
+    }
   },
   calendar: {
     type: {
       type: String,
-      default: 'month',
+      default: 'month'
     },
     value: {
       type: [String, Number, Date] as PropType<string | number | Date>,
-      validate: validateTimestamp,
-    },
+      validate: validateTimestamp
+    }
   },
   category: {
     categories: {
       type: [Array, String] as PropType<CalendarCategory[] | string>,
-      default: '',
+      default: ''
     },
     categoryText: {
-      type: [String, Function] as PropType<string | CalendarCategoryTextFunction>,
+      type: [String, Function] as PropType<string | CalendarCategoryTextFunction>
     },
     categoryHideDynamic: {
-      type: Boolean,
+      type: Boolean
     },
     categoryShowAll: {
-      type: Boolean,
+      type: Boolean
     },
     categoryForInvalid: {
       type: String,
-      default: '',
+      default: ''
     },
     categoryDays: {
       type: [Number, String],
       default: 1,
-      validate: (x: any) => isFinite(parseInt(x)) && parseInt(x) > 0,
-    },
+      validate: (x: any) => isFinite(parseInt(x)) && parseInt(x) > 0
+    }
   },
   events: {
     events: {
       type: Array,
-      default: () => [],
-    } as PropValidator<CalendarEvent[]>,
+      default: () => []
+    } as unknown as PropType<CalendarEvent[]>,
     eventStart: {
       type: String,
-      default: 'start',
+      default: 'start'
     },
     eventEnd: {
       type: String,
-      default: 'end',
+      default: 'end'
     },
     eventTimed: {
       type: [String, Function] as PropType<string | CalendarEventTimedFunction>,
-      default: 'timed',
+      default: 'timed'
     },
     eventCategory: {
       type: [String, Function] as PropType<string | CalendarEventCategoryFunction>,
-      default: 'category',
+      default: 'category'
     },
     eventHeight: {
       type: Number,
-      default: 20,
+      default: 20
     },
     eventColor: {
       type: [String, Function] as PropType<string | CalendarEventColorFunction>,
-      default: 'primary',
+      default: 'primary'
     },
     eventTextColor: {
       type: [String, Function] as PropType<string | CalendarEventColorFunction>,
-      default: 'white',
+      default: 'white'
     },
     eventName: {
       type: [String, Function] as PropType<string | CalendarEventNameFunction>,
-      default: 'name',
+      default: 'name'
     },
     eventOverlapThreshold: {
       type: [String, Number],
-      default: 60,
+      default: 60
     },
     eventOverlapMode: {
       type: [String, Function],
       default: 'stack',
-      validate: (mode: any) => mode in CalendarEventOverlapModes || typeof mode === 'function',
-    } as PropValidator<'stack' | 'column' | CalendarEventOverlapMode>,
+      validate: (mode: any) => mode in CalendarEventOverlapModes || typeof mode === 'function'
+    } as unknown as PropType<'stack' | 'column' | CalendarEventOverlapMode>,
     eventMore: {
       type: Boolean,
-      default: true,
+      default: true
     },
     eventMoreText: {
       type: String,
-      default: '$vuetify.calendar.moreEvents',
+      default: '$vuetify.calendar.moreEvents'
     },
     eventRipple: {
       type: [Boolean, Object],
-      default: null,
+      default: null
     },
     eventMarginBottom: {
       type: Number,
-      default: 1,
-    },
-  },
+      default: 1
+    }
+  }
 }
 
 export function validateNumber (input: any): boolean {

package/src/components/VCalendar/util/timestamp.ts

@@ -157,7 +157,7 @@ export function parseTimestamp (input: VTimestampInput, required = false, now?:
     hasTime: !!(parts[6] && parts[8]),
     past: false,
     present: false,
-    future: false,
+    future: false
   }
 
   updateWeekday(timestamp)
@@ -184,7 +184,7 @@ export function parseDate (date: Date): CalendarTimestamp {
     hasTime: true,
     past: false,
     present: true,
-    future: false,
+    future: false
   })
 }
 

package/src/components/VCard/VCard.ts

@@ -10,7 +10,7 @@ import Routable from '../../mixins/routable'
 
 // Helpers
 import mixins from '../../util/mixins'
-import { getSlot } from '../../util/helpers'
+import { getSlot, getTagValue } from '../../util/helpers'
 
 // Types
 import { VNode, h, withDirectives } from 'vue'
@@ -30,9 +30,9 @@ export default mixins(
     link: Boolean,
     loaderHeight: {
       type: [Number, String],
-      default: 4,
+      default: 4
     },
-    raised: Boolean,
+    raised: Boolean
   },
 
   computed: {
@@ -46,12 +46,12 @@ export default mixins(
         'v-card--loading': this.loading,
         'v-card--disabled': this.disabled,
         'v-card--raised': this.raised,
-        ...VSheet.computed.classes.call(this),
+        ...VSheet.computed.classes.call(this)
       }
     },
     styles (): object {
       const style: Dictionary<string> = {
-        ...VSheet.computed.styles.call(this),
+        ...VSheet.computed.styles.call(this)
       }
 
       if (this.img) {
@@ -59,7 +59,7 @@ export default mixins(
       }
 
       return style
-    },
+    }
   },
 
   methods: {
@@ -70,9 +70,9 @@ export default mixins(
 
       return h('div', {
         class: 'v-card__progress',
-        key: 'progress',
+        key: 'progress'
       }, [render])
-    },
+    }
   },
 
   render (): VNode {
@@ -84,9 +84,11 @@ export default mixins(
       data.tabindex = 0
     }
 
-    return withDirectives(h(tag, this.setBackgroundColor(this.color, data), [
+    const tagForH = typeof tag === 'string' ? getTagValue(tag) : tag
+
+    return withDirectives(h(tagForH as any, this.setBackgroundColor(this.color, data), [
       this.genProgress(),
-      getSlot(this),
+      getSlot(this)
     ]), directives)
-  },
+  }
 })

package/src/components/VCard/__tests__/VCard.spec.ts

@@ -1,21 +1,49 @@
 import {
   mount,
-  Wrapper,
-  MountOptions,
+  VueWrapper,
+  MountingOptions
 } from '@vue/test-utils'
 import VCard from '../VCard'
-import { ExtractVue } from '../../../util/mixins'
 
 describe('VCard.vue', () => {
-  type Instance = ExtractVue<typeof VCard>
-  let mountFunction: (options?: MountOptions<Instance>) => Wrapper<Instance>
+  type Instance = InstanceType<typeof VCard>
+  let mountFunction: (options?: MountingOptions<Instance>) => VueWrapper<Instance>
+
   beforeEach(() => {
-    mountFunction = (options?: MountOptions<Instance>) => {
-      return mount(VCard, {
-        // https://github.com/vuejs/vue-test-utils/issues/1130
-        sync: false,
+    mountFunction = (options?: MountingOptions<Instance>) => {
+      const defaultOptions = {
+        global: {
+          mocks: {
+            $vuetify: {
+              rtl: false,
+              lang: {
+                t: (val: string) => val
+              },
+              icons: {
+                component: 'mdi'
+              }
+            },
+            $activeClass: 'v-card--active'
+          }
+        },
+        slots: {}
+      }
+
+      // Объединяем опции правильно
+      const mergedOptions = {
+        ...defaultOptions,
         ...options,
-      })
+        slots: {
+          ...defaultOptions.slots,
+          ...options?.slots
+        },
+        global: {
+          ...defaultOptions.global,
+          ...options?.global
+        }
+      }
+
+      return mount(VCard, mergedOptions)
     }
   })
 
@@ -27,14 +55,9 @@ describe('VCard.vue', () => {
 
   it('should render loading card', () => {
     const wrapper = mountFunction({
-      propsData: {
-        loading: true,
-      },
-      mocks: {
-        $vuetify: {
-          rtl: false,
-        },
-      },
+      props: {
+        loading: true
+      }
     })
 
     expect(wrapper.html()).toMatchSnapshot()
@@ -42,11 +65,9 @@ describe('VCard.vue', () => {
 
   it('should render card, which is link', () => {
     const wrapper = mountFunction({
-      // https://github.com/vuejs/vue-test-utils/issues/1130
-      sync: false,
-      listeners: {
-        click: () => {},
-      },
+      attrs: {
+        onClick: () => {}
+      }
     })
 
     expect(wrapper.html()).toMatchSnapshot()
@@ -54,9 +75,9 @@ describe('VCard.vue', () => {
 
   it('should render card with img', () => {
     const wrapper = mountFunction({
-      propsData: {
-        img: 'image.jpg',
-      },
+      props: {
+        img: 'image.jpg'
+      }
     })
 
     expect(wrapper.html()).toMatchSnapshot()
@@ -64,9 +85,9 @@ describe('VCard.vue', () => {
 
   it('should render a flat card', () => {
     const wrapper = mountFunction({
-      propsData: {
-        flat: true,
-      },
+      props: {
+        flat: true
+      }
     })
 
     expect(wrapper.html()).toMatchSnapshot()
@@ -74,9 +95,9 @@ describe('VCard.vue', () => {
 
   it('should render a raised card', () => {
     const wrapper = mountFunction({
-      propsData: {
-        raised: true,
-      },
+      props: {
+        raised: true
+      }
     })
 
     expect(wrapper.html()).toMatchSnapshot()
@@ -85,20 +106,17 @@ describe('VCard.vue', () => {
   it('should render a card with custom height', async () => {
     const heightpx = '400px'
     const wrapper = mountFunction({
-      // https://github.com/vuejs/vue-test-utils/issues/1130
-      sync: false,
-      propsData: {
-        height: heightpx,
-      },
+      props: {
+        height: heightpx
+      }
     })
 
     expect(wrapper.element.style.height).toBe(heightpx)
     expect(wrapper.html()).toMatchSnapshot()
 
-    wrapper.setProps({
-      height: 401,
+    await wrapper.setProps({
+      height: 401
     })
-    await wrapper.vm.$nextTick()
     expect(wrapper.element.style.height).toBe('401px')
   })
 })

package/src/components/VCard/__tests__/__snapshots__/VCard.spec.ts.snap

@@ -37,10 +37,10 @@ exports[`VCard.vue should render component and match snapshot 1`] = `
 exports[`VCard.vue should render loading card 1`] = `
 <div class="v-card v-card--loading v-sheet theme--light">
   <div class="v-card__progress">
-    <div role="progressbar"
+    <div class="v-progress-linear v-progress-linear--absolute v-progress-linear--visible theme--light"
+         role="progressbar"
          aria-valuemin="0"
          aria-valuemax="100"
-         class="v-progress-linear v-progress-linear--absolute v-progress-linear--visible theme--light"
          style="height: 4px;"
     >
       <div class="v-progress-linear__background primary"

package/src/components/VCard/index.ts

@@ -11,7 +11,7 @@ export {
   VCardActions,
   VCardSubtitle,
   VCardText,
-  VCardTitle,
+  VCardTitle
 }
 
 export default {
@@ -20,6 +20,6 @@ export default {
     VCardActions,
     VCardSubtitle,
     VCardText,
-    VCardTitle,
-  },
+    VCardTitle
+  }
 }