OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.
import type { IServiceSession } from '@openpanel/core';
import type { UseInfiniteQueryResult } from '@tanstack/react-query';
import { useNavigate } from '@tanstack/react-router';
import type { Table } from '@tanstack/react-table';
import { getCoreRowModel, useReactTable } from '@tanstack/react-table';
import { useWindowVirtualizer } from '@tanstack/react-virtual';
import type { TRPCInfiniteData } from '@trpc/tanstack-react-query';
import { Loader2Icon, RotateCwIcon, UsersIcon } from 'lucide-react';
import { last } from 'ramda';
import { memo, useCallback, useEffect, useMemo, useRef } from 'react';
import { useInViewport } from 'react-in-viewport';
import { useLocalStorage } from 'usehooks-ts';
import { useColumns } from './columns';
import { EmptyState } from '@/components/empty-state';
import { TableFilterPills } from '@/components/filters/TableFilterPills';
import { FullPageErrorState } from '@/components/full-page-error-state';
import { Skeleton } from '@/components/skeleton';
import { Button } from '@/components/ui/button';
import {
AnimatedSearchInput,
DataTableToolbarContainer,
} from '@/components/ui/data-table/data-table-toolbar';
import { DataTableViewOptions } from '@/components/ui/data-table/data-table-view-options';
import { useAppParams } from '@/hooks/use-app-params';
import { useSearchQueryState } from '@/hooks/use-search-query-state';
import type { RouterInputs, RouterOutputs } from '@/trpc/client';
import { cn } from '@/utils/cn';
// Custom hook for persistent column visibility
const usePersistentColumnVisibility = (columns: any[]) => {
const [savedVisibility, setSavedVisibility] = useLocalStorage<
Record<string, boolean>
>('@op:sessions-table-column-visibility', {});
// Create column visibility from saved state, defaulting to true (visible)
const columnVisibility = useMemo(() => {
return columns.reduce(
(acc, column) => {
const columnId = column.id || column.accessorKey;
if (columnId) {
acc[columnId] = savedVisibility[columnId] ?? true;
}
return acc;
},
{} as Record<string, boolean>
);
}, [columns, savedVisibility]);
const handleColumnVisibilityChange = (updater: any) => {
const newVisibility =
typeof updater === 'function' ? updater(columnVisibility) : updater;
setSavedVisibility(newVisibility);
};
return {
columnVisibility,
setColumnVisibility: handleColumnVisibilityChange,
};
};
interface Props {
query: UseInfiniteQueryResult<
TRPCInfiniteData<
RouterInputs['session']['list'],
RouterOutputs['session']['list']
>,
unknown
>;
}
const LOADING_DATA = [{}, {}, {}, {}, {}, {}, {}, {}, {}] as IServiceSession[];
const ROW_HEIGHT = 40;
interface VirtualizedSessionsTableProps {
table: Table<IServiceSession>;
data: IServiceSession[];
isLoading: boolean;
}
interface VirtualRowProps {
row: any;
virtualRow: any;
headerColumns: any[];
scrollMargin: number;
isLoading: boolean;
headerColumnsHash: string;
onRowClick?: (row: any) => void;
}
const VirtualRow = memo(
function VirtualRow({
row,
virtualRow,
headerColumns,
scrollMargin,
isLoading,
onRowClick,
}: VirtualRowProps) {
return (
<div
className={cn(
'group/row absolute top-0 left-0 w-full border-b transition-colors hover:bg-muted/50',
onRowClick && 'cursor-pointer'
)}
data-index={virtualRow.index}
onClick={
onRowClick
? (e) => {
if ((e.target as HTMLElement).closest('a, button')) {
return;
}
onRowClick(row);
}
: undefined
}
ref={virtualRow.measureElement}
style={{
transform: `translateY(${virtualRow.start - scrollMargin}px)`,
display: 'grid',
gridTemplateColumns: headerColumns
.map((col) => `${col.getSize()}px`)
.join(' '),
minWidth: 'fit-content',
minHeight: ROW_HEIGHT,
}}
>
{row.getVisibleCells().map((cell: any) => {
const width = `${cell.column.getSize()}px`;
return (
<div
className="flex items-center whitespace-nowrap p-2 px-4 align-middle"
key={cell.id}
style={{
width,
overflow: 'hidden',
}}
>
{isLoading ? (
<Skeleton className="h-4 w-3/5" />
) : cell.column.columnDef.cell ? (
typeof cell.column.columnDef.cell === 'function' ? (
cell.column.columnDef.cell(cell.getContext())
) : (
cell.column.columnDef.cell
)
) : (
(cell.getValue() as React.ReactNode)
)}
</div>
);
})}
</div>
);
},
(prevProps, nextProps) => {
return (
prevProps.row.id === nextProps.row.id &&
prevProps.virtualRow.index === nextProps.virtualRow.index &&
prevProps.virtualRow.start === nextProps.virtualRow.start &&
prevProps.virtualRow.size === nextProps.virtualRow.size &&
prevProps.isLoading === nextProps.isLoading &&
prevProps.headerColumnsHash === nextProps.headerColumnsHash &&
prevProps.onRowClick === nextProps.onRowClick
);
}
);
const VirtualizedSessionsTable = ({
table,
data,
isLoading,
onRowClick,
}: VirtualizedSessionsTableProps & { onRowClick?: (row: any) => void }) => {
const parentRef = useRef<HTMLDivElement>(null);
const headerColumns = table.getAllLeafColumns().filter((col) => {
return table.getState().columnVisibility[col.id] !== false;
});
const rowVirtualizer = useWindowVirtualizer({
count: data.length,
estimateSize: () => ROW_HEIGHT, // Estimated row height
overscan: 10,
scrollMargin: parentRef.current?.offsetTop ?? 0,
// Key cache entries by row id so when filters refetch and the data
// array changes, the virtualizer doesn't reuse stale per-index
// measurements (which produces overlapping rows).
getItemKey: (index) => data[index]?.id ?? index,
});
const virtualRows = rowVirtualizer.getVirtualItems();
const headerColumnsHash = headerColumns.map((col) => col.id).join(',');
return (
<div
className="w-full overflow-x-auto rounded-md border bg-card"
ref={parentRef}
>
<div
className="sticky top-0 z-10 border-b bg-card"
style={{
display: 'grid',
gridTemplateColumns: headerColumns
.map((col) => `${col.getSize()}px`)
.join(' '),
minWidth: 'fit-content',
}}
>
{headerColumns.map((column) => {
const header = column.columnDef.header;
const width = `${column.getSize()}px`;
return (
<div
className="flex h-10 items-center whitespace-nowrap px-4 text-left font-semibold text-3xs text-foreground uppercase"
key={column.id}
style={{
width,
}}
>
{typeof header === 'function' ? header({} as any) : header}
</div>
);
})}
</div>
{!isLoading && data.length === 0 && (
<EmptyState
className="py-16"
description="Nothing matches this date range and filters. Sessions appear as soon as your site or app sends events."
icon={UsersIcon}
title="No sessions"
variant="inline"
/>
)}
<div
className="relative w-full"
style={{
height: `${rowVirtualizer.getTotalSize()}px`,
minHeight: 'fit-content',
minWidth: 'fit-content',
}}
>
{virtualRows.map((virtualRow) => {
const row = table.getRowModel().rows[virtualRow.index];
if (!row) {
return null;
}
return (
<VirtualRow
headerColumns={headerColumns}
headerColumnsHash={headerColumnsHash}
isLoading={isLoading}
key={row.id}
onRowClick={onRowClick}
row={row}
scrollMargin={rowVirtualizer.options.scrollMargin}
virtualRow={{
...virtualRow,
measureElement: rowVirtualizer.measureElement,
}}
/>
);
})}
</div>
</div>
);
};
export const SessionsTable = ({ query }: Props) => {
const { isLoading } = query;
const columns = useColumns();
const navigate = useNavigate();
const { organizationId, projectId } = useAppParams();
const handleRowClick = useCallback(
(row: any) => {
navigate({
to: '/$organizationId/$projectId/sessions/$sessionId',
params: { organizationId, projectId, sessionId: row.original.id },
});
},
[navigate, organizationId, projectId]
);
const data = useMemo(() => {
if (isLoading) {
return LOADING_DATA;
}
return query.data?.pages?.flatMap((p) => p.items) ?? [];
}, [query.data, isLoading]);
const { columnVisibility, setColumnVisibility } =
usePersistentColumnVisibility(columns);
const table = useReactTable({
data,
getCoreRowModel: getCoreRowModel(),
manualPagination: true,
manualFiltering: true,
manualSorting: true,
columns,
rowCount: 50,
pageCount: 1,
filterFns: {
isWithinRange: () => true,
},
state: {
columnVisibility,
},
onColumnVisibilityChange: setColumnVisibility,
getRowId: (row, index) => row.id ?? `loading-${index}`,
});
const inViewportRef = useRef<HTMLDivElement>(null);
const { inViewport, enterCount } = useInViewport(inViewportRef, undefined, {
disconnectOnLeave: true,
});
const hasNextPage = last(query.data?.pages ?? [])?.meta.next;
useEffect(() => {
if (
hasNextPage &&
data.length > 0 &&
inViewport &&
enterCount > 0 &&
query.isFetchingNextPage === false
) {
query.fetchNextPage();
}
}, [inViewport, enterCount, hasNextPage]);
const hasFailedWithoutData = query.isError && !query.data;
if (hasFailedWithoutData) {
return (
<>
<SessionTableToolbar table={table} />
<FullPageErrorState
description="We could not load this data. Try again in a moment."
title="Something went wrong"
variant="inline"
>
<Button
icon={RotateCwIcon}
loading={query.isFetching}
onClick={() => query.refetch()}
variant="outline"
>
Try again
</Button>
</FullPageErrorState>
</>
);
}
return (
<>
<SessionTableToolbar table={table} />
<VirtualizedSessionsTable
data={data}
isLoading={isLoading}
onRowClick={handleRowClick}
table={table}
/>
<div className="center-center h-10 w-full pt-4" ref={inViewportRef}>
<div
className={cn(
'center-center size-8 rounded-full border bg-background opacity-0 transition-opacity',
query.isFetchingNextPage && 'opacity-100'
)}
>
<Loader2Icon className="size-4 animate-spin" />
</div>
</div>
</>
);
};
function SessionTableToolbar({ table }: { table: Table<IServiceSession> }) {
const { search, setSearch } = useSearchQueryState();
return (
<DataTableToolbarContainer>
<div className="flex flex-1 flex-wrap items-center gap-2">
<AnimatedSearchInput
onChange={setSearch}
placeholder="Search sessions by path, referrer..."
value={search}
/>
<TableFilterPills
categories={['profile', 'group', 'cohort', 'session']}
title="Session filters"
urlKey="f"
/>
</div>
<DataTableViewOptions table={table} />
</DataTableToolbarContainer>
);
}