📈 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!
TypeScript chartsclickhousedockergdprgoogle-analyticsmetricsmonitoringmysqlnestjsprivacyredisself-hostedselfhostedstatisticstailwindcssweb-analyticswebanalyticswebsite
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