@plone/volto 19.1.6 → 19.2.0

package/types/helpers/Pagination/Pagination.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Pagination helpers.
+ * @module helpers/Pagination/Pagination
+ */
+/**
+ * A value that is meant to represent an integer, but which reaches us from
+ * user-editable block settings. The querystring widget stores `offset`,
+ * `limit` and `b_size` as JSON schema `number` fields, so a value may arrive
+ * as a string (`'3'`), as a float (`3.7`), or not at all.
+ */
+export type IntegerLike = number | string | null | undefined;
+/**
+ * Compute the `b_start` index for a `@querystring-search` request: the index
+ * of the first item the backend should return for the requested page.
+ *
+ * `offset` shifts the whole result set, letting a listing skip the first N
+ * items of its query while paginating over the remainder.
+ *
+ * Every parameter is coerced to an integer and the result is always a
+ * non-negative integer, so a malformed block setting degrades to a sane batch
+ * rather than sending `NaN` to the backend. When neither `bSize` nor
+ * `defaultPageSize` yields a positive batch size, paging cannot be applied and
+ * the result is `offset` alone.
+ * @function computeBStart
+ * @param {IntegerLike} page 1-based page number. Defaults to the first page.
+ * @param {IntegerLike} offset Number of leading items to skip. Defaults to 0.
+ * @param {IntegerLike} bSize Batch size configured on the block, if any.
+ * @param {IntegerLike} defaultPageSize Batch size to use when bSize is unset.
+ * @returns {number} A non-negative integer `b_start` index.
+ */
+export declare function computeBStart(page: IntegerLike, offset: IntegerLike, bSize: IntegerLike, defaultPageSize: IntegerLike): number;
+/**
+ * Compute the effective `limit` for a `@querystring-search` request.
+ *
+ * A listing that skips the first `offset` items still wants `limit` items
+ * afterwards, so the backend has to return the skipped items on top of the
+ * wanted ones: `offset + limit`.
+ *
+ * A limit of zero, or one that resolves to no usable number, means "no limit"
+ * — matching `plone.app.querystring`'s querybuilder, whose `limit` defaults to
+ * 0 and is only applied when truthy. Returning `offset` in that case would cap
+ * the batch at the very items the listing is about to skip, leaving it empty.
+ * @function computeLimit
+ * @param {IntegerLike} offset Number of leading items to skip. Defaults to 0.
+ * @param {IntegerLike} limit Number of items the listing wants, if capped.
+ * @returns {number | null} A positive integer limit, or null for no limit.
+ */
+export declare function computeLimit(offset: IntegerLike, limit: IntegerLike): number | null;
+/**
+ * Compute how many items a listing can actually show.
+ *
+ * The `items_total` reported by `@querystring-search` is the length of the
+ * whole result set: `plone.restapi`'s HypermediaBatch derives it from the
+ * sequence length, so `b_start` never reduces it. The items an offset skips
+ * are counted in there even though the listing never renders them.
+ * @function computeVisibleTotal
+ * @param {IntegerLike} total The `items_total` reported by the backend.
+ * @param {IntegerLike} offset Number of leading items skipped. Defaults to 0.
+ * @returns {number} A non-negative integer count of reachable items.
+ */
+export declare function computeVisibleTotal(total: IntegerLike, offset: IntegerLike): number;
+/**
+ * Compute how many pages a listing spans.
+ *
+ * `total` is expected to be the reachable item count, so pass the result of
+ * `computeVisibleTotal` for an offset listing rather than the raw backend
+ * total. Otherwise the listing advertises pages that resolve to an empty batch.
+ * @function computeTotalPages
+ * @param {IntegerLike} total Number of items the listing can show.
+ * @param {IntegerLike} bSize Batch size, i.e. items per page.
+ * @returns {number} A non-negative integer page count, 0 when there is no
+ * usable batch size.
+ */
+export declare function computeTotalPages(total: IntegerLike, bSize: IntegerLike): number;

package/src/actions/querystringsearch/querystringsearch.js

@@ -1,63 +0,0 @@
-import { GET_QUERYSTRING_RESULTS } from '@plone/volto/constants/ActionTypes';
-import config from '@plone/volto/registry';
-
-/**
- * Get querystring results.
- * @function getQueryStringResults
- * @param {Object} data Data.
- * @returns {Object} Get querystringsearch results action.
- */
-export function getQueryStringResults(path, data, subrequest, page) {
-  const { settings } = config;
-
-  // fixes https://github.com/plone/volto/issues/1059
-  let requestData = JSON.parse(JSON.stringify(data));
-
-  if (data?.depth != null) {
-    delete requestData.depth;
-    requestData.query.forEach((q) => {
-      if (q.i === 'path') {
-        // fixes https://github.com/plone/volto/issues/8349
-        // Skip if depth is already embedded in the path value (e.g. set via object browser)
-        const hasEmbeddedDepth = /::\d+$/.test(q.v);
-        if (!hasEmbeddedDepth) q.v += '::' + data.depth;
-      }
-    });
-  }
-
-  // fixes https://github.com/plone/volto/issues/2397
-  if (requestData?.sort_order !== null) {
-    if (typeof requestData.sort_order === 'boolean') {
-      requestData.sort_order = requestData.sort_order
-        ? 'descending'
-        : 'ascending';
-    }
-  }
-
-  const query = {
-    ...requestData,
-    ...(!requestData.b_size && {
-      b_size: settings.defaultPageSize,
-    }),
-    ...(page && {
-      b_start: requestData.b_size
-        ? data.b_size * (page - 1)
-        : settings.defaultPageSize * (page - 1),
-    }),
-    query: requestData?.query,
-  };
-
-  return {
-    type: GET_QUERYSTRING_RESULTS,
-    subrequest,
-    request: {
-      op: settings.querystringSearchGet ? 'get' : 'post',
-      path: `${path}/@querystring-search${
-        settings.querystringSearchGet
-          ? `?query=${encodeURIComponent(JSON.stringify(query))}`
-          : ''
-      }`,
-      data: settings.querystringSearchGet ? null : query,
-    },
-  };
-}