willba-component-library 0.3.26 → 0.4.0

package/src/core/components/calendar/utils/calendarSelectionRules.tsx

@@ -1,180 +0,0 @@
-import { addDays, isAfter, isBefore, endOfDay, isEqual } from 'date-fns'
-import { DateRange, Matcher } from 'react-day-picker'
-
-import { DisableCalendarDates, RangeContext } from '../CalendarTypes'
-
-type Props = {
-  range: DateRange | undefined
-  newDisableCalendarDates?: DisableCalendarDates
-  setCalendarRange: (range: DateRange | undefined) => void
-  setCalendarHasError?: (arg: boolean) => void
-  calendarRange?: DateRange
-  overlappingDate?: DateRange[]
-  calendarHasError?: boolean
-  rangeContext?: RangeContext
-}
-
-export const calendarSelectionRules = ({
-  range,
-  newDisableCalendarDates,
-  setCalendarRange,
-  calendarRange,
-  overlappingDate,
-  setCalendarHasError,
-  rangeContext,
-}: Props) => {
-  // Get and parse needed data
-  const rangeFrom = range?.from ? endOfDay(range.from) : null
-  const rangeTo = range?.to ? endOfDay(range.to) : null
-  const calendarRangeFrom = calendarRange?.from
-    ? endOfDay(calendarRange.from)
-    : null
-  const calendarRangeTo = calendarRange?.to ? endOfDay(calendarRange.to) : null
-
-  const rangeContextFrom = rangeContext?.from
-    ? endOfDay(rangeContext.from)
-    : null
-  const rangeContextTo = rangeContext?.to ? endOfDay(rangeContext.to) : null
-
-  // When some dates are not available for selection, the earliest date will be available only for "end"
-  // and the latest date will only be available for "start"
-  const rangeFromDate =
-    !range && calendarRangeFrom && calendarRangeTo
-      ? calendarRangeFrom
-      : rangeFrom
-  const overlappingDateFrom = overlappingDate?.length
-    ? overlappingDate.find((date) =>
-        !!(date.from && rangeFromDate)
-          ? isEqual(endOfDay(date.from), rangeFromDate)
-          : false
-      )
-    : null
-
-  const overlappingDateTo = overlappingDate?.length
-    ? overlappingDate.find((date) =>
-        !!(date.from && rangeTo) ? isEqual(endOfDay(date.from), rangeTo) : false
-      )
-    : null
-  //----------
-
-  const checkOutRange = newDisableCalendarDates?.availableDates?.length
-    ? newDisableCalendarDates.availableDates.find((checkInDate) =>
-        !!(checkInDate.checkIn && rangeFrom)
-          ? isEqual(endOfDay(checkInDate.checkIn), rangeFrom)
-          : false
-      )
-    : null
-
-  // Calendar selection rules: The cases are handled sequentially, starting from simple selections to more complex contextual selections.
-  // The rules are processed in a specific order, so one case is handled before another.
-  // Changing the order will cause the rules to break or not work properly.
-
-  if (
-    (calendarRangeFrom &&
-      overlappingDateFrom &&
-      rangeFrom &&
-      !isEqual(rangeFrom, calendarRangeFrom)) ||
-    !range ||
-    (calendarRangeFrom &&
-      calendarRangeTo &&
-      overlappingDateTo &&
-      rangeTo &&
-      !isEqual(rangeTo, calendarRangeTo))
-  ) {
-    // 1. If dates overlap, clear the selection.
-    return setCalendarRange(undefined)
-  }
-
-  if (
-    // 2. If selected "start" is after "range context end", clear selection and display error.
-    // Also, if there are unavailable dates between the rangeContext "start" and "end", do not allow a fully overlapping selection.
-    (rangeFrom && rangeContextTo && isAfter(rangeFrom, rangeContextTo)) ||
-    // In case of current rangeTo is after contextRange and user clicks the new check-in
-    (calendarRangeFrom &&
-      calendarRangeTo &&
-      rangeContextTo &&
-      rangeTo &&
-      // If rangeTo has been adjusted, the current click was at the end
-      // In this case we can verify if the new click (check-in-to-be) goes over the context range end
-      !isEqual(rangeTo, calendarRangeTo) &&
-      isAfter(rangeTo, rangeContextTo))
-  ) {
-    setCalendarHasError && setCalendarHasError(true)
-    return setCalendarRange(undefined)
-  }
-
-  if (rangeFrom && rangeTo && isEqual(rangeFrom, rangeTo)) {
-    // 3. If "start" is selected and the same date is clicked again, keep the current "start" selection.
-    return setCalendarRange({ from: rangeFrom, to: undefined })
-  }
-
-  if (calendarRangeFrom && calendarRangeTo && !range) {
-    // 4. If "calendarRange" has dates selected and the same "start" date is clicked, the "range" will become undefined.
-    // Set the current selection (calendarRange) to the initial "start" of calendarRange.
-    return setCalendarRange({ from: calendarRangeFrom, to: undefined })
-  }
-
-  // 5. Handle gap selection backwards and forwards
-  if (
-    // In the range context case, every date selection that is after selected "start" last checkout,
-    // clear selection and prompt error
-    rangeContext &&
-    rangeTo &&
-    checkOutRange?.lastCheckOut &&
-    isAfter(rangeTo, endOfDay(checkOutRange.lastCheckOut)) &&
-    // Handle case of existing range that span over the end of the context range
-    ((calendarRangeTo && !isEqual(rangeTo, calendarRangeTo)) ||
-      !calendarRangeTo) &&
-    isAfter(rangeTo, endOfDay(rangeContext.to))
-  ) {
-    setCalendarHasError && setCalendarHasError(true)
-    return setCalendarRange(undefined)
-  }
-
-  if (
-    // Enforce on every date selection before current "start", mark as "start" selection
-    rangeFrom &&
-    calendarRangeFrom &&
-    isBefore(rangeFrom, calendarRangeFrom)
-  ) {
-    return setCalendarRange({ from: rangeFrom, to: undefined })
-  }
-
-  if (
-    // Every date selection that is after selected "start" last checkout, mark as "start"
-    rangeTo &&
-    checkOutRange?.lastCheckOut &&
-    isAfter(rangeTo, endOfDay(checkOutRange.lastCheckOut))
-  ) {
-    if (overlappingDateTo) {
-      return setCalendarRange(undefined)
-    }
-    return setCalendarRange({ from: rangeTo, to: undefined })
-  }
-
-  if (
-    calendarRangeFrom &&
-    rangeFrom &&
-    !isEqual(calendarRangeFrom, rangeFrom)
-  ) {
-    // 6. If "calendarRange" has selected dates and the new selection "start" differs from the current "calendarRange start", reset and make a new "start" selection.
-    return setCalendarRange({ from: rangeFrom, to: undefined })
-  } else if (calendarRangeTo && rangeTo && !isEqual(calendarRangeTo, rangeTo)) {
-    // 7. If "calendarRange" has selected dates and the new selection "end" differs from the current "calendarRange end", reset and make a new "start" selection.
-
-    return setCalendarRange({ from: rangeTo, to: undefined })
-  }
-
-  if (
-    // 8. If selected "end" is before "context start", mark as "start" and display error
-    rangeFrom &&
-    rangeTo &&
-    rangeContextFrom &&
-    isBefore(rangeTo, rangeContextFrom)
-  ) {
-    setCalendarHasError && setCalendarHasError(true)
-    return setCalendarRange({ from: rangeTo, to: undefined })
-  }
-
-  setCalendarRange(range)
-}

