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

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

@@ -1,633 +1,460 @@
-"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
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { useMemo, useCallback, useRef, useEffect } from "react";
+import {
+  saveTableState,
+  getTableState,
+  clearTableState
+} from "../utils/table-helpers";
+import { isArray } from "lodash-es";
+import { UNSUPPORTED_STATE_PERSISTENCE_TYPES } from "../utils/constants";
+const useTableStateManager = (props) => {
+  const {
+    name,
+    storage,
+    currentPage,
+    currentPageSize,
+    selectedRowIds,
+    internalDataset,
+    initialActualPageSize,
+    datasource,
+    multiselect,
+    filterData,
+    sortData,
+    navigation = "Pager",
+    isStateConfigured = false,
+    defaultPageSize,
+    initialSortState,
+    initialFilterState
+  } = props;
+  const prevStateRef = useRef({});
+  const hasCalculatedAfterLoadingRef = useRef(false);
+  const wasLoadingRef = useRef(false);
+  const selectionStateRef = useRef([]);
+  const prevFilterDataRef = useRef(void 0);
+  const filterStatePersistenceTriggeredRef = useRef(false);
+  const prevSortDataRef = useRef(void 0);
+  const filterStatePendingRef = useRef(false);
+  const sortStatePendingRef = useRef(false);
+  const isStatePersistenceDisabled = UNSUPPORTED_STATE_PERSISTENCE_TYPES.includes(navigation);
+  const currentState = useMemo(() => {
     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
+    const isLoading = !!(datasource == null ? void 0 : datasource.loading);
+    const isFirstCalculationAfterLoading = wasLoadingRef.current && !isLoading && !hasCalculatedAfterLoadingRef.current;
     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 = {};
+      const 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) {
+    const state = {};
+    const hasActiveFilter = filterData !== void 0 && filterData.length > 0 && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+    if (initialActualPageSize !== void 0) {
       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) {
+      const isSortChanged2 = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+      if (isSortChanged2) {
         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);
+    const 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 || [];
+    const 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) {
+      const allSelectedIds = new Set(selectedIds);
+      const currentPageItemsMap = /* @__PURE__ */ new Map();
+      internalDataset.forEach((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) {
+      const updatedSelections = [];
+      selectionStateRef.current.forEach((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
-          });
+      allSelectedIds.forEach((id) => {
+        const index = currentPageItemsMap.get(id);
+        if (index !== void 0) {
+          updatedSelections.push({ page: currentPage, index, 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
-          };
-        });
+        state.selectedItem = updatedSelections.map(({ page, index }) => ({ page, 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;
-        });
+      const selectedIndices = [];
+      selectedIds.forEach((id) => {
+        const index = internalDataset.findIndex((item) => 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
-          };
-        });
+        const selectedItemsWithPage = selectedIndices.map((idx) => ({
+          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) {
+  }, [
+    currentPage,
+    currentPageSize,
+    selectedRowIds,
+    internalDataset,
+    initialActualPageSize,
+    multiselect,
+    datasource == null ? void 0 : datasource.loading,
+    filterData,
+    sortData,
+    defaultPageSize,
+    initialSortState,
+    initialFilterState,
+    isStatePersistenceDisabled
+  ]);
+  const getStateForPageSizeChange = useCallback(
+    (newPageSize, existingSelectedItems, oldPageSize) => {
+      if (isStatePersistenceDisabled) {
+        return {};
+      }
+      const hasActiveFilter = filterData !== void 0 && filterData.length > 0 && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+      const state = {};
+      state.pagesize = newPageSize;
+      if (initialActualPageSize !== void 0) {
+        state.actualpagesize = initialActualPageSize;
+      }
+      if (hasActiveFilter) {
+        state.search = filterData;
+      }
+      const isSortChanged = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+      if (isSortChanged) {
+        state.sort = sortData;
+      }
+      if (hasActiveFilter) {
+        return state;
+      }
+      let recalculatedItems = [];
+      if (existingSelectedItems && existingSelectedItems.length > 0 && oldPageSize) {
+        recalculatedItems = existingSelectedItems.map(({ page, index }) => {
+          const absoluteIndex = (page - 1) * oldPageSize + index;
+          const newPage = Math.floor(absoluteIndex / newPageSize) + 1;
+          const newIndex = absoluteIndex % newPageSize;
+          return {
+            page: newPage,
+            index: newIndex
+          };
+        });
+      }
+      if (multiselect) {
+        selectionStateRef.current = [];
+      }
+      if (recalculatedItems.length > 0) {
+        state.selectedItem = recalculatedItems;
+      }
       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)
+    },
+    [
+      initialActualPageSize,
+      multiselect,
+      filterData,
+      sortData,
+      defaultPageSize,
+      initialSortState,
+      initialFilterState,
+      isStatePersistenceDisabled
+    ]
+  );
+  const isDefaultState = useCallback(() => {
     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
+    const hasSelection = selectedRowIds && selectedRowIds.length > 0;
+    const hasFilterChange = filterData && filterData.length > 0 && JSON.stringify(filterData) !== JSON.stringify(initialFilterState || []);
+    const hasSortChange = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+    const hasPageSizeChange = defaultPageSize && currentPageSize !== defaultPageSize;
     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;
+  }, [
+    currentPage,
+    currentPageSize,
+    selectedRowIds,
+    filterData,
+    sortData,
+    defaultPageSize,
+    isStatePersistenceDisabled,
+    initialSortState,
+    initialFilterState
+  ]);
+  const mergeWithExisting = useCallback(
+    (newState, existingState) => {
+      if (isStatePersistenceDisabled) {
+        return {};
       }
-      // Preserve actualPageSize from existing state if not in new state
-      if (!filteredMerged.actualpagesize && existingState.actualpagesize !== undefined) {
-        filteredMerged.actualpagesize = existingState.actualpagesize;
+      if (!existingState) {
+        return newState;
       }
-      if (!filteredMerged.sort && existingState.sort) {
-        filteredMerged.sort = existingState.sort;
+      const merged = __spreadValues({}, newState);
+      const hasActiveFilter = newState.search !== void 0 && newState.search.length > 0;
+      if (hasActiveFilter) {
+        const filteredMerged = __spreadValues({}, newState);
+        if (!filteredMerged.pagesize && existingState.pagesize && (!defaultPageSize || existingState.pagesize !== defaultPageSize)) {
+          filteredMerged.pagesize = existingState.pagesize;
+        }
+        if (!filteredMerged.actualpagesize && existingState.actualpagesize !== void 0) {
+          filteredMerged.actualpagesize = existingState.actualpagesize;
+        }
+        if (!filteredMerged.sort && existingState.sort) {
+          filteredMerged.sort = existingState.sort;
+        }
+        delete filteredMerged.pagination;
+        delete filteredMerged.selectedItem;
+        return filteredMerged;
       }
-
-      // 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
+      if (newState.selectedItem !== void 0) {
+        if (multiselect || newState.selectedItem.length > 0) {
+          merged.selectedItem = newState.selectedItem;
+        } else if (existingState.selectedItem) {
+          merged.selectedItem = existingState.selectedItem;
+        }
+      } else if (existingState.selectedItem && !hasActiveFilter) {
         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 (!merged.pagesize && existingState.pagesize && (!defaultPageSize || existingState.pagesize !== defaultPageSize)) {
+        merged.pagesize = existingState.pagesize;
+      }
+      if (!merged.actualpagesize && existingState.actualpagesize !== void 0) {
+        merged.actualpagesize = existingState.actualpagesize;
+      }
+      if (!merged.sort && existingState.sort) {
+        merged.sort = existingState.sort;
+      }
+      return merged;
+    },
+    [multiselect, defaultPageSize, isStatePersistenceDisabled]
+  );
+  const handleFilterStateChange = useCallback(() => {
     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 || []);
+    const hasFilterData = isArray(filterData) && filterData.length > 0;
+    const 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 = {
+      const currentFullState = getTableState(name, storage);
+      const newState = {
         search: filterData
       };
-
-      // Include actualPageSize if available
-      if ((currentFullState === null || currentFullState === void 0 ? void 0 : currentFullState.actualpagesize) !== undefined) {
+      if ((currentFullState == null ? void 0 : currentFullState.actualpagesize) !== void 0) {
         newState.actualpagesize = currentFullState.actualpagesize;
-      } else if (initialActualPageSize !== undefined) {
+      } else if (initialActualPageSize !== void 0) {
         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) {
+      if ((currentFullState == null ? void 0 : currentFullState.pagesize) !== void 0 && 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 ((currentFullState == null ? void 0 : currentFullState.sort) !== void 0) {
+        const 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
+      clearTableState(name, storage);
+      saveTableState(name, storage, newState);
       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
+      const currentFullState = getTableState(name, storage);
+      const hadStoredFilter = (currentFullState == null ? void 0 : currentFullState.search) && currentFullState.search.length > 0;
+      const hadInitialFilter = initialFilterState && initialFilterState.length > 0;
       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;
+        const newState = {};
+        if ((currentFullState == null ? void 0 : currentFullState.actualpagesize) !== void 0) {
+          newState.actualpagesize = currentFullState.actualpagesize;
+        } else if (initialActualPageSize !== void 0) {
+          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;
+        if ((currentFullState == null ? void 0 : currentFullState.pagesize) !== void 0 && 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;
+        if ((currentFullState == null ? void 0 : currentFullState.sort) !== void 0) {
+          const isSortChanged = JSON.stringify(currentFullState.sort) !== JSON.stringify(initialSortState);
+          if (isSortChanged) {
+            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);
+        clearTableState(name, storage);
+        if (Object.keys(newState).length > 0) {
+          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
+  }, [
+    filterData,
+    isStateConfigured,
+    storage,
+    isStatePersistenceDisabled,
+    name,
+    multiselect,
+    defaultPageSize,
+    initialSortState,
+    initialFilterState
+  ]);
+  const handleSortStateChange = useCallback(() => {
     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;
+    const hasSortChanged = sortData && JSON.stringify(sortData) !== JSON.stringify(initialSortState);
+    const isSortReset = !sortData && initialSortState;
     if (hasSortChanged || isSortReset) {
-      // If we're in default state after this change, clear everything
       if (isDefaultState()) {
-        (0, _tableHelpers.clearTableState)(name, storage);
+        clearTableState(name, storage);
       } else {
-        // Build a clean state with only non-default values
-        var newState = {};
-
-        // Include actualPageSize if available
-        if (initialActualPageSize !== undefined) {
+        const newState = {};
+        if (initialActualPageSize !== void 0) {
           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 || []);
+        const 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;
+        const 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);
+        clearTableState(name, storage);
         if (Object.keys(newState).length > 0) {
-          (0, _tableHelpers.saveTableState)(name, storage, newState);
+          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
+  }, [
+    sortData,
+    isStateConfigured,
+    storage,
+    isStatePersistenceDisabled,
+    name,
+    currentState,
+    initialSortState,
+    isDefaultState,
+    currentPage,
+    currentPageSize,
+    defaultPageSize,
+    filterData,
+    initialFilterState,
+    selectedRowIds
+  ]);
+  useEffect(() => {
     if (isStatePersistenceDisabled) {
       return;
     }
-
-    // Check if filter data has changed
-    var filterDataChanged = JSON.stringify(filterData) !== JSON.stringify(prevFilterDataRef.current);
+    const 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) {
+      if (datasource == null ? 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
+  }, [filterData, handleFilterStateChange, datasource == null ? void 0 : datasource.loading, isStatePersistenceDisabled]);
+  useEffect(() => {
     if (isStatePersistenceDisabled) {
       return;
     }
-    if (!(datasource !== null && datasource !== void 0 && datasource.loading) && filterStatePendingRef.current) {
+    if (!(datasource == null ? 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
+  }, [datasource == null ? void 0 : datasource.loading, handleFilterStateChange, isStatePersistenceDisabled]);
+  useEffect(() => {
     if (isStatePersistenceDisabled) {
       return;
     }
-
-    // Check if sort data has changed
-    var sortDataChanged = JSON.stringify(sortData) !== JSON.stringify(prevSortDataRef.current);
+    const 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) {
+      if (datasource == null ? 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
+  }, [sortData, handleSortStateChange, datasource == null ? void 0 : datasource.loading, isStatePersistenceDisabled]);
+  useEffect(() => {
     if (isStatePersistenceDisabled) {
       return;
     }
-    if (!(datasource !== null && datasource !== void 0 && datasource.loading) && sortStatePendingRef.current) {
+    if (!(datasource == null ? void 0 : datasource.loading) && sortStatePendingRef.current) {
       sortStatePendingRef.current = false;
       handleSortStateChange();
     }
-  }, [datasource === null || datasource === void 0 ? void 0 : datasource.loading, handleSortStateChange, isStatePersistenceDisabled]);
+  }, [datasource == null ? void 0 : datasource.loading, handleSortStateChange, isStatePersistenceDisabled]);
   return {
-    currentState: currentState,
-    getStateForPageSizeChange: getStateForPageSizeChange,
-    isDefaultState: isDefaultState,
-    mergeWithExisting: mergeWithExisting,
-    handleFilterStateChange: handleFilterStateChange,
-    handleSortStateChange: handleSortStateChange
+    currentState,
+    getStateForPageSizeChange,
+    isDefaultState,
+    mergeWithExisting,
+    handleFilterStateChange,
+    handleSortStateChange
   };
-};
+};
+export {
+  useTableStateManager
+};