@wavemaker/react-runtime 11.14.2-rc.6311 → 11.15.0-1.246

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

@@ -17,7 +17,6 @@ var useTableInitialization = exports.useTableInitialization = function useTableI
     useRadioSelect = _ref.useRadioSelect,
     useMultiSelect = _ref.useMultiSelect,
     setActiveRow = _ref.setActiveRow,
-    selectedRowId = _ref.selectedRowId,
     selectedRowIds = _ref.selectedRowIds,
     activeRowIds = _ref.activeRowIds,
     formName = _ref.formName,
@@ -53,49 +52,51 @@ var useTableInitialization = exports.useTableInitialization = function useTableI
   }, [gridfirstrowselect, useRadioSelect, useMultiSelect, internalDataset, setActiveRow]);
 
   /**
-   * Sync active rows with selected rows for multiselect mode
-   * When multiselect is enabled, all selected rows should be marked as active
+   * Sync active rows with selected rows
+   * Works for both radio select (single item) and multiselect (multiple items)
    */
   (0, _react.useEffect)(function () {
-    if (useMultiSelect) {
-      // Set all selected rows as active
+    if ((useMultiSelect || useRadioSelect) && selectedRowIds.length > 0) {
+      // Set all selected rows as active (for radio select, this will be just one)
       setActiveRow(selectedRowIds);
     }
-  }, [selectedRowIds, useMultiSelect, setActiveRow]);
-
-  /**
-   * Sync active row with selected row for radioselect mode
-   * When radioselect is enabled, the selected row should be marked as active
-   */
-  (0, _react.useEffect)(function () {
-    if (useRadioSelect && selectedRowId) {
-      // Set the selected row as active
-      setActiveRow(selectedRowId);
-    }
-  }, [selectedRowId, useRadioSelect, setActiveRow]);
+  }, [selectedRowIds, useMultiSelect, useRadioSelect, setActiveRow]);
 
   // Monitor when there are no active rows
   (0, _react.useEffect)(function () {
     // Check if there are no active rows
     var hasNoActiveRows = !activeRowIds || activeRowIds.length === 0;
-    if (hasNoActiveRows && internalDataset.length > 0) {
+    if (hasNoActiveRows) {
       // Handle the case when there are no active rows
       // You can customize this logic based on your requirements
-      if (listener && editmode === "form" && formName) {
+      if (listener && (editmode === "form" || editmode === "none") && formName) {
         setTimeout(function () {
           var _listener$Widgets$for;
           (_listener$Widgets$for = listener.Widgets[formName]) === null || _listener$Widgets$for === void 0 || _listener$Widgets$for.setShowViewMode(true);
         }, 10);
       }
     } else {
-      if (activeRowIds.length > 0 && listener && editmode === "form" && formName) {
+      if (activeRowIds.length > 0 && listener && formName) {
         setTimeout(function () {
           var formWidget = listener.Widgets[formName];
           var getRow = internalDataset.find(function (row) {
             if (row._wmTableRowId === activeRowIds[0]) return true;
           });
-          formWidget === null || formWidget === void 0 || formWidget.edit(getRow);
-          formWidget === null || formWidget === void 0 || formWidget.setShowViewMode(true);
+
+          // For readonly mode (editmode === "none"), always show view mode
+          // For form mode (editmode === "form"), only update form data without changing view/edit state
+          // Edit mode should only be triggered by clicking the edit icon (via editRow method)
+          if (editmode === "none") {
+            var _formWidget$setFormDa;
+            formWidget === null || formWidget === void 0 || (_formWidget$setFormDa = formWidget.setFormData) === null || _formWidget$setFormDa === void 0 || _formWidget$setFormDa.call(formWidget, getRow);
+            formWidget === null || formWidget === void 0 || formWidget.setShowViewMode(true);
+          } else if (editmode === "form") {
+            var _formWidget$setFormDa2;
+            // Only update form data, preserve current view/edit mode
+            formWidget === null || formWidget === void 0 || (_formWidget$setFormDa2 = formWidget.setFormData) === null || _formWidget$setFormDa2 === void 0 || _formWidget$setFormDa2.call(formWidget, getRow);
+          } else {
+            formWidget === null || formWidget === void 0 || formWidget.edit(getRow);
+          }
         }, 10);
       }
     }

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

@@ -1,9 +1,11 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useTableState = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _react = require("react");
 var useTableState = exports.useTableState = function useTableState(_ref) {
   var _ref$editMode = _ref.editMode,
@@ -38,7 +40,7 @@ var useTableState = exports.useTableState = function useTableState(_ref) {
   // Check if a row is active
   var isRowActive = (0, _react.useCallback)(function (rowId, isSelected) {
     // Check if the row is in the active rows array
-    return activeRowIds.includes(rowId);
+    return activeRowIds && Array.isArray(activeRowIds) && activeRowIds.includes(rowId);
   }, [activeRowIds]);
 
   // Clear active rows
@@ -50,15 +52,19 @@ var useTableState = exports.useTableState = function useTableState(_ref) {
   var setActiveRow = (0, _react.useCallback)(function (rowIds) {
     if (rowIds === null) {
       setActiveRowIds([]);
-    } else if (typeof rowIds === "string") {
-      setActiveRowIds([rowIds]);
-    } else {
+    } else if (typeof rowIds === "string" || typeof rowIds === "number") {
+      setActiveRowIds([String(rowIds)]);
+    } else if (Array.isArray(rowIds)) {
       setActiveRowIds(rowIds);
+    } else {
+      // Fallback for unexpected types
+      console.warn("Unexpected type for rowIds:", (0, _typeof2["default"])(rowIds), rowIds);
+      setActiveRowIds([]);
     }
   }, []);
 
   // For backwards compatibility, provide activeRowId as the first active row
-  var activeRowId = activeRowIds.length > 0 ? activeRowIds[0] : null;
+  var activeRowId = activeRowIds && activeRowIds.length > 0 ? activeRowIds[0] : null;
   return {
     activeRowIds: activeRowIds,
     setActiveRow: setActiveRow,

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

@@ -9,16 +9,14 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 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; }
-// Unsupported navigation types for state persistence
-var UNSUPPORTED_STATE_PERSISTENCE_TYPES = ["Scroll", "On-Demand", "Inline"];
 var useTableStateManager = exports.useTableStateManager = function useTableStateManager(props) {
   var name = props.name,
     storage = props.storage,
     currentPage = props.currentPage,
     currentPageSize = props.currentPageSize,
-    selectedRowId = props.selectedRowId,
     selectedRowIds = props.selectedRowIds,
     internalDataset = props.internalDataset,
     initialActualPageSize = props.initialActualPageSize,
@@ -55,8 +53,21 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
   // 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
@@ -83,9 +94,12 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
         selectionStateRef.current = [];
       }
       // Return minimal state for first calculation after loading to avoid stale data
-      return {
-        pagination: currentPage
-      };
+      // 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
@@ -127,8 +141,9 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
       state.pagination = currentPage;
     }
 
-    // Get selected items based on multiselect mode
-    var selectedIds = multiselect ? selectedRowIds || [] : selectedRowId ? [selectedRowId] : [];
+    // 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
@@ -213,10 +228,15 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
       state.pagesize = currentPageSize;
     }
     return state;
-  }, [currentPage, currentPageSize, selectedRowId, selectedRowIds, internalDataset, initialActualPageSize, multiselect, datasource === null || datasource === void 0 ? void 0 : datasource.loading, filterData, sortData, defaultPageSize, initialSortState, initialFilterState]);
+  }, [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 = {};
@@ -279,11 +299,15 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
       state.selectedItem = recalculatedItems;
     }
     return state;
-  }, [initialActualPageSize, multiselect, filterData, sortData, defaultPageSize, initialSortState, initialFilterState]);
+  }, [initialActualPageSize, multiselect, filterData, sortData, defaultPageSize, initialSortState, initialFilterState, isStatePersistenceDisabled]);
 
   // Check if current state is default (no need to persist)
   var isDefaultState = (0, _react.useCallback)(function () {
-    var hasSelection = selectedRowId !== null && selectedRowId !== undefined || selectedRowIds && selectedRowIds.length > 0;
+    // 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 || []);
@@ -296,10 +320,14 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
 
     // If nothing has changed from defaults, it's default state
     return currentPage === 1 && !hasSelection && !hasFilterChange && !hasSortChange && !hasPageSizeChange;
-  }, [currentPage, currentPageSize, selectedRowId, selectedRowIds, filterData, sortData, defaultPageSize, initialSortState, initialFilterState]);
+  }, [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;
     }
