Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

24.3 KB
Raw Blame
import { ReactNode } from 'react';
import { act, renderHook } from '@testing-library/react';
import {
	NuqsTestingAdapter,
	OnUrlUpdateFunction,
	UrlUpdateEvent,
} from 'nuqs/adapters/testing';

import { useTableParams } from '../useTableParams';
import { usePreferredPageSizeStore } from '../usePreferredPageSize.store';

function createNuqsWrapper(
	queryParams?: Record<string, string>,
	onUrlUpdate?: OnUrlUpdateFunction,
): ({ children }: { children: ReactNode }) => JSX.Element {
	return function NuqsWrapper({
		children,
	}: {
		children: ReactNode;
	}): JSX.Element {
		return (
			<NuqsTestingAdapter
				searchParams={queryParams}
				onUrlUpdate={onUrlUpdate}
				hasMemory
			>
				{children}
			</NuqsTestingAdapter>
		);
	};
}

describe('useTableParams (local mode — enableQueryParams not set)', () => {
	beforeEach(() => {
		jest.useFakeTimers();
	});

	afterEach(() => {
		jest.useRealTimers();
	});

	it('returns default page=1 and limit=50', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(() => useTableParams(), { wrapper });
		expect(result.current.page).toBe(1);
		expect(result.current.limit).toBe(50);
		expect(result.current.orderBy).toBeNull();
	});

	it('respects custom defaults', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(
			() => useTableParams(undefined, { page: 2, limit: 25 }),
			{ wrapper },
		);
		expect(result.current.page).toBe(2);
		expect(result.current.limit).toBe(25);
	});

	it('setPage updates page', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(() => useTableParams(), { wrapper });
		act(() => {
			result.current.setPage(3);
		});
		expect(result.current.page).toBe(3);
	});

	it('setLimit updates limit', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(() => useTableParams(), { wrapper });
		act(() => {
			result.current.setLimit(100);
		});
		expect(result.current.limit).toBe(100);
	});

	it('setOrderBy updates orderBy', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(() => useTableParams(), { wrapper });
		act(() => {
			result.current.setOrderBy({ columnName: 'cpu', order: 'desc' });
		});
		expect(result.current.orderBy).toStrictEqual({
			columnName: 'cpu',
			order: 'desc',
		});
	});
});

