@wavemaker-ai/react-runtime 1.0.0-next.27766

package/components/data/pagination/hooks/usePagination.js

@@ -0,0 +1,914 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { useState, useCallback, useEffect, useRef, useMemo } from "react";
+import { isArray, isEmpty, isNull } from "lodash-es";
+import { addUniqueRowIds, extractDataArray } from "../../table/utils";
+const isDataSourceHasPaging = (datasource) => {
+  return datasource && typeof datasource.execute === "function" && datasource.execute("IS_PAGEABLE");
+};
+const calculatePagingValues = (dataSize, maxResults) => {
+  return dataSize > maxResults ? Math.ceil(dataSize / maxResults) : dataSize < 0 ? 0 : 1;
+};
+const createDummyEvent = (eventName = "synthetic") => {
+  return {
+    bubbles: false,
+    cancelable: false,
+    currentTarget: null,
+    defaultPrevented: false,
+    eventPhase: 0,
+    isTrusted: false,
+    nativeEvent: new Event(eventName),
+    target: null,
+    timeStamp: Date.now(),
+    type: eventName,
+    // Dynamic type based on the event being triggered
+    isDefaultPrevented: () => false,
+    isPropagationStopped: () => false,
+    persist: () => {
+    },
+    preventDefault: () => {
+    },
+    stopPropagation: () => {
+    }
+  };
+};
+const usePagination = ({
+  dataset,
+  maxResults = 10,
+  currentPage: initialPage,
+  navigation,
+  name,
+  listener,
+  onPaginationChange,
+  onSetRecord,
+  onPageSizeChange,
+  paginationMeta,
+  totalItems,
+  datasource,
+  setIsLoadingMore,
+  isServerSidePagination = false,
+  listDirection,
+  scrollContainerRef,
+  sentinelRef: sentinelRefProp,
+  datasourceInvokeOptions
+}) => {
+  var _a;
+  const pageSizeChangeHandler = onPageSizeChange || (listener == null ? void 0 : listener.onPageSizeChange);
+  const widgetInstance = (_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[name];
+  const [paginationState, setPaginationState] = useState({
+    currentPage: initialPage || 1,
+    pageCount: 0,
+    dataSize: 0,
+    currentMaxResults: (paginationMeta == null ? void 0 : paginationMeta.size) || maxResults,
+    error: null
+  });
+  const [dataState, setDataState] = useState({
+    fullData: [],
+    result: []
+  });
+  const [accumulatingState, setAccumulatingState] = useState({
+    accumulatedData: [],
+    lastLoadedPage: 0,
+    isAccumulating: navigation === "Scroll" || navigation === "On-Demand",
+    isInitialized: false
+  });
+  const [disableStates, setDisableStates] = useState({
+    isDisableNext: true,
+    isDisablePrevious: true,
+    isDisableFirst: true,
+    isDisableLast: true,
+    isDisableCurrent: false,
+    isDisableCount: false
+  });
+  const isFetchingRef = useRef(false);
+  const isResettingRef = useRef(false);
+  const observerRef = useRef(null);
+  const internalSentinelRef = useRef(null);
+  const sentinelRef = sentinelRefProp !== void 0 ? sentinelRefProp : internalSentinelRef;
+  const accumulatingStateRef = useRef(accumulatingState);
+  const sentinelHasLeftViewportRef = useRef(true);
+  useEffect(() => {
+    accumulatingStateRef.current = accumulatingState;
+  }, [accumulatingState]);
+  const isFirstPage = useMemo(() => {
+    if (paginationMeta && paginationMeta.first !== void 0) {
+      return paginationMeta.first;
+    }
+    return paginationState.currentPage === 1 || !paginationState.currentPage;
+  }, [paginationState.currentPage, paginationMeta]);
+  const isLastPage = useMemo(() => {
+    if (paginationMeta && paginationMeta.last !== void 0) {
+      return paginationMeta.last;
+    }
+    return paginationState.currentPage === paginationState.pageCount;
+  }, [paginationState.currentPage, paginationState.pageCount, paginationMeta]);
+  const allowedNavControls = ["Basic", "Classic", "Pager", "Scroll", "On-Demand"];
+  const getValidNavControl = (nav) => {
+    return allowedNavControls.includes(nav) ? nav : "Basic";
+  };
+  const [navcontrols, setNavcontrols] = useState(getValidNavControl(navigation));
+  const getPaginationStartIndex = () => {
+    var _a2, _b;
+    const startIndex = (_a2 = datasource == null ? void 0 : datasource._paginationConfig) == null ? void 0 : _a2.paginationStartIndex;
+    return startIndex !== void 0 && ((_b = datasource._paginationConfig) == null ? void 0 : _b.type) === "page" ? Number(startIndex) : 1;
+  };
+  const datasourceInvoke = useCallback(
+    (page, size, isScrollMode = false) => {
+      if (isServerSidePagination && datasource && typeof datasource.invoke === "function") {
+        if (isFetchingRef.current) {
+          return Promise.resolve();
+        }
+        isFetchingRef.current = true;
+        setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { error: null }));
+        try {
+          const invokeOptions = { page };
+          if (size !== void 0) {
+            invokeOptions.size = size;
+          }
+          if (datasourceInvokeOptions) {
+            Object.assign(invokeOptions, datasourceInvokeOptions);
+          }
+          invokeOptions.page = page - 1 + getPaginationStartIndex();
+          const result = datasource.invoke(invokeOptions);
+          return Promise.resolve(result).then((response) => {
+            isFetchingRef.current = false;
+            if (isScrollMode && response && response.data) {
+              const currentAccumulatedData = accumulatingStateRef.current.accumulatedData;
+              const newDataWithIds = addUniqueRowIds(response.data);
+              const newAccumulatedData = [...currentAccumulatedData, ...newDataWithIds];
+              setAccumulatingState((prev) => __spreadProps(__spreadValues({}, prev), {
+                accumulatedData: newAccumulatedData,
+                lastLoadedPage: page
+              }));
+              setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+                fullData: newAccumulatedData,
+                result: newAccumulatedData
+              }));
+            }
+            return response;
+          }).catch((error) => {
+            isFetchingRef.current = false;
+            setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), {
+              error: error.message || "Failed to fetch page data"
+            }));
+            return Promise.reject(error);
+          });
+        } catch (error) {
+          isFetchingRef.current = false;
+          console.error("Error invoking datasource:", error);
+          setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), {
+            error: error.message || "Failed to invoke datasource"
+          }));
+          return Promise.reject(error);
+        }
+      }
+      return Promise.resolve();
+    },
+    [datasource, isServerSidePagination, datasourceInvokeOptions]
+  );
+  const loadMoreData = useCallback(
+    (event) => {
+      const isAccumulatingMode = navigation === "Scroll" || navigation === "On-Demand";
+      if (!isAccumulatingMode || isLastPage || isFetchingRef.current) {
+        return;
+      }
+      if (!isServerSidePagination) {
+        const currentVisible = accumulatingStateRef.current.accumulatedData.length;
+        const totalAvailable = dataState.fullData.length;
+        const nextBatchSize = paginationState.currentMaxResults;
+        const newVisibleCount = Math.min(currentVisible + nextBatchSize, totalAvailable);
+        const nextBatch = dataState.fullData.slice(currentVisible, newVisibleCount);
+        const newAccumulatedData = [...accumulatingStateRef.current.accumulatedData, ...nextBatch];
+        setAccumulatingState((prev) => __spreadProps(__spreadValues({}, prev), {
+          accumulatedData: newAccumulatedData,
+          lastLoadedPage: prev.lastLoadedPage + 1
+        }));
+        setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+          result: newAccumulatedData
+        }));
+        const nextPage2 = accumulatingStateRef.current.lastLoadedPage + 1;
+        setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: nextPage2 }));
+        if (onPaginationChange) {
+          onPaginationChange(
+            event || createDummyEvent("paginationchange"),
+            widgetInstance,
+            nextPage2
+          );
+        }
+        return;
+      }
+      const nextPage = accumulatingStateRef.current.lastLoadedPage + 1;
+      if (setIsLoadingMore) {
+        setIsLoadingMore(true);
+      }
+      datasourceInvoke(nextPage, paginationState.currentMaxResults, true).then(() => {
+        setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: nextPage }));
+        if (onPaginationChange) {
+          onPaginationChange(
+            event || createDummyEvent("paginationchange"),
+            widgetInstance,
+            nextPage
+          );
+        }
+        if (setIsLoadingMore) {
+          setIsLoadingMore(false);
+        }
+      }).catch(() => {
+        if (setIsLoadingMore) {
+          setIsLoadingMore(false);
+        }
+      });
+    },
+    [
+      navigation,
+      isServerSidePagination,
+      isLastPage,
+      setIsLoadingMore,
+      datasourceInvoke,
+      paginationState.currentMaxResults,
+      onPaginationChange,
+      widgetInstance,
+      dataState.fullData
+    ]
+  );
+  const resetAccumulatedData = useCallback(
+    (event) => {
+      if (navigation === "Scroll") {
+        sentinelHasLeftViewportRef.current = false;
+      }
+      isResettingRef.current = true;
+      setAccumulatingState({
+        accumulatedData: [],
+        lastLoadedPage: 0,
+        isAccumulating: navigation === "Scroll" || navigation === "On-Demand",
+        isInitialized: false
+      });
+      setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+        result: []
+      }));
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: 1 }));
+      if (onPaginationChange) {
+        onPaginationChange(event || createDummyEvent(), widgetInstance, 1);
+      }
+      if (!isServerSidePagination && dataState.fullData.length > 0) {
+        const firstPageData = dataState.fullData.slice(0, paginationState.currentMaxResults);
+        setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+          result: firstPageData
+        }));
+        setTimeout(() => {
+          setAccumulatingState({
+            accumulatedData: firstPageData,
+            lastLoadedPage: 1,
+            isAccumulating: true,
+            isInitialized: true
+          });
+        }, 0);
+      }
+      if (isServerSidePagination && datasource && typeof datasource.invoke === "function") {
+        if (setIsLoadingMore) {
+          setIsLoadingMore(true);
+        }
+        const invokeOptions = {
+          page: 1
+        };
+        if (datasourceInvokeOptions) {
+          Object.assign(invokeOptions, datasourceInvokeOptions);
+        }
+        const result = datasource.invoke(invokeOptions);
+        Promise.resolve(result).then((response) => {
+          if (response && response.data) {
+            const newDataWithIds = addUniqueRowIds(response.data);
+            setAccumulatingState({
+              accumulatedData: newDataWithIds,
+              lastLoadedPage: 1,
+              isAccumulating: true,
+              isInitialized: true
+            });
+            setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+              fullData: newDataWithIds,
+              result: newDataWithIds
+            }));
+            isResettingRef.current = false;
+          }
+          if (setIsLoadingMore) {
+            setIsLoadingMore(false);
+          }
+        }).catch(() => {
+          isResettingRef.current = false;
+          if (setIsLoadingMore) {
+            setIsLoadingMore(false);
+          }
+        });
+      } else {
+        setTimeout(() => {
+          isResettingRef.current = false;
+        }, 0);
+      }
+    },
+    [
+      navigation,
+      isServerSidePagination,
+      datasource,
+      datasourceInvokeOptions,
+      dataState.fullData,
+      paginationState.currentMaxResults,
+      setIsLoadingMore,
+      onPaginationChange,
+      widgetInstance
+    ]
+  );
+  const isRowScroll = navigation === "Scroll" && (listDirection === "row" || listDirection === "horizontal");
+  const setupInfiniteScrollObserver = useCallback(
+    (sentinel, scrollRoot) => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
+      if (!sentinel || navigation !== "Scroll" || !accumulatingStateRef.current.isInitialized) {
+        return;
+      }
+      if (isRowScroll && !scrollRoot) {
+        return;
+      }
+      observerRef.current = new IntersectionObserver(
+        (entries) => {
+          const entry = entries[0];
+          if (!entry.isIntersecting && sentinelHasLeftViewportRef.current === false) {
+            sentinelHasLeftViewportRef.current = true;
+          }
+          if (entry.isIntersecting && accumulatingStateRef.current.isInitialized && !isLastPage && !isFetchingRef.current && sentinelHasLeftViewportRef.current) {
+            loadMoreData();
+            sentinelHasLeftViewportRef.current = false;
+          }
+        },
+        {
+          root: scrollRoot != null ? scrollRoot : null,
+          rootMargin: isRowScroll ? "0px" : "100px",
+          threshold: 0.1
+        }
+      );
+      observerRef.current.observe(sentinel);
+    },
+    [navigation, isLastPage, loadMoreData, listDirection, isRowScroll]
+  );
+  const setDefaultPagingValues = useCallback(
+    (newDataSize, newMaxResults, currentPage) => {
+      setPaginationState((prev) => {
+        if (!newDataSize && !newMaxResults) {
+          return __spreadProps(__spreadValues({}, prev), {
+            pageCount: 1,
+            dataSize: newDataSize,
+            currentPage: currentPage !== void 0 ? currentPage : prev.currentPage
+          });
+        } else {
+          const updatedMaxResults = newMaxResults || prev.currentMaxResults;
+          const updatedDataSize = newDataSize !== void 0 ? newDataSize : prev.dataSize;
+          const updatedCurrentPage = currentPage !== void 0 ? currentPage : prev.currentPage;
+          const newPageCount = (paginationMeta == null ? void 0 : paginationMeta.totalPages) !== void 0 && (paginationMeta == null ? void 0 : paginationMeta.totalPages) > 1 ? paginationMeta.totalPages : updatedDataSize > updatedMaxResults ? Math.ceil(updatedDataSize / updatedMaxResults) : updatedDataSize < 0 ? 0 : 1;
+          return __spreadProps(__spreadValues({}, prev), {
+            currentPage: updatedCurrentPage,
+            dataSize: updatedDataSize,
+            pageCount: newPageCount
+          });
+        }
+      });
+    },
+    [paginationMeta]
+  );
+  const disableNavigation = useCallback(() => {
+    setDisableStates({
+      isDisableFirst: isFirstPage,
+      isDisablePrevious: isFirstPage,
+      isDisableNext: isLastPage,
+      isDisableLast: isLastPage,
+      isDisableCurrent: isFirstPage && isLastPage,
+      isDisableCount: false
+    });
+  }, [isFirstPage, isLastPage]);
+  const setNonPageableData = useCallback(
+    (newVal) => {
+      let newDataSize, newMaxResults, currentPage, startIndex;
+      if (isServerSidePagination) {
+        const serverTotalCount = totalItems != null ? totalItems : paginationMeta == null ? void 0 : paginationMeta.totalElements;
+        newDataSize = serverTotalCount !== void 0 && serverTotalCount >= 0 ? serverTotalCount : isArray(newVal) ? newVal.length : isEmpty(newVal) ? 0 : 1;
+      } else {
+        newDataSize = isArray(newVal) ? newVal.length : isEmpty(newVal) ? 0 : 1;
+      }
+      newMaxResults = paginationState.currentMaxResults || newDataSize;
+      currentPage = paginationState.currentPage;
+      setDefaultPagingValues(newDataSize, newMaxResults, currentPage);
+      disableNavigation();
+      startIndex = (currentPage - 1) * newMaxResults;
+      setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+        result: isArray(newVal) ? newVal.slice(startIndex, startIndex + newMaxResults) : newVal
+      }));
+    },
+    [
+      paginationState.currentPage,
+      paginationState.currentMaxResults,
+      disableNavigation,
+      setDefaultPagingValues,
+      isServerSidePagination,
+      totalItems,
+      paginationMeta
+    ]
+  );
+  const setPagingValues = useCallback(
+    (newVal) => {
+      const isAccumulatingMode = (navigation === "Scroll" || navigation === "On-Demand") && isServerSidePagination;
+      if (isAccumulatingMode) {
+        const currentAccumulatedData = accumulatingStateRef.current.accumulatedData;
+        if (currentAccumulatedData.length === 0 && isArray(newVal)) {
+          const initialDataWithIds = addUniqueRowIds(newVal);
+          setAccumulatingState((prev) => __spreadProps(__spreadValues({}, prev), {
+            accumulatedData: initialDataWithIds,
+            lastLoadedPage: 1,
+            isInitialized: true
+          }));
+          setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+            fullData: initialDataWithIds,
+            result: initialDataWithIds
+          }));
+        } else if (currentAccumulatedData.length > 0) {
+          setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+            fullData: currentAccumulatedData,
+            result: currentAccumulatedData
+          }));
+        }
+        return;
+      }
+      if (navigation === "On-Demand" && !isServerSidePagination) {
+        setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+          fullData: isArray(newVal) ? newVal : []
+        }));
+        const currentAccumulatedData = accumulatingStateRef.current.accumulatedData;
+        if (currentAccumulatedData.length === 0 && isArray(newVal) && newVal.length > 0) {
+          const firstPageData = newVal.slice(0, paginationState.currentMaxResults);
+          setAccumulatingState((prev) => __spreadProps(__spreadValues({}, prev), {
+            accumulatedData: firstPageData,
+            lastLoadedPage: 1,
+            isInitialized: true
+          }));
+          setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+            result: firstPageData
+          }));
+        } else if (currentAccumulatedData.length > 0) {
+          setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+            result: currentAccumulatedData
+          }));
+        }
+        if (isArray(newVal)) {
+          setDefaultPagingValues(newVal.length, paginationState.currentMaxResults, 1);
+        }
+        return;
+      }
+      setDataState((prev) => __spreadProps(__spreadValues({}, prev), {
+        fullData: isArray(newVal) ? newVal : []
+      }));
+      if (newVal && !isArray(newVal)) {
+        setNonPageableData(newVal);
+      } else if (newVal) {
+        setNonPageableData(newVal);
+      } else {
+        setDataState((prev) => __spreadProps(__spreadValues({}, prev), { result: newVal }));
+        setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { pageCount: 0, dataSize: 0 }));
+      }
+    },
+    [
+      setNonPageableData,
+      navigation,
+      isServerSidePagination,
+      paginationState.currentMaxResults,
+      setDefaultPagingValues
+    ]
+  );
+  const validateCurrentPage = useCallback(
+    (event) => {
+      const { currentPage, pageCount } = paginationState;
+      if (event && (isNaN(currentPage) || currentPage <= 0 || pageCount && (currentPage > pageCount || isNull(currentPage)))) {
+        if (currentPage <= 0) {
+          setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: 1 }));
+        } else if (currentPage > pageCount) {
+          setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: pageCount }));
+        }
+        return false;
+      }
+      return true;
+    },
+    [paginationState]
+  );
+  const goToPage = useCallback(() => {
+    const { currentPage, currentMaxResults } = paginationState;
+    const { fullData } = dataState;
+    const firstRow = (currentPage - 1) * currentMaxResults;
+    const startIndex = firstRow;
+    const data = isArray(fullData) ? fullData.slice(startIndex, startIndex + currentMaxResults) : fullData;
+    setDataState((prev) => __spreadProps(__spreadValues({}, prev), { result: data }));
+    disableNavigation();
+  }, [paginationState, dataState.fullData, disableNavigation]);
+  const performPageNavigation = useCallback(
+    (newPage, previousPage, event) => {
+      if (setIsLoadingMore) {
+        setIsLoadingMore(true);
+      }
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: newPage }));
+      if (isServerSidePagination) {
+        datasourceInvoke(newPage).then(() => {
+          if (onPaginationChange) {
+            onPaginationChange(
+              event || createDummyEvent("paginationchange"),
+              widgetInstance,
+              newPage
+            );
+          }
+          if (onSetRecord) {
+            const firstRow = (newPage - 1) * paginationState.currentMaxResults;
+            const startIndex = firstRow;
+            const data = isArray(dataState.fullData) ? dataState.fullData.slice(
+              startIndex,
+              startIndex + paginationState.currentMaxResults
+            ) : dataState.fullData;
+            const pageInfo = {
+              currentPage: newPage,
+              size: paginationState.currentMaxResults,
+              totalElements: (paginationMeta == null ? void 0 : paginationMeta.totalElements) || dataState.fullData.length,
+              totalPages: paginationState.pageCount
+            };
+            onSetRecord(event || createDummyEvent("setrecord"), widgetInstance, data, pageInfo);
+          }
+          if (setIsLoadingMore) {
+            setIsLoadingMore(false);
+          }
+        }).catch(() => {
+          setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), {
+            currentPage: previousPage || paginationState.currentPage
+          }));
+          if (setIsLoadingMore) {
+            setIsLoadingMore(false);
+          }
+        });
+      } else {
+        if (onPaginationChange) {
+          onPaginationChange(
+            event || createDummyEvent("paginationchange"),
+            widgetInstance,
+            newPage
+          );
+        }
+        if (onSetRecord) {
+          const firstRow = (newPage - 1) * paginationState.currentMaxResults;
+          const startIndex = firstRow;
+          const data = isArray(dataState.fullData) ? dataState.fullData.slice(startIndex, startIndex + paginationState.currentMaxResults) : dataState.fullData;
+          const pageInfo = {
+            currentPage: newPage,
+            size: paginationState.currentMaxResults,
+            totalElements: (paginationMeta == null ? void 0 : paginationMeta.totalElements) || dataState.fullData.length,
+            totalPages: paginationState.pageCount
+          };
+          onSetRecord(event || createDummyEvent("setrecord"), widgetInstance, data, pageInfo);
+        }
+        if (setIsLoadingMore) {
+          setIsLoadingMore(false);
+        }
+      }
+    },
+    [
+      isServerSidePagination,
+      datasourceInvoke,
+      onPaginationChange,
+      onSetRecord,
+      widgetInstance,
+      paginationState,
+      dataState.fullData,
+      setIsLoadingMore,
+      paginationMeta
+    ]
+  );
+  const navigatePage = useCallback(
+    (index, event, isRefresh = false) => {
+      const currentPage = +paginationState.currentPage;
+      let newPage = currentPage;
+      switch (index) {
+        case "first":
+          if (!isFirstPage) {
+            newPage = 1;
+          } else if (isRefresh) {
+            goToPage();
+            return;
+          } else {
+            return;
+          }
+          break;
+        case "prev":
+          if (isFirstPage || !validateCurrentPage(event)) {
+            return;
+          }
+          newPage = currentPage - 1;
+          break;
+        case "next":
+          if (isLastPage || !validateCurrentPage(event)) {
+            return;
+          }
+          newPage = currentPage + 1;
+          break;
+        case "last":
+          if (!isLastPage) {
+            newPage = paginationState.pageCount;
+          } else if (isRefresh) {
+            goToPage();
+            return;
+          } else {
+            return;
+          }
+          break;
+        default:
+          return;
+      }
+      if (newPage !== currentPage) {
+        performPageNavigation(newPage, currentPage, event);
+      }
+    },
+    [paginationState, isFirstPage, isLastPage, validateCurrentPage, goToPage, performPageNavigation]
+  );
+  const handlePageChange = useCallback(
+    (event, page) => {
+      if (page !== paginationState.currentPage) {
+        const previousPage = paginationState.currentPage;
+        performPageNavigation(page, previousPage, event);
+      }
+    },
+    [paginationState.currentPage, performPageNavigation]
+  );
+  const handleInputChange = useCallback((event) => {
+    const value = parseInt(event.target.value, 10);
+    if (!isNaN(value)) {
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: value }));
+    }
+  }, []);
+  const onModelChange = useCallback(
+    (event) => {
+      if (!validateCurrentPage(event)) {
+        return;
+      }
+      if (onSetRecord) {
+        const { currentPage, currentMaxResults, pageCount } = paginationState;
+        const { fullData } = dataState;
+        const firstRow = (currentPage - 1) * currentMaxResults;
+        const startIndex = firstRow;
+        const data = isArray(fullData) ? fullData.slice(startIndex, startIndex + currentMaxResults) : fullData;
+        const pageInfo = {
+          currentPage,
+          size: currentMaxResults,
+          totalElements: (paginationMeta == null ? void 0 : paginationMeta.totalElements) || fullData.length,
+          totalPages: pageCount
+        };
+        onSetRecord(event, widgetInstance, data, pageInfo);
+      }
+      goToPage();
+    },
+    [
+      goToPage,
+      validateCurrentPage,
+      onSetRecord,
+      paginationState,
+      dataState.fullData,
+      widgetInstance,
+      paginationMeta
+    ]
+  );
+  const onKeyDown = useCallback((event) => {
+    if (event.code === "KeyE") {
+      event.currentTarget.classList.add("ng-invalid");
+      return false;
+    }
+    event.currentTarget.classList.remove("ng-invalid");
+    return true;
+  }, []);
+  const handlePageSizeChange = useCallback(
+    (event, pageSize) => {
+      const { currentMaxResults: oldPageSize, currentPage: oldPage, dataSize } = paginationState;
+      const actualPageSize = oldPageSize;
+      if (isDataSourceHasPaging(datasource) && datasource) {
+        datasource.maxResults = pageSize;
+      }
+      setPaginationState((prev) => {
+        const newPageCount = calculatePagingValues(dataSize, pageSize);
+        return __spreadProps(__spreadValues({}, prev), {
+          currentMaxResults: pageSize,
+          currentPage: 1,
+          // Always go to first page like Angular
+          pageCount: newPageCount
+        });
+      });
+      if (setIsLoadingMore) {
+        setIsLoadingMore(true);
+      }
+      if (pageSizeChangeHandler) {
+        pageSizeChangeHandler(pageSize);
+      }
+      if (isServerSidePagination) {
+        datasourceInvoke(1, pageSize).then(() => {
+          if (onPaginationChange) {
+            onPaginationChange(event || createDummyEvent("paginationchange"), widgetInstance, 1);
+          }
+          if (onSetRecord) {
+            const data = isArray(dataState.fullData) ? dataState.fullData.slice(0, pageSize) : dataState.fullData;
+            const newPageCount = calculatePagingValues(dataState.fullData.length, pageSize);
+            const pageInfo = {
+              currentPage: 1,
+              size: pageSize,
+              totalElements: (paginationMeta == null ? void 0 : paginationMeta.totalElements) || dataState.fullData.length,
+              totalPages: newPageCount
+            };
+            onSetRecord(event || createDummyEvent("setrecord"), widgetInstance, data, pageInfo);
+          }
+          if (setIsLoadingMore) {
+            setIsLoadingMore(false);
+          }
+        }).catch(() => {
+          if (setIsLoadingMore) {
+            setIsLoadingMore(false);
+          }
+        });
+      } else {
+        setTimeout(() => {
+          navigatePage("first", event, true);
+        }, 0);
+        if (setIsLoadingMore) {
+          setIsLoadingMore(false);
+        }
+      }
+    },
+    [
+      pageSizeChangeHandler,
+      navigatePage,
+      datasource,
+      paginationState,
+      isServerSidePagination,
+      datasourceInvoke,
+      onPaginationChange,
+      onSetRecord,
+      widgetInstance,
+      dataState.fullData,
+      setIsLoadingMore,
+      paginationMeta
+    ]
+  );
+  useEffect(() => {
+    setNavcontrols(getValidNavControl(navigation));
+    if (navigation === "Scroll" || navigation === "On-Demand") {
+      setAccumulatingState({
+        accumulatedData: [],
+        lastLoadedPage: 0,
+        isAccumulating: true,
+        isInitialized: false
+      });
+    }
+  }, [navigation]);
+  useEffect(() => {
+    if (dataset !== void 0) {
+      const processedDataset = extractDataArray(dataset);
+      const isAccumulatingMode = (navigation === "Scroll" || navigation === "On-Demand") && isServerSidePagination;
+      if (isAccumulatingMode) {
+        const currentAccumulatedData = accumulatingStateRef.current.accumulatedData;
+        if (currentAccumulatedData.length === 0 && !isResettingRef.current) {
+          setPagingValues(processedDataset);
+        }
+      } else {
+        setPagingValues(processedDataset);
+      }
+    }
+  }, [dataset, setPagingValues, navigation, isServerSidePagination]);
+  useEffect(() => {
+    if (isServerSidePagination) {
+      const totalCount = totalItems != null ? totalItems : paginationMeta == null ? void 0 : paginationMeta.totalElements;
+      if (totalCount !== void 0 && totalCount >= 0) {
+        setPaginationState((prev) => {
+          let updates = {
+            dataSize: totalCount
+          };
+          if ((paginationMeta == null ? void 0 : paginationMeta.totalPages) !== void 0) {
+            updates.pageCount = paginationMeta.totalPages;
+          } else if (prev.currentMaxResults > 0) {
+            updates.pageCount = Math.ceil(totalCount / prev.currentMaxResults) || 1;
+          }
+          if ((paginationMeta == null ? void 0 : paginationMeta.totalPages) && prev.currentPage > paginationMeta.totalPages) {
+            updates.currentPage = Math.max(1, paginationMeta.totalPages);
+          }
+          if (totalCount === 0) {
+            updates.pageCount = 1;
+            updates.currentPage = 1;
+          }
+          return __spreadValues(__spreadValues({}, prev), updates);
+        });
+      }
+    }
+  }, [isServerSidePagination, totalItems, paginationMeta]);
+  const hasServerReportedPage = isServerSidePagination && (paginationMeta == null ? void 0 : paginationMeta.number) !== void 0 && (paginationMeta == null ? void 0 : paginationMeta.number) !== null;
+  useEffect(() => {
+    if (hasServerReportedPage) {
+      return;
+    }
+    if (initialPage !== void 0 && initialPage !== paginationState.currentPage) {
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: initialPage }));
+      disableNavigation();
+    }
+  }, [initialPage, paginationState.currentPage, disableNavigation, hasServerReportedPage]);
+  useEffect(() => {
+    if (!isServerSidePagination) {
+      return;
+    }
+    const metaPageNumber = paginationMeta == null ? void 0 : paginationMeta.number;
+    if (metaPageNumber === void 0 || metaPageNumber === null) {
+      return;
+    }
+    const serverCurrentPage = metaPageNumber + 1;
+    if (serverCurrentPage > 0 && serverCurrentPage !== paginationState.currentPage) {
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentPage: serverCurrentPage }));
+      disableNavigation();
+    }
+  }, [
+    isServerSidePagination,
+    paginationMeta == null ? void 0 : paginationMeta.number,
+    paginationState.currentPage,
+    disableNavigation
+  ]);
+  useEffect(() => {
+    if (maxResults !== paginationState.currentMaxResults) {
+      setPaginationState((prev) => __spreadProps(__spreadValues({}, prev), { currentMaxResults: maxResults }));
+    }
+  }, [maxResults, paginationState.currentMaxResults]);
+  useEffect(() => {
+    var _a2;
+    if (!accumulatingState.isInitialized || !sentinelRef.current || navigation !== "Scroll") return;
+    const scrollRoot = isRowScroll ? (_a2 = scrollContainerRef == null ? void 0 : scrollContainerRef.current) != null ? _a2 : null : null;
+    if (isRowScroll && !scrollRoot) return;
+    setupInfiniteScrollObserver(sentinelRef.current, scrollRoot);
+  }, [accumulatingState.isInitialized, navigation, setupInfiniteScrollObserver, isRowScroll]);
+  useEffect(() => {
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
+    };
+  }, []);
+  return {
+    // State
+    currentPage: paginationState.currentPage,
+    pageCount: paginationState.pageCount,
+    dataSize: paginationState.dataSize,
+    result: dataState.result,
+    navcontrols,
+    currentMaxResults: paginationState.currentMaxResults,
+    error: paginationState.error,
+    // Disable states
+    isDisableNext: disableStates.isDisableNext,
+    isDisablePrevious: disableStates.isDisablePrevious,
+    isDisableFirst: disableStates.isDisableFirst,
+    isDisableLast: disableStates.isDisableLast,
+    isDisableCurrent: disableStates.isDisableCurrent,
+    isDisableCount: disableStates.isDisableCount,
+    // Actions
+    navigatePage,
+    handlePageChange,
+    handleInputChange,
+    onModelChange,
+    onKeyDown,
+    setDn: (value) => setPaginationState((prev) => __spreadValues(__spreadValues({}, prev), value)),
+    handlePageSizeChange,
+    // Utilities
+    isFirstPage,
+    isLastPage,
+    isFetching: isFetchingRef.current,
+    // Infinite scroll specific
+    setupInfiniteScrollObserver,
+    sentinelRef,
+    isLoadingMore: isFetchingRef.current && (navigation === "Scroll" || navigation === "On-Demand") && accumulatingStateRef.current.lastLoadedPage > 0,
+    hasMoreData: !isLastPage && (navigation === "Scroll" || navigation === "On-Demand"),
+    // On-Demand specific
+    loadMoreData,
+    resetAccumulatedData,
+    accumulatedDataCount: accumulatingStateRef.current.accumulatedData.length
+  };
+};
+export {
+  usePagination
+};