@bagelink/vue 1.2.15 → 1.2.20

package/src/components/calendar/helpers/Errors.ts

@@ -1,69 +0,0 @@
-import type { ConfigInterface } from '../typings/config.interface'
-import type { EventInterface } from '../typings/interfaces/event.interface'
-import { DATE_TIME_STRING_FULL_DAY_PATTERN, DATE_TIME_STRING_PATTERN } from '../constants'
-
-type RecursivePartial<T> = {
-	[P in keyof T]?: RecursivePartial<T[P]>;
-}
-
-export default class Errors {
-	public static PREFIX = '[Qalendar warning]'
-	// public static SUFFIX = 'This is a development warning, which will never be displayed in production environments'
-	public static SUFFIX = ''
-
-	public static readonly MISSING_ID_WARNING = `${this.PREFIX} required event property 'id' is missing \n${this.SUFFIX}`
-
-	public static readonly MISSING_TITLE_WARNING = `${this.PREFIX} required event property 'title' is missing \n${this.SUFFIX}`
-
-	public static readonly MISSING_TIME_WARNING = `${this.PREFIX} required event property 'time' is missing \n${this.SUFFIX}`
-
-	public static readonly MISSING_TIME_START_WARNING = `${this.PREFIX} required event property 'time.start' is missing \n${this.SUFFIX}`
-
-	public static readonly MISSING_TIME_END_WARNING = `${this.PREFIX} required event property 'time.end' is missing \n${this.SUFFIX}`
-
-	static checkEventProperties(event: RecursivePartial<EventInterface>) {
-		// Warn if required property is missing
-		if (!event.id) console.warn(this.MISSING_ID_WARNING)
-		if (!event.title) console.warn(this.MISSING_TITLE_WARNING)
-		if (!event.time) console.warn(this.MISSING_TIME_WARNING)
-		if (!event.time?.start) console.warn(this.MISSING_TIME_START_WARNING)
-		if (!event.time?.end) console.warn(this.MISSING_TIME_END_WARNING)
-
-		if (
-			event.time?.start
-			&& event.time.end
-			&& !DATE_TIME_STRING_PATTERN.test(event.time.start)
-			&& !DATE_TIME_STRING_FULL_DAY_PATTERN.test(event.time.start)
-		) {
-			console.warn(
-				`${this.PREFIX} event property 'time.start' expects a string formatted like 'YYYY-MM-DD hh:mm', or 'YYYY-MM-DD', received ${event.time.start} \n${this.SUFFIX}`
-			)
-		}
-		if (
-			event.time?.start
-			&& event.time.end
-			&& !DATE_TIME_STRING_PATTERN.test(event.time.end)
-			&& !DATE_TIME_STRING_FULL_DAY_PATTERN.test(event.time.end)
-		) {
-			console.warn(
-				`${this.PREFIX} event property 'time.end' expects a string formatted like 'YYYY-MM-DD hh:mm',  or 'YYYY-MM-DD', received ${event.time.end} \n${this.SUFFIX}`
-			)
-		}
-	}
-
-	static checkConfig(config: ConfigInterface) {
-		if (config.locale && !/^[a-z]{2}-[A-Z]{2}$/.test(config.locale)) {
-			console.warn(
-				`${this.PREFIX} config.locale expects a string of format xx-XX, received: ${config.locale}`
-			)
-		}
-		if (
-			config.defaultMode
-			&& !['month', 'week', 'day'].includes(config.defaultMode)
-		) {
-			console.warn(
-				`${this.PREFIX} config.defaultMode expects either one of the values "day", "week" or "month"`
-			)
-		}
-	}
-}

package/src/components/calendar/helpers/EventChange.ts