package/src/core/components/calendar/utils/checkForContinuousSelection.tsx

@@ -1,86 +0,0 @@
-import { useEffect } from 'react'
-import { DateRange } from 'react-day-picker'
-import {
-  isAfter,
-  isEqual,
-  isBefore,
-  endOfDay,
-  isWithinInterval,
-  areIntervalsOverlapping,
-} from 'date-fns'
-
-import { DisableCalendarDates, RangeContext } from '../CalendarTypes'
-
-type Props = {
-  setCalendarHasError?: (arg: boolean) => void
-  rangeContext?: RangeContext
-  calendarRange?: DateRange
-  calendarHasError?: boolean
-  disabledDates?: DisableCalendarDates['disabledDates']
-}
-
-// Case: If the selected dates do not overlap with the rangeContext during continuous selection,
-//       set setCalendarHasError to true. This will display an error message and
-//       prevent the submission of the selected dates.
-
-export const checkForContinuousSelection = ({
-  setCalendarHasError,
-  rangeContext,
-  calendarRange,
-  calendarHasError,
-  disabledDates,
-}: Props) => {
-  const calendarRangeFrom = calendarRange?.from && endOfDay(calendarRange.from)
-  const calendarRangeTo = calendarRange?.to && endOfDay(calendarRange.to)
-  const rangeContextFrom = rangeContext?.from && endOfDay(rangeContext.from)
-  const rangeContextTo = rangeContext?.to && endOfDay(rangeContext.to)
-
-  // Checking if rangeFrom is equal to or before rangeContextTo
-  const startIsEqualOrBeforeRangeContextEnd =
-    calendarRangeFrom && rangeContextTo
-      ? isBefore(calendarRangeFrom, rangeContextTo) ||
-        isEqual(calendarRangeFrom, rangeContextTo)
-      : null
-
-  // Checking if rangeTo is equal to or after rangeContextFrom
-  const endIsEqualOrAfterRangeContextStart =
-    calendarRangeTo && rangeContextFrom && rangeContextTo
-      ? isAfter(calendarRangeTo, rangeContextFrom) ||
-        isEqual(calendarRangeTo, rangeContextFrom)
-      : null
-
-  // Check if selection overlapping unavailable dates
-  const selectionOverlappingUnavailableDate = disabledDates?.find((range) => {
-    const rangeFrom = endOfDay(range.from)
-    const rangeTo = endOfDay(range.to)
-
-    return (
-      rangeContextFrom &&
-      rangeContextTo &&
-      areIntervalsOverlapping(
-        { start: rangeContextFrom, end: rangeContextTo },
-        { start: rangeFrom, end: rangeTo }
-      ) &&
-      calendarRangeFrom &&
-      calendarRangeTo &&
-      areIntervalsOverlapping(
-        { start: calendarRangeFrom, end: calendarRangeTo },
-        { start: rangeFrom, end: rangeTo }
-      )
-    )
-  })
-
-  useEffect(() => {
-    if (
-      (rangeContext &&
-        calendarRangeFrom &&
-        !startIsEqualOrBeforeRangeContextEnd) ||
-      (rangeContext &&
-        calendarRangeTo &&
-        !endIsEqualOrAfterRangeContextStart) ||
-      selectionOverlappingUnavailableDate
-    ) {
-      !!(setCalendarHasError && !calendarHasError) && setCalendarHasError(true)
-    }
-  })
-}