describe('useTableParams (URL mode — enableQueryParams set)', () => {
	beforeEach(() => {
		jest.useFakeTimers();
	});

	afterEach(() => {
		jest.useRealTimers();
	});

	it('uses nuqs state when enableQueryParams=true', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(() => useTableParams(true), { wrapper });
		expect(result.current.page).toBe(1);
		act(() => {
			result.current.setPage(5);
			jest.runAllTimers();
		});
		expect(result.current.page).toBe(5);
	});

	it('uses prefixed keys when enableQueryParams is a string', () => {
		const wrapper = createNuqsWrapper({ pods_page: '2' });
		const { result } = renderHook(() => useTableParams('pods', { page: 2 }), {
			wrapper,
		});
		expect(result.current.page).toBe(2);
		act(() => {
			result.current.setPage(4);
			jest.runAllTimers();
		});
		expect(result.current.page).toBe(4);
	});

	it('local state is ignored when enableQueryParams is set', () => {
		const localWrapper = createNuqsWrapper();
		const urlWrapper = createNuqsWrapper();
		const { result: local } = renderHook(() => useTableParams(), {
			wrapper: localWrapper,
		});
		const { result: url } = renderHook(() => useTableParams(true), {
			wrapper: urlWrapper,
		});
		act(() => {
			local.current.setPage(99);
		});
		// URL mode hook in a separate wrapper should still have its own state
		expect(url.current.page).toBe(1);
	});

	it('reads initial page from URL params', () => {
		const wrapper = createNuqsWrapper({ page: '3' });
		// Pass matching default to prevent reset on mount (page resets when orderBy changes)
		const { result } = renderHook(() => useTableParams(true, { page: 3 }), {
			wrapper,
		});
		expect(result.current.page).toBe(3);
	});

	it('reads initial orderBy from URL params', () => {
		const orderBy = JSON.stringify({ columnName: 'name', order: 'desc' });
		const wrapper = createNuqsWrapper({ order_by: orderBy });
		const { result } = renderHook(() => useTableParams(true), { wrapper });
		expect(result.current.orderBy).toStrictEqual({
			columnName: 'name',
			order: 'desc',
		});
	});

	it('updates URL when setPage is called', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(() => useTableParams(true), { wrapper });

		act(() => {
			result.current.setPage(5);
			jest.runAllTimers();
		});

		const lastPage = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('page'))
			.filter(Boolean)
			.pop();
		expect(lastPage).toBe('5');
	});

	it('updates URL when setOrderBy is called', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(() => useTableParams(true), { wrapper });

		act(() => {
			result.current.setOrderBy({ columnName: 'value', order: 'asc' });
			jest.runAllTimers();
		});

		const lastOrderBy = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('order_by'))
			.filter(Boolean)
			.pop();
		expect(lastOrderBy).toBeDefined();
		expect(JSON.parse(lastOrderBy!)).toStrictEqual({
			columnName: 'value',
			order: 'asc',
		});
	});

	it('uses custom param names from config object', () => {
		const config = {
			page: 'listPage',
			limit: 'listLimit',
			orderBy: 'listOrderBy',
			expanded: 'listExpanded',
		};
		const wrapper = createNuqsWrapper({ listPage: '3' });
		const { result } = renderHook(() => useTableParams(config, { page: 3 }), {
			wrapper,
		});
		expect(result.current.page).toBe(3);
	});

	it('manages expanded state for row expansion', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(() => useTableParams(true), { wrapper });

		act(() => {
			result.current.setExpanded({ 'row-1': true });
		});

		expect(result.current.expanded).toStrictEqual({ 'row-1': true });
	});

	it('toggles sort order correctly: null → asc → desc → null', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(() => useTableParams(true), { wrapper });

		// Initial state
		expect(result.current.orderBy).toBeNull();

		// First click: null → asc
		act(() => {
			result.current.setOrderBy({ columnName: 'id', order: 'asc' });
		});
		expect(result.current.orderBy).toStrictEqual({
			columnName: 'id',
			order: 'asc',
		});

		// Second click: asc → desc
		act(() => {
			result.current.setOrderBy({ columnName: 'id', order: 'desc' });
		});
		expect(result.current.orderBy).toStrictEqual({
			columnName: 'id',
			order: 'desc',
		});

		// Third click: desc → null
		act(() => {
			result.current.setOrderBy(null);
		});
		expect(result.current.orderBy).toBeNull();
	});
});

