@kokoccc/vuetify 1.0.1

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

@@ -0,0 +1,512 @@
+import {
+  parseTime,
+  validateTimestamp,
+  parseTimestamp,
+  parseDate,
+  getDayIdentifier,
+  getTimeIdentifier,
+  updateRelative,
+  copyTimestamp,
+  getWeekdaySkips,
+  createDayList,
+  getStartOfWeek,
+  getEndOfWeek,
+  createIntervalList,
+  createNativeLocaleFormatter,
+  getStartOfMonth,
+  getEndOfMonth,
+  nextMinutes,
+  updateMinutes,
+  findWeekday,
+  nextDay,
+  prevDay,
+  relativeDays,
+} from '../timestamp'
+
+describe('VCalendar/util/timestamp.ts', () => { // eslint-disable-line max-statements
+  it('should parse time number', () => {
+    expect(parseTime(0)).toBe(0)
+    expect(parseTime(120)).toBe(120)
+  })
+
+  it('should parse time string', () => {
+    expect(parseTime('00:00')).toBe(0)
+    expect(parseTime('00:30')).toBe(30)
+    expect(parseTime('08:00')).toBe(8 * 60)
+    expect(parseTime('08:30')).toBe(8 * 60 + 30)
+    expect(parseTime('15:13')).toBe(15 * 60 + 13)
+    expect(parseTime('23:59')).toBe(23 * 60 + 59)
+    expect(parseTime('7')).toBe(7 * 60)
+    expect(parseTime('04:23:11')).toBe(4 * 60 + 23)
+  })
+
+  it('should parse time object', () => {
+    expect(parseTime({ hour: 0, minute: 0 })).toBe(0)
+    expect(parseTime({ hour: 0, minute: 30 })).toBe(30)
+    expect(parseTime({ hour: 8, minute: 0 })).toBe(8 * 60)
+    expect(parseTime({ hour: 8, minute: 30 })).toBe(8 * 60 + 30)
+    expect(parseTime({ hour: 15, minute: 13 })).toBe(15 * 60 + 13)
+    expect(parseTime({ hour: 23, minute: 59 })).toBe(23 * 60 + 59)
+  })
+
+  it('should not parse time', () => {
+    expect(parseTime('nopes')).toBe(false)
+    expect(parseTime({ hour: 23 })).toBe(false)
+    expect(parseTime([23])).toBe(false)
+    expect(parseTime(false)).toBe(false)
+    expect(parseTime(true)).toBe(false)
+  })
+
+  it('should validate timestamp', () => {
+    expect(validateTimestamp('2019-01')).toBe(true)
+    expect(validateTimestamp('2019-01-03')).toBe(true)
+    expect(validateTimestamp('2019-01-03 12')).toBe(true)
+    expect(validateTimestamp('2019-01-03 12:30')).toBe(true)
+    expect(validateTimestamp('2019-01-03 12:30:45')).toBe(true)
+  })
+
+  it('should not validate timestamp', () => {
+    expect(validateTimestamp('2019-01-03 x')).toBe(false)
+    expect(validateTimestamp('20-01-03 12')).toBe(false)
+    expect(validateTimestamp('not a timestamp')).toBe(false)
+    expect(validateTimestamp([])).toBe(false)
+    expect(validateTimestamp({})).toBe(false)
+    expect(validateTimestamp(new Date())).toBe(true)
+    expect(validateTimestamp(2345)).toBe(true)
+  })
+
+  it('should parse timestamp', () => {
+    expect(parseTimestamp('2019-04')).toEqual({
+      date: '2019-04',
+      time: '',
+      year: 2019,
+      month: 4,
+      day: 1,
+      hour: 0,
+      minute: 0,
+      weekday: 0,
+      hasDay: false,
+      hasTime: false,
+      past: false,
+      present: false,
+      future: false,
+    })
+    expect(parseTimestamp('2019-01-03')).toEqual({
+      date: '2019-01-03',
+      time: '',
+      year: 2019,
+      month: 1,
+      day: 3,
+      hour: 0,
+      minute: 0,
+      weekday: 4,
+      hasDay: true,
+      hasTime: false,
+      past: false,
+      present: false,
+      future: false,
+    })
+    expect(parseTimestamp('2019-01-03 12')).toEqual({
+      date: '2019-01-03',
+      time: '',
+      year: 2019,
+      month: 1,
+      day: 3,
+      hour: 12,
+      minute: 0,
+      weekday: 4,
+      hasDay: true,
+      hasTime: false,
+      past: false,
+      present: false,
+      future: false,
+    })
+    expect(parseTimestamp('2019-01-03 12:30')).toEqual({
+      date: '2019-01-03',
+      time: '12:30',
+      year: 2019,
+      month: 1,
+      day: 3,
+      hour: 12,
+      minute: 30,
+      weekday: 4,
+      hasDay: true,
+      hasTime: true,
+      past: false,
+      present: false,
+      future: false,
+    })
+    expect(parseTimestamp('2019-01-03 07:00')).toEqual({
+      date: '2019-01-03',
+      time: '07:00',
+      year: 2019,
+      month: 1,
+      day: 3,
+      hour: 7,
+      minute: 0,
+      weekday: 4,
+      hasDay: true,
+      hasTime: true,
+      past: false,
+      present: false,
+      future: false,
+    })
+    expect(parseTimestamp('2019-01-03 07:00:45')).toEqual({
+      date: '2019-01-03',
+      time: '07:00',
+      year: 2019,
+      month: 1,
+      day: 3,
+      hour: 7,
+      minute: 0,
+      weekday: 4,
+      hasDay: true,
+      hasTime: true,
+      past: false,
+      present: false,
+      future: false,
+    })
+    expect(parseTimestamp('bad')).toBeNull()
+  })
+
+  it('should parse timestamp and update relative flags', () => {
+    expect(parseTimestamp('2019-01-03', true, parseTimestamp('2019-02-08'))).toMatchObject({
+      past: true,
+      present: false,
+      future: false,
+    })
+    expect(parseTimestamp('2019-01-03 07:00', true, parseTimestamp('2019-01-03 07:00'))).toMatchObject({
+      past: false,
+      present: true,
+      future: false,
+    })
+  })
+
+  it('should parse date', () => {
+    expect(parseDate(new Date(2019, 2, 18, 20, 30, 40))).toEqual({
+      date: '2019-03-18',
+      time: '20:30',
+      year: 2019,
+      month: 3,
+      day: 18,
+      hour: 20,
+      minute: 30,
+      weekday: 1,
+      hasDay: true,
+      hasTime: true,
+      past: false,
+      present: true,
+      future: false,
+    })
+  })
+
+  it('should generate day identifiers', () => {
+    expect(getDayIdentifier({
+      year: 2019,
+      month: 9,
+      day: 11,
+    })).toBe(20190911)
+
+    expect(getDayIdentifier({
+      year: 1989,
+      month: 1,
+      day: 1,
+    })).toBe(19890101)
+
+    expect(getDayIdentifier({
+      year: 2020,
+      month: 12,
+      day: 31,
+    })).toBe(20201231)
+  })
+
+  it('should generate time identifiers', () => {
+    expect(getTimeIdentifier({
+      hour: 0,
+      minute: 0,
+    })).toBe(0)
+
+    expect(getTimeIdentifier({
+      hour: 0,
+      minute: 23,
+    })).toBe(23)
+
+    expect(getTimeIdentifier({
+      hour: 11,
+      minute: 6,
+    })).toBe(1106)
+  })
+
+  it('should copy timestamp', () => {
+    const a = {
+      date: '1989-01-03',
+      time: '18:23',
+      year: 1989,
+      month: 1,
+      day: 3,
+      hour: 18,
+      minute: 23,
+      hasTime: true,
+      hasDay: true,
+      past: false,
+      present: false,
+      future: true,
+    }
+    const b = copyTimestamp(a)
+    expect(a).not.toBe(b)
+    expect(a).toEqual(b)
+  })
+
+  it('should update relative flags without time', () => {
+    const now = parseTimestamp('2019-02-04 09:30')
+    const a = parseTimestamp('2019-02-04')
+    const b = parseTimestamp('2019-02-06')
+    const c = parseTimestamp('2019-02-01')
+
+    const aa = copyTimestamp(a)
+    const bb = copyTimestamp(b)
+    const cc = copyTimestamp(c)
+
+    updateRelative(aa, now)
+    expect(aa.past).toBe(false)
+    expect(aa.present).toBe(true)
+    expect(aa.future).toBe(false)
+
+    updateRelative(bb, now)
+    expect(bb.past).toBe(false)
+    expect(bb.present).toBe(false)
+    expect(bb.future).toBe(true)
+
+    updateRelative(cc, now)
+    expect(cc.past).toBe(true)
+    expect(cc.present).toBe(false)
+    expect(cc.future).toBe(false)
+  })
+
+  it('should update relative flags with time', () => {
+    const now = parseTimestamp('2019-02-04 09:30')
+    const a = parseTimestamp('2019-02-04 09:30')
+    const b = parseTimestamp('2019-02-04 12:30')
+    const c = parseTimestamp('2019-02-04 05:10')
+
+    const aa = copyTimestamp(a)
+    const bb = copyTimestamp(b)
+    const cc = copyTimestamp(c)
+
+    updateRelative(aa, now, true)
+    expect(aa.past).toBe(false)
+    expect(aa.present).toBe(true)
+    expect(aa.future).toBe(false)
+
+    updateRelative(bb, now, true)
+    expect(bb.past).toBe(false)
+    expect(bb.present).toBe(false)
+    expect(bb.future).toBe(true)
+
+    updateRelative(cc, now, true)
+    expect(cc.past).toBe(true)
+    expect(cc.present).toBe(false)
+    expect(cc.future).toBe(false)
+  })
+
+  it('should calculate weekday', () => { // eslint-disable-line max-statements
+    expect(parseTimestamp('2019-01-01').weekday).toBe(2)
+    expect(parseTimestamp('2019-01-02').weekday).toBe(3)
+    expect(parseTimestamp('2019-01-03').weekday).toBe(4)
+    expect(parseTimestamp('2019-01-04').weekday).toBe(5)
+    expect(parseTimestamp('2019-01-05').weekday).toBe(6)
+    expect(parseTimestamp('2019-01-06').weekday).toBe(0)
+    expect(parseTimestamp('2019-01-07').weekday).toBe(1)
+    expect(parseTimestamp('2019-01-08').weekday).toBe(2)
+    expect(parseTimestamp('2019-01-09').weekday).toBe(3)
+    expect(parseTimestamp('2019-01-10').weekday).toBe(4)
+    expect(parseTimestamp('2019-01-11').weekday).toBe(5)
+    expect(parseTimestamp('2019-01-12').weekday).toBe(6)
+    expect(parseTimestamp('2019-01-13').weekday).toBe(0)
+    expect(parseTimestamp('2019-01-14').weekday).toBe(1)
+    expect(parseTimestamp('2019-01-15').weekday).toBe(2)
+    expect(parseTimestamp('2019-01-16').weekday).toBe(3)
+    expect(parseTimestamp('2019-01-17').weekday).toBe(4)
+    expect(parseTimestamp('2019-01-18').weekday).toBe(5)
+    expect(parseTimestamp('2019-01-19').weekday).toBe(6)
+    expect(parseTimestamp('2019-01-20').weekday).toBe(0)
+    expect(parseTimestamp('2019-01-21').weekday).toBe(1)
+    expect(parseTimestamp('2019-01-22').weekday).toBe(2)
+    expect(parseTimestamp('2019-01-23').weekday).toBe(3)
+    expect(parseTimestamp('2019-01-24').weekday).toBe(4)
+    expect(parseTimestamp('2019-01-25').weekday).toBe(5)
+    expect(parseTimestamp('2019-01-26').weekday).toBe(6)
+    expect(parseTimestamp('2019-01-27').weekday).toBe(0)
+    expect(parseTimestamp('2019-01-28').weekday).toBe(1)
+    expect(parseTimestamp('2019-01-29').weekday).toBe(2)
+    expect(parseTimestamp('2019-01-30').weekday).toBe(3)
+    expect(parseTimestamp('2019-01-31').weekday).toBe(4)
+    expect(parseTimestamp('2019-02-01').weekday).toBe(5)
+    expect(parseTimestamp('2019-02-02').weekday).toBe(6)
+    expect(parseTimestamp('2019-02-03').weekday).toBe(0)
+    expect(parseTimestamp('2019-02-04').weekday).toBe(1)
+    expect(parseTimestamp('2019-02-05').weekday).toBe(2)
+    expect(parseTimestamp('2019-02-06').weekday).toBe(3)
+    expect(parseTimestamp('2019-02-07').weekday).toBe(4)
+    expect(parseTimestamp('2019-02-08').weekday).toBe(5)
+    expect(parseTimestamp('2019-02-09').weekday).toBe(6)
+    expect(parseTimestamp('2019-02-10').weekday).toBe(0)
+    expect(parseTimestamp('2019-02-11').weekday).toBe(1)
+    expect(parseTimestamp('2019-02-12').weekday).toBe(2)
+    expect(parseTimestamp('2019-02-13').weekday).toBe(3)
+    expect(parseTimestamp('2019-02-14').weekday).toBe(4)
+    expect(parseTimestamp('2019-02-15').weekday).toBe(5)
+    expect(parseTimestamp('2019-02-16').weekday).toBe(6)
+    expect(parseTimestamp('2019-02-17').weekday).toBe(0)
+    expect(parseTimestamp('2019-02-18').weekday).toBe(1)
+    expect(parseTimestamp('2019-02-19').weekday).toBe(2)
+    expect(parseTimestamp('2019-02-20').weekday).toBe(3)
+    expect(parseTimestamp('2019-02-21').weekday).toBe(4)
+    expect(parseTimestamp('2019-02-22').weekday).toBe(5)
+    expect(parseTimestamp('2019-02-23').weekday).toBe(6)
+    expect(parseTimestamp('2019-02-24').weekday).toBe(0)
+    expect(parseTimestamp('2019-02-25').weekday).toBe(1)
+    expect(parseTimestamp('2019-02-26').weekday).toBe(2)
+    expect(parseTimestamp('2019-02-27').weekday).toBe(3)
+    expect(parseTimestamp('2019-02-28').weekday).toBe(4)
+    expect(parseTimestamp('2019-03-01').weekday).toBe(5)
+  })
+
+  it('should create interval list', () => {
+    expect(createIntervalList(parseTimestamp('2019-02-08'), 30, 15, 10)).toMatchSnapshot()
+    expect(createIntervalList(parseTimestamp('2019-02-08'), 15, 15, 10)).toMatchSnapshot()
+    expect(createIntervalList(parseTimestamp('2019-02-08'), 10, 5, 2)).toMatchSnapshot()
+  })
+
+  // TODO Create a test that doesn't fail when
+  // the day changes or ignore the code it
+  // covers
+  it.skip('should create native locale formatter', () => {
+    expect(createNativeLocaleFormatter('en-US', () => {})(parseTimestamp('2019-02-08'))).toBe('2/8/2019')
+    expect(createNativeLocaleFormatter('en-UK', () => {})(parseTimestamp('2019-02-08'))).toBe('2/8/2019')
+    expect(createNativeLocaleFormatter('ru-RU', () => {})(parseTimestamp('2019-02-08'))).toBe('2019-2-8')
+  })
+
+  it(`should return emptyFormatter if Intl isn't defined`, () => {
+    const intl = global.Intl
+    global.Intl = undefined
+    expect(createNativeLocaleFormatter('', () => {})(parseTimestamp('2019-02-08'))).toBe('')
+    global.Intl = intl
+  })
+
+  it('should return emptyFormatter if Intl throws error', () => {
+    global.Intl.DateTimeFormat = () => { throw new Error() }
+    expect(createNativeLocaleFormatter('', () => {})(parseTimestamp('2019-02-08'))).toBe('')
+  })
+
+  it('should get month start', () => {
+    expect(getStartOfMonth(parseTimestamp('2019-02-08')).date).toEqual('2019-02-01')
+    expect(getStartOfMonth(parseTimestamp('2019-03-08')).date).toEqual('2019-03-01')
+    expect(getStartOfMonth(parseTimestamp('2019-06-08')).date).toEqual('2019-06-01')
+  })
+
+  it('should get month end', () => {
+    expect(getEndOfMonth(parseTimestamp('2019-02-08')).date).toEqual('2019-02-28')
+    expect(getEndOfMonth(parseTimestamp('2019-03-08')).date).toEqual('2019-03-31')
+    expect(getEndOfMonth(parseTimestamp('2019-06-08')).date).toEqual('2019-06-30')
+  })
+
+  it('should get next minutes', () => {
+    expect(nextMinutes({ hour: 8, minute: 30 }, 40)).toEqual({ hour: 9, minute: 10 })
+    expect(nextMinutes({ hour: 8, minute: 10 }, 90)).toEqual({ hour: 9, minute: 40 })
+    expect(nextMinutes({ hour: 8, minute: 0 }, 40)).toEqual({ hour: 8, minute: 40 })
+    expect(nextMinutes({ day: 1, weekday: 1, hour: 23, minute: 50 }, 40)).toEqual({ hour: 0, minute: 30, day: 2, weekday: 2 })
+  })
+
+  it('should update minutes', () => {
+    expect(updateMinutes({}, 40)).toMatchObject({ hour: 0, minute: 40 })
+    expect(updateMinutes({}, 90)).toMatchObject({ hour: 1, minute: 30 })
+    expect(updateMinutes({}, 40, {})).toMatchObject({ hour: 0, minute: 40 })
+    expect(updateMinutes({}, 90, {})).toMatchObject({ hour: 1, minute: 30 })
+  })
+
+  it('should get weekday skips', () => {
+    expect(getWeekdaySkips([0, 1, 2, 3, 4, 5, 6])).toEqual([1, 1, 1, 1, 1, 1, 1])
+    expect(getWeekdaySkips([1, 5, 0, 3, 4, 2, 6])).toEqual([1, 1, 1, 1, 1, 1, 1])
+    expect(getWeekdaySkips([1, 5, 1, 3, 4, 2, 6])).toEqual([0, 1, 1, 1, 1, 1, 2])
+  })
+
+  describe('createDayList', () => {
+    it('should create day list', () => {
+      const skips = getWeekdaySkips([0, 1, 2, 3, 4, 5, 6])
+      const skips1 = getWeekdaySkips([1, 1, 1, 1, 1, 1, 0])
+      expect(() => createDayList(parseTimestamp('2019-02-02'), parseTimestamp('2019-02-01'), parseTimestamp('2019-02-02'), skips)).toThrow()
+      expect(createDayList(parseTimestamp('2019-02-01'), parseTimestamp('2019-02-10'), parseTimestamp('2019-02-02'), skips)).toHaveLength(10)
+      expect(createDayList(parseTimestamp('2019-02-01'), parseTimestamp('2019-02-10'), parseTimestamp('2019-02-02'), skips1)).toHaveLength(3)
+    })
+
+    it('should allow first day of week', () => {
+      const weekdays = [1, 2, 3, 4, 5, 6, 0]
+      const skips = getWeekdaySkips(weekdays)
+      const today = parseTimestamp('2019-05-03')
+      const date = parseTimestamp('2019-04-30')
+      const start = getStartOfWeek(date, weekdays, today)
+      const end = getEndOfWeek(date, weekdays, today)
+
+      const days = createDayList(
+        start,
+        end,
+        today,
+        skips,
+        Number.MAX_SAFE_INTEGER
+      )
+
+      expect(days).toEqual([
+        { date: '2019-04-29', day: 29, future: false, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 4, past: true, present: false, time: '', weekday: 1, year: 2019 },
+        { date: '2019-04-30', day: 30, future: false, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 4, past: true, present: false, time: '', weekday: 2, year: 2019 },
+        { date: '2019-05-01', day: 1, future: false, hasDay: true, hasTime: false, hour: 0, minute: 0, month: 5, past: true, present: false, time: '', weekday: 3, year: 2019 },
+        { 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 },
+      ])
+    })
+
+    it('should handle skips equal to zero', () => {
+      const weekdays = [1, 2, 3, 4, 5, 6, 0]
+      const skips = [0, 1, 0, 1, 0, 1, 0]
+      const today = parseTimestamp('2019-04-30')
+      const date = parseTimestamp('2019-04-27')
+      const start = getStartOfWeek(date, weekdays, today)
+      const end = getEndOfWeek(date, weekdays, today)
+
+      const days = createDayList(
+        start,
+        end,
+        today,
+        skips,
+        Number.MAX_SAFE_INTEGER
+      )
+
+      expect(days).toMatchSnapshot()
+    })
+
+    it('should throw error if no days are available given specified weekday skips (#7155)', () => {
+      const skips = getWeekdaySkips([1, 2, 3, 4, 5])
+      // 2019-01-12 is a saturday (weekday 6)
+      expect(() => createDayList(parseTimestamp('2019-01-12'), parseTimestamp('2019-01-12'), parseTimestamp('2019-02-01'), skips))
+        .toThrow('No dates found using specified start date, end date, and weekdays.')
+    })
+  })
+
+  it('should find weekday', () => {
+    expect(findWeekday(parseTimestamp('2019-02-03'), 5, nextDay, 100)).toMatchObject({ weekday: 5 })
+    expect(findWeekday(parseTimestamp('2019-01-03'), 1, nextDay, 100)).toMatchObject({ weekday: 1 })
+    expect(findWeekday(parseTimestamp('2019-01-03'), 5, prevDay, 100)).toMatchObject({ weekday: 5 })
+    expect(findWeekday(parseTimestamp('2019-01-03'), 1, prevDay, 100)).toMatchObject({ weekday: 1 })
+  })
+
+  it('should calculate relative days', () => {
+    expect(relativeDays(parseTimestamp('2019-02-03'), nextDay, 1)).toMatchObject({ day: 4 })
+    expect(relativeDays(parseTimestamp('2019-01-03'), nextDay, 10)).toMatchObject({ day: 13 })
+    expect(relativeDays(parseTimestamp('2019-01-03'), nextDay, 1000)).toMatchObject({ day: 29, month: 9, year: 2021 })
+    expect(relativeDays(parseTimestamp('2019-01-03'), prevDay, 1)).toMatchObject({ day: 2 })
+    expect(relativeDays(parseTimestamp('2019-01-03'), prevDay, 10)).toMatchObject({ day: 24 })
+    expect(relativeDays(parseTimestamp('2019-01-03'), prevDay, 1000)).toMatchObject({ day: 8, month: 4, year: 2016 })
+  })
+})

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

