@wavemaker-ai/react-runtime 1.0.0-rc.309

package/components/data/table/hooks/useTableStateManager.js

@@ -0,0 +1,633 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTableStateManager = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = require("react");
+var _tableHelpers = require("../utils/table-helpers");
+var _lodashEs = require("lodash-es");
+var _constants = require("../utils/constants");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var useTableStateManager = exports.useTableStateManager = function useTableStateManager(props) {
+  var name = props.name,
+    storage = props.storage,
+    currentPage = props.currentPage,
+    currentPageSize = props.currentPageSize,
+    selectedRowIds = props.selectedRowIds,
+    internalDataset = props.internalDataset,
+    initialActualPageSize = props.initialActualPageSize,
+    datasource = props.datasource,
+    multiselect = props.multiselect,
+    filterData = props.filterData,
+    sortData = props.sortData,
+    _props$navigation = props.navigation,
+    navigation = _props$navigation === void 0 ? "Pager" : _props$navigation,
+    _props$isStateConfigu = props.isStateConfigured,
+    isStateConfigured = _props$isStateConfigu === void 0 ? false : _props$isStateConfigu,
+    defaultPageSize = props.defaultPageSize,
+    initialSortState = props.initialSortState,
+    initialFilterState = props.initialFilterState;
+
+  // Track previous state to return when loading
+  var prevStateRef = (0, _react.useRef)({});
+
+  // Track if we've already calculated state after loading
+  var hasCalculatedAfterLoadingRef = (0, _react.useRef)(false);
+
+  // Track the previous loading state
+  var wasLoadingRef = (0, _react.useRef)(false);
+
+  // Track complete selection state with page info for multiselect
+  var selectionStateRef = (0, _react.useRef)([]);
+
+  // Track previous filter data to detect changes
+  var prevFilterDataRef = (0, _react.useRef)(undefined);
+
+  // Track if filter state has been persisted after a change
+  var filterStatePersistenceTriggeredRef = (0, _react.useRef)(false);
+
+  // Track previous sort data to detect changes
+  var prevSortDataRef = (0, _react.useRef)(undefined);
+
+  // Track if filter state needs to be saved after loading completes
+  var filterStatePendingRef = (0, _react.useRef)(false);
+
+  // Track if sort state needs to be saved after loading completes
+  var sortStatePendingRef = (0, _react.useRef)(false);
+
+  // Check if state persistence is disabled for this navigation type
+  var isStatePersistenceDisabled = _constants.UNSUPPORTED_STATE_PERSISTENCE_TYPES.includes(navigation);
+
+  // Build the current state object
+  var currentState = (0, _react.useMemo)(function () {
+    // Completely disable state calculation for unsupported navigation types
+    if (isStatePersistenceDisabled) {
+      return {};
+    }
+    var isLoading = !!(datasource !== null && datasource !== void 0 && datasource.loading);
+
+    // Detect first calculation after loading becomes false
+    var isFirstCalculationAfterLoading = wasLoadingRef.current && !isLoading && !hasCalculatedAfterLoadingRef.current;
+
+    // If loading just started, reset the flag for next time
+    if (isLoading && !wasLoadingRef.current) {
+      hasCalculatedAfterLoadingRef.current = false;
+    }
+
+    // Update the loading state tracker
+    wasLoadingRef.current = isLoading;
+
+    // If datasource is loading, return the previous state without any calculations
+    if (isLoading) {
+      return prevStateRef.current;
+    }
+
+    // If this is the first calculation after loading, mark as calculated and return minimal state
+    if (isFirstCalculationAfterLoading) {
+      hasCalculatedAfterLoadingRef.current = true;
+      // Clear selection state ref for fresh start after loading
+      if (multiselect) {
+        selectionStateRef.current = [];
+      }
+      // Return minimal state for first calculation after loading to avoid stale data
+      // Only include pagination if not on page 1 (consistent with normal calculation path)
+      var minimalState = {};
+      if (currentPage !== 1) {
+        minimalState.pagination = currentPage;
+      }
+      return minimalState;
+    }
+
+    // Otherwise, calculate the new state
+    var state = {};
+
+    // Check if filtering is active and different from initial
+    var hasActiveFilter = filterData !== undefined && filterData.length > 0 && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+
+    // Include actualPageSize if it's provided (should be persisted once and never change)
+    if (initialActualPageSize !== undefined) {
+      state.actualpagesize = initialActualPageSize;
+    }
+
+    // Include search/filter state if it differs from initial
+    if (hasActiveFilter) {
+      state.search = filterData;
+
+      // Include sort state if it differs from initial (even when filtering)
+      var _isSortChanged = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+      if (_isSortChanged) {
+        state.sort = sortData;
+      }
+
+      // When filtering is active, don't include pagination or selectedItem at all
+      // They should be completely removed from state
+      // Save the calculated state for next time
+      prevStateRef.current = state;
+      return state;
+    }
+
+    // Include sort state if it differs from initial
+    var isSortChanged = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+    if (isSortChanged) {
+      state.sort = sortData;
+    }
+
+    // Only include pagination if not on page 1 (default)
+    if (currentPage !== 1) {
+      state.pagination = currentPage;
+    }
+
+    // Get selected items from unified selectedRowIds array
+    // Works for both radio select (1 item) and multiselect (multiple items)
+    var selectedIds = selectedRowIds || [];
+    if (multiselect) {
+      // For multiselect, we need to maintain selections across pages
+      // Get all currently selected IDs
+      var allSelectedIds = new Set(selectedIds);
+
+      // Build a map of items on the current page for quick lookup
+      var currentPageItemsMap = new Map();
+      internalDataset.forEach(function (item, index) {
+        if (item._wmRowId) {
+          currentPageItemsMap.set(item._wmRowId, index);
+        }
+      });
+
+      // Update selection state:
+      // 1. Keep selections from other pages if their IDs are still selected
+      // 2. Add/update selections from current page
+      var updatedSelections = [];
+
+      // Keep selections from other pages that are still selected
+      selectionStateRef.current.forEach(function (item) {
+        if (item.page !== currentPage && allSelectedIds.has(item.id)) {
+          updatedSelections.push(item);
+        }
+      });
+
+      // Add selections from current page
+      allSelectedIds.forEach(function (id) {
+        var index = currentPageItemsMap.get(id);
+        if (index !== undefined) {
+          updatedSelections.push({
+            page: currentPage,
+            index: index,
+            id: id
+          });
+        }
+      });
+
+      // Update the ref
+      selectionStateRef.current = updatedSelections;
+
+      // Only include selectedItem if there are selections
+      if (updatedSelections.length > 0) {
+        state.selectedItem = updatedSelections.map(function (_ref) {
+          var page = _ref.page,
+            index = _ref.index;
+          return {
+            page: page,
+            index: index
+          };
+        });
+      }
+    } else {
+      // For single select, just find the selected item in current dataset
+      var selectedIndices = [];
+      selectedIds.forEach(function (id) {
+        var index = internalDataset.findIndex(function (item) {
+          return item._wmRowId === id;
+        });
+        if (index >= 0) {
+          selectedIndices.push(index);
+        }
+      });
+
+      // Only include selectedItem if there are selections
+      if (selectedIndices.length > 0) {
+        // Build selected items with page info
+        var selectedItemsWithPage = selectedIndices.map(function (idx) {
+          return {
+            page: currentPage,
+            index: idx
+          };
+        });
+        state.selectedItem = selectedItemsWithPage;
+      }
+    }
+
+    // Save the calculated state for next time
+    prevStateRef.current = state;
+
+    // Only include pagesize if it differs from default
+    if (defaultPageSize && currentPageSize !== defaultPageSize) {
+      state.pagesize = currentPageSize;
+    }
+    return state;
+  }, [currentPage, currentPageSize, selectedRowIds, internalDataset, initialActualPageSize, multiselect, datasource === null || datasource === void 0 ? void 0 : datasource.loading, filterData, sortData, defaultPageSize, initialSortState, initialFilterState, isStatePersistenceDisabled]);
+
+  // Get state for page size change
+  var getStateForPageSizeChange = (0, _react.useCallback)(function (newPageSize, existingSelectedItems, oldPageSize) {
+    // Completely disable for unsupported navigation types
+    if (isStatePersistenceDisabled) {
+      return {};
+    }
+
+    // Check if filtering is currently active and different from initial
+    var hasActiveFilter = filterData !== undefined && filterData.length > 0 && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+    var state = {};
+
+    // Always include pagesize in page size change state
+    // This ensures proper state management when changing page sizes
+    state.pagesize = newPageSize;
+
+    // Include actualPageSize if it's provided (should be persisted)
+    if (initialActualPageSize !== undefined) {
+      state.actualpagesize = initialActualPageSize;
+    }
+
+    // If filtering is active, maintain the filter but don't include pagination or selectedItem
+    if (hasActiveFilter) {
+      state.search = filterData;
+    }
+
+    // Include sort if it differs from initial
+    var isSortChanged = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+    if (isSortChanged) {
+      state.sort = sortData;
+    }
+
+    // If filtering is active, don't include pagination or selectedItem
+    if (hasActiveFilter) {
+      return state;
+    }
+
+    // Only handle pagination and selectedItem if no filter is active
+    var recalculatedItems = [];
+    if (existingSelectedItems && existingSelectedItems.length > 0 && oldPageSize) {
+      // Recalculate selected items positions based on new page size
+      recalculatedItems = existingSelectedItems.map(function (_ref2) {
+        var page = _ref2.page,
+          index = _ref2.index;
+        // Calculate absolute position using the OLD page size
+        var absoluteIndex = (page - 1) * oldPageSize + index;
+
+        // Calculate new page and index with the NEW page size
+        var newPage = Math.floor(absoluteIndex / newPageSize) + 1;
+        var newIndex = absoluteIndex % newPageSize;
+        return {
+          page: newPage,
+          index: newIndex
+        };
+      });
+    }
+
+    // Clear selection state ref when page size changes
+    if (multiselect) {
+      selectionStateRef.current = [];
+    }
+
+    // Don't include pagination if it's page 1 (default)
+    // state.pagination = 1; // Don't include this as it's the default
+
+    // Only include selectedItem if there are selections
+    if (recalculatedItems.length > 0) {
+      state.selectedItem = recalculatedItems;
+    }
+    return state;
+  }, [initialActualPageSize, multiselect, filterData, sortData, defaultPageSize, initialSortState, initialFilterState, isStatePersistenceDisabled]);
+
+  // Check if current state is default (no need to persist)
+  var isDefaultState = (0, _react.useCallback)(function () {
+    // For unsupported navigation types, always return true (treat as default, no persistence)
+    if (isStatePersistenceDisabled) {
+      return true;
+    }
+    var hasSelection = selectedRowIds && selectedRowIds.length > 0;
+
+    // Check if filter differs from initial
+    var hasFilterChange = filterData && filterData.length > 0 && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+
+    // Check if sort differs from initial
+    var hasSortChange = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+
+    // Check if page size differs from default
+    var hasPageSizeChange = defaultPageSize && currentPageSize !== defaultPageSize;
+
+    // If nothing has changed from defaults, it's default state
+    return currentPage === 1 && !hasSelection && !hasFilterChange && !hasSortChange && !hasPageSizeChange;
+  }, [currentPage, currentPageSize, selectedRowIds, filterData, sortData, defaultPageSize, isStatePersistenceDisabled, initialSortState, initialFilterState]);
+
+  // Merge with existing state
+  var mergeWithExisting = (0, _react.useCallback)(function (newState, existingState) {
+    // Completely disable for unsupported navigation types
+    if (isStatePersistenceDisabled) {
+      return {};
+    }
+    if (!existingState) {
+      return newState;
+    }
+    var merged = _objectSpread({}, newState);
+
+    // Check if filtering is active in the new state
+    var hasActiveFilter = newState.search !== undefined && newState.search.length > 0;
+
+    // If filtering is active, return only what's in newState plus preserved size properties
+    if (hasActiveFilter) {
+      // Start fresh with only what's in newState
+      var filteredMerged = _objectSpread({}, newState);
+
+      // Only preserve pagesize from existing if not in new state and it differs from default
+      if (!filteredMerged.pagesize && existingState.pagesize && (!defaultPageSize || existingState.pagesize !== defaultPageSize)) {
+        filteredMerged.pagesize = existingState.pagesize;
+      }
+      // Preserve actualPageSize from existing state if not in new state
+      if (!filteredMerged.actualpagesize && existingState.actualpagesize !== undefined) {
+        filteredMerged.actualpagesize = existingState.actualpagesize;
+      }
+      if (!filteredMerged.sort && existingState.sort) {
+        filteredMerged.sort = existingState.sort;
+      }
+
+      // Explicitly ensure pagination and selectedItem are not in the merged state
+      delete filteredMerged.pagination;
+      delete filteredMerged.selectedItem;
+      return filteredMerged;
+    }
+
+    // If no active filter, proceed with normal merging
+    // Handle selected items based on multiselect mode
+    if (newState.selectedItem !== undefined) {
+      // For multiselect, the newState already contains all selections across pages
+      // For single select, use the new selection if available, otherwise keep existing
+      if (multiselect || newState.selectedItem.length > 0) {
+        merged.selectedItem = newState.selectedItem;
+      } else if (existingState.selectedItem) {
+        // For single select with no current selection, keep existing
+        merged.selectedItem = existingState.selectedItem;
+      }
+    } else if (existingState.selectedItem && !hasActiveFilter) {
+      // Preserve existing selectedItem if not in new state and no filter
+      merged.selectedItem = existingState.selectedItem;
+    }
+
+    // Preserve pagesize if not in new state and it differs from default
+    if (!merged.pagesize && existingState.pagesize && (!defaultPageSize || existingState.pagesize !== defaultPageSize)) {
+      merged.pagesize = existingState.pagesize;
+    }
+
+    // Preserve actualPageSize from existing state if not in new state
+    if (!merged.actualpagesize && existingState.actualpagesize !== undefined) {
+      merged.actualpagesize = existingState.actualpagesize;
+    }
+
+    // Note: We intentionally do NOT preserve pagination from existingState when newState doesn't have it.
+    // When newState omits pagination, it means the current page is 1 (the default).
+    // The old logic checked `existingState.pagination !== 1` which validates the stored value,
+    // not the current page. This caused stale pagination values (e.g., 2) to persist when on page 1.
+
+    // Preserve sort if not in new state
+    if (!merged.sort && existingState.sort) {
+      merged.sort = existingState.sort;
+    }
+    return merged;
+  }, [multiselect, defaultPageSize, isStatePersistenceDisabled]);
+
+  // Handle filter state changes
+  var handleFilterStateChange = (0, _react.useCallback)(function () {
+    // Completely disable for unsupported navigation types
+    if (isStatePersistenceDisabled || !isStateConfigured || storage === "none") {
+      return;
+    }
+
+    // Check if filter data is different from initial
+    var hasFilterData = (0, _lodashEs.isArray)(filterData) && filterData.length > 0;
+    var isFilterChanged = hasFilterData && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+    if (isFilterChanged) {
+      // When filter is applied, we need to save a state that explicitly excludes pagination and selectedItem
+      // Get the current full state
+      var currentFullState = (0, _tableHelpers.getTableState)(name, storage);
+
+      // Build new state with only the properties we want to keep
+      var newState = {
+        search: filterData
+      };
+
+      // Include actualPageSize if available
+      if ((currentFullState === null || currentFullState === void 0 ? void 0 : currentFullState.actualpagesize) !== undefined) {
+        newState.actualpagesize = currentFullState.actualpagesize;
+      } else if (initialActualPageSize !== undefined) {
+        newState.actualpagesize = initialActualPageSize;
+      }
+
+      // Only include pagesize if it differs from default
+      if ((currentFullState === null || currentFullState === void 0 ? void 0 : currentFullState.pagesize) !== undefined && defaultPageSize && currentFullState.pagesize !== defaultPageSize) {
+        newState.pagesize = currentFullState.pagesize;
+      }
+
+      // Only include sort if it differs from initial
+      if ((currentFullState === null || currentFullState === void 0 ? void 0 : currentFullState.sort) !== undefined) {
+        var isSortChanged = JSON.stringify(currentFullState.sort) !== JSON.stringify(initialSortState);
+        if (isSortChanged) {
+          newState.sort = currentFullState.sort;
+        }
+      }
+
+      // Clear and save to ensure no merge happens
+      (0, _tableHelpers.clearTableState)(name, storage);
+      (0, _tableHelpers.saveTableState)(name, storage, newState);
+
+      // Clear the selection state ref for multiselect
+      if (multiselect) {
+        selectionStateRef.current = [];
+      }
+    } else if (!hasFilterData) {
+      // When filter is cleared, we need to update/clear the state
+      var _currentFullState = (0, _tableHelpers.getTableState)(name, storage);
+
+      // Check if there was a stored filter that needs to be cleared
+      var hadStoredFilter = (_currentFullState === null || _currentFullState === void 0 ? void 0 : _currentFullState.search) && _currentFullState.search.length > 0;
+      var hadInitialFilter = initialFilterState && initialFilterState.length > 0;
+
+      // Only proceed if there was a stored filter or initial filter to clear
+      if (hadStoredFilter || hadInitialFilter) {
+        var _newState = {};
+
+        // Include actualPageSize if available
+        if ((_currentFullState === null || _currentFullState === void 0 ? void 0 : _currentFullState.actualpagesize) !== undefined) {
+          _newState.actualpagesize = _currentFullState.actualpagesize;
+        } else if (initialActualPageSize !== undefined) {
+          _newState.actualpagesize = initialActualPageSize;
+        }
+
+        // Only include pagesize if it differs from default
+        if ((_currentFullState === null || _currentFullState === void 0 ? void 0 : _currentFullState.pagesize) !== undefined && defaultPageSize && _currentFullState.pagesize !== defaultPageSize) {
+          _newState.pagesize = _currentFullState.pagesize;
+        }
+
+        // Only include sort if it differs from initial
+        if ((_currentFullState === null || _currentFullState === void 0 ? void 0 : _currentFullState.sort) !== undefined) {
+          var _isSortChanged2 = JSON.stringify(_currentFullState.sort) !== JSON.stringify(initialSortState);
+          if (_isSortChanged2) {
+            _newState.sort = _currentFullState.sort;
+          }
+        }
+
+        // Clear and save if there's anything to save (excluding the search which we want to remove)
+        (0, _tableHelpers.clearTableState)(name, storage);
+        if (Object.keys(_newState).length > 0) {
+          (0, _tableHelpers.saveTableState)(name, storage, _newState);
+        }
+
+        // Clear the selection state ref for multiselect
+        if (multiselect) {
+          selectionStateRef.current = [];
+        }
+      }
+    }
+  }, [filterData, isStateConfigured, storage, isStatePersistenceDisabled, name, multiselect, defaultPageSize, initialSortState, initialFilterState]);
+
+  // Handle sort state changes
+  var handleSortStateChange = (0, _react.useCallback)(function () {
+    // Completely disable for unsupported navigation types
+    if (isStatePersistenceDisabled || !isStateConfigured || storage === "none") {
+      return;
+    }
+
+    // Check if sort actually changed from initial
+    var hasSortChanged = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+    var isSortReset = !sortData && initialSortState;
+    if (hasSortChanged || isSortReset) {
+      // If we're in default state after this change, clear everything
+      if (isDefaultState()) {
+        (0, _tableHelpers.clearTableState)(name, storage);
+      } else {
+        // Build a clean state with only non-default values
+        var newState = {};
+
+        // Include actualPageSize if available
+        if (initialActualPageSize !== undefined) {
+          newState.actualpagesize = initialActualPageSize;
+        }
+
+        // Only include sort if it changed from initial
+        if (hasSortChanged) {
+          newState.sort = sortData;
+        }
+
+        // Only include pagination if not on page 1
+        if (currentPage !== 1) {
+          newState.pagination = currentPage;
+        }
+
+        // Only include pagesize if it differs from default
+        if (defaultPageSize && currentPageSize !== defaultPageSize) {
+          newState.pagesize = currentPageSize;
+        }
+
+        // Only include search if it differs from initial
+        var hasActiveFilter = filterData && filterData.length > 0 && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+        if (hasActiveFilter) {
+          newState.search = filterData;
+        }
+
+        // Only include selectedItem if there are selections
+        var hasSelection = selectedRowIds && selectedRowIds.length > 0;
+        if (hasSelection && currentState.selectedItem && currentState.selectedItem.length > 0) {
+          newState.selectedItem = currentState.selectedItem;
+        }
+
+        // Clear and save to ensure clean state
+        (0, _tableHelpers.clearTableState)(name, storage);
+        if (Object.keys(newState).length > 0) {
+          (0, _tableHelpers.saveTableState)(name, storage, newState);
+        }
+      }
+    }
+  }, [sortData, isStateConfigured, storage, isStatePersistenceDisabled, name, currentState, initialSortState, isDefaultState, currentPage, currentPageSize, defaultPageSize, filterData, initialFilterState, selectedRowIds]);
+
+  // Detect filter data changes and mark for pending state persistence
+  (0, _react.useEffect)(function () {
+    // Skip for unsupported navigation types
+    if (isStatePersistenceDisabled) {
+      return;
+    }
+
+    // Check if filter data has changed
+    var filterDataChanged = JSON.stringify(filterData) !== JSON.stringify(prevFilterDataRef.current);
+    if (filterDataChanged) {
+      // Reset the flag when filter data changes
+      filterStatePersistenceTriggeredRef.current = false;
+
+      // Update the previous filter data reference
+      prevFilterDataRef.current = filterData;
+
+      // If datasource is loading, mark as pending to save after loading completes
+      if (datasource !== null && datasource !== void 0 && datasource.loading) {
+        filterStatePendingRef.current = true;
+      } else {
+        // Handle the filter state change immediately if not loading
+        handleFilterStateChange();
+      }
+    }
+  }, [filterData, handleFilterStateChange, datasource === null || datasource === void 0 ? void 0 : datasource.loading, isStatePersistenceDisabled]);
+
+  // Save pending filter state when loading completes
+  (0, _react.useEffect)(function () {
+    // Skip for unsupported navigation types
+    if (isStatePersistenceDisabled) {
+      return;
+    }
+    if (!(datasource !== null && datasource !== void 0 && datasource.loading) && filterStatePendingRef.current) {
+      filterStatePendingRef.current = false;
+      handleFilterStateChange();
+    }
+  }, [datasource === null || datasource === void 0 ? void 0 : datasource.loading, handleFilterStateChange, isStatePersistenceDisabled]);
+
+  // Detect sort data changes and mark for pending state persistence
+  (0, _react.useEffect)(function () {
+    // Skip for unsupported navigation types
+    if (isStatePersistenceDisabled) {
+      return;
+    }
+
+    // Check if sort data has changed
+    var sortDataChanged = JSON.stringify(sortData) !== JSON.stringify(prevSortDataRef.current);
+    if (sortDataChanged) {
+      // Update the previous sort data reference
+      prevSortDataRef.current = sortData;
+
+      // If datasource is loading, mark as pending to save after loading completes
+      if (datasource !== null && datasource !== void 0 && datasource.loading) {
+        sortStatePendingRef.current = true;
+      } else {
+        // Handle the sort state change immediately if not loading
+        handleSortStateChange();
+      }
+    }
+  }, [sortData, handleSortStateChange, datasource === null || datasource === void 0 ? void 0 : datasource.loading, isStatePersistenceDisabled]);
+
+  // Save pending sort state when loading completes
+  (0, _react.useEffect)(function () {
+    // Skip for unsupported navigation types
+    if (isStatePersistenceDisabled) {
+      return;
+    }
+    if (!(datasource !== null && datasource !== void 0 && datasource.loading) && sortStatePendingRef.current) {
+      sortStatePendingRef.current = false;
+      handleSortStateChange();
+    }
+  }, [datasource === null || datasource === void 0 ? void 0 : datasource.loading, handleSortStateChange, isStatePersistenceDisabled]);
+  return {
+    currentState: currentState,
+    getStateForPageSizeChange: getStateForPageSizeChange,
+    isDefaultState: isDefaultState,
+    mergeWithExisting: mergeWithExisting,
+    handleFilterStateChange: handleFilterStateChange,
+    handleSortStateChange: handleSortStateChange
+  };
+};