@@ -1,88 +0,0 @@
-import type { EventInterface } from '../typings/interfaces/event.interface'
-import type Time from './Time'
-import { DAY_MODE } from '../typings/interfaces/time-modes'
-import { DRAG_N_RESIZE_DIRECTION } from '../typings/types'
-
-export class EventChange {
-	private dayStart = ''
-	private dayEnd = ''
-
-	constructor(private timeInstance: Time, private date: string) {
-		this.setDayBoundariesTimeStrings()
-	}
-
-	public canEventBeMoved(event: EventInterface, direction: DRAG_N_RESIZE_DIRECTION): boolean {
-		if (this.timeInstance.dayMode !== DAY_MODE.FLEXIBLE) {
-			return this.handleNonFlexibleDays(direction, event)
-		}
-
-		return this.handleFlexibleDays(direction, event)
-	}
-
-	private handleNonFlexibleDays(direction: DRAG_N_RESIZE_DIRECTION, event: EventInterface) {
-		if (direction === DRAG_N_RESIZE_DIRECTION.FORWARDS) {
-			return this.handleForwardsMoveForNonFlexibleDays(event)
-		}
-
-		return this.handleBackwardsMoveForNonFlexibleDays(event)
-	}
-
-	private handleFlexibleDays(direction: DRAG_N_RESIZE_DIRECTION, event: EventInterface) {
-		if (direction == DRAG_N_RESIZE_DIRECTION.FORWARDS) {
-			return this.handleForwardsMoveForFlexibleDays(event)
-		}
-
-		return this.handleBackwardsMoveForFlexibleDays(event)
-	}
-
-	private handleForwardsMoveForNonFlexibleDays(event: EventInterface) {
-		const endTimePlus15Minutes = this.timeInstance.addMinutesToDateTimeString(15, event.time.end)
-		const endTimeString = this.timeInstance.timeStringFrom(endTimePlus15Minutes)
-		const newEndDateString = this.timeInstance.dateStringFrom(endTimePlus15Minutes)
-
-		if (newEndDateString > this.date) return false
-
-		return endTimeString <= this.dayEnd
-	}
-
-	private handleBackwardsMoveForNonFlexibleDays(event: EventInterface) {
-		const startTimeMinus15Minutes = this.timeInstance.addMinutesToDateTimeString(-15, event.time.start)
-		const startTimeString = this.timeInstance.timeStringFrom(startTimeMinus15Minutes)
-		const newStartDateString = this.timeInstance.dateStringFrom(startTimeMinus15Minutes)
-
-		if (newStartDateString < this.date) return false
-
-		return startTimeString >= this.dayStart
-	}
-
-	private handleForwardsMoveForFlexibleDays(event: EventInterface) {
-		const endTimePlus15Minutes = this.timeInstance.addMinutesToDateTimeString(15, event.time.end)
-		const endTimeString = this.timeInstance.timeStringFrom(endTimePlus15Minutes)
-		const newEndDateString = this.timeInstance.dateStringFrom(endTimePlus15Minutes)
-
-		if (newEndDateString === this.date) return true
-
-		return endTimeString <= this.dayEnd
-	}
-
-	private handleBackwardsMoveForFlexibleDays(event: EventInterface) {
-		const startTimeMinus15Minutes = this.timeInstance.addMinutesToDateTimeString(-15, event.time.start)
-		const startTimeString = this.timeInstance.timeStringFrom(startTimeMinus15Minutes)
-		const newStartDateString = this.timeInstance.dateStringFrom(startTimeMinus15Minutes)
-
-		if (newStartDateString > this.date) return true
-
-		return startTimeString >= this.dayStart
-	}
-
-	private setDayBoundariesTimeStrings() {
-		const startHour = this.timeInstance.getHourAndMinutesFromTimePoints(this.timeInstance.DAY_START).hour
-		const endHour = this.timeInstance.getHourAndMinutesFromTimePoints(this.timeInstance.DAY_END).hour
-
-		const startHourString = this.timeInstance.doubleDigit(startHour)
-		this.dayStart = `${startHourString}:00`
-
-		const endHourString = this.timeInstance.doubleDigit(endHour)
-		this.dayEnd = `${endHourString}:00`
-	}
-}

package/src/components/calendar/helpers/EventConcurrency.ts

