Skip to content

📈 Open source, privacy-first web analytics — a cookie-less Google Analytics alternative with built-in error tracking and performance monitoring. Self-host it or use our cloud. Get started for free!

57.8 KB
Raw Blame
import { useQueryClient } from '@tanstack/react-query'
import cx from 'clsx'
import dayjs from 'dayjs'
import _filter from 'lodash/filter'
import _find from 'lodash/find'
import _includes from 'lodash/includes'
import _replace from 'lodash/replace'
import {
  MoonIcon,
  SunIcon,
  WarningIcon,
  GaugeIcon,
  ChartBarIcon,
  FunnelIcon,
  GearIcon,
  KeyboardIcon,
  TargetIcon,
  ShieldCheckIcon,
  SparkleIcon,
  FlaskIcon,
  IdentificationCardIcon,
  PathIcon,
  UserListIcon,
  MonitorPlayIcon,
  ToggleRightIcon,
  MagnifyingGlassIcon,
} from '@phosphor-icons/react'
import React, {
  useState,
  useEffect,
  useMemo,
  useRef,
  useCallback,
  createContext,
  useContext,
  lazy,
  Suspense,
} from 'react'
import { useHotkeys } from 'react-hotkeys-hook'
import { useTranslation } from 'react-i18next'
import {
  useNavigate,
  useSearchParams,
  LinkProps,
  useFetcher,
} from 'react-router'
import { ClientOnly } from 'remix-utils/client-only'
import { toast } from 'sonner'

import Footer from '~/components/Footer'
import Header from '~/components/Header'
import { useProjectFeatureAccess } from '~/hooks/useProjectFeatureAccess'
import useSize from '~/hooks/useSize'
import { changeLanguage } from '~/i18n'
import {
  tbPeriodPairs,
  DEFAULT_TIMEZONE,
  timeBucketToDays,
  PROJECT_TABS,
  TimeFormat,
  chartTypes,
  isSelfhosted,
  tbPeriodPairsCompare,
  LS_IS_ACTIVE_COMPARE_KEY,
  TITLE_SUFFIX,
  TBPeriodPairsProps,
  type Period,
  type TimeBucket,
  VALID_PERIODS,
  VALID_TIME_BUCKETS,
  whitelist,
  languages,
  languageFlag,
} from '~/lib/constants'
import ViewProjectHotkeys from '~/modals/ViewProjectHotkeys'
import { useAuth } from '~/providers/AuthProvider'
import { useTheme } from '~/providers/ThemeProvider'
import { ProjectViewActionData } from '~/routes/projects.$id'
import Button from '~/ui/Button'
import Dropdown from '~/ui/Dropdown'
import Flag from '~/ui/Flag'
import Loader from '~/ui/Loader'
import { getItem, setItem } from '~/utils/localstorage'

import {
  useCurrentProject,
  useProjectPassword,
} from '../../../providers/CurrentProjectProvider'
import AddAViewModal from './components/AddAViewModal'
import { ChartManagerProvider } from './components/ChartManager'
import LockedDashboard from './components/LockedDashboard'
import PasswordRequiredModal from './components/PasswordRequiredModal'
import PlanFeatureLocked from './components/PlanFeatureLocked'
import ProjectSidebar, {
  MobileSidebarTrigger,
} from './components/ProjectSidebar'
import SearchFilters from './components/SearchFilters'
import { ProjectView, ProjectViewCustomEvent } from './interfaces/traffic'
import { V2Filter } from '~/api/v2/types'
import { parseFiltersFromUrl } from '~/utils/analyticsUrl'
import {
  getProjectViewCreateType,
  getProjectViewFilterOptions,
} from './utils/projectViewSegments'
import {
  getFormatDate,
  typeNameMapping,
  SHORTCUTS_TABS_LISTENERS,
  SHORTCUTS_TABS_MAP,
  SHORTCUTS_GENERAL_LISTENERS,
  SHORTCUTS_TIMEBUCKETS_LISTENERS,
} from './ViewProject.helpers'

const AskAIView = lazy(() => import('../tabs/AskAI'))
const CaptchaView = lazy(() => import('../tabs/Captcha/CaptchaView'))
const ErrorsView = lazy(() => import('../tabs/Errors/ErrorsView'))
const ExperimentsView = lazy(
  () => import('../tabs/Experiments/ExperimentsView'),
)
const FeatureFlagsView = lazy(
  () => import('../tabs/FeatureFlags/FeatureFlagsView'),
)
const FunnelsView = lazy(() => import('../tabs/Funnels/FunnelsView'))
const GoalsView = lazy(() => import('../tabs/Goals/GoalsView'))
const JourneysView = lazy(() => import('../tabs/Journeys/JourneysView'))
const PerformanceView = lazy(
  () => import('../tabs/Performance/PerformanceView'),
)
const ProfilesView = lazy(() => import('../tabs/Profiles/ProfilesView'))
const ReplaysView = lazy(() => import('../tabs/Replays/ReplaysView'))
const SessionsView = lazy(() => import('../tabs/Sessions/SessionsView'))
const SEOView = lazy(() => import('../tabs/SEO/SEOView'))
const TrafficView = lazy(() => import('../tabs/Traffic/TrafficView'))

interface ViewProjectContextType {
  timezone: string
  dateRange: Date[] | null
  isLoading: boolean
  timeBucket: string
  period: string
  activePeriod: TBPeriodPairsProps | undefined
  periodPairs: TBPeriodPairsProps[]
  timeFormat: '12-hour' | '24-hour'
  size: ReturnType<typeof useSize>[1]
  dataLoading: boolean
  activeTab: keyof typeof PROJECT_TABS
  filters: V2Filter[]
  isActiveCompare: boolean

  dateRangeCompare: Date[] | null
  activePeriodCompare: string
  setIsActiveCompare: (value: boolean) => void
  setDateRangeCompare: (value: Date[] | null) => void
  setActivePeriodCompare: (value: string) => void
  compareDisable: () => void
  maxRangeCompare: number
  periodPairsCompare: { label: string; period: string }[]
  setPeriodPairsCompare: (value: { label: string; period: string }[]) => void

  chartType: keyof typeof chartTypes
  setChartTypeOnClick: (type: keyof typeof chartTypes) => void
  rotateXAxis: boolean

  onMainChartZoom: (domain: [Date, Date] | null) => void
  shouldEnableZoom: boolean

  getFilterLink: (dimension: string, value: string | null) => LinkProps['to']
  getVersionFilterLink: (
    parent: string | null,
    version: string | null,
    panelType: 'browser' | 'os',
  ) => string

  updatePeriod: (newPeriod: { period: Period; label?: string }) => void
  updateTimebucket: (newTimebucket: TimeBucket) => void
  setShowFiltersSearch: (value: boolean) => void
  resetDateRange: () => void
  refreshStats: (isManual?: boolean) => Promise<void>

  refCalendar: React.RefObject<any>
  refCalendarCompare: React.RefObject<any>

  fullscreenMapRef: React.RefObject<HTMLDivElement | null>
  isMapFullscreen: boolean
  setIsMapFullscreen: (value: boolean) => void
}