@@ -357,25 +385,22 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
       merged.actualpagesize = existingState.actualpagesize;
     }
 
-    // Preserve pagination if not in new state and no filter AND not on page 1
-    if (!merged.pagination && existingState.pagination && !hasActiveFilter && existingState.pagination !== 1) {
-      merged.pagination = existingState.pagination;
-    }
+    // 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]);
+  }, [multiselect, defaultPageSize, isStatePersistenceDisabled]);
 
   // Handle filter state changes
   var handleFilterStateChange = (0, _react.useCallback)(function () {
-    // Check if state persistence is supported for this navigation type
-    if (!isStateConfigured || storage === "none" || UNSUPPORTED_STATE_PERSISTENCE_TYPES.includes(navigation)) {
-      if (navigation && UNSUPPORTED_STATE_PERSISTENCE_TYPES.includes(navigation)) {
-        console.warn("Retain State handling on Widget ".concat(name, " is not supported for ").concat(navigation, " navigation type."));
-      }
+    // Completely disable for unsupported navigation types
+    if (isStatePersistenceDisabled || !isStateConfigured || storage === "none") {
       return;
     }
 
@@ -420,50 +445,56 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
       if (multiselect) {
         selectionStateRef.current = [];
       }
-    } else if (!hasFilterData && initialFilterState && initialFilterState.length > 0) {
-      // When filter is cleared but there was an initial filter, we need to update state
+    } else if (!hasFilterData) {
+      // When filter is cleared, we need to update/clear the state
       var _currentFullState = (0, _tableHelpers.getTableState)(name, storage);
-      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;
-      }
+      // 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 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 proceed if there was a stored filter or initial filter to clear
+      if (hadStoredFilter || hadInitialFilter) {
+        var _newState = {};
 
-      // 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;
+        // 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;
         }
-      }
 
-      // Clear and save if there's anything to save
-      if (Object.keys(_newState).length > 0) {
-        (0, _tableHelpers.clearTableState)(name, storage);
-        (0, _tableHelpers.saveTableState)(name, storage, _newState);
-      } else {
+        // 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 = [];
+        // Clear the selection state ref for multiselect
+        if (multiselect) {
+          selectionStateRef.current = [];
+        }
       }
     }