describe('useTableParams (selective URL mode — partial config object)', () => {
	beforeEach(() => {
		jest.useFakeTimers();
	});

	afterEach(() => {
		jest.useRealTimers();
	});

	it('syncs only page to URL when only page is configured', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(() => useTableParams({ page: 'myPage' }), {
			wrapper,
		});

		// Update page - should sync to URL
		act(() => {
			result.current.setPage(5);
			jest.runAllTimers();
		});
		expect(result.current.page).toBe(5);
		const lastPage = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('myPage'))
			.filter(Boolean)
			.pop();
		expect(lastPage).toBe('5');

		// Update limit - should stay local (not in URL)
		act(() => {
			result.current.setLimit(100);
			jest.runAllTimers();
		});
		expect(result.current.limit).toBe(100);
		const limitInUrl = onUrlUpdate.mock.calls.some(
			(call) => call[0].searchParams.get('limit') !== null,
		);
		expect(limitInUrl).toBe(false);

		// Update orderBy - should stay local (not in URL)
		act(() => {
			result.current.setOrderBy({ columnName: 'test', order: 'asc' });
			jest.runAllTimers();
		});
		expect(result.current.orderBy).toStrictEqual({
			columnName: 'test',
			order: 'asc',
		});
		const orderByInUrl = onUrlUpdate.mock.calls.some(
			(call) => call[0].searchParams.get('order_by') !== null,
		);
		expect(orderByInUrl).toBe(false);
	});

	it('syncs only orderBy to URL when only orderBy is configured', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(() => useTableParams({ orderBy: 'mySort' }), {
			wrapper,
		});

		// Update orderBy - should sync to URL
		act(() => {
			result.current.setOrderBy({ columnName: 'cpu', order: 'desc' });
			jest.runAllTimers();
		});
		expect(result.current.orderBy).toStrictEqual({
			columnName: 'cpu',
			order: 'desc',
		});
		const lastOrderBy = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('mySort'))
			.filter(Boolean)
			.pop();
		expect(lastOrderBy).toBeDefined();
		expect(JSON.parse(lastOrderBy!)).toStrictEqual({
			columnName: 'cpu',
			order: 'desc',
		});

		// Update page - should stay local
		act(() => {
			result.current.setPage(3);
			jest.runAllTimers();
		});
		expect(result.current.page).toBe(3);
		const pageInUrl = onUrlUpdate.mock.calls.some(
			(call) => call[0].searchParams.get('page') !== null,
		);
		expect(pageInUrl).toBe(false);
	});

	it('syncs only limit to URL when only limit is configured', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(() => useTableParams({ limit: 'myLimit' }), {
			wrapper,
		});

		// Update limit - should sync to URL
		act(() => {
			result.current.setLimit(25);
			jest.runAllTimers();
		});
		expect(result.current.limit).toBe(25);
		const lastLimit = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('myLimit'))
			.filter(Boolean)
			.pop();
		expect(lastLimit).toBe('25');

		// Update page - should stay local
		act(() => {
			result.current.setPage(2);
			jest.runAllTimers();
		});
		expect(result.current.page).toBe(2);
		const pageInUrl = onUrlUpdate.mock.calls.some(
			(call) => call[0].searchParams.get('page') !== null,
		);
		expect(pageInUrl).toBe(false);
	});

	it('syncs only expanded to URL when only expanded is configured', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(
			() => useTableParams({ expanded: 'myExpanded' }),
			{ wrapper },
		);

		// Update expanded - should sync to URL
		act(() => {
			result.current.setExpanded({ 'row-1': true, 'row-2': true });
			jest.runAllTimers();
		});
		expect(result.current.expanded).toStrictEqual({
			'row-1': true,
			'row-2': true,
		});
		const lastExpanded = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('myExpanded'))
			.filter(Boolean)
			.pop();
		expect(lastExpanded).toBeDefined();
		expect(JSON.parse(lastExpanded!)).toStrictEqual(
			expect.arrayContaining(['row-1', 'row-2']),
		);

		// Update page - should stay local
		act(() => {
			result.current.setPage(4);
			jest.runAllTimers();
		});
		expect(result.current.page).toBe(4);
		const pageInUrl = onUrlUpdate.mock.calls.some(
			(call) => call[0].searchParams.get('page') !== null,
		);
		expect(pageInUrl).toBe(false);
	});

	it('syncs page and orderBy to URL but keeps limit and expanded local', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(
			() => useTableParams({ page: 'p', orderBy: 'sort' }),
			{ wrapper },
		);

		// Update limit and expanded first (should stay local)
		act(() => {
			result.current.setLimit(75);
			result.current.setExpanded({ 'row-5': true });
			jest.runAllTimers();
		});

		expect(result.current.limit).toBe(75);
		expect(result.current.expanded).toStrictEqual({ 'row-5': true });

		// Update page (should sync to URL)
		act(() => {
			result.current.setPage(2);
			jest.runAllTimers();
		});

		expect(result.current.page).toBe(2);
		const lastPage = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('p'))
			.filter(Boolean)
			.pop();
		expect(lastPage).toBe('2');

		// Update orderBy (should sync to URL, and resets page to default)
		act(() => {
			result.current.setOrderBy({ columnName: 'name', order: 'asc' });
			jest.runAllTimers();
		});

		expect(result.current.orderBy).toStrictEqual({
			columnName: 'name',
			order: 'asc',
		});
		const lastOrderBy = onUrlUpdate.mock.calls
			.map((call) => call[0].searchParams.get('sort'))
			.filter(Boolean)
			.pop();
		expect(lastOrderBy).toBeDefined();

		// limit should NOT be in URL
		const limitInUrl = onUrlUpdate.mock.calls.some(
			(call) =>
				call[0].searchParams.get('limit') !== null ||
				call[0].searchParams.get('myLimit') !== null,
		);
		expect(limitInUrl).toBe(false);

		// expanded should NOT be in URL
		const expandedInUrl = onUrlUpdate.mock.calls.some(
			(call) =>
				call[0].searchParams.get('expanded') !== null ||
				call[0].searchParams.get('myExpanded') !== null,
		);
		expect(expandedInUrl).toBe(false);
	});

	it('reads initial values from URL for configured params only', () => {
		const wrapper = createNuqsWrapper({
			customPage: '7',
			limit: '999', // This should be ignored since limit is not configured
		});
		const { result } = renderHook(
			// Pass page default matching URL to prevent reset on mount
			() => useTableParams({ page: 'customPage' }, { page: 7 }),
			{ wrapper },
		);

		// Page should come from URL
		expect(result.current.page).toBe(7);
		// Limit should be default (not from URL since it's not configured)
		expect(result.current.limit).toBe(50);
	});

	it('supports updater function for expanded state', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(() => useTableParams({ expanded: 'exp' }), {
			wrapper,
		});

		// Set initial expanded state
		act(() => {
			result.current.setExpanded({ 'row-1': true });
		});
		expect(result.current.expanded).toStrictEqual({ 'row-1': true });

		// Use updater function to add another row
		act(() => {
			result.current.setExpanded((prev) => ({
				...(typeof prev === 'boolean' ? {} : prev),
				'row-2': true,
			}));
		});
		expect(result.current.expanded).toStrictEqual({
			'row-1': true,
			'row-2': true,
		});
	});

	it('supports updater function for local expanded state', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(() => useTableParams(), { wrapper });

		// Set initial expanded state
		act(() => {
			result.current.setExpanded({ 'row-a': true });
		});
		expect(result.current.expanded).toStrictEqual({ 'row-a': true });

		// Use updater function
		act(() => {
			result.current.setExpanded((prev) => ({
				...(typeof prev === 'boolean' ? {} : prev),
				'row-b': true,
			}));
		});
		expect(result.current.expanded).toStrictEqual({
			'row-a': true,
			'row-b': true,
		});
	});
});