@@ -1,69 +0,0 @@
-import type { EventInterface } from '../typings/interfaces/event.interface'
-
-export default class EventConcurrency {
-	protected sortEventsAccordingToStartOfTime(events: EventInterface[]) {
-		function compare(a: EventInterface, b: EventInterface) {
-			if (a.time.start < b.time.start) {
-				return -1
-			}
-			if (a.time.start > b.time.start) {
-				return 1
-			}
-			return 0
-		}
-
-		return events.sort(compare)
-	}
-
-	/**
-	 * Sets the "zIndex" and "nOfPreviousConcurrentEvents" properties on an event
-	 *
-	 * zIndex - lets the event know with which z-index it should be displayed
-	 * nOfPreviousConcurrentEvents - lets the event know, how many other, previous events, are competing for the same width
-	 */
-	calculateConcurrencyForEvents(events: EventInterface[]) {
-		const updatedEvents = this.sortEventsAccordingToStartOfTime(events)
-		if (!updatedEvents.length) return []
-
-		for (const [index, calendarEvent] of updatedEvents.entries()) {
-			if (index === 0) continue
-
-			// let _unused_previousEvent = updatedEvents[index - 1]
-
-			// Set nOfPreviousConcurrentEvents
-			let iterator = 0
-			let nOfConcurrentEvents = 0
-			while (iterator < index) {
-				if (updatedEvents[iterator].time.end > calendarEvent.time.start)
-					nOfConcurrentEvents++
-				iterator++
-			}
-
-			if (nOfConcurrentEvents)
-				updatedEvents[index].nOfPreviousConcurrentEvents = nOfConcurrentEvents
-		}
-
-		// Iterate backwards over the events, in order to tell all concurrent events how many concurrent events they have
-		for (let index = updatedEvents.length - 1; index >= 0; index--) {
-			let nOfUpcomingConcurrentEvents = 0
-			let iterator = updatedEvents.length - 1
-
-			while (iterator > index) {
-				if (
-					updatedEvents[iterator].time.start < updatedEvents[index].time.end
-				) {
-					nOfUpcomingConcurrentEvents++
-				}
-
-				iterator--
-			}
-
-			const nfOfPreviousEvents
-        = updatedEvents[index].nOfPreviousConcurrentEvents || 0
-			updatedEvents[index].totalConcurrentEvents
-        = nfOfPreviousEvents + nOfUpcomingConcurrentEvents + 1 // One for the event itself
-		}
-
-		return events
-	}
-}

package/src/components/calendar/helpers/EventFlyoutPosition.ts

@@ -1,96 +0,0 @@
-interface elementDimensions { height: number, width: number }
-import type { DOMRect } from '../typings/types'
-
-const calendarDomRectForVitest = {
-	x: 8,
-	y: 26,
-	width: 903,
-	height: 702,
-	top: 26,
-	right: 911,
-	bottom: 728,
-	left: 8,
-}
-
-export const EVENT_FLYOUT_WIDTH = 400
-
-export default class EventFlyoutPosition {
-	calculateFlyoutPosition(
-		eventElementDOMRect: DOMRect,
-		flyoutDimensions: elementDimensions,
-		calendarDomRectParam: DOMRect | null = null
-	): { top: number | null, left: number | null } | undefined {
-		const calendarDomRect = calendarDomRectParam || calendarDomRectForVitest
-
-		// The four variables below, contain the space in pixels, from the event to the calendar border
-		// i.e. spaceTop === length from event top border, to calendar top border
-		// and spaceRight === length from event right border to calendar right border
-		const spaceTop = eventElementDOMRect.top - calendarDomRect.top
-		const spaceRight = calendarDomRect.right - eventElementDOMRect.right
-		const spaceBottom = calendarDomRect.bottom - eventElementDOMRect.bottom
-		const spaceLeft = eventElementDOMRect.left - calendarDomRect.left
-
-		const flyoutNeededWidth = flyoutDimensions.width + 10
-
-		// Set 'top' for events whose bottom is outside the viewport
-		const topWhenSpaceToBottomIsNegative
-      = spaceBottom < 0
-      	? calendarDomRect.bottom - flyoutDimensions.height - 10
-      	: null
-
-		const topWhenSpaceTopIsNegative
-      = spaceTop < 0 ? calendarDomRect.top + 10 : null
-
-		// Position flyout to the right of event, facing downwards, when possible
-		if (
-			spaceBottom > flyoutDimensions.height
-			&& spaceRight > flyoutNeededWidth
-		) {
-			return {
-				top: topWhenSpaceTopIsNegative || Math.round(eventElementDOMRect.top),
-				left: Math.round(eventElementDOMRect.right) + 10,
-			}
-		}
-
-		// Position flyout to the right of event, facing upwards, when too close to the bottom
-		if (spaceTop > flyoutDimensions.height && spaceRight > flyoutNeededWidth) {
-			return {
-				top: topWhenSpaceToBottomIsNegative || Math.round(eventElementDOMRect.bottom) - flyoutDimensions.height,
-				left: Math.round(eventElementDOMRect.right) + 10,
-			}
-		}
-
-		// Position flyout left of event, facing downwards, when possible
-		if (
-			spaceLeft > flyoutNeededWidth
-			&& spaceBottom > flyoutDimensions.height
-		) {
-			return {
-				top: topWhenSpaceTopIsNegative || eventElementDOMRect.top,
-				left: Math.round(
-					eventElementDOMRect.left - (flyoutDimensions.width + 10)
-				),
-			}
-		}
-
-		// Position flyout left of event, facing upwards when possible
-		if (spaceLeft > flyoutNeededWidth && spaceTop > flyoutDimensions.height) {
-			return {
-				top: topWhenSpaceToBottomIsNegative || Math.round(eventElementDOMRect.bottom - flyoutDimensions.height),
-				left: Math.round(
-					eventElementDOMRect.left - (flyoutDimensions.width + 10)
-				),
-			}
-		}
-
-		// Fallback for smaller screens - scenario 1
-		// Flyout is glued to the bottom of the calendar and horizontally centered
-		if (spaceBottom < flyoutDimensions.height) {
-			return { top: calendarDomRect.bottom - flyoutDimensions.height, left: null }
-		}
-
-		// Fallback for smaller screens - scenario 2
-		// Flyout is placed vertically based on the top of the event, and centered horizontally
-		return { top: eventElementDOMRect.top, left: null }
-	}
-}

