feat: disable table features when infinite scroll is enabled

app/client/src/widgets/TableWidgetV2/component/cellComponents/HeaderCell.tsx

@@ -160,6 +160,7 @@ const HeaderCellComponent = (props: HeaderProps) => {
     canFreezeColumn,
     editMode,
     handleColumnFreeze,
+    isInfiniteScrollEnabled,
     isResizingColumn,
     isSortable,
     multiRowSelection,
@@ -193,7 +194,8 @@ const HeaderCellComponent = (props: HeaderProps) => {
     sortTableColumn(columnIndex, sortOrder);
   };
 
-  const disableSort = editMode === false && isSortable === false;
+  const disableSort =
+    isInfiniteScrollEnabled || (editMode === false && isSortable === false);
 
   const isColumnEditable =
     props.column.columnProperties.isCellEditable &&

app/client/src/widgets/TableWidgetV2/widget/__tests__/propertyUtils.test.ts

@@ -1,3 +1,4 @@
+import { updateAllowAddNewRowOnInfiniteScrollChange } from "../propertyUtils";
 import {
   totalRecordsCountValidation,
   uniqueColumnNameValidation,
@@ -9,6 +10,8 @@ import {
   updateCustomColumnAliasOnLabelChange,
   selectColumnOptionsValidation,
   allowedFirstDayOfWeekRange,
+  updateCellEditabilityOnInfiniteScrollChange,
+  updateSearchSortFilterOnInfiniteScrollChange,
 } from "../propertyUtils";
 import _ from "lodash";
 import type { ColumnTypes, TableWidgetProps } from "../../constants";
@@ -1049,3 +1052,195 @@ describe("allowedFirstDayOfWeekRange", () => {
     });
   });
 });
+
+describe("Infinite Scroll Update Hooks - ", () => {
+  it("updateAllowAddNewRowOnInfiniteScrollChange - should disable/enable add new row when infinite scroll is toggled", () => {
+    const props = {} as TableWidgetProps;
+
+    // When infinite scroll is enabled
+    expect(
+      updateAllowAddNewRowOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        true,
+      ),
+    ).toEqual([
+      {
+        propertyPath: "allowAddNewRow",
+        propertyValue: false,
+      },
+    ]);
+
+    // When infinite scroll is disabled
+    expect(
+      updateAllowAddNewRowOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        false,
+      ),
+    ).toEqual([
+      {
+        propertyPath: "allowAddNewRow",
+        propertyValue: true,
+      },
+    ]);
+
+    // When some other value is passed
+    expect(
+      updateAllowAddNewRowOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        "some-other-value",
+      ),
+    ).toBeUndefined();
+  });
+
+  it("updateSearchSortFilterOnInfiniteScrollChange - should disable/enable search, filter, sort when infinite scroll is toggled", () => {
+    const props = {} as TableWidgetProps;
+
+    // When infinite scroll is enabled
+    expect(
+      updateSearchSortFilterOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        true,
+      ),
+    ).toEqual([
+      {
+        propertyPath: "isVisibleSearch",
+        propertyValue: false,
+      },
+      {
+        propertyPath: "isVisibleFilters",
+        propertyValue: false,
+      },
+      {
+        propertyPath: "isSortable",
+        propertyValue: false,
+      },
+    ]);
+
+    // When infinite scroll is disabled
+    expect(
+      updateSearchSortFilterOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        false,
+      ),
+    ).toEqual([
+      {
+        propertyPath: "isVisibleFilters",
+        propertyValue: true,
+      },
+      {
+        propertyPath: "isVisibleSearch",
+        propertyValue: true,
+      },
+      {
+        propertyPath: "isSortable",
+        propertyValue: true,
+      },
+    ]);
+
+    // When some other value is passed
+    expect(
+      updateSearchSortFilterOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        "some-other-value",
+      ),
+    ).toBeUndefined();
+  });
+
+  it("updateCellEditabilityOnInfiniteScrollChange - should disable cell editability when infinite scroll is enabled", () => {
+    // Setup mock primary columns
+    const props = {
+      primaryColumns: {
+        column1: {
+          id: "column1",
+          alias: "column1",
+          isEditable: true,
+          isCellEditable: true,
+        },
+        column2: {
+          id: "column2",
+          alias: "column2",
+          isEditable: true,
+          isCellEditable: true,
+        },
+      },
+    } as unknown as TableWidgetProps;
+
+    // When infinite scroll is enabled
+    expect(
+      updateCellEditabilityOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        true,
+      ),
+    ).toEqual([
+      {
+        propertyPath: "primaryColumns.column1.isCellEditable",
+        propertyValue: false,
+      },
+      {
+        propertyPath: "primaryColumns.column1.isEditable",
+        propertyValue: false,
+      },
+      {
+        propertyPath: "primaryColumns.column2.isCellEditable",
+        propertyValue: false,
+      },
+      {
+        propertyPath: "primaryColumns.column2.isEditable",
+        propertyValue: false,
+      },
+    ]);
+
+    // When infinite scroll is disabled
+    expect(
+      updateCellEditabilityOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        false,
+      ),
+    ).toEqual([
+      {
+        propertyPath: "primaryColumns.column1.isCellEditable",
+        propertyValue: true,
+      },
+      {
+        propertyPath: "primaryColumns.column1.isEditable",
+        propertyValue: true,
+      },
+      {
+        propertyPath: "primaryColumns.column2.isCellEditable",
+        propertyValue: true,
+      },
+      {
+        propertyPath: "primaryColumns.column2.isEditable",
+        propertyValue: true,
+      },
+    ]);
+
+    // Test with no primary columns
+    const propsWithoutColumns = {} as TableWidgetProps;
+
+    expect(
+      updateCellEditabilityOnInfiniteScrollChange(
+        propsWithoutColumns,
+        "infiniteScrollEnabled",
+        true,
+      ),
+    ).toBeUndefined();
+
+    // When some other value is passed
+    expect(
+      updateCellEditabilityOnInfiniteScrollChange(
+        props,
+        "infiniteScrollEnabled",
+        "some-other-value",
+      ),
+    ).toBeUndefined();
+  });
+});