-  }, [filterData, isStateConfigured, storage, navigation, name, multiselect, defaultPageSize, initialSortState, initialFilterState]);
+  }, [filterData, isStateConfigured, storage, isStatePersistenceDisabled, name, multiselect, defaultPageSize, initialSortState, initialFilterState]);
 
   // Handle sort state changes
   var handleSortStateChange = (0, _react.useCallback)(function () {
-    // Check if state persistence is supported for this navigation type
-    if (!isStateConfigured || storage === "none" || UNSUPPORTED_STATE_PERSISTENCE_TYPES.includes(navigation)) {
+    // Completely disable for unsupported navigation types
+    if (isStatePersistenceDisabled || !isStateConfigured || storage === "none") {
       return;
     }
 
@@ -505,7 +536,7 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
         }
 
         // Only include selectedItem if there are selections
-        var hasSelection = selectedRowId !== null && selectedRowId !== undefined || selectedRowIds && selectedRowIds.length > 0;
+        var hasSelection = selectedRowIds && selectedRowIds.length > 0;
         if (hasSelection && currentState.selectedItem && currentState.selectedItem.length > 0) {
           newState.selectedItem = currentState.selectedItem;
         }
@@ -517,36 +548,80 @@ var useTableStateManager = exports.useTableStateManager = function useTableState
         }
       }
     }
-  }, [sortData, isStateConfigured, storage, navigation, name, currentState, initialSortState, isDefaultState, currentPage, currentPageSize, defaultPageSize, filterData, initialFilterState, selectedRowId, selectedRowIds]);
+  }, [sortData, isStateConfigured, storage, isStatePersistenceDisabled, name, currentState, initialSortState, isDefaultState, currentPage, currentPageSize, defaultPageSize, filterData, initialFilterState, selectedRowIds]);
 
-  // Detect filter data changes and handle state persistence
+  // 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;
 
-      // Handle the filter state change
-      handleFilterStateChange();
-
       // 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();
     }
-  }, [filterData, handleFilterStateChange]);
+  }, [datasource === null || datasource === void 0 ? void 0 : datasource.loading, handleFilterStateChange, isStatePersistenceDisabled]);
 
-  // Detect sort data changes and handle state persistence
+  // 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) {
-      // Handle the sort state change
-      handleSortStateChange();
-
       // 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();
     }
-  }, [sortData, handleSortStateChange]);
+  }, [datasource === null || datasource === void 0 ? void 0 : datasource.loading, handleSortStateChange, isStatePersistenceDisabled]);
   return {
     currentState: currentState,
     getStateForPageSizeChange: getStateForPageSizeChange,