package/src/components/calendar/helpers/EventPosition.ts

@@ -1,154 +0,0 @@
-import type { DayInterface } from '../typings/interfaces/day.interface'
-/**
- * The following class contains methods for calculating where to position
- * calendar events within a given day
- */
-import type { EventInterface } from '../typings/interfaces/event.interface'
-import type { FullDayEventsWeek } from '../typings/interfaces/full-day-events-week.type'
-import Time from './Time'
-
-interface eventWithJSDatesInterface extends EventInterface {
-	timeJS: {
-		start: Date
-		end: Date
-	}
-}
-
-export default class EventPosition extends Time {
-	/**
-	 * Yields a full calendar week, with all full-day events positioned in it
-	 */
-	positionFullDayEventsInWeek(weekStart: Date, weekEnd: Date, events: EventInterface[]) {
-		// 1. add timeJS.start and timeJS.end to all objects
-		const eventsWithJSDates: eventWithJSDatesInterface[] = events.map((scheduleEvent: EventInterface) => {
-			const { year: startYear, month: startMonth, date: startDate } = this.getAllVariablesFromDateTimeString(scheduleEvent.time.start)
-			const { year: endYear, month: endMonth, date: endDate } = this.getAllVariablesFromDateTimeString(scheduleEvent.time.end)
-			scheduleEvent.timeJS = {
-				start: new Date(startYear, startMonth, startDate),
-				end: new Date(endYear, endMonth, endDate),
-			}
-
-			return scheduleEvent as eventWithJSDatesInterface
-		}).sort((a, b) => {
-			if (a.time.start < b.time.start) return -1
-			if (a.time.start > b.time.start) return 1
-
-			return 0
-		})
-
-		// 2. create a week array, where each day is represented as an object with different levels, level1, level2, level3, level4 etc.
-		// An event starts on a certain level, the first day when it occurs, and then blocks that level for the rest of its duration
-		const allDatesOfWeek = this.getDatesBetweenTwoDates(weekStart, weekEnd)
-		const week: FullDayEventsWeek = allDatesOfWeek.map(d => ({ date: d }))
-
-		for (const scheduleEvent of eventsWithJSDates) {
-			for (const [dayIndex, day] of week.entries()) {
-				const thisDayDateString = this.getDateStringFromDate(day.date)
-
-				if (
-					this.getDateStringFromDate(scheduleEvent.timeJS.start) <= thisDayDateString
-					&& this.getDateStringFromDate(scheduleEvent.timeJS.end) >= thisDayDateString
-				) {
-					// 2A. Get the first free level of the day
-					let levelToStartOn = 1
-					while (typeof week[dayIndex][`level${levelToStartOn}`] !== 'undefined') {
-						levelToStartOn++
-					}
-
-					// 2B. set the event on this day
-					let eventNDays = (Math.ceil((scheduleEvent.timeJS.end.getTime() - day.date.getTime()) / this.MS_PER_DAY) + 1) // Get difference in days, plus the first day itself
-					const remainingDaysOfWeek = (week.length - dayIndex)
-					if (eventNDays > remainingDaysOfWeek) eventNDays = remainingDaysOfWeek
-
-					week[dayIndex][`level${levelToStartOn}`] = {
-						...scheduleEvent,
-						nDays: eventNDays, // Denotes the number of days to display in the week, not the actual number of days
-					}
-
-					// 2C. And block the specified level, for the following days of the event
-					for (let i = 1; i < eventNDays; i++) {
-						week[dayIndex + i][`level${levelToStartOn}`] = 'blocked'
-					}
-
-					break
-				}
-			}
-		}
-
-		const weekWithSortedLevelsInDays = []
-
-		// 3. Sort the levels of the day objects
-		for (const day of week) {
-			weekWithSortedLevelsInDays.push(Object.keys(day).sort().reduce(
-				(obj: any, key: any) => {
-					obj[key] = day[key]
-					return obj
-				},
-				{}
-			))
-		}
-
-		return weekWithSortedLevelsInDays
-	}
-
-	positionFullDayEventsInMonth(
-		calendarMonth: DayInterface[][],
-		fullDayEvents: EventInterface[]
-	): DayInterface[][] {
-		const newMonth: DayInterface[][] = []
-		const flatMonth = calendarMonth.flat()
-		// Create a map, where each key is a dateString in the format of YYYY-MM-DD, and the value is the calendarDay. This will help us skip 2 levels of nested loops.
-		// Instead of iterating over the following units for => week of calendarMonth => day of week => event of fullDayEvents => date of allDatesOfEvent
-		// we can stay on 2 levels of nesting with for => fullDayEvent of fullDayEvents => date of allDatesOfEvent, and then see if the map has a matching date
-		const monthMap = new Map()
-		flatMonth.forEach(day => monthMap.set(this.dateStringFrom(day.dateTimeString), day))
-		// Sort events with the latest first. This will help the algorithm place the oldest events at the start of each "events" array later
-		fullDayEvents = fullDayEvents.sort((a, b) => {
-			if (a.time.start < b.time.start) return 1
-			if (a.time.start > b.time.start) return -1
-
-			return 0
-		})
-
-		for (const fullDayEvent of fullDayEvents) {
-			const { year: startYear, month: startMonth, date: startDate } = this.getAllVariablesFromDateTimeString(fullDayEvent.time.start)
-			const { year: endYear, month: endMonth, date: endDate } = this.getAllVariablesFromDateTimeString(fullDayEvent.time.end)
-			const allDatesOfEvent = this.getDatesBetweenTwoDates(
-				new Date(startYear, startMonth, startDate),
-				new Date(endYear, endMonth, endDate),
-			)
-
-			for (const date of allDatesOfEvent) {
-				const dateString = this.getDateStringFromDate(date)
-				const dateInMap = monthMap.get(dateString)
-
-				if (dateInMap) { monthMap.set(dateString, {
-					...dateInMap,
-					// Since we're iterating over the fullDayEvents sorted backwards, the earliest events will end up first (which is the wanted behavior)
-					events: [fullDayEvent, ...dateInMap.events]
-				})
-				}
-			}
-		}
-
-		let weekIterator = 0
-
-		monthMap.forEach((day) => {
-			// For the very first day, create an array for the first week, and push day onto it
-			if (!newMonth.length) { newMonth.push([day])
-			}
-
-			// When the week exists, and is not yet filled with 7 days, push day onto week
-			else if (newMonth[weekIterator] && newMonth[weekIterator].length < 7) { newMonth[weekIterator].push(day)
-			}
-
-			// When the week exists, but is full, create a new week with the day in it, and increment the week iterator
-			else if (newMonth[weekIterator] && newMonth[weekIterator].length === 7) {
-				newMonth.push([day])
-				weekIterator++
-			}
-		})
-
-		return newMonth
-	}
-}