app/client/src/widgets/TableWidgetV2/widget/propertyConfig/__tests__/contentConfig.test.ts

@@ -0,0 +1,114 @@
+import contentConfig from "../contentConfig";
+import type { TableWidgetProps } from "../../../constants";
+import type { PropertyPaneSectionConfig } from "constants/PropertyControlConstants";
+
+describe("TableWidgetV2 contentConfig tests", () => {
+  it("should disable relevant sections when infinite scroll is enabled", () => {
+    const sectionsToCheck = ["Search & filters", "Sorting", "Adding a row"];
+
+    const disabledHelpText =
+      "This feature is disabled because infinite scroll is enabled";
+
+    sectionsToCheck.forEach((sectionName) => {
+      const section = contentConfig.find(
+        (section) =>
+          (section as PropertyPaneSectionConfig).sectionName === sectionName,
+      ) as PropertyPaneSectionConfig & { dependencies: string[] };
+
+      expect(section).toBeDefined();
+
+      if (section) {
+        expect(typeof section.shouldDisableSection).toBe("function");
+        expect(section.disabledHelpText).toBe(disabledHelpText);
+        expect(section.dependencies).toContain("infiniteScrollEnabled");
+
+        const enabledProps = {
+          infiniteScrollEnabled: true,
+        } as TableWidgetProps;
+        const disabledProps = {
+          infiniteScrollEnabled: false,
+        } as TableWidgetProps;
+
+        expect(section.shouldDisableSection!(enabledProps, "")).toBe(true);
+        expect(section.shouldDisableSection!(disabledProps, "")).toBe(false);
+      }
+    });
+
+    const paginationSection = contentConfig.find(
+      (section) =>
+        (section as PropertyPaneSectionConfig).sectionName === "Pagination",
+    ) as PropertyPaneSectionConfig;
+
+    expect(paginationSection).toBeDefined();
+
+    if (paginationSection && paginationSection.children) {
+      const serverSidePagination = paginationSection.children.find(
+        (child) =>
+          (child as PropertyPaneSectionConfig & { propertyName: string })
+            .propertyName === "serverSidePaginationEnabled",
+      ) as PropertyPaneSectionConfig & {
+        propertyName: string;
+        shouldDisableSection: (
+          props: TableWidgetProps,
+          propertyPath: string,
+        ) => boolean;
+        disabledHelpText: string;
+        dependencies: string[];
+      };
+
+      expect(serverSidePagination).toBeDefined();
+
+      if (serverSidePagination) {
+        expect(typeof serverSidePagination.shouldDisableSection).toBe(
+          "function",
+        );
+        expect(serverSidePagination.disabledHelpText).toBe(disabledHelpText);
+        expect(serverSidePagination.dependencies).toContain(
+          "infiniteScrollEnabled",
+        );
+
+        const enabledProps = {
+          infiniteScrollEnabled: true,
+        } as TableWidgetProps;
+        const disabledProps = {
+          infiniteScrollEnabled: false,
+        } as TableWidgetProps;
+
+        expect(
+          serverSidePagination.shouldDisableSection(enabledProps, ""),
+        ).toBe(true);
+        expect(
+          serverSidePagination.shouldDisableSection(disabledProps, ""),
+        ).toBe(false);
+      }
+    }
+  });
+
+  it("should have proper update hooks for infiniteScrollEnabled property", () => {
+    const paginationSection = contentConfig.find(
+      (section) =>
+        (section as PropertyPaneSectionConfig).sectionName === "Pagination",
+    ) as PropertyPaneSectionConfig;
+
+    expect(paginationSection).toBeDefined();
+
+    if (paginationSection && paginationSection.children) {
+      const infiniteScrollProperty = paginationSection.children.find(
+        (child) =>
+          (child as PropertyPaneSectionConfig & { propertyName: string })
+            .propertyName === "infiniteScrollEnabled",
+      ) as PropertyPaneSectionConfig & {
+        propertyName: string;
+        updateHook: unknown;
+        dependencies: string[];
+      };
+
+      expect(infiniteScrollProperty).toBeDefined();
+
+      if (infiniteScrollProperty) {
+        expect(infiniteScrollProperty.updateHook).toBeDefined();
+        expect(infiniteScrollProperty.dependencies).toContain("primaryColumns");
+      }
+    }
+  });
+});