@adyen/adyen-platform-experience-web 0.1.2 → 1.0.0-beta.1

package/dist/es/components/internal/Pagination/hooks/usePageLimit.js

@@ -1,67 +1,75 @@
-import { useRef as f, useMemo as a } from "../../../../external/preact/hooks/dist/hooks.module.js";
-import { DEFAULT_PAGE_LIMIT as l } from "../constants.js";
-import { getClampedPageLimit as m } from "../utils.js";
-import { isNumber as d, mid as p } from "../../../../utils/common/index.js";
-const h = (r, o) => {
-  const n = r.length - 1;
-  if (n < 0)
-    return o;
-  if (o <= r[0])
-    return r[0];
-  if (o >= r[n])
-    return r[n];
-  let i = 0, c = 0, s = n;
-  for (; ; ) {
-    const e = r[i = p(c, s)];
-    if (c > s || o === e)
-      return e;
-    o > e ? c = i + 1 : s = i - 1;
+import { _, F } from "../../../../../hooks.module-8565d716.mjs";
+import { DEFAULT_PAGE_LIMIT } from "../constants.js";
+import { getClampedPageLimit } from "../utils.js";
+import { mid, isNumber } from "../../../../utils/common/index.js";
+const getNearestFromSortedUniqueNums = (nums, target) => {
+  const lastindex = nums.length - 1;
+  if (lastindex < 0)
+    return target;
+  if (target <= nums[0])
+    return nums[0];
+  if (target >= nums[lastindex])
+    return nums[lastindex];
+  let index = 0, lo = 0, hi = lastindex;
+  while (true) {
+    const current = nums[index = mid(lo, hi)];
+    if (lo > hi || target === current)
+      return current;
+    target > current ? lo = index + 1 : hi = index - 1;
   }
-}, b = ({
-  preferredLimit: r = l,
-  preferredLimitOptions: o
+};
+const usePageLimit = ({
+  preferredLimit = DEFAULT_PAGE_LIMIT,
+  preferredLimitOptions
 }) => {
-  const n = f(), i = f(), c = a(() => {
+  const cachedLimitOptions = _();
+  const cachedLimit = _();
+  const options = F(() => {
     try {
-      const e = /* @__PURE__ */ new Set();
-      for (const t of o) {
-        const u = m(t);
-        u > 0 && e.add(u);
+      const uniqueOptions = /* @__PURE__ */ new Set();
+      for (const option of preferredLimitOptions) {
+        const limit2 = getClampedPageLimit(option);
+        if (limit2 > 0)
+          uniqueOptions.add(limit2);
       }
-      return Object.freeze([...e].sort((t, u) => t - u));
+      return Object.freeze([...uniqueOptions].sort((a, b) => a - b));
     } catch {
     }
-  }, [o]);
-  return { limit: a(() => {
-    let e = m(r) || l;
-    e:
+  }, [preferredLimitOptions]);
+  const limit = F(() => {
+    let limit2 = getClampedPageLimit(preferredLimit) || DEFAULT_PAGE_LIMIT;
+    parsing:
       try {
-        if (n.current === c)
-          break e;
-        const t = new Set(n.current = c);
-        if (t.size === 0) {
-          n.current = void 0;
-          break e;
+        if (cachedLimitOptions.current === options)
+          break parsing;
+        const uniqueOptions = new Set(cachedLimitOptions.current = options);
+        if (uniqueOptions.size === 0) {
+          cachedLimitOptions.current = void 0;
+          break parsing;
         }
-        if (i.current !== e)
-          t: {
-            if (t.size === t.add(e).size)
-              break t;
-            if (t.delete(e), t.size === t.add(i.current).size) {
-              if (d(i.current)) {
-                e = i.current;
-                break t;
+        if (cachedLimit.current !== limit2) {
+          selection: {
+            if (uniqueOptions.size === uniqueOptions.add(limit2).size) {
+              break selection;
+            } else
+              uniqueOptions.delete(limit2);
+            if (uniqueOptions.size === uniqueOptions.add(cachedLimit.current).size) {
+              if (isNumber(cachedLimit.current)) {
+                limit2 = cachedLimit.current;
+                break selection;
               }
             } else
-              t.delete(i.current);
-            e = h(n.current, e);
+              uniqueOptions.delete(cachedLimit.current);
+            limit2 = getNearestFromSortedUniqueNums(cachedLimitOptions.current, limit2);
           }
+        }
       } catch {
       }
-    return i.current = e;
-  }, [c, r]), limitOptions: c };
-}, P = b;
+    return cachedLimit.current = limit2;
+  }, [options, preferredLimit]);
+  return { limit, limitOptions: options };
+};
 export {
-  P as default,
-  h as getNearestFromSortedUniqueNums
+  usePageLimit as default,
+  getNearestFromSortedUniqueNums
 };

package/dist/es/components/internal/Pagination/hooks/usePaginatedRecords.js

@@ -1,80 +1,13 @@
-import { useState as R, useRef as q, useMemo as M, useCallback as b, useEffect as D } from "../../../../external/preact/hooks/dist/hooks.module.js";
-import H from "./usePageLimit.js";
-import K from "./useCursorPagination.js";
-import Q from "./useOffsetPagination.js";
-import W from "./usePaginatedRecordsFilters.js";
-import Z from "../../../../hooks/useBooleanState/useBooleanState.js";
-import C from "../../../../hooks/useMounted/useMounted.js";
-import { PageNeighbour as f, PaginationType as z } from "../types.js";
-import { EMPTY_OBJECT as w } from "../../../../utils/common/constants.js";
-const ee = [f.NEXT, f.PREV], te = ["hasNext", "hasPrevious"], y = (e) => {
-  const t = Object.getOwnPropertyNames(e);
-  return !te.some((r) => t.includes(r));
-}, re = (e, t = "data") => {
-  const r = e[t];
-  if (y(e)) {
-    const a = Object.fromEntries(
-      Object.entries(e || w).filter(
-        ([s, o]) => ee.includes(s) && o
-      )
-    );
-    return { records: r, paginationData: a };
-  }
-  throw new TypeError("MALFORMED_PAGINATED_DATA");
-}, se = (e, t = "data") => {
-  const r = e[t];
-  if (!y(e)) {
-    const { hasNext: a, hasPrevious: s } = e, o = {
-      [f.NEXT]: a === !0,
-      [f.PREV]: s === !0
-    };
-    return { records: r, paginationData: o };
-  }
-  throw new TypeError("MALFORMED_PAGINATED_DATA");
-}, oe = ({
-  dataField: e = "data",
-  fetchRecords: t,
-  filterParams: r = w,
-  initialFiltersSameAsDefault: a = !0,
-  initialize: s,
-  onFiltersChanged: o,
-  onLimitChanged: P,
-  pagination: F,
-  preferredLimit: _,
-  preferredLimitOptions: h,
-  enabled: T
-}) => {
-  const [$, j] = R([]), [v, m] = Z(!0), [x, O] = R(), [I, L] = R(_), A = C(), d = q(!0), N = W(r, a), { limit: u, limitOptions: S } = H({ preferredLimit: I, preferredLimitOptions: h }), { defaultFilters: ae, filters: n, updateFilters: B, ...G } = N, [V, X] = M(
-    () => F === z.CURSOR ? [re, K] : [se, Q],
-    []
-  ), k = b((E) => L(E), []), { goto: g, page: J, pages: U, ...Y } = X(
-    b(
-      async (E, i) => {
-        try {
-          if (O(void 0), !A.current || m(!0))
-            return;
-          const p = await t({ ...E, ...n }, i), { records: c, paginationData: l } = V(p, e);
-          return d.current && (s == null || s([c, l], N), d.current = !1), A.current && (j(c), m(!1)), { ...l, size: c == null ? void 0 : c.length };
-        } catch (p) {
-          if (i != null && i.aborted)
-            return;
-          m(!1), O(p), console.error(p);
-        }
-      },
-      [t, n, u]
-    ),
-    u
-  );
-  return M(() => {
-    d.current = !0;
-  }, [r]), D(() => {
-    T && g(1);
-  }, [g, T]), D(() => {
-    o == null || o(n);
-  }, [n]), D(() => {
-    P == null || P(u);
-  }, [u]), { error: x, fetching: v, filters: n, goto: g, limitOptions: S, page: J, pages: U, records: $, updateFilters: B, updateLimit: k, ...G, ...Y };
-}, ge = oe;
+import "../../../../../hooks.module-8565d716.mjs";
+import "../../../../utils/common/index.js";
+import "./usePageLimit.js";
+import "./useCursorPagination.js";
+import "./useOffsetPagination.js";
+import "./usePaginatedRecordsFilters.js";
+import "../../../../hooks/useBooleanState/useBooleanState.js";
+import "../../../../hooks/useMounted/useMounted.js";
+import { u } from "../../../../../usePaginatedRecords-63a69bf1.mjs";
+import "../../../../utils/common/constants.js";
 export {
-  ge as default
+  u as default
 };

package/dist/es/components/internal/Pagination/hooks/usePaginatedRecordsFilters.js

@@ -1,15 +1,16 @@
-import o from "../../../../hooks/useReactiveState/useReactiveState.js";
-import { EMPTY_OBJECT as d } from "../../../../utils/common/constants.js";
-const u = (t = d, e) => {
+import "../../../../utils/common/index.js";
+import useReactiveState from "../../../../hooks/useReactiveState/useReactiveState.js";
+import { EMPTY_OBJECT } from "../../../../utils/common/constants.js";
+const usePaginatedRecordsFilters = (filterParams = EMPTY_OBJECT, initialFiltersSameAsDefault) => {
   const {
-    canResetState: s,
-    defaultState: a,
-    resetState: r,
-    state: i,
-    updateState: l
-  } = o(t, e);
-  return { canResetFilters: s, defaultFilters: a, filters: i, resetFilters: r, updateFilters: l };
-}, f = u;
+    canResetState: canResetFilters,
+    defaultState: defaultFilters,
+    resetState: resetFilters,
+    state: filters,
+    updateState: updateFilters
+  } = useReactiveState(filterParams, initialFiltersSameAsDefault);
+  return { canResetFilters, defaultFilters, filters, resetFilters, updateFilters };
+};
 export {
-  f as default
+  usePaginatedRecordsFilters as default
 };

package/dist/es/components/internal/Pagination/hooks/usePagination.js

@@ -1,45 +1,91 @@
-import { useRef as p, useCallback as C, useState as F, useMemo as a, useEffect as G } from "../../../../external/preact/hooks/dist/hooks.module.js";
-import T from "../../../../hooks/useBooleanState/useBooleanState.js";
-import _ from "../../../../hooks/useMounted/useMounted.js";
-import { getClampedPageLimit as j } from "../utils.js";
-import { noop as H } from "../../../../utils/common/index.js";
-const J = (y, P, M) => {
-  const u = p(), s = p(), l = p(), r = p(), i = _(
-    C(() => {
-      var o;
-      (o = u.current) == null || o.abort(), u.current = void 0;
+import { _, T, h, F, p } from "../../../../../hooks.module-8565d716.mjs";
+import useBooleanState from "../../../../hooks/useBooleanState/useBooleanState.js";
+import useMounted from "../../../../hooks/useMounted/useMounted.js";
+import { getClampedPageLimit } from "../utils.js";
+import { noop } from "../../../../utils/common/index.js";
+const usePagination = (paginationSetupConfig, requestPageCallback, pageLimit) => {
+  const $controller = _();
+  const $maxVisitedPage = _();
+  const $maxVisitedPageSize = _();
+  const $page = _();
+  const $mounted = useMounted(
+    T(() => {
+      var _a;
+      (_a = $controller.current) == null ? void 0 : _a.abort();
+      $controller.current = void 0;
     }, [])
-  ), [t, h] = F(r.current), [m, $] = T(!1), e = a(() => j(M), [M]), { getPageCount: x, getPageParams: V, resetPageCount: I, updatePagination: R } = y, n = a(() => (I(), s.current = l.current = r.current = void 0, i.current && h(r.current), P ? (o) => {
-    var z;
-    if (!(e && Number.isInteger(o)))
-      return;
-    const g = x(), c = o < 0 ? o + g + 1 : o;
-    c > 0 && (g ? c <= g : c === 1) && ((z = u.current) == null || z.abort(), u.current = new AbortController(), i.current && (((r.current = c) > 1 || g) && h(r.current), (async () => {
-      const { signal: S } = u.current, B = { ...V(c, e), limit: e };
-      try {
-        const d = await P(B, S);
-        if (!d || !i.current)
-          return;
-        const { size: b, ...D } = d;
-        R(c, e, D), s.current = r.current && Math.max(r.current, s.current || -1 / 0), r.current && r.current === s.current && (l.current = b), r.current === 1 && b > 0 && h(r.current), r.current = void 0, $(!0);
-      } catch (d) {
-        if (S.aborted)
-          return;
-        console.error(d);
+  );
+  const [page, setCurrentPage] = h($page.current);
+  const [paginationChanged, updatePaginationChanged] = useBooleanState(false);
+  const limit = F(() => getClampedPageLimit(pageLimit), [pageLimit]);
+  const { getPageCount, getPageParams, resetPageCount, updatePagination } = paginationSetupConfig;
+  const goto = F(() => {
+    return requestPageCallback ? (page2) => {
+      var _a;
+      if (!(limit && Number.isInteger(page2)))
+        return;
+      const PAGES = getPageCount();
+      const requestedPage = page2 < 0 ? page2 + PAGES + 1 : page2;
+      const isValidPageRequest = requestedPage > 0 && (PAGES ? requestedPage <= PAGES : requestedPage === 1);
+      if (!isValidPageRequest)
+        return;
+      (_a = $controller.current) == null ? void 0 : _a.abort();
+      $controller.current = new AbortController();
+      if (!$mounted.current)
+        return;
+      if (($page.current = requestedPage) > 1 || PAGES) {
+        setCurrentPage($page.current);
       }
-    })()));
-  } : H), [e, P]), w = C(() => {
-    t && n(Math.min(t + 1, x()));
-  }, [n, t]), A = C(() => {
-    t && n(Math.max(t - 1, 1));
-  }, [n, t]), f = a(() => x() || t || void 0, [n, m]), E = a(() => !!(t && f) && t < f, [t, f]), N = a(() => !!t && t > 1, [t]), v = a(
-    () => s.current ? (s.current - 1) * e + (l.current || 0) : 0,
-    [n, m]
-  ), q = a(() => e && Math.min(e, v || 1 / 0) % e, [e, v]);
-  return G(() => {
-    i.current && m && $(!1);
-  }, [m]), { goto: n, hasNext: E, hasPrev: N, limit: e, next: w, page: t, pages: f, pageSize: q, prev: A, size: v };
-}, X = J;
+      (async () => {
+        const { signal } = $controller.current;
+        const params = { ...getPageParams(requestedPage, limit), limit, page: requestedPage };
+        try {
+          const data = await requestPageCallback(params, signal);
+          if (!data || !$mounted.current)
+            return;
+          const { size: size2, ...paginationData } = data;
+          updatePagination(requestedPage, limit, paginationData);
+          $maxVisitedPage.current = $page.current && Math.max($page.current, $maxVisitedPage.current || -Infinity);
+          if ($page.current && $page.current === $maxVisitedPage.current)
+            $maxVisitedPageSize.current = size2;
+          if ($page.current === 1 && size2 > 0)
+            setCurrentPage($page.current);
+          $page.current = void 0;
+          updatePaginationChanged(true);
+        } catch (ex) {
+          if (signal.aborted)
+            return;
+          console.error(ex);
+        }
+      })();
+    } : noop;
+  }, [limit, requestPageCallback]);
+  const next = T(() => {
+    page && goto(Math.min(page + 1, getPageCount()));
+  }, [goto, page]);
+  const prev = T(() => {
+    page && goto(Math.max(page - 1, 1));
+  }, [goto, page]);
+  const pages = F(() => getPageCount() || page || void 0, [goto, paginationChanged]);
+  const hasNext = F(() => !!(page && pages) && page < pages, [page, pages]);
+  const hasPrev = F(() => !!page && page > 1, [page]);
+  const size = F(
+    () => $maxVisitedPage.current ? ($maxVisitedPage.current - 1) * limit + ($maxVisitedPageSize.current || 0) : 0,
+    [goto, paginationChanged]
+  );
+  const pageSize = F(() => limit && Math.min(limit, size || Infinity) % limit, [limit, size]);
+  const resetPagination = T(() => {
+    resetPageCount();
+    $maxVisitedPage.current = $maxVisitedPageSize.current = $page.current = void 0;
+    $mounted.current && setCurrentPage($page.current);
+  }, [resetPageCount]);
+  p(() => {
+    if ($mounted.current && paginationChanged) {
+      updatePaginationChanged(false);
+    }
+  }, [paginationChanged]);
+  return { goto, hasNext, hasPrev, limit, next, page, pages, pageSize, prev, resetPagination, size };
+};
 export {
-  X as default
+  usePagination as default
 };

package/dist/es/components/internal/Pagination/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./Pagination.js";
+export {
+  default2 as default
+};

package/dist/es/components/internal/Pagination/utils.js

@@ -1,8 +1,8 @@
-import { MAX_PAGE_LIMIT as o } from "./constants.js";
-const a = (m) => {
-  const t = ~~m;
-  return t === m && t > 0 ? Math.min(t, o) : Math.max(t, 0);
+import { MAX_PAGE_LIMIT } from "./constants.js";
+const getClampedPageLimit = (pageLimit) => {
+  const limit = ~~pageLimit;
+  return limit === pageLimit && limit > 0 ? Math.min(limit, MAX_PAGE_LIMIT) : Math.max(limit, 0);
 };
 export {
-  a as getClampedPageLimit
+  getClampedPageLimit
 };