package/src/core/components/calendar/utils/disabledDatesByPage.tsx

@@ -1,31 +0,0 @@
-import { addDays } from 'date-fns'
-
-import { DisableCalendarDates } from '../CalendarTypes'
-
-export const disabledDatesByPage = ({
-  newDisableCalendarDates,
-  selectedPath,
-  today,
-}: {
-  newDisableCalendarDates?: DisableCalendarDates
-  selectedPath?: string
-  today: Date
-}) => {
-  const daysToOffsetCalendar =
-    newDisableCalendarDates?.disabledDatesByPage && selectedPath
-      ? [
-          newDisableCalendarDates?.disabledDatesByPage?.find(
-            (item) => selectedPath === item.page
-          ),
-        ]
-      : []
-
-  return daysToOffsetCalendar.length
-    ? [
-        {
-          from: addDays(today, daysToOffsetCalendar[0]?.offset ?? -1),
-          to: addDays(today, -100),
-        },
-      ]
-    : []
-}

package/src/core/components/calendar/utils/handleCalendarModifiers.tsx

@@ -1,118 +0,0 @@
-import { addDays, endOfDay, isAfter, isBefore } from 'date-fns'
-import { DateRange, Matcher } from 'react-day-picker'
-
-import { DisableCalendarDates, RangeContext } from '../CalendarTypes'
-
-type Props = {
-  calendarRange?: DateRange
-  disabledDates?: Matcher[]
-  overlappingDate?: DateRange[]
-  rangeContext?: RangeContext
-  findFirstPossibleRangeContextCheckIn?: NonNullable<
-    DisableCalendarDates['availableDates']
-  >['0']
-  findLastPossibleRangeContextCheckOut?: NonNullable<
-    DisableCalendarDates['availableDates']
-  >['0']
-  currentSelectionLastCheckoutDate?: NonNullable<
-    DisableCalendarDates['availableDates']
-  >['0']
-}
-
-export const handleCalendarModifiers = ({
-  calendarRange,
-  disabledDates,
-  overlappingDate,
-  rangeContext,
-  findFirstPossibleRangeContextCheckIn,
-  findLastPossibleRangeContextCheckOut,
-  currentSelectionLastCheckoutDate,
-}: Props) => {
-  // Parse data
-  const calendarRangeFrom = calendarRange?.from && endOfDay(calendarRange.from)
-  const calendarRangeTo = calendarRange?.to && endOfDay(calendarRange.to)
-  const rangeContextFrom = rangeContext?.from && endOfDay(rangeContext.from)
-  const rangeContextTo = rangeContext?.to && endOfDay(rangeContext.to)
-
-  const filteredOverlappingDates = overlappingDate
-    ? overlappingDate
-        .filter((date) => {
-          const dateFrom = date.from ? endOfDay(date.from) : null
-          const isBeforeRange =
-            dateFrom &&
-            findFirstPossibleRangeContextCheckIn?.checkIn &&
-            isBefore(dateFrom, findFirstPossibleRangeContextCheckIn?.checkIn)
-          const isAfterRange =
-            dateFrom &&
-            findLastPossibleRangeContextCheckOut?.lastCheckOut &&
-            isAfter(
-              dateFrom,
-              endOfDay(findLastPossibleRangeContextCheckOut?.lastCheckOut)
-            )
-
-          return !(isBeforeRange || isAfterRange)
-        })
-        .map((date) => ({ from: date.from }))
-    : []
-
-  return {
-    booked: disabledDates || [],
-
-    disabledAfterCheckIn: calendarRangeFrom
-      ? [{ after: calendarRangeFrom }]
-      : [],
-
-    overlappingDate:
-      !calendarRangeFrom && !!filteredOverlappingDates.length
-        ? filteredOverlappingDates.map((date) => ({ from: date.from }))
-        : [],
-
-    noActiveSelectionStart: rangeContextFrom || [],
-
-    noActiveSelectionMid: [
-      rangeContextFrom && rangeContextTo
-        ? { after: rangeContextFrom, before: rangeContextTo }
-        : [],
-    ],
-
-    noActiveSelectionEnd: rangeContextTo || [],
-
-    checkoutOptionsMid: [
-      ...(calendarRangeFrom &&
-      !calendarRangeTo &&
-      currentSelectionLastCheckoutDate?.lastCheckOut
-        ? [
-            {
-              after: calendarRangeFrom,
-              before: addDays(currentSelectionLastCheckoutDate.lastCheckOut, 1),
-            },
-          ]
-        : []),
-    ],
-
-    checkInOnly: [
-      ...(findFirstPossibleRangeContextCheckIn?.checkIn &&
-      rangeContext &&
-      rangeContextFrom
-        ? [
-            {
-              from: findFirstPossibleRangeContextCheckIn.checkIn,
-              to: addDays(rangeContextFrom, -1),
-            },
-          ]
-        : []),
-    ],
-
-    checkOutOnly: [
-      ...(findLastPossibleRangeContextCheckOut?.checkIn &&
-      findLastPossibleRangeContextCheckOut.lastCheckOut
-        ? [
-            {
-              from: addDays(findLastPossibleRangeContextCheckOut.checkIn, 1),
-              to: findLastPossibleRangeContextCheckOut.lastCheckOut,
-            },
-          ]
-        : []),
-    ],
-  }
-}