package/src/components/calendar/helpers/EventsFilter.ts

@@ -1,50 +0,0 @@
-import type { EventInterface } from '../typings/interfaces/event.interface'
-import type Time from './Time'
-import { DAY_MODE } from '../typings/interfaces/time-modes'
-
-export class EventsFilter {
-	constructor(private events: EventInterface[]) {}
-
-	public getEventsForDay(timeInstance: Time, startDateTimeString: string): EventInterface[] {
-		return this.events.filter(event => this.isEventInDayBoundaries(event, timeInstance, startDateTimeString))
-	}
-
-	private isEventInDayBoundaries(event: EventInterface, timeInstance: Time, startDateTimeString: string): boolean {
-		const eventIsInDay
-      = timeInstance.dateStringFrom(event.time.start) === timeInstance.dateStringFrom(startDateTimeString)
-
-		if (timeInstance.dayMode === DAY_MODE.REGULAR) {
-			return eventIsInDay
-		}
-
-		if (eventIsInDay && timeInstance.dayMode === DAY_MODE.SHORTENED) {
-			return this.handlePartialDayWithinOneDayBoundary(timeInstance, event)
-		}
-
-		if (timeInstance.dayMode === DAY_MODE.FLEXIBLE) {
-			return this.handleDayStretchingTwoDates(timeInstance, event, startDateTimeString, eventIsInDay)
-		}
-
-		return false
-	}
-
-	private handleDayStretchingTwoDates(timeInstance: Time, event: EventInterface, startDateTimeString: string, eventIsInDay: boolean) {
-		const { hour: dayStartHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_START)
-		const { hour: dayEndHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_END)
-		const { hour: eventStartHour } = timeInstance.getAllVariablesFromDateTimeString(event.time.start)
-		const nextDay = timeInstance.addDaysToDateTimeString(1, startDateTimeString)
-		const eventStartsInNextDay = event.time.start.substring(0, 11) === nextDay.substring(0, 11)
-
-		return eventIsInDay && eventStartHour >= dayStartHour
-			|| eventStartsInNextDay && eventStartHour < dayEndHour
-	}
-
-	private handlePartialDayWithinOneDayBoundary(timeInstance: Time, event: EventInterface) {
-		const { hour: dayStartHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_START)
-		const { hour: dayEndHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_END)
-		const { hour: eventStartHour } = timeInstance.getAllVariablesFromDateTimeString(event.time.start)
-
-		// TODO: add check for event end time overlapping the day start time
-		return eventStartHour >= dayStartHour && eventStartHour < dayEndHour
-	}
-}