interface ProjectViewsContextType {
  projectViews: ProjectView[]
  projectViewsLoading: boolean | null
  loadProjectViews: (forced?: boolean) => void
  setProjectViewToUpdate: (view: ProjectView | undefined) => void
  setIsAddAViewOpened: (value: boolean) => void
}

interface RefreshTriggersContextType {
  goalsRefreshTrigger: number
  experimentsRefreshTrigger: number
  featureFlagsRefreshTrigger: number
  journeysRefreshTrigger: number
  replaysRefreshTrigger: number
}

const defaultViewProjectContext: ViewProjectContextType = {
  timezone: DEFAULT_TIMEZONE,
  dateRange: null,
  isLoading: false,
  timeBucket: '',
  period: '7d',
  activePeriod: undefined,
  periodPairs: [],
  timeFormat: TimeFormat['12-hour'],
  size: { width: 0, height: 0 } as any,
  dataLoading: false,
  activeTab: PROJECT_TABS.traffic,
  filters: [],
  isActiveCompare: false,

  dateRangeCompare: null,
  activePeriodCompare: '',
  setIsActiveCompare: () => {},
  setDateRangeCompare: () => {},
  setActivePeriodCompare: () => {},
  compareDisable: () => {},
  maxRangeCompare: 0,
  periodPairsCompare: [],
  setPeriodPairsCompare: () => {},

  chartType: chartTypes.line,
  setChartTypeOnClick: () => {},
  rotateXAxis: false,

  onMainChartZoom: () => {},
  shouldEnableZoom: true,

  getFilterLink: () => ({ search: '' }) as LinkProps['to'],
  getVersionFilterLink: () => '',

  updatePeriod: () => {},
  updateTimebucket: (_newTimebucket) => {},
  setShowFiltersSearch: () => {},
  resetDateRange: () => {},
  refreshStats: async () => {},

  refCalendar: { current: null } as any,
  refCalendarCompare: { current: null } as any,

  fullscreenMapRef: { current: null } as any,
  isMapFullscreen: false,
  setIsMapFullscreen: () => {},
}

const defaultProjectViewsContext: ProjectViewsContextType = {
  projectViews: [],
  projectViewsLoading: null,
  loadProjectViews: () => {},
  setProjectViewToUpdate: () => {},
  setIsAddAViewOpened: () => {},
}

const defaultRefreshTriggersContext: RefreshTriggersContextType = {
  goalsRefreshTrigger: 0,
  experimentsRefreshTrigger: 0,
  featureFlagsRefreshTrigger: 0,
  journeysRefreshTrigger: 0,
  replaysRefreshTrigger: 0,
}

const ViewProjectContext = createContext<ViewProjectContextType>(
  defaultViewProjectContext,
)
const ProjectViewsContext = createContext<ProjectViewsContextType>(
  defaultProjectViewsContext,
)
const RefreshTriggersContext = createContext<RefreshTriggersContextType>(
  defaultRefreshTriggersContext,
)

const ProjectViewAuxiliaryProviders = ({
  projectViewsContextValue,
  refreshTriggersValue,
  children,
}: {
  projectViewsContextValue: ProjectViewsContextType
  refreshTriggersValue: RefreshTriggersContextType
  children: React.ReactNode
}) => (
  <ProjectViewsContext.Provider value={projectViewsContextValue}>
    <RefreshTriggersContext.Provider value={refreshTriggersValue}>
      {children}
    </RefreshTriggersContext.Provider>
  </ProjectViewsContext.Provider>
)

export const useViewProjectContext = () => {
  const context = useContext(ViewProjectContext)
  return context
}

export const useProjectViewsContext = () => {
  const context = useContext(ProjectViewsContext)
  return context
}

export const useRefreshTriggers = () => {
  const context = useContext(RefreshTriggersContext)
  return context
}

