@dimailn/vuetify 2.7.2-alpha40 → 2.7.2-alpha42

package/src/components/VCalendar/modes/common.ts

@@ -11,7 +11,7 @@ export function getVisuals (events: CalendarEventParsed[], minStart = 0): Calend
     columnCount: 0,
     column: 0,
     left: 0,
-    width: 100,
+    width: 100
   }))
 
   visuals.sort((a, b) => {
@@ -133,7 +133,7 @@ export function getOverlapGroupHandler (firstWeekday: number) {
       }
 
       return visuals
-    },
+    }
   }
 
   return handler

package/src/components/VCalendar/modes/index.ts

@@ -4,5 +4,5 @@ import { column } from './column'
 
 export const CalendarEventOverlapModes: Record<string, CalendarEventOverlapMode> = {
   stack,
-  column,
+  column
 }

package/src/components/VCalendar/modes/stack.ts

@@ -230,7 +230,7 @@ function getNode (visual: CalendarEventVisual, dayStart: number): Node {
     visual,
     start,
     end,
-    children: [],
+    children: []
   }
 }
 

package/src/components/VCalendar/util/__tests__/events.spec.ts

@@ -5,33 +5,33 @@ describe('events.ts', () => {
   it('should parse events', () => {
     expect(parseEvent({
       start: '2019-02-13',
-      end: '2019-02-14',
+      end: '2019-02-14'
     }, 0, 'start', 'end')).toMatchSnapshot()
     expect(parseEvent({
       a: '2019-02-13',
-      b: '2019-02-14',
+      b: '2019-02-14'
     }, 0, 'a', 'b')).toMatchSnapshot()
     expect(parseEvent({
       start: '2019-02-13',
-      end: '2019-02-14',
+      end: '2019-02-14'
     }, 1, 'start', 'end')).toMatchSnapshot()
     expect(parseEvent({
       a: '2019-02-13',
-      b: '2019-02-14',
+      b: '2019-02-14'
     }, 1, 'a', 'b')).toMatchSnapshot()
   })
 
   it('should parse timed events', () => {
     expect(parseEvent({
       start: '2019-02-13 8:30',
-      end: '2019-02-14',
+      end: '2019-02-14'
     }, 0, 'start', 'end')).toMatchSnapshot()
   })
 
   it('should check if event is on', () => {
     const parsed = parseEvent({
       start: '2019-02-13 8:30',
-      end: '2019-02-15',
+      end: '2019-02-15'
     }, 0, 'start', 'end')
 
     expect(isEventOn(parsed, getDayIdentifier(parseTimestamp('2019-02-12')))).toBeFalsy()
@@ -44,7 +44,7 @@ describe('events.ts', () => {
   it('should check if event is hidden if ending but not starting at midnight', () => {
     const parsed = parseEvent({
       start: '2021-05-17 10:30',
-      end: '2021-05-18 00:00',
+      end: '2021-05-18 00:00'
     }, 0, 'start', 'end')
 
     expect(isEventHiddenOn(parsed, parseTimestamp('2021-05-16'))).toBeFalsy()
@@ -56,7 +56,7 @@ describe('events.ts', () => {
   it('should check if event is hidden if starting and ending at midnight', () => {
     const parsed = parseEvent({
       start: '2021-05-18 00:00',
-      end: '2021-05-18 00:00',
+      end: '2021-05-18 00:00'
     }, 0, 'start', 'end')
 
     expect(isEventHiddenOn(parsed, parseTimestamp('2021-05-17'))).toBeFalsy()
@@ -67,7 +67,7 @@ describe('events.ts', () => {
   it('should check if event is overlapping', () => {
     const parsed = parseEvent({
       start: '2019-02-13 8:30',
-      end: '2019-02-15',
+      end: '2019-02-15'
     }, 0, 'start', 'end')
 
     expect(isEventOverlapping(parsed, getDayIdentifier(parseTimestamp('2019-02-10')), getDayIdentifier(parseTimestamp('2019-02-12')))).toBeFalsy()
@@ -77,7 +77,7 @@ describe('events.ts', () => {
 
   it(`should throw an error if start isn't defined`, () => {
     const fn = () => parseEvent({
-      end: '2019-02-15',
+      end: '2019-02-15'
     }, 0, 'start', 'end')
 
     expect(fn).toThrow('undefined is not a valid timestamp. It must be a Date, number of milliseconds since Epoch, or a string in the format of YYYY-MM-DD or YYYY-MM-DD hh:mm. Zero-padding is optional and seconds are ignored.')

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

@@ -20,7 +20,7 @@ import {
   findWeekday,
   nextDay,
   prevDay,
-  relativeDays,
+  relativeDays
 } from '../timestamp'
 
 describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-statements
@@ -89,7 +89,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasTime: false,
       past: false,
       present: false,
-      future: false,
+      future: false
     })
     expect(parseTimestamp('2019-01-03')).toEqual({
       date: '2019-01-03',
@@ -104,7 +104,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasTime: false,
       past: false,
       present: false,
-      future: false,
+      future: false
     })
     expect(parseTimestamp('2019-01-03 12')).toEqual({
       date: '2019-01-03',
@@ -119,7 +119,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasTime: false,
       past: false,
       present: false,
-      future: false,
+      future: false
     })
     expect(parseTimestamp('2019-01-03 12:30')).toEqual({
       date: '2019-01-03',
@@ -134,7 +134,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasTime: true,
       past: false,
       present: false,
-      future: false,
+      future: false
     })
     expect(parseTimestamp('2019-01-03 07:00')).toEqual({
       date: '2019-01-03',
@@ -149,7 +149,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasTime: true,
       past: false,
       present: false,
-      future: false,
+      future: false
     })
     expect(parseTimestamp('2019-01-03 07:00:45')).toEqual({
       date: '2019-01-03',
@@ -164,7 +164,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasTime: true,
       past: false,
       present: false,
-      future: false,
+      future: false
     })
     expect(parseTimestamp('bad')).toBeNull()
   })
@@ -173,12 +173,12 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
     expect(parseTimestamp('2019-01-03', true, parseTimestamp('2019-02-08'))).toMatchObject({
       past: true,
       present: false,
-      future: false,
+      future: false
     })
     expect(parseTimestamp('2019-01-03 07:00', true, parseTimestamp('2019-01-03 07:00'))).toMatchObject({
       past: false,
       present: true,
-      future: false,
+      future: false
     })
   })
 
@@ -196,7 +196,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasTime: true,
       past: false,
       present: true,
-      future: false,
+      future: false
     })
   })
 
@@ -204,36 +204,36 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
     expect(getDayIdentifier({
       year: 2019,
       month: 9,
-      day: 11,
+      day: 11
     })).toBe(20190911)
 
     expect(getDayIdentifier({
       year: 1989,
       month: 1,
-      day: 1,
+      day: 1
     })).toBe(19890101)
 
     expect(getDayIdentifier({
       year: 2020,
       month: 12,
-      day: 31,
+      day: 31
     })).toBe(20201231)
   })
 
   it('should generate time identifiers', () => {
     expect(getTimeIdentifier({
       hour: 0,
-      minute: 0,
+      minute: 0
     })).toBe(0)
 
     expect(getTimeIdentifier({
       hour: 0,
-      minute: 23,
+      minute: 23
     })).toBe(23)
 
     expect(getTimeIdentifier({
       hour: 11,
-      minute: 6,
+      minute: 6
     })).toBe(1106)
   })
 
@@ -250,7 +250,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
       hasDay: true,
       past: false,
       present: false,
-      future: true,
+      future: true
     }
     const b = copyTimestamp(a)
     expect(a).not.toBe(b)
@@ -463,7 +463,7 @@ describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-state
         { date: '2019-05-02', day: 2, future: false, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 5, past: true, present: false, time: '', weekday: 4, year: 2019 },
         { date: '2019-05-03', day: 3, future: false, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 5, past: false, present: true, time: '', weekday: 5, year: 2019 },
         { date: '2019-05-04', day: 4, future: true, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 5, past: false, present: false, time: '', weekday: 6, year: 2019 },
-        { date: '2019-05-05', day: 5, future: true, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 5, past: false, present: false, time: '', weekday: 0, year: 2019 },
+        { date: '2019-05-05', day: 5, future: true, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 5, past: false, present: false, time: '', weekday: 0, year: 2019 }
       ])
     })
 

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

@@ -3,7 +3,7 @@ import {
   getDayIdentifier,
   getTimestampIdentifier,
   isTimedless,
-  updateHasTime,
+  updateHasTime
 } from './timestamp'
 import { CalendarTimestamp, CalendarEvent, CalendarEventParsed } from 'vuetify/types'
 
@@ -13,7 +13,7 @@ export function parseEvent (
   startProperty: string,
   endProperty: string,
   timed = false,
-  category: string | false = false,
+  category: string | false = false
 ): CalendarEventParsed {
   const startInput = input[startProperty]
   const endInput = input[endProperty]

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)
-  },
+  }
 })