package/src/core/components/calendar/utils/handleRangeContextDisabledDates.tsx

@@ -1,75 +0,0 @@
-import { DateRange, Matcher } from 'react-day-picker'
-import { isEqual, endOfDay } from 'date-fns'
-
-import { DisableCalendarDates, RangeContext } from '../CalendarTypes'
-
-type Props = {
-  rangeContext?: RangeContext
-  availableDates?: DisableCalendarDates['availableDates']
-  calendarRange?: DateRange
-}
-
-export const handleRangeContextDisabledDates = ({
-  rangeContext,
-  availableDates,
-  calendarRange,
-}: Props) => {
-  let findFirstPossibleRangeContextCheckIn:
-    | NonNullable<DisableCalendarDates['availableDates']>['0']
-    | undefined
-  let findLastPossibleRangeContextCheckOut:
-    | NonNullable<DisableCalendarDates['availableDates']>['0']
-    | undefined
-
-  let firstPossibleRangeContextCheckIn: Matcher[] = []
-  let lastPossibleRangeContextCheckOut: Matcher[] = []
-
-  // Parse data
-  const rangeContextFrom = rangeContext?.from && endOfDay(rangeContext.from)
-  const rangeContextTo = rangeContext?.to && endOfDay(rangeContext.to)
-  const calendarRangeFrom = calendarRange?.from && endOfDay(calendarRange.from)
-
-  if (rangeContext && availableDates?.length) {
-    // Find the first possible check-in after the last date gap till the range context
-
-    findFirstPossibleRangeContextCheckIn = availableDates?.find(
-      (date) =>
-        rangeContextFrom &&
-        endOfDay(date.checkIn) < rangeContextFrom &&
-        endOfDay(date.lastCheckOut) >= rangeContextFrom
-    )
-
-    if (findFirstPossibleRangeContextCheckIn?.checkIn) {
-      firstPossibleRangeContextCheckIn.push({
-        before: findFirstPossibleRangeContextCheckIn.checkIn,
-      })
-    }
-
-    // Find the last possible checkout before the first date gap till the range context
-    findLastPossibleRangeContextCheckOut = availableDates?.find(
-      (date) =>
-        rangeContextTo && isEqual(rangeContextTo, endOfDay(date.checkIn))
-    )
-
-    if (findLastPossibleRangeContextCheckOut?.checkIn) {
-      lastPossibleRangeContextCheckOut.push({
-        after: findLastPossibleRangeContextCheckOut.lastCheckOut,
-      })
-    }
-  }
-
-  // Get possible check-out dates for current check-in
-  const currentSelectionAvailability = availableDates?.find((date) => {
-    return calendarRangeFrom
-      ? isEqual(endOfDay(date.checkIn), calendarRangeFrom)
-      : false
-  })
-
-  return {
-    findFirstPossibleRangeContextCheckIn,
-    findLastPossibleRangeContextCheckOut,
-    firstPossibleRangeContextCheckIn,
-    lastPossibleRangeContextCheckOut,
-    currentSelectionAvailability,
-  }
-}