const ViewProjectContent = () => {
  const {
    id,
    projectSettingsPath,
    project,
    allowedToManage,
    liveVisitors,
    isPasswordRequired,
    isCheckingStoredPassword,
    submitPassword,
  } = useCurrentProject()
  const projectPassword = useProjectPassword(id)
  const experimentsAccess = useProjectFeatureAccess('experiments')
  const featureFlagsAccess = useProjectFeatureAccess('featureFlags')
  const replaysAccess = useProjectFeatureAccess('replays')

  const { theme, setTheme } = useTheme()

  const { user, isLoading: authLoading } = useAuth()

  const { timezone = DEFAULT_TIMEZONE } = user || {}

  const {
    t,
    i18n: { language },
  } = useTranslation('common')

  const dashboardRef = useRef<HTMLDivElement>(null)
  const fullscreenMapRef = useRef<HTMLDivElement>(null)

  const [isMapFullscreen, setIsMapFullscreen] = useState(false)

  useEffect(() => {
    if (!isMapFullscreen) return
    const previousOverflow = document.body.style.overflow
    document.body.style.overflow = 'hidden'
    return () => {
      document.body.style.overflow = previousOverflow
    }
  }, [isMapFullscreen])

  const navigate = useNavigate()
  const queryClient = useQueryClient()

  const [searchParams, setSearchParams] = useSearchParams()

  const isEmbedded = searchParams.get('embedded') === 'true'
  const projectQueryTabs = useMemo(() => {
    const tabs = searchParams.get('tabs')

    if (!tabs) {
      return []
    }

    return tabs.split(',')
  }, [searchParams])

  const [isAddAViewOpened, setIsAddAViewOpened] = useState(false)

  const [dataLoading] = useState(false)
  const [goalsRefreshTrigger, setGoalsRefreshTrigger] = useState(0)
  const [experimentsRefreshTrigger, setExperimentsRefreshTrigger] = useState(0)
  const [featureFlagsRefreshTrigger, setFeatureFlagsRefreshTrigger] =
    useState(0)
  const [journeysRefreshTrigger, setJourneysRefreshTrigger] = useState(0)
  const [replaysRefreshTrigger, setReplaysRefreshTrigger] = useState(0)
  const customMetrics = useMemo<ProjectViewCustomEvent[]>(() => {
    const raw = searchParams.get('metrics')
    if (!raw) return []
    try {
      return JSON.parse(raw)
    } catch {
      return []
    }
  }, [searchParams])
  const filters = useMemo<V2Filter[]>(() => {
    return parseFiltersFromUrl(searchParams)
  }, [searchParams])

  const tnMapping = useMemo(() => typeNameMapping(t), [t])
  const refCalendar = useRef(null)
  const refCalendarCompare = useRef(null)
  const activeTab = useMemo(() => {
    const tab = searchParams.get('tab') as keyof typeof PROJECT_TABS

    if (tab in PROJECT_TABS) {
      return tab
    }

    return PROJECT_TABS.traffic
  }, [searchParams])
  const projectViewFilterOptions = useMemo(
    () => getProjectViewFilterOptions(activeTab),
    [activeTab],
  )
  const projectViewCreateType = useMemo(
    () => getProjectViewCreateType(activeTab),
    [activeTab],
  )

  const period = useMemo<Period>(() => {
    const urlPeriod = searchParams.get('period') as Period

    if (VALID_PERIODS.includes(urlPeriod)) {
      return urlPeriod
    }

    return '7d'
  }, [searchParams])

  // Extract compare params from URL early (needed for state initialization)
  const urlCompareEnabled = searchParams.get('compare') === 'true'
  const urlCompareFrom = searchParams.get('compareFrom')
  const urlCompareTo = searchParams.get('compareTo')

  // Initialize dateRangeCompare from URL params if available
  const [dateRangeCompare, setDateRangeCompare] = useState<null | Date[]>(
    () => {
      if (urlCompareFrom && urlCompareTo) {
        const fromDate = new Date(urlCompareFrom)
        const toDate = new Date(urlCompareTo)
        if (
          !Number.isNaN(fromDate.getTime()) &&
          !Number.isNaN(toDate.getTime())
        ) {
          return [fromDate, toDate]
        }
      }
      return null
    },
  )

  const dateRange = useMemo<Date[] | null>(() => {
    if (period !== 'custom') {
      return null
    }

    const from = searchParams.get('from')
    const to = searchParams.get('to')

    if (from && to) {
      const fromDate = new Date(from)
      const toDate = new Date(to)

      if (fromDate.getDate() && toDate.getDate()) {
        return [fromDate, toDate]
      }
    }

    return null
  }, [period, searchParams])

  const periodPairs = useMemo<TBPeriodPairsProps[]>(() => {
    let tbs = null

    if (dateRange) {
      const days = Math.ceil(
        Math.abs(dateRange[1].getTime() - dateRange[0].getTime()) /
          (1000 * 3600 * 24),
      )

      for (const index in timeBucketToDays) {
        if (timeBucketToDays[index].lt >= days) {
          tbs = timeBucketToDays[index].tb
          break
        }
      }
    }

    return tbPeriodPairs(t, tbs, dateRange, language)
  }, [t, language, dateRange])

  const timeBucket = useMemo<TimeBucket>(() => {
    const currentPeriodPair = _find(periodPairs, (el) => el.period === period)
    let _timeBucket = currentPeriodPair?.tbs?.[0] || 'day'
    const urlTimeBucket = searchParams.get('timeBucket') as TimeBucket

    // Use the time bucket from the URL if it's compatible with the current period
    if (
      VALID_TIME_BUCKETS.includes(urlTimeBucket) &&
      currentPeriodPair?.tbs?.includes(urlTimeBucket)
    ) {
      _timeBucket = urlTimeBucket
    }

    if (dateRange) {
      const days = Math.ceil(
        Math.abs(dateRange[1].getTime() - dateRange[0].getTime()) /
          (1000 * 3600 * 24),
      )

      for (const index in timeBucketToDays) {
        if (timeBucketToDays[index].lt >= days) {
          if (!timeBucketToDays[index].tb?.includes(_timeBucket)) {
            _timeBucket = timeBucketToDays[index].tb[0]
          }

          break
        }
      }
    }

    return _timeBucket
  }, [searchParams, periodPairs, period, dateRange])

  const activePeriod = useMemo(
    () => _find(periodPairs, (p) => p.period === period),
    [period, periodPairs],
  )

  const [isHotkeysHelpOpened, setIsHotkeysHelpOpened] = useState(false)

  // null -> not loaded yet
  const [projectViews, setProjectViews] = useState<ProjectView[]>([])
  const [projectViewsLoading, setProjectViewsLoading] = useState<
    boolean | null
  >(null) //  // null - not loaded, true - loading, false - loaded
  const [projectViewToUpdate, setProjectViewToUpdate] = useState<
    ProjectView | undefined
  >()

  const viewsLoadFetcher = useFetcher<ProjectViewActionData>()

  const loadProjectViews = useCallback(
    (forced?: boolean) => {
      if (!forced && projectViewsLoading !== null) {
        return
      }

      if (viewsLoadFetcher.state !== 'idle') {
        return
      }

      setProjectViewsLoading(true)

      const formData = new FormData()
      formData.append('intent', 'get-project-views')
      if (projectPassword) {
        formData.append('password', projectPassword)
      }

      viewsLoadFetcher.submit(formData, { method: 'POST' })
    },
    [projectViewsLoading, viewsLoadFetcher, projectPassword],
  )

  // Handle views load fetcher response
  useEffect(() => {
    if (viewsLoadFetcher.state === 'idle' && viewsLoadFetcher.data) {
      if (viewsLoadFetcher.data.success && viewsLoadFetcher.data.data) {
        setProjectViews((viewsLoadFetcher.data.data as ProjectView[]) || [])
      } else if (viewsLoadFetcher.data.error) {
        console.error('[ERROR] (loadProjectViews)', viewsLoadFetcher.data.error)
        toast.error(viewsLoadFetcher.data.error)
      }
      setProjectViewsLoading(false)
    }
  }, [viewsLoadFetcher.state, viewsLoadFetcher.data])

  const getVersionFilterLink = useCallback(
    (
      parent: string | null,
      version: string | null,
      panelType: 'browser' | 'os',
    ) => {
      const filterParams = new URLSearchParams(searchParams.toString())

      filterParams.set(panelType, parent ?? 'null')
      filterParams.set(`${panelType}_version`, version ?? 'null')

      return `?${filterParams.toString()}`
    },
    [searchParams],
  )

  const timeFormat = useMemo<'12-hour' | '24-hour'>(
    () => user?.timeFormat || TimeFormat['12-hour'],
    [user],
  )
  const [ref, size] = useSize({ trackHeight: false })
  const rotateXAxis = useMemo(() => size.width > 0 && size.width < 500, [size])
  const [chartType, setChartType] = useState<keyof typeof chartTypes>(
    (getItem('chartType') as keyof typeof chartTypes) || chartTypes.line,
  )

  const [periodPairsCompare, setPeriodPairsCompare] = useState<
    {
      label: string
      period: string
    }[]
  >(tbPeriodPairsCompare(t, undefined, language))

  // Initialize compare state from URL params or localStorage
  const [isActiveCompare, setIsActiveCompare] = useState(
    urlCompareEnabled || getItem(LS_IS_ACTIVE_COMPARE_KEY) === 'true',
  )

  // Determine initial activePeriodCompare based on URL params
  const getInitialActivePeriodCompare = () => {
    if (urlCompareFrom && urlCompareTo) {
      return 'custom'
    }
    if (urlCompareEnabled) {
      return 'previous'
    }
    return 'previous'
  }

  const [activePeriodCompare, setActivePeriodCompare] = useState(
    getInitialActivePeriodCompare(),
  )
  const maxRangeCompare = useMemo(() => {
    if (!isActiveCompare) {
      return 0
    }

    const findActivePeriod = _find(periodPairs, (p) => p.period === period)

    if (findActivePeriod?.period === 'custom' && dateRange) {
      return dayjs.utc(dateRange[1]).diff(dayjs.utc(dateRange[0]), 'day')
    }

    return findActivePeriod?.countDays || 0
  }, [isActiveCompare, period, dateRange, periodPairs])

  // Sync compare state to URL params for SSR data fetching
  useEffect(() => {
    const newSearchParams = new URLSearchParams(searchParams.toString())
    let shouldUpdate = false

    if (isActiveCompare) {
      // Set compare=true in URL
      if (newSearchParams.get('compare') !== 'true') {
        newSearchParams.set('compare', 'true')
        shouldUpdate = true
      }

      // Calculate compare dates
      let compareFrom: string | null = null
      let compareTo: string | null = null

      if (activePeriodCompare === 'previous') {
        // Calculate previous period dates based on current period
        const currentActivePeriod = _find(
          periodPairs,
          (p) => p.period === period,
        )

        if (period === 'custom' && dateRange) {
          // For custom period, calculate the same duration before the start date
          const from = dayjs.utc(dateRange[0])
          const to = dayjs.utc(dateRange[1])
          const daysDiff = to.diff(from, 'day') + 1

          const prevTo = from.subtract(1, 'day')
          const prevFrom = prevTo.subtract(daysDiff - 1, 'day')

          compareFrom = prevFrom.format('YYYY-MM-DD')
          compareTo = prevTo.format('YYYY-MM-DD')
        } else if (currentActivePeriod?.countDays) {
          // For preset periods, use countDays to calculate previous period
          const now = dayjs.utc()
          const periodDays = currentActivePeriod.countDays

          // Current period: (now - periodDays) to now
          // Previous period: (now - 2*periodDays) to (now - periodDays - 1)
          const prevTo = now.subtract(periodDays, 'day').subtract(1, 'day')
          const prevFrom = prevTo.subtract(periodDays - 1, 'day')

          compareFrom = prevFrom.format('YYYY-MM-DD')
          compareTo = prevTo.format('YYYY-MM-DD')
        }
      } else if (activePeriodCompare === 'custom' && dateRangeCompare) {
        // Use custom compare date range
        compareFrom = dayjs.utc(dateRangeCompare[0]).format('YYYY-MM-DD')
        compareTo = dayjs.utc(dateRangeCompare[1]).format('YYYY-MM-DD')
      }

      if (compareFrom && compareTo) {
        if (newSearchParams.get('compareFrom') !== compareFrom) {
          newSearchParams.set('compareFrom', compareFrom)
          shouldUpdate = true
        }
        if (newSearchParams.get('compareTo') !== compareTo) {
          newSearchParams.set('compareTo', compareTo)
          shouldUpdate = true
        }
      }
    } else {
      // Remove compare params from URL when compare is disabled
      if (newSearchParams.has('compare')) {
        newSearchParams.delete('compare')
        shouldUpdate = true
      }
      if (newSearchParams.has('compareFrom')) {
        newSearchParams.delete('compareFrom')
        shouldUpdate = true
      }
      if (newSearchParams.has('compareTo')) {
        newSearchParams.delete('compareTo')
        shouldUpdate = true
      }
    }

    if (shouldUpdate) {
      setSearchParams(newSearchParams)
    }
  }, [
    isActiveCompare,
    activePeriodCompare,
    dateRangeCompare,
    period,
    dateRange,
    periodPairs,
    searchParams,
    setSearchParams,
  ])

  // Persist isActiveCompare to localStorage
  useEffect(() => {
    setItem(LS_IS_ACTIVE_COMPARE_KEY, isActiveCompare ? 'true' : 'false')
  }, [isActiveCompare])

  const [showFiltersSearch, setShowFiltersSearch] = useState(false)
  const [isMobileSidebarOpen, setIsMobileSidebarOpen] = useState(false)

  // @ts-expect-error
  const tabs: {
    id: keyof typeof PROJECT_TABS | 'settings'
    label: string
    icon: any
  }[] = useMemo(() => {
    const baseTabs = [
      {
        id: PROJECT_TABS.traffic,
        label: t('dashboard.traffic'),
        icon: ChartBarIcon,
      },
      {
        id: PROJECT_TABS.seo,
        label: t('project.seo.title'),
        icon: MagnifyingGlassIcon,
      },
      {
        id: PROJECT_TABS.performance,
        label: t('dashboard.performance'),
        icon: GaugeIcon,
      },
      {
        id: PROJECT_TABS.profiles,
        label: t('dashboard.profiles'),
        icon: IdentificationCardIcon,
      },
      {
        id: PROJECT_TABS.sessions,
        label: t('dashboard.sessions'),
        icon: UserListIcon,
      },
      {
        id: PROJECT_TABS.replays,
        label: t('dashboard.replays'),
        icon: MonitorPlayIcon,
      },
      {
        id: PROJECT_TABS.errors,
        label: t('dashboard.errors'),
        icon: WarningIcon,
      },
      {
        id: PROJECT_TABS.journeys,
        label: t('dashboard.journeys'),
        icon: PathIcon,
      },
      {
        id: PROJECT_TABS.funnels,
        label: t('dashboard.funnels'),
        icon: FunnelIcon,
      },
      {
        id: PROJECT_TABS.goals,
        label: t('dashboard.goals'),
        icon: TargetIcon,
      },
      {
        id: PROJECT_TABS.featureFlags,
        label: t('dashboard.featureFlags'),
        icon: ToggleRightIcon,
      },
      {
        id: PROJECT_TABS.experiments,
        label: t('dashboard.experiments'),
        icon: FlaskIcon,
      },
      {
        id: PROJECT_TABS.captcha,
        label: t('common.captcha'),
        icon: ShieldCheckIcon,
      },
    ]

    const adminTabs = allowedToManage
      ? [
          {
            id: 'settings',
            label: t('common.settings'),
            icon: GearIcon,
          },
        ]
      : []

    const newTabs = (
      isSelfhosted
        ? [...baseTabs, ...adminTabs]
        : [
            ...baseTabs,
            {
              id: PROJECT_TABS.ai,
              label: t('dashboard.askAi'),
              icon: SparkleIcon,
            },
            ...adminTabs,
          ]
    ).filter((x) => !!x)

    if (projectQueryTabs && projectQueryTabs.length) {
      return _filter(newTabs, (tab) => _includes(projectQueryTabs, tab.id))
    }

    return newTabs
  }, [t, projectQueryTabs, allowedToManage])

  const activeTabLabel = useMemo(
    () => _find(tabs, (tab) => tab.id === activeTab)?.label,
    [tabs, activeTab],
  )

  useEffect(() => {
    if (!project || !user?.showLiveVisitorsInTitle) {
      return
    }

    const title = `${activeTabLabel || t('dashboard.traffic')} > ${project.name}`
    document.title = `👀 ${liveVisitors} - ${title} ${TITLE_SUFFIX}`
  }, [project, user?.showLiveVisitorsInTitle, liveVisitors, activeTabLabel, t])

  const compareDisable = useCallback(() => {
    setIsActiveCompare(false)
    setDateRangeCompare(null)
    setActivePeriodCompare(periodPairsCompare[0].period)
  }, [periodPairsCompare])

  const onRemoveCustomMetric = useCallback(
    (metricId: ProjectViewCustomEvent['id']) => {
      if (activeTab !== PROJECT_TABS.traffic) {
        return
      }

      const newMetrics = _filter(
        customMetrics,
        (metric) => metric.id !== metricId,
      )

      setSearchParams((prev) => {
        const next = new URLSearchParams(prev)
        if (newMetrics.length > 0) {
          next.set('metrics', JSON.stringify(newMetrics))
        } else {
          next.delete('metrics')
        }
        return next
      })
    },
    [activeTab, customMetrics, setSearchParams],
  )

  const resetCustomMetrics = useCallback(() => {
    if (activeTab !== PROJECT_TABS.traffic) {
      return
    }

    setSearchParams((prev) => {
      const next = new URLSearchParams(prev)
      next.delete('metrics')
      return next
    })
  }, [activeTab, setSearchParams])

  const setDashboardTab = useCallback(
    (key: keyof typeof PROJECT_TABS) => {
      if (dataLoading) {
        return
      }

      setIsMapFullscreen(false)

      const newSearchParams = new URLSearchParams(searchParams.toString())
      newSearchParams.set('tab', key)
      setSearchParams(newSearchParams)
    },
    [dataLoading, searchParams, setSearchParams],
  )

  const V2_TABS = useMemo(
    () =>
      new Set<keyof typeof PROJECT_TABS>([
        PROJECT_TABS.traffic,
        PROJECT_TABS.performance,
        PROJECT_TABS.sessions,
        PROJECT_TABS.errors,
        PROJECT_TABS.funnels,
        PROJECT_TABS.profiles,
        PROJECT_TABS.captcha,
        PROJECT_TABS.seo,
      ]),
    [],
  )

  const refreshStats = useCallback(
    async (_isManual = true) => {
      if (authLoading || dataLoading) {
        return
      }

      if (V2_TABS.has(activeTab)) {
        await queryClient.invalidateQueries({ queryKey: ['v2', id] })
        return
      }

      if (activeTab === PROJECT_TABS.journeys) {
        setJourneysRefreshTrigger((prev) => prev + 1)
        return
      }

      if (activeTab === PROJECT_TABS.goals) {
        setGoalsRefreshTrigger((prev) => prev + 1)
        return
      }

      if (activeTab === PROJECT_TABS.experiments) {
        setExperimentsRefreshTrigger((prev) => prev + 1)
        return
      }

      if (activeTab === PROJECT_TABS.featureFlags) {
        setFeatureFlagsRefreshTrigger((prev) => prev + 1)
        return
      }

      if (activeTab === PROJECT_TABS.replays) {
        setReplaysRefreshTrigger((prev) => prev + 1)
        return
      }
    },
    [authLoading, dataLoading, activeTab, queryClient, id, V2_TABS],
  )

  useEffect(() => {
    setPeriodPairsCompare(tbPeriodPairsCompare(t, undefined, language))
  }, [t, language])

  // We can assume period provided is never custom, as it's handled separately in the Datepicker callback function
  const updatePeriod = useCallback(
    ({ period: newPeriod }: { period: Period }) => {
      if (period === newPeriod) {
        return
      }

      const newSearchParams = new URLSearchParams(searchParams.toString())
      newSearchParams.delete('from')
      newSearchParams.delete('to')
      newSearchParams.set('period', newPeriod)

      setSearchParams(newSearchParams)
    },
    [period, searchParams, setSearchParams],
  )

  const updateTimebucket = useCallback(
    (newTimebucket: TimeBucket) => {
      if (dataLoading) {
        return
      }

      const newSearchParams = new URLSearchParams(searchParams.toString())
      newSearchParams.set('timeBucket', newTimebucket)
      setSearchParams(newSearchParams)
    },
    [dataLoading, searchParams, setSearchParams],
  )

  const openSettingsHandler = () => {
    navigate(projectSettingsPath)
  }

  const onMainChartZoom = useCallback(
    (domain: [Date, Date] | null) => {
      if (!domain) {
        return
      }

      const [from, to] = domain
      const newSearchParams = new URLSearchParams(searchParams.toString())

      // Format dates based on time bucket precision
      let fromFormatted = from.toISOString().split('T')[0] + 'T00:00:00.000Z'
      let toFormatted = to.toISOString().split('T')[0] + 'T23:59:59.999Z'

      newSearchParams.set('from', fromFormatted)
      newSearchParams.set('to', toFormatted)
      newSearchParams.set('period', 'custom')
      setSearchParams(newSearchParams)
    },
    [searchParams, setSearchParams],
  )

  // Detect touch-capable devices (mobile/tablets) to avoid accidental zoom while scrolling
  const isTouchDevice = useMemo(() => {
    if (typeof window === 'undefined') return false
    const hasTouchEvent = 'ontouchstart' in window
    const hasMaxTouchPoints =
      typeof navigator !== 'undefined' && navigator.maxTouchPoints > 0
    const coarsePointer = window.matchMedia
      ? window.matchMedia('(pointer: coarse)').matches
      : false
    return hasTouchEvent || hasMaxTouchPoints || coarsePointer
  }, [])

  const shouldEnableZoom = useMemo(() => {
    if (isTouchDevice) {
      return false
    }

    if (period !== 'custom' || !dateRange) {
      return true
    }

    // Enable zoom only if the range is more than 1 day
    const daysDiff = Math.ceil(
      (dateRange[1].getTime() - dateRange[0].getTime()) / (1000 * 3600 * 24),
    )
    return daysDiff > 1
  }, [period, dateRange, isTouchDevice])

  const getFilterLink = useCallback(
    (dimension: string, value: string | null): LinkProps['to'] => {
      const urlValue = value ?? 'null'
      const variants = [
        dimension,
        `!${dimension}`,
        `~${dimension}`,
        `^${dimension}`,
      ]
      const isFilterActive = variants.some((key) =>
        searchParams.getAll(key).includes(urlValue),
      )

      const newSearchParams = new URLSearchParams(searchParams.toString())

      if (isFilterActive) {
        for (const key of variants) {
          newSearchParams.delete(key, urlValue)
        }
      } else {
        newSearchParams.append(dimension, urlValue)
      }

      return {
        search: newSearchParams.toString(),
      }
    },
    [searchParams],
  )

  const setChartTypeOnClick = useCallback((type: keyof typeof chartTypes) => {
    setItem('chartType', type)
    setChartType(type)
  }, [])

  const resetDateRange = useCallback(() => {
    const newSearchParams = new URLSearchParams(searchParams.toString())
    newSearchParams.delete('from')
    newSearchParams.delete('to')
    setSearchParams(newSearchParams)
  }, [searchParams, setSearchParams])

  /* KEYBOARD SHORTCUTS */
  const generalShortcutsActions = {
    B: () => setChartTypeOnClick(chartTypes.bar),
    '∫': () => setChartTypeOnClick(chartTypes.bar),
    L: () => setChartTypeOnClick(chartTypes.line),
    '¬': () => setChartTypeOnClick(chartTypes.line),
    S: () => setShowFiltersSearch(true),
    ß: () => setShowFiltersSearch(true),
    r: refreshStats,
  }

  const timebucketShortcutsMap = {
    h: '1h',
    t: 'today',
    y: 'yesterday',
    d: '1d',
    w: '7d',
    m: '4w',
    q: '3M',
    l: '12M',
    z: '24M',
    a: 'all',
    u: 'custom',
    c: 'compare',
  }

  // 'Keyboard shortcuts' help modal
  useHotkeys(
    'shift+?',
    () => {
      setIsHotkeysHelpOpened((val) => !val)
    },
    { useKey: true },
  )

  // 'Tabs switching' shortcuts
  useHotkeys(SHORTCUTS_TABS_LISTENERS, ({ key }) => {
    if (key === 'E') {
      openSettingsHandler()
      return
    }

    // @ts-expect-error
    const tab = SHORTCUTS_TABS_MAP[key]

    if (!tab) {
      return
    }

    setDashboardTab(tab)
  })

  // 'General' shortcuts
  useHotkeys(SHORTCUTS_GENERAL_LISTENERS, ({ key }) => {
    // @ts-expect-error
    generalShortcutsActions[key]?.()
  })

  // 'Timebuckets selection' shortcuts
  useHotkeys(SHORTCUTS_TIMEBUCKETS_LISTENERS, ({ key }) => {
    const pairs = tbPeriodPairs(t, undefined, undefined, language)
    const pair = _find(
      pairs,
      ({ period }) =>
        period ===
        timebucketShortcutsMap[key as keyof typeof timebucketShortcutsMap],
    )

    if (!pair) {
      return
    }

    if (pair.isCustomDate) {
      // @ts-expect-error
      refCalendar.current?.openCalendar?.()
      return
    }

    if (pair.period === 'compare') {
      if (isActiveCompare) {
        compareDisable()
      } else {
        setIsActiveCompare(true)
      }

      return
    }

    resetDateRange()

    updatePeriod(pair)
  })

  const openMobileSidebar = useCallback(() => setIsMobileSidebarOpen(true), [])
  const closeMobileSidebar = useCallback(
    () => setIsMobileSidebarOpen(false),
    [],
  )

  const contextValue = useMemo(
    () => ({
      timezone,
      dateRange,
      isLoading: authLoading,
      timeBucket,
      period,
      activePeriod,
      periodPairs,
      timeFormat,
      size,
      dataLoading,
      activeTab,
      filters,

      isActiveCompare,
      dateRangeCompare,
      activePeriodCompare,
      setIsActiveCompare,
      setDateRangeCompare,
      setActivePeriodCompare,
      compareDisable,
      maxRangeCompare,
      periodPairsCompare,
      setPeriodPairsCompare,

      chartType,
      setChartTypeOnClick,
      rotateXAxis,

      onMainChartZoom,
      shouldEnableZoom,

      getFilterLink,
      getVersionFilterLink,

      updatePeriod,
      updateTimebucket,
      setShowFiltersSearch,
      resetDateRange,
      refreshStats,

      refCalendar,
      refCalendarCompare,
      fullscreenMapRef,
      isMapFullscreen,
      setIsMapFullscreen,
    }),
    [
      timezone,
      dateRange,
      authLoading,
      timeBucket,
      period,
      activePeriod,
      periodPairs,
      timeFormat,
      size,
      dataLoading,
      activeTab,
      filters,
      isActiveCompare,
      dateRangeCompare,
      activePeriodCompare,
      setIsActiveCompare,
      setDateRangeCompare,
      setActivePeriodCompare,
      compareDisable,
      maxRangeCompare,
      periodPairsCompare,
      setPeriodPairsCompare,
      chartType,
      setChartTypeOnClick,
      rotateXAxis,
      onMainChartZoom,
      shouldEnableZoom,
      getFilterLink,
      getVersionFilterLink,
      updatePeriod,
      updateTimebucket,
      setShowFiltersSearch,
      resetDateRange,
      refreshStats,
      refCalendar,
      refCalendarCompare,
      fullscreenMapRef,
      isMapFullscreen,
      setIsMapFullscreen,
    ],
  )

  const projectViewsContextValue = useMemo(
    () => ({
      projectViews,
      projectViewsLoading,
      loadProjectViews,
      setProjectViewToUpdate,
      setIsAddAViewOpened,
    }),
    [projectViews, projectViewsLoading, loadProjectViews],
  )

  const refreshTriggersValue = useMemo(
    () => ({
      goalsRefreshTrigger,
      experimentsRefreshTrigger,
      featureFlagsRefreshTrigger,
      journeysRefreshTrigger,
      replaysRefreshTrigger,
    }),
    [
      goalsRefreshTrigger,
      experimentsRefreshTrigger,
      featureFlagsRefreshTrigger,
      journeysRefreshTrigger,
      replaysRefreshTrigger,
    ],
  )

  if (isPasswordRequired) {
    return (
      <>
        {!isEmbedded ? <Header /> : null}
        <div className='flex min-h-screen flex-col bg-gray-50 dark:bg-slate-950'>
          <div className='mx-auto w-full max-w-7xl flex-1 px-4 py-2 sm:px-6 lg:px-8'>
            <div className='relative flex gap-4'>
              <ProjectSidebar
                tabs={tabs}
                activeTab={activeTab}
                onTabChange={() => {}}
                projectId={id}
                projectName=''
                websiteUrl={null}
                dataLoading={false}
                searchParams={searchParams}
                allowedToManage={false}
                isEmbedded={isEmbedded}
                className='hidden md:flex'
              />

              <div className='flex min-w-0 flex-1 flex-col'>
                {/* Skeleton header */}
                <div className='mb-6 flex items-center justify-between'>
                  <div className='h-8 w-48 animate-pulse rounded bg-gray-200 dark:bg-slate-700' />
                  <div className='flex gap-2'>
                    <div className='h-10 w-24 animate-pulse rounded bg-gray-200 dark:bg-slate-700' />
                    <div className='h-10 w-32 animate-pulse rounded bg-gray-200 dark:bg-slate-700' />
                  </div>
                </div>

                {/* Skeleton metric cards */}
                <div className='mb-6 grid grid-cols-2 gap-4 md:grid-cols-4'>
                  {[...Array(4)].map((_, i) => (
                    <div
                      key={i}
                      className='h-24 animate-pulse rounded-lg bg-gray-200 dark:bg-slate-700'
                    />
                  ))}
                </div>

                {/* Skeleton chart */}
                <div className='mb-6 h-80 animate-pulse rounded-lg bg-gray-200 dark:bg-slate-700' />

                {/* Skeleton panels */}
                <div className='grid grid-cols-1 gap-4 md:grid-cols-2'>
                  {[...Array(4)].map((_, i) => (
                    <div
                      key={i}
                      className='h-48 animate-pulse rounded-lg bg-gray-200 dark:bg-slate-700'
                    />
                  ))}
                </div>
              </div>
            </div>
          </div>

          {!isEmbedded ? <Footer /> : null}
        </div>

        {/* Password Modal - wrapped in ClientOnly to prevent SSR hydration mismatch with HeadlessUI portals */}
        <ClientOnly>
          {() => (
            <PasswordRequiredModal
              isOpen={isPasswordRequired && !isCheckingStoredPassword}
              onSubmit={submitPassword}
            />
          )}
        </ClientOnly>
      </>
    )
  }

  if (authLoading || !project) {
    return (
      <>
        {!isEmbedded ? <Header /> : null}
        <div
          className={cx('flex flex-col bg-gray-50 dark:bg-slate-950', {
            'min-h-including-header': !isEmbedded,
            'min-h-screen': isEmbedded,
          })}
        >
          <Loader />
        </div>
        {!isEmbedded ? <Footer /> : null}
      </>
    )
  }

  if (project.isLocked) {
    return (
      <>
        {!isEmbedded ? <Header /> : null}
        <div
          className={cx(
            'flex min-h-screen flex-col bg-gray-50 dark:bg-slate-950',
            {
              'min-h-including-header': !isEmbedded,
              'min-h-screen': isEmbedded,
            },
          )}
        >
          <div className='mx-auto w-full max-w-7xl flex-1 px-4 py-2 sm:px-6 lg:px-8'>
            <div className='relative flex gap-4'>
              {/* Desktop Sidebar */}
              <ProjectSidebar
                tabs={tabs}
                activeTab={activeTab}
                onTabChange={setDashboardTab}
                projectId={id}
                projectName={project.name}
                websiteUrl={project.websiteUrl}
                dataLoading={dataLoading}
                searchParams={searchParams}
                allowedToManage={allowedToManage}
                isEmbedded={isEmbedded}
                className='hidden md:flex'
              />
              {/* Mobile Sidebar */}
              {isMobileSidebarOpen ? (
                <div className='pointer-events-auto'>
                  <ProjectSidebar
                    tabs={tabs}
                    activeTab={activeTab}
                    onTabChange={setDashboardTab}
                    projectId={id}
                    projectName={project.name}
                    websiteUrl={project.websiteUrl}
                    dataLoading={dataLoading}
                    searchParams={searchParams}
                    allowedToManage={allowedToManage}
                    isEmbedded={isEmbedded}
                    isMobileOpen={isMobileSidebarOpen}
                    onMobileClose={closeMobileSidebar}
                  />
                </div>
              ) : null}

              {/* Main Content */}
              <div className='flex min-w-0 flex-1 flex-col'>
                <div className='pointer-events-auto'>
                  <MobileSidebarTrigger
                    onClick={openMobileSidebar}
                    activeTabLabel={activeTabLabel}
                  />
                </div>
                <LockedDashboard />
              </div>
            </div>
          </div>

          {!isEmbedded ? <Footer /> : null}
        </div>
      </>
    )
  }

  return (
    <ClientOnly>
      {() => (
        <ViewProjectContext.Provider value={contextValue}>
          <ProjectViewAuxiliaryProviders
            projectViewsContextValue={projectViewsContextValue}
            refreshTriggersValue={refreshTriggersValue}
          >
            <>
              <div
                className={cx(
                  'flex min-h-screen flex-col bg-gray-50 dark:bg-slate-950',
                  {
                    'min-h-including-header': !isEmbedded,
                    'min-h-screen': isEmbedded,
                  },
                )}
              >
                {!isEmbedded && !isMapFullscreen ? <Header /> : null}

                <div className='grid flex-1 grid-cols-1'>
                  <div
                    ref={fullscreenMapRef}
                    className='z-0 col-start-1 row-start-1 min-h-full w-full empty:hidden'
                  />

                  <div
                    className={cx(
                      'z-10 col-start-1 row-start-1 mx-auto w-full max-w-7xl px-4 py-2 sm:px-6 lg:px-8',
                      isMapFullscreen
                        ? 'pointer-events-none'
                        : 'pointer-events-auto',
                    )}
                  >
                    <div ref={ref} className='relative flex gap-4'>
                      {!isMapFullscreen ? (
                        <ProjectSidebar
                          tabs={tabs}
                          activeTab={activeTab}
                          onTabChange={setDashboardTab}
                          projectId={id}
                          projectName={project.name}
                          websiteUrl={project.websiteUrl}
                          dataLoading={dataLoading}
                          searchParams={searchParams}
                          allowedToManage={allowedToManage}
                          isEmbedded={isEmbedded}
                          className='pointer-events-auto z-20 hidden md:flex'
                        />
                      ) : null}
                      {isMobileSidebarOpen && !isMapFullscreen ? (
                        <div className='pointer-events-auto'>
                          <ProjectSidebar
                            tabs={tabs}
                            activeTab={activeTab}
                            onTabChange={setDashboardTab}
                            projectId={id}
                            projectName={project.name}
                            websiteUrl={project.websiteUrl}
                            dataLoading={dataLoading}
                            searchParams={searchParams}
                            allowedToManage={allowedToManage}
                            isEmbedded={isEmbedded}
                            isMobileOpen={isMobileSidebarOpen}
                            onMobileClose={closeMobileSidebar}
                          />
                        </div>
                      ) : null}
                      {/* Main Content */}
                      <div
                        className={cx(
                          'pointer-events-auto flex min-w-0 flex-1 flex-col',
                          isMapFullscreen
                            ? 'pointer-events-none'
                            : 'pointer-events-auto',
                        )}
                        ref={dashboardRef}
                      >
                        {!isMapFullscreen ? (
                          <div className='pointer-events-auto'>
                            <MobileSidebarTrigger
                              onClick={openMobileSidebar}
                              activeTabLabel={activeTabLabel}
                            />
                          </div>
                        ) : null}
                        <div key={activeTab}>
                          {/* Reserve roughly a screenful while the tab chunk
                                downloads, otherwise the page is briefly short
                                enough to pull the footer into view and then
                                jumps once the tab renders. */}
                          <Suspense
                            fallback={
                              <Loader className='min-h-including-header items-start' />
                            }
                          >
                            {activeTab === PROJECT_TABS.ai ? (
                              <AskAIView projectId={id} />
                            ) : null}
                            {activeTab === PROJECT_TABS.traffic ? (
                              <TrafficView
                                tnMapping={tnMapping}
                                customMetrics={customMetrics}
                                onRemoveCustomMetric={onRemoveCustomMetric}
                                resetCustomMetrics={resetCustomMetrics}
                              />
                            ) : null}
                            {activeTab === PROJECT_TABS.performance ? (
                              <PerformanceView tnMapping={tnMapping} />
                            ) : null}
                            {activeTab === PROJECT_TABS.seo ? (
                              <SEOView projectId={id} tnMapping={tnMapping} />
                            ) : null}
                            {activeTab === PROJECT_TABS.funnels ? (
                              <FunnelsView tnMapping={tnMapping} />
                            ) : null}
                            {activeTab === PROJECT_TABS.journeys ? (
                              <JourneysView tnMapping={tnMapping} />
                            ) : null}
                            {activeTab === PROJECT_TABS.profiles ? (
                              <ProfilesView tnMapping={tnMapping} />
                            ) : null}
                            {activeTab === PROJECT_TABS.sessions ? (
                              <SessionsView
                                tnMapping={tnMapping}
                                rotateXAxis={rotateXAxis}
                              />
                            ) : null}
                            {activeTab === PROJECT_TABS.replays ? (
                              replaysAccess.hasAccess ? (
                                <ReplaysView tnMapping={tnMapping} />
                              ) : (
                                <PlanFeatureLocked feature='replays' />
                              )
                            ) : null}
                            {activeTab === PROJECT_TABS.errors ? (
                              <ErrorsView />
                            ) : null}
                            {activeTab === PROJECT_TABS.goals ? (
                              <GoalsView
                                tnMapping={tnMapping}
                                period={period}
                                from={
                                  dateRange ? getFormatDate(dateRange[0]) : ''
                                }
                                to={
                                  dateRange ? getFormatDate(dateRange[1]) : ''
                                }
                                timezone={timezone}
                              />
                            ) : null}
                            {activeTab === PROJECT_TABS.experiments ? (
                              experimentsAccess.hasAccess ? (
                                <ExperimentsView
                                  period={period}
                                  from={
                                    dateRange ? getFormatDate(dateRange[0]) : ''
                                  }
                                  to={
                                    dateRange ? getFormatDate(dateRange[1]) : ''
                                  }
                                  timezone={timezone}
                                />
                              ) : (
                                <PlanFeatureLocked feature='experiments' />
                              )
                            ) : null}
                            {activeTab === PROJECT_TABS.featureFlags ? (
                              featureFlagsAccess.hasAccess ? (
                                <FeatureFlagsView
                                  period={period}
                                  from={
                                    dateRange ? getFormatDate(dateRange[0]) : ''
                                  }
                                  to={
                                    dateRange ? getFormatDate(dateRange[1]) : ''
                                  }
                                  timezone={timezone}
                                />
                              ) : (
                                <PlanFeatureLocked feature='featureFlags' />
                              )
                            ) : null}
                            {activeTab === PROJECT_TABS.captcha ? (
                              <CaptchaView projectId={id} />
                            ) : null}
                          </Suspense>
                        </div>

                        {isEmbedded || isMapFullscreen ? null : (
                          <>
                            <div className='flex-1' />
                            <div className='pointer-events-auto mt-4 flex w-full items-center justify-between gap-2'>
                              <Dropdown
                                items={whitelist}
                                buttonClassName='relative rounded-md border border-transparent bg-gray-50 p-2 hover:border-gray-300 hover:bg-white focus:z-10 focus:ring-1 focus:ring-slate-900 focus:outline-hidden ring-inset dark:bg-slate-950 hover:dark:border-slate-700/80 dark:hover:bg-slate-900 dark:focus:ring-slate-300 inline-flex items-center [&>svg]:w-4 [&>svg]:h-4 [&>svg]:mr-0 [&>svg]:ml-1 font-medium !text-sm text-slate-900 dark:text-gray-50'
                                title={
                                  <span className='inline-flex items-center'>
                                    <Flag
                                      className='mr-2 rounded-xs'
                                      country={languageFlag[language]}
                                      size={16}
                                      alt={languages[language]}
                                    />
                                    {languages[language]}
                                  </span>
                                }
                                labelExtractor={(lng: string) => (
                                  <div className='flex items-center'>
                                    <Flag
                                      className='mr-2 rounded-xs'
                                      country={languageFlag[lng]}
                                      size={16}
                                      alt={languageFlag[lng]}
                                    />
                                    {languages[lng]}
                                  </div>
                                )}
                                onSelect={(lng: string) => {
                                  changeLanguage(lng)
                                }}
                                headless
                              />
                              <div className='flex items-center gap-2'>
                                <Button
                                  variant='icon'
                                  onClick={() => setIsHotkeysHelpOpened(true)}
                                  aria-label={t('modals.shortcuts.title')}
                                >
                                  <KeyboardIcon className='size-6 text-slate-700 dark:text-gray-200' />
                                </Button>
                                <Dropdown
                                  title={
                                    <span className='flex items-center justify-center'>
                                      <span className='sr-only'>
                                        {t('header.switchTheme')}
                                      </span>
                                      {theme === 'dark' ? (
                                        <SunIcon
                                          className='h-6 w-6 text-gray-200'
                                          aria-hidden='true'
                                        />
                                      ) : (
                                        <MoonIcon
                                          className='h-6 w-6 text-slate-700'
                                          aria-hidden='true'
                                        />
                                      )}
                                    </span>
                                  }
                                  items={[
                                    {
                                      key: 'light',
                                      label: t('header.light'),
                                      icon: SunIcon,
                                    },
                                    {
                                      key: 'dark',
                                      label: t('header.dark'),
                                      icon: MoonIcon,
                                    },
                                  ]}
                                  keyExtractor={(item) => item.key}
                                  labelExtractor={(item) => (
                                    <div
                                      className={cx(
                                        'flex w-full items-center',
                                        {
                                          'light:text-indigo-600':
                                            item.key === 'light',
                                          'dark:text-indigo-400':
                                            item.key === 'dark',
                                        },
                                      )}
                                    >
                                      <item.icon
                                        className={cx('mr-2 h-5 w-5', {
                                          'dark:text-gray-300':
                                            item.key === 'light',
                                          'light:text-gray-400':
                                            item.key === 'dark',
                                        })}
                                        aria-hidden='true'
                                      />
                                      {item.label}
                                    </div>
                                  )}
                                  onSelect={(item) =>
                                    setTheme(item.key as 'light' | 'dark')
                                  }
                                  className='flex'
                                  chevron={null}
                                  headless
                                  buttonClassName='relative rounded-md border border-transparent bg-gray-50 p-2 md:px-2 hover:border-gray-300 hover:bg-white focus:z-10 focus:ring-1 focus:ring-slate-900 focus:outline-hidden ring-inset dark:bg-slate-950 hover:dark:border-slate-700/80 dark:hover:bg-slate-900 dark:focus:ring-slate-300'
                                  menuItemsClassName='top-5'
                                  selectItemClassName='font-semibold'
                                />
                              </div>
                            </div>
                          </>
                        )}
                      </div>
                    </div>
                  </div>
                </div>

                {isEmbedded || isMapFullscreen ? null : (
                  <Footer showDBIPMessage />
                )}
              </div>
              <ViewProjectHotkeys
                isOpened={isHotkeysHelpOpened}
                onClose={() => setIsHotkeysHelpOpened(false)}
              />
              <SearchFilters
                type={activeTab === PROJECT_TABS.errors ? 'errors' : 'traffic'}
                showModal={showFiltersSearch}
                setShowModal={setShowFiltersSearch}
                tnMapping={tnMapping}
                filters={filters}
                filterOptions={projectViewFilterOptions}
              />
              <AddAViewModal
                showModal={isAddAViewOpened}
                setShowModal={(show) => {
                  setIsAddAViewOpened(show)
                  setProjectViewToUpdate(undefined)
                }}
                onSubmit={() => {
                  setProjectViews([])
                  setProjectViewsLoading(null)
                  setProjectViewToUpdate(undefined)
                }}
                defaultView={projectViewToUpdate}
                tnMapping={tnMapping}
                filterOptions={projectViewFilterOptions}
                filterDataType={
                  activeTab === PROJECT_TABS.errors ? 'errors' : 'traffic'
                }
                supportsCustomMetrics={activeTab === PROJECT_TABS.traffic}
                viewType={projectViewCreateType}
              />
            </>
          </ProjectViewAuxiliaryProviders>
        </ViewProjectContext.Provider>
      )}
    </ClientOnly>
  )
}

const ViewProject = () => {
  return (
    <ChartManagerProvider>
      <ViewProjectContent />
    </ChartManagerProvider>
  )
}

export default ViewProject