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

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

@@ -1,203 +1,137 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useServerSideSorting = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _react = require("react");
-var _crudHandlers = require("../utils/crud-handlers");
-var _utils = require("../utils");
-var _useDebounce = require("@wavemaker-ai/react-runtime/hooks/useDebounce");
-/**
- * Hook to handle server-side sorting for table data
- */
-var useServerSideSorting = exports.useServerSideSorting = function useServerSideSorting(_ref) {
-  var datasource = _ref.datasource,
-    sorting = _ref.sorting,
-    setInternalDataset = _ref.setInternalDataset,
-    showToast = _ref.showToast,
-    isServerSidePagination = _ref.isServerSidePagination,
-    pageIndex = _ref.pageIndex,
-    onError = _ref.onError,
-    onBeforefilter = _ref.onBeforefilter,
-    filterFields = _ref.filterFields,
-    logicalOp = _ref.logicalOp,
-    listener = _ref.listener,
-    name = _ref.name;
-  var prevSortingRef = (0, _react.useRef)(sorting);
-  var prevPageRef = (0, _react.useRef)(pageIndex);
-  var prevFilterRef = (0, _react.useRef)("");
-  var isMountedRef = (0, _react.useRef)(false);
-
-  // Determine if we should use server-side sorting
-  var isServerSideSorting = !!(datasource && isServerSidePagination);
-
-  // Convert TanStack sorting state to orderBy string
-  var convertSortingToOrderBy = (0, _react.useCallback)(function (sortingState) {
+import { useEffect, useRef, useCallback } from "react";
+import { refreshDataSource } from "../utils/crud-handlers";
+import { addUniqueRowIds } from "../utils";
+import { useDebounceCallback } from "../../../../hooks/useDebounce";
+const useServerSideSorting = ({
+  datasource,
+  sorting,
+  setInternalDataset,
+  showToast,
+  isServerSidePagination,
+  pageIndex,
+  onError,
+  onBeforefilter,
+  filterFields,
+  logicalOp,
+  listener,
+  name
+}) => {
+  const prevSortingRef = useRef(sorting);
+  const prevPageRef = useRef(pageIndex);
+  const prevFilterRef = useRef("");
+  const isMountedRef = useRef(false);
+  const isServerSideSorting = !!(datasource && isServerSidePagination);
+  const convertSortingToOrderBy = useCallback((sortingState) => {
     if (!sortingState || sortingState.length === 0) {
       return "";
     }
-
-    // Map sorting state to orderBy format (e.g., "name asc, age desc")
-    return sortingState.map(function (sort) {
-      return "".concat(sort.id, " ").concat(sort.desc ? "desc" : "asc");
-    }).join(", ");
+    return sortingState.map((sort) => `${sort.id} ${sort.desc ? "desc" : "asc"}`).join(", ");
   }, []);
-
-  // Fetch data with sorting
-  var fetchSortedDataImpl = (0, _react.useCallback)(/*#__PURE__*/function () {
-    var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(forcePage) {
-      var orderBy, currentPage, response, responseData, dataWithIds, _listener$Widgets, widget;
-      return _regenerator["default"].wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            if (!(!datasource || !isServerSideSorting)) {
-              _context.next = 2;
-              break;
-            }
-            return _context.abrupt("return");
-          case 2:
-            _context.prev = 2;
-            orderBy = convertSortingToOrderBy(sorting); // Use forcePage if provided (for sorting changes), otherwise use current page
-            currentPage = forcePage !== undefined ? forcePage : pageIndex + 1; // Convert 0-based to 1-based
-            _context.next = 7;
-            return (0, _crudHandlers.refreshDataSource)(datasource, {
-              orderBy: orderBy,
-              page: currentPage || 1,
-              filterFields: filterFields || {},
-              condition: logicalOp || ""
-            });
-          case 7:
-            response = _context.sent;
-            // Handle response data - always update dataset even if empty
-            responseData = []; // Handle different response formats
-            if (response && response.data) {
-              responseData = Array.isArray(response.data) ? response.data : [];
-            }
-
-            // Add unique row IDs to the server response data
-            dataWithIds = (0, _utils.addUniqueRowIds)(responseData);
-            setInternalDataset(dataWithIds);
-            _context.next = 19;
-            break;
-          case 14:
-            _context.prev = 14;
-            _context.t0 = _context["catch"](2);
-            console.error("Error fetching sorted data:", _context.t0);
-            if (showToast) {
-              showToast("Failed to sort data", "Error");
-            }
-            if (onError) {
-              widget = name ? listener === null || listener === void 0 || (_listener$Widgets = listener.Widgets) === null || _listener$Widgets === void 0 ? void 0 : _listener$Widgets[name] : undefined;
-              onError(null, widget, _context.t0, "sort");
-            }
-          case 19:
-          case "end":
-            return _context.stop();
+  const fetchSortedDataImpl = useCallback(
+    async (forcePage) => {
+      var _a;
+      if (!datasource || !isServerSideSorting) {
+        return;
+      }
+      try {
+        const orderBy = convertSortingToOrderBy(sorting);
+        const currentPage = forcePage !== void 0 ? forcePage : pageIndex + 1;
+        const response = await refreshDataSource(datasource, {
+          orderBy,
+          page: currentPage || 1,
+          filterFields: filterFields || {},
+          condition: logicalOp || ""
+        });
+        let responseData = [];
+        if (response && response.data) {
+          responseData = Array.isArray(response.data) ? response.data : [];
+        }
+        const dataWithIds = addUniqueRowIds(responseData);
+        setInternalDataset(dataWithIds);
+      } catch (error) {
+        console.error("Error fetching sorted data:", error);
+        if (showToast) {
+          showToast("Failed to sort data", "Error");
         }
-      }, _callee, null, [[2, 14]]);
-    }));
-    return function (_x) {
-      return _ref2.apply(this, arguments);
-    };
-  }(), [datasource, isServerSideSorting, sorting, pageIndex, convertSortingToOrderBy, setInternalDataset, showToast, onError, filterFields, logicalOp, listener, name]);
-
-  // Debounced version to handle rapid successive calls
-  var fetchSortedData = (0, _useDebounce.useDebounceCallback)(fetchSortedDataImpl, 100);
-
-  // Combined effect to handle sorting, pagination, and filter changes
-  (0, _react.useEffect)(function () {
-    // Skip if not server-side sorting
+        if (onError) {
+          const widget = name ? (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name] : void 0;
+          onError(null, widget, error, "sort");
+        }
+      }
+    },
+    [
+      datasource,
+      isServerSideSorting,
+      sorting,
+      pageIndex,
+      convertSortingToOrderBy,
+      setInternalDataset,
+      showToast,
+      onError,
+      filterFields,
+      logicalOp,
+      listener,
+      name
+    ]
+  );
+  const fetchSortedData = useDebounceCallback(fetchSortedDataImpl, 100);
+  useEffect(() => {
     if (!isServerSideSorting) {
       return;
     }
-
-    // Skip initial mount
     if (!isMountedRef.current) {
       isMountedRef.current = true;
       prevSortingRef.current = sorting;
       prevPageRef.current = pageIndex;
-      prevFilterRef.current = JSON.stringify({
-        filterFields: filterFields,
-        logicalOp: logicalOp
-      });
+      prevFilterRef.current = JSON.stringify({ filterFields, logicalOp });
       return;
     }
-
-    // Check what changed
-    var sortingString = JSON.stringify(sorting);
-    var prevSortingString = JSON.stringify(prevSortingRef.current);
-    var filterString = JSON.stringify({
-      filterFields: filterFields,
-      logicalOp: logicalOp
-    });
-    var sortingChanged = sortingString !== prevSortingString;
-    // const pageChanged = pageIndex !== prevPageRef.current;
-    var filterChanged = filterString !== prevFilterRef.current;
-
-    // Only fetch if something actually changed
+    const sortingString = JSON.stringify(sorting);
+    const prevSortingString = JSON.stringify(prevSortingRef.current);
+    const filterString = JSON.stringify({ filterFields, logicalOp });
+    const sortingChanged = sortingString !== prevSortingString;
+    const filterChanged = filterString !== prevFilterRef.current;
     if (sortingChanged || filterChanged) {
-      // If filter changed, call onBeforefilter callback
       if (filterChanged && onBeforefilter) {
-        var handleFilterChange = /*#__PURE__*/function () {
-          var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-            var _listener$Widgets2;
-            var widget, result;
-            return _regenerator["default"].wrap(function _callee2$(_context2) {
-              while (1) switch (_context2.prev = _context2.next) {
-                case 0:
-                  widget = name ? listener === null || listener === void 0 || (_listener$Widgets2 = listener.Widgets) === null || _listener$Widgets2 === void 0 ? void 0 : _listener$Widgets2[name] : undefined;
-                  _context2.next = 3;
-                  return onBeforefilter(widget, filterFields);
-                case 3:
-                  result = _context2.sent;
-                  if (!(result === false)) {
-                    _context2.next = 6;
-                    break;
-                  }
-                  return _context2.abrupt("return");
-                case 6:
-                  // Update refs before fetching to prevent duplicate calls
-                  prevSortingRef.current = sorting;
-                  prevPageRef.current = pageIndex;
-                  prevFilterRef.current = filterString;
-
-                  // When sorting or filter changes, fetch from page 1
-                  fetchSortedData(1);
-                case 10:
-                case "end":
-                  return _context2.stop();
-              }
-            }, _callee2);
-          }));
-          return function handleFilterChange() {
-            return _ref3.apply(this, arguments);
-          };
-        }();
+        const handleFilterChange = async () => {
+          var _a;
+          const widget = name ? (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name] : void 0;
+          const result = await onBeforefilter(widget, filterFields);
+          if (result === false) {
+            return;
+          }
+          prevSortingRef.current = sorting;
+          prevPageRef.current = pageIndex;
+          prevFilterRef.current = filterString;
+          fetchSortedData(1);
+        };
         handleFilterChange();
       } else {
-        // Update refs before fetching to prevent duplicate calls
         prevSortingRef.current = sorting;
         prevPageRef.current = pageIndex;
         prevFilterRef.current = filterString;
-
-        // When sorting or filter changes, fetch from page 1
         fetchSortedData(1);
       }
     }
-  }, [sorting, pageIndex, filterFields, logicalOp, isServerSideSorting, fetchSortedData, onBeforefilter, listener, name]);
-
-  // Custom sorting change handler
-  var handleSortingChange = (0, _react.useCallback)(function (updaterOrValue) {
-    // This will be called instead of the default setSorting
-    // We'll still update the sorting state, but also trigger server-side fetch
+  }, [
+    sorting,
+    pageIndex,
+    filterFields,
+    logicalOp,
+    isServerSideSorting,
+    fetchSortedData,
+    onBeforefilter,
+    listener,
+    name
+  ]);
+  const handleSortingChange = useCallback((updaterOrValue) => {
     return updaterOrValue;
   }, []);
   return {
-    handleSortingChange: handleSortingChange,
-    isServerSideSorting: isServerSideSorting
+    handleSortingChange,
+    isServerSideSorting
   };
-};
+};
+export {
+  useServerSideSorting
+};