describe('useTableParams (cleanupOnUnmount option)', () => {
	beforeEach(() => {
		jest.useFakeTimers();
		localStorage.clear();
		usePreferredPageSizeStore.setState({ tables: {} });
	});

	afterEach(() => {
		jest.useRealTimers();
	});

	it('clears URL params on unmount when cleanupOnUnmount is true', async () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);

		const { result, unmount } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit', orderBy: 'orderBy' },
					{
						page: 1,
						limit: 10,
						cleanupOnUnmount: true,
					},
				),
			{ wrapper },
		);

		// Set some values
		await act(async () => {
			result.current.setLimit(50);
			result.current.setPage(3);
			jest.runAllTimers();
			await Promise.resolve();
		});

		// Verify values set
		expect(result.current.limit).toBe(50);
		expect(result.current.page).toBe(3);

		// Unmount triggers cleanup
		unmount();

		await act(async () => {
			jest.runAllTimers();
			await Promise.resolve();
		});

		// Last URL update should have cleared params
		const lastUpdate = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1];
		expect(lastUpdate[0].searchParams.get('limit')).toBeNull();
		expect(lastUpdate[0].searchParams.get('page')).toBeNull();
	});

	it('does not clear URL params on unmount when cleanupOnUnmount is false', async () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);

		const { result, unmount } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						cleanupOnUnmount: false,
					},
				),
			{ wrapper },
		);

		await act(async () => {
			result.current.setLimit(50);
			jest.runAllTimers();
			await Promise.resolve();
		});

		expect(result.current.limit).toBe(50);

		unmount();

		await act(async () => {
			jest.runAllTimers();
			await Promise.resolve();
		});

		// No new URL updates after unmount (or same count)
		const lastUpdate = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1];
		expect(lastUpdate[0].searchParams.get('limit')).toBe('50');
	});

	it('defaults cleanupOnUnmount to false', async () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);

		const { result, unmount } = renderHook(
			() =>
				useTableParams({ page: 'page', limit: 'limit' }, { page: 1, limit: 10 }),
			{ wrapper },
		);

		await act(async () => {
			result.current.setLimit(50);
			jest.runAllTimers();
			await Promise.resolve();
		});

		unmount();

		await act(async () => {
			jest.runAllTimers();
			await Promise.resolve();
		});

		// URL should still have limit=50 (cleanup not triggered)
		const lastUpdate = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1];
		expect(lastUpdate[0].searchParams.get('limit')).toBe('50');
	});
});