package/src/components/calendar/helpers/Week.ts

@@ -1,37 +0,0 @@
-import type { EventInterface } from '../typings/interfaces/event.interface'
-import { DAY_MODE } from '../typings/interfaces/time-modes'
-import Helpers from './Helpers'
-import Time from './Time'
-
-export class WeekHelper {
-	public static getNHoursIntoDayFromHour(hour: number, timeInstance: Time): number {
-		const dayStartHour = Time.getHourFromTimePoints(timeInstance.DAY_START)
-
-		if (timeInstance.dayMode === DAY_MODE.REGULAR) return hour
-
-		if (
-			timeInstance.dayMode === DAY_MODE.SHORTENED
-			|| (timeInstance.dayMode === DAY_MODE.FLEXIBLE && hour >= dayStartHour)
-		) {
-			return hour - dayStartHour
-		}
-
-		return (24 - dayStartHour) + hour
-	}
-
-	public static eventSeparator(events: EventInterface[], time: Time) {
-		const singleDayTimedEvents: EventInterface[] = []
-		const fullDayAndMultipleDayEvents: EventInterface[] = []
-
-		for (const scheduleEvent of events) {
-			const eventType = Helpers.getEventType(scheduleEvent, time)
-			if (['SINGLE_DAY_TIMED', 'SINGLE_HYBRID_DAY_TIMED'].includes(eventType)) {
-				singleDayTimedEvents.push(scheduleEvent)
-			} else {
-				fullDayAndMultipleDayEvents.push(scheduleEvent)
-			}
-		}
-
-		return { fullDayAndMultipleDayEvents, singleDayTimedEvents }
-	}
-}

package/src/components/calendar/language/index.ts

@@ -1,41 +0,0 @@
-import { languageKeys } from './keys'
-
-export const localeMap = new Map<string, string>([
-	['de', 'de-DE'],
-	['en', 'en-US'],
-	['it', 'it-IT'],
-	['sv', 'sv-SE'],
-	['zh', 'zh-CN'],
-	['pt', 'pt-BR'],
-	['fr', 'fr-FR'],
-	['th', 'th-TH'],
-	['nl', 'nl-NL'],
-	['ru', 'ru-RU'],
-	['ar', 'ar-YE'],
-	['es', 'es-ES'],
-	['ja', 'ja-JP'],
-	['pl', 'pl-PL'],
-	['hu', 'hu-HU'],
-	['he', 'he-IL']
-])
-
-export function overrideShortLocaleWithLongLocale(locale: string): string {
-	if (localeMap.has(locale)) {
-		locale = localeMap.get(locale) as string
-	}
-
-	return locale
-}
-
-export function getLanguage(languageKeys: any, locale: string = 'en-US') {
-	locale = overrideShortLocaleWithLongLocale(locale)
-
-	return languageKeys[locale]
-}
-export function translate(key: string, locale: string = 'en-US') {
-	const language: { [key: string]: any } = languageKeys[key as keyof typeof languageKeys] || {}
-
-	return language[locale] || key
-}
-
-export { languageKeys }