package/src/core/components/calendar/utils/index.ts

@@ -1,8 +0,0 @@
-export { parseDates } from './parseDates'
-export { parseDate } from './parseDate'
-export { nightsCount } from './nightsCount'
-export { calendarSelectionRules } from './calendarSelectionRules'
-export { disabledDatesByPage } from './disabledDatesByPage'
-export { handleCalendarModifiers } from './handleCalendarModifiers'
-export { handleRangeContextDisabledDates } from './handleRangeContextDisabledDates'
-export { checkForContinuousSelection } from './checkForContinuousSelection'

package/src/core/components/calendar/utils/nightsCount.tsx

@@ -1,19 +0,0 @@
-import { differenceInCalendarDays } from 'date-fns'
-import { DateRange } from 'react-day-picker'
-
-type Props = {
-  calendarRange?: DateRange
-}
-
-export const nightsCount = ({ calendarRange }: Props) => {
-  if (!calendarRange || !calendarRange.from || !calendarRange.to) {
-    return undefined
-  }
-
-  const diffDays = differenceInCalendarDays(
-    calendarRange.to,
-    calendarRange.from
-  )
-
-  return diffDays
-}

package/src/core/components/calendar/utils/parseDate.tsx

@@ -1,17 +0,0 @@
-import { format } from 'date-fns'
-import { fi, enUS } from 'date-fns/locale'
-
-type Props = {
-  date?: Date
-  dateFormat?: string
-  language?: string
-}
-export const parseDate = ({
-  date,
-  dateFormat = 'dd.MM.yyyy',
-  language,
-}: Props) => {
-  return date
-    ? format(date, dateFormat, { locale: language === 'en' ? enUS : fi })
-    : null
-}

package/src/core/components/calendar/utils/parseDates.tsx

@@ -1,12 +0,0 @@
-import { format } from 'date-fns'
-import { DateRange } from 'react-day-picker'
-
-type Props = {
-  calendarRange?: DateRange
-}
-
-export const parseDates = ({ calendarRange }: Props) =>
-  calendarRange?.to && calendarRange?.from
-    ? `${format(calendarRange.from, 'dd.MM.yyyy')} -
-${format(calendarRange.to, 'dd.MM.yyyy')}`
-    : null

package/src/core/components/index.ts