@@ -0,0 +1,52 @@
+import {
+  parseTimestamp,
+  getDayIdentifier,
+  getTimestampIdentifier,
+  isTimedless,
+  updateHasTime,
+} from './timestamp'
+import { CalendarTimestamp, CalendarEvent, CalendarEventParsed } from 'vuetify/types'
+
+export function parseEvent (
+  input: CalendarEvent,
+  index: number,
+  startProperty: string,
+  endProperty: string,
+  timed = false,
+  category: string | false = false,
+): CalendarEventParsed {
+  const startInput = input[startProperty]
+  const endInput = input[endProperty]
+  const startParsed: CalendarTimestamp = parseTimestamp(startInput, true)
+  const endParsed: CalendarTimestamp = (endInput ? parseTimestamp(endInput, true) : startParsed)
+  const start: CalendarTimestamp = isTimedless(startInput)
+    ? updateHasTime(startParsed, timed)
+    : startParsed
+  const end: CalendarTimestamp = isTimedless(endInput)
+    ? updateHasTime(endParsed, timed)
+    : endParsed
+  const startIdentifier: number = getDayIdentifier(start)
+  const startTimestampIdentifier: number = getTimestampIdentifier(start)
+  const endIdentifier: number = getDayIdentifier(end)
+  const endOffset: number = start.hasTime ? 0 : 2359
+  const endTimestampIdentifier: number = getTimestampIdentifier(end) + endOffset
+  const allDay = !start.hasTime
+
+  return { input, start, startIdentifier, startTimestampIdentifier, end, endIdentifier, endTimestampIdentifier, allDay, index, category }
+}
+
+export function isEventOn (event: CalendarEventParsed, dayIdentifier: number): boolean {
+  return dayIdentifier >= event.startIdentifier && dayIdentifier <= event.endIdentifier
+}
+
+export function isEventHiddenOn (event: CalendarEventParsed, day: CalendarTimestamp): boolean {
+  return event.end.time === '00:00' && event.end.date === day.date && event.start.date !== day.date
+}
+
+export function isEventStart (event: CalendarEventParsed, day: CalendarTimestamp, dayIdentifier: number, firstWeekday: number): boolean {
+  return dayIdentifier === event.startIdentifier || (firstWeekday === day.weekday && isEventOn(event, dayIdentifier))
+}
+
+export function isEventOverlapping (event: CalendarEventParsed, startIdentifier: number, endIdentifier: number): boolean {
+  return startIdentifier <= event.endIdentifier && endIdentifier >= event.startIdentifier
+}

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

@@ -0,0 +1,30 @@
+import { CalendarCategory, CalendarCategoryTextFunction } from 'types'
+
+export function parsedCategoryText (
+  category: CalendarCategory,
+  categoryText: string | CalendarCategoryTextFunction
+): string {
+  return typeof categoryText === 'string' && typeof category === 'object' && category
+    ? category[categoryText]
+    : typeof categoryText === 'function'
+      ? categoryText(category)
+      : category
+}
+
+export function getParsedCategories (
+  categories: CalendarCategory | CalendarCategory[],
+  categoryText: string | CalendarCategoryTextFunction
+): CalendarCategory[] {
+  if (typeof categories === 'string') return categories.split(/\s*,\s/)
+  if (Array.isArray(categories)) {
+    return categories.map((category: CalendarCategory) => {
+      if (typeof category === 'string') return category
+
+      const categoryName = typeof category.categoryName === 'string'
+        ? category.categoryName
+        : parsedCategoryText(category, categoryText)
+      return { ...category, categoryName }
+    })
+  }
+  return []
+}