fix(table): keep rows rendered when pageSizes prop changes at runtime

Pagination's mount effect persists the initial page size into Table's
internal pagination state. If a consumer later passes a different
pagination.pageSizes (e.g. derived from the viewport height), the stale
internal pageSize no longer matches any entry: the pageData memo's lookup
loop falls through to return null and the table renders its empty state
("No data found") with data still present, recovering only on remount.

Two-layer fix:
- usePagination: normalize a merged pageSize that is not contained in the
  merged pageSizes to pageSizes[0], keeping the data slice, pager count,
  and currentPage clamp consistent.
- Table pageData memo: replace the terminal return-null fallthrough with a
  defensive slice using the first available size.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: agupta-eightfold

src/components/Table/Hooks/usePagination.ts

@@ -80,6 +80,18 @@ export default function usePagination(
     }
   );
 
+  // Normalize a stale pageSize: Pagination's mount effect persists the initial
+  // size into inner state, so a later pageSizes prop (e.g. derived from the
+  // viewport) may no longer contain it. Without this, the page data slice
+  // finds no matching size and the table renders empty.
+  if (
+    mergedPagination.pageSizes &&
+    mergedPagination.pageSize !== undefined &&
+    !mergedPagination.pageSizes.includes(mergedPagination.pageSize)
+  ) {
+    mergedPagination.pageSize = mergedPagination.pageSizes[0];
+  }
+
   // Reset `current` if data length or pageSize changed
   const pages: number[] = mergedPagination.pageSizes!;
   let maxPage: number;

src/components/Table/Table.tsx

@@ -579,6 +579,16 @@ function InternalTable<RecordType extends object = any>(
           );
         }
       }
+
+      // Defensive fallback: pageSize not found in pageSizes (stale internal
+      // state vs. an updated prop). Slice with the first available size
+      // rather than rendering an empty table.
+      const fallbackPageSize: number = pageSizes[0] ?? DEFAULT_PAGE_SIZE;
+      mergedPagination.pageSize = fallbackPageSize;
+      return mergedData.slice(
+        (currentPage - 1) * fallbackPageSize,
+        currentPage * fallbackPageSize
+      );
     } else {
       if (mergedData.length < total!) {
         if (mergedData.length > pageSize) {

src/components/Table/Tests/Table.pagination.test.js

@@ -1,4 +1,5 @@
 import React from 'react';
+import { act } from 'react-dom/test-utils';
 import Enzyme, { mount } from 'enzyme';
 import Adapter from '@wojtekmaj/enzyme-adapter-react-17';
 import Table from '../index';
@@ -77,6 +78,30 @@ describe('Table.table-pagination', () => {
     expect(renderedNames(wrapper)).toEqual(['Lola']);
   });
 
+  it('keeps rendering rows when a dynamic pageSizes prop changes value', () => {
+    // Consumers may derive pageSizes from the viewport (e.g. rows that fit the
+    // window height). Pagination's mount effect persists the initial size into
+    // Table's internal pagination state; a later pageSizes value must not
+    // orphan that stale pageSize and blank the table.
+    let wrapper;
+    act(() => {
+      wrapper = mount(
+        createTable({
+          dataSource: longData,
+          pagination: { pageSizes: [10] },
+        })
+      );
+    });
+    wrapper.update();
+    expect(renderedNames(wrapper)).toHaveLength(10);
+
+    act(() => {
+      wrapper.setProps({ pagination: { pageSizes: [9] } });
+    });
+    wrapper.update();
+    expect(renderedNames(wrapper)).toHaveLength(9);
+  });
+
   it('should not crash when trigger onChange in render', () => {
     function App() {
       const [page, setPage] = React.useState({