@@ -1,7 +0,0 @@
-export { SubmitButton } from './buttons/SubmitButton/SubmitButton'
-export { CloseButton } from './buttons/CloseButton/CloseButton'
-
-// Calendar
-export { Calendar } from './calendar/Calendar'
-export type { CalendarTypes } from './calendar/CalendarTypes'
-export { parseDates } from './calendar/utils'

package/src/core/hooks/index.ts

@@ -1,4 +0,0 @@
-export { useAwaitRender } from './useAwaitRender'
-export { useUpdateTranslations } from './useUpdateTranslations'
-export { useCloseFilterSection } from './useCloseFilterSection'
-export { useAutoFocus } from './useAutoFocus'

package/src/core/hooks/useAutoFocus.tsx

@@ -1,27 +0,0 @@
-import { useEffect, useRef } from 'react'
-
-export const useAutoFocus = <T extends HTMLElement>(autoFocus?: boolean) => {
-  const ref = useRef<T>(null)
-
-  useEffect(() => {
-    if (!autoFocus || !ref.current) return
-
-    const attemptFocus = (attempts = 0): void => {
-      if (attempts > 20 || !ref.current) return
-
-      const focusable = ref.current.querySelector<HTMLElement>(
-        'button:not([disabled]), [tabindex]:not([tabindex="-1"])'
-      )
-
-      if (focusable) {
-        focusable.focus()
-      } else {
-        requestAnimationFrame(() => attemptFocus(attempts + 1))
-      }
-    }
-
-    requestAnimationFrame(() => attemptFocus())
-  }, [autoFocus])
-
-  return ref
-}

package/src/core/hooks/useAwaitRender.tsx

@@ -1,12 +0,0 @@
-import { useEffect, useState } from 'react'
-
-export const useAwaitRender = () => {
-  const [initialRenderComplete, setInitialRenderComplete] =
-    useState<boolean>(false)
-
-  useEffect(() => {
-    setInitialRenderComplete(true)
-  }, [])
-
-  if (!initialRenderComplete) return null
-}

package/src/core/hooks/useCloseFilterSection.tsx

@@ -1,29 +0,0 @@
-import { useEffect, useRef } from 'react'
-
-type Props = {
-  handleSelectedFilter: (arg: boolean) => void
-}
-
-// TODO - Refactor and rename this hook
-export const useCloseFilterSection = ({ handleSelectedFilter }: Props) => {
-  const filterSectionRef = useRef<HTMLDivElement | null>(null)
-
-  useEffect(() => {
-    const handleClickOutside = (event: MouseEvent) => {
-      if (
-        filterSectionRef.current &&
-        !filterSectionRef.current.contains(event.target as Node)
-      ) {
-        handleSelectedFilter(false)
-      }
-    }
-
-    document.addEventListener('mousedown', handleClickOutside)
-
-    return () => {
-      document.removeEventListener('mousedown', handleClickOutside)
-    }
-  }, [filterSectionRef])
-
-  return { filterSectionRef }
-}

package/src/core/hooks/useUpdateTranslations.tsx

@@ -1,14 +0,0 @@
-import { useEffect, useState } from 'react'
-import i18n from '../../i18n'
-
-type Props = { language?: string }
-
-export const useUpdateTranslations = ({ language }: Props) => {
-  const [rerenderKey, setRerenderKey] = useState(0)
-
-  useEffect(() => {
-    i18n.changeLanguage(language)
-
-    setRerenderKey((prevKey) => prevKey + 1)
-  }, [language])
-}

package/src/i18n.ts

@@ -1,27 +0,0 @@
-import i18n from 'i18next'
-import { initReactI18next } from 'react-i18next'
-
-import enFilterBar from './locales/en/filterBar.json'
-import enCommon from './locales/en/common.json'
-import fiFilterBar from './locales/fi/filterBar.json'
-import fiCommon from './locales/fi/common.json'
-
-const urlParams =
-  typeof window !== 'undefined'
-    ? new URLSearchParams(window.location.search)
-    : null
-const localeFromUrl = urlParams?.get('locale') || 'fi'
-
-i18n.use(initReactI18next).init({
-  resources: {
-    en: { filterBar: enFilterBar, common: enCommon },
-    fi: { filterBar: fiFilterBar, common: fiCommon },
-  },
-  lng: localeFromUrl,
-  fallbackLng: 'fi',
-  interpolation: {
-    escapeValue: false,
-  },
-})
-
-export default i18n