describe('useTableParams (auto page size with storageKey)', () => {
	beforeEach(() => {
		jest.useFakeTimers();
		localStorage.clear();
		usePreferredPageSizeStore.setState({ tables: {} });
	});

	afterEach(() => {
		jest.useRealTimers();
	});

	it('uses explicit default when no URL, no calculated, no preferred', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: null,
					},
				),
			{ wrapper },
		);

		// Should use explicit default (10), NOT the internal DEFAULT_LIMIT (50)
		expect(result.current.limit).toBe(10);
	});

	it('uses calculatedPageSize when available and no preferred', () => {
		const wrapper = createNuqsWrapper();
		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: 42,
					},
				),
			{ wrapper },
		);

		expect(result.current.limit).toBe(42);
	});

	it('prefers stored value over calculatedPageSize', () => {
		// Pre-populate the store
		localStorage.setItem(
			'@signoz/table-columns/test-table-preferred-page-size',
			'25',
		);

		const wrapper = createNuqsWrapper();
		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: 42,
					},
				),
			{ wrapper },
		);

		// Should use preferred (25), not calculated (42)
		expect(result.current.limit).toBe(25);
	});

	it('preserves URL limit over calculated and preferred', () => {
		localStorage.setItem(
			'@signoz/table-columns/test-table-preferred-page-size',
			'25',
		);

		const wrapper = createNuqsWrapper({ limit: '30' });
		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: 42,
					},
				),
			{ wrapper },
		);

		// Should use URL (30), not preferred (25) or calculated (42)
		expect(result.current.limit).toBe(30);
	});

	it('persists user selection when different from calculated', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({}, onUrlUpdate);
		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: 42,
					},
				),
			{ wrapper },
		);

		// User selects 30 (different from calculated 42)
		act(() => {
			result.current.setLimit(30);
			jest.runAllTimers();
		});

		expect(result.current.limit).toBe(30);
		expect(
			localStorage.getItem('@signoz/table-columns/test-table-preferred-page-size'),
		).toBe('30');
	});

	it('clears preference when user selects calculated value', () => {
		// Pre-set a preference
		localStorage.setItem(
			'@signoz/table-columns/test-table-preferred-page-size',
			'30',
		);
		usePreferredPageSizeStore.setState({ tables: { 'test-table': 30 } });

		const wrapper = createNuqsWrapper();
		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: 42,
					},
				),
			{ wrapper },
		);

		// User selects 42 (same as calculated)
		act(() => {
			result.current.setLimit(42);
			jest.runAllTimers();
		});

		expect(result.current.limit).toBe(42);
		// Preference should be cleared (null removes from storage)
		expect(
			localStorage.getItem('@signoz/table-columns/test-table-preferred-page-size'),
		).toBeNull();
	});

	it('returns calculated value even before URL is synced', () => {
		const wrapper = createNuqsWrapper();

		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: 42,
					},
				),
			{ wrapper },
		);

		// Limit should be 42 (calculated) even if URL sync is async
		expect(result.current.limit).toBe(42);
	});

	it('does not override URL when it already has a value', () => {
		const onUrlUpdate = jest.fn<void, [UrlUpdateEvent]>();
		const wrapper = createNuqsWrapper({ limit: '30' }, onUrlUpdate);

		const { result } = renderHook(
			() =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table',
						calculatedPageSize: 42,
					},
				),
			{ wrapper },
		);

		act(() => {
			jest.runAllTimers();
		});

		// Limit should stay at 30 (from URL), not change to 42
		expect(result.current.limit).toBe(30);
	});

	it('handles calculatedPageSize changing from null to number', () => {
		const wrapper = createNuqsWrapper();

		const { result, rerender } = renderHook(
			({ calculated }) =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table-2',
						calculatedPageSize: calculated,
					},
				),
			{ wrapper, initialProps: { calculated: null as number | null } },
		);

		// Initially should use explicit default (10)
		expect(result.current.limit).toBe(10);

		// When calculated becomes available, should update
		rerender({ calculated: 42 });

		act(() => {
			jest.runAllTimers();
		});

		// Limit should now be 42
		expect(result.current.limit).toBe(42);
	});

	it('keeps user selection when calculatedPageSize changes', () => {
		const wrapper = createNuqsWrapper();

		const { result, rerender } = renderHook(
			({ calculated }) =>
				useTableParams(
					{ page: 'page', limit: 'limit' },
					{
						page: 1,
						limit: 10,
						storageKey: 'test-table-3',
						calculatedPageSize: calculated,
					},
				),
			{ wrapper, initialProps: { calculated: 42 as number | null } },
		);

		expect(result.current.limit).toBe(42);

		// User selects 30
		act(() => {
			result.current.setLimit(30);
			jest.runAllTimers();
		});

		expect(result.current.limit).toBe(30);

		// calculatedPageSize changes (e.g., window resize)
		rerender({ calculated: 50 });

		act(() => {
			jest.runAllTimers();
		});

		// Should keep user's selection (30), not change to new calculated (50)
		expect(result.current.limit).toBe(30);
	});
});