@plone/volto 19.1.5 → 19.2.0

package/theme/themes/pastanaga/extras/skiplinks.less

@@ -12,9 +12,7 @@
       top: 10px;
       left: 10px;
       padding: 10px;
-      border: 2px solid @linkColor;
       background: #fff;
-      outline: 3px solid @linkColor;
     }
 
     &:hover {

package/theme/themes/pastanaga/globals/site.variables

@@ -362,3 +362,10 @@
 /*---  Dark Tones  ---*/
 
 /*---  Light Tones  ---*/
+
+/*-------------------
+    Focused Input
+--------------------*/
+
+@innerFocusShadow: #fff;
+@outerFocusOutline: #000;

package/types/actions/querystringsearch/querystringsearch.d.ts

@@ -1,7 +1,55 @@
+/**
+ * Querystring search actions.
+ * @module actions/querystringsearch/querystringsearch
+ */
+import { GET_QUERYSTRING_RESULTS } from '@plone/volto/constants/ActionTypes';
+import { type IntegerLike } from '@plone/volto/helpers/Pagination/Pagination';
+/**
+ * A single `plone.app.querystring` criterion: index, operation, value.
+ */
+export interface QuerystringCriterion {
+    i: string;
+    o: string;
+    v?: unknown;
+}
+/**
+ * The querystring settings stored on a block. Numeric fields are typed as
+ * `IntegerLike` because they are edited through JSON schema `number` widgets
+ * and may reach us as strings.
+ */
+export interface QuerystringData {
+    query?: QuerystringCriterion[];
+    sort_on?: string;
+    sort_order?: string | boolean | null;
+    b_size?: IntegerLike;
+    offset?: IntegerLike;
+    limit?: IntegerLike;
+    depth?: IntegerLike;
+    [key: string]: unknown;
+}
+/**
+ * The payload sent to the `@querystring-search` endpoint. `b_start` is only
+ * present once a page or an offset places the batch past the beginning.
+ */
+export interface QuerystringSearchQuery extends QuerystringData {
+    b_start?: number;
+}
+export interface GetQueryStringResultsAction {
+    type: typeof GET_QUERYSTRING_RESULTS;
+    subrequest?: string;
+    request: {
+        op: 'get' | 'post';
+        path: string;
+        data: QuerystringSearchQuery | null;
+    };
+}
 /**
  * Get querystring results.
  * @function getQueryStringResults
- * @param {Object} data Data.
- * @returns {Object} Get querystringsearch results action.
+ * @param {string} path Path to search under.
+ * @param {QuerystringData} data Querystring settings from the block.
+ * @param {string} subrequest Subrequest id used to store the results.
+ * @param {IntegerLike} page 1-based page number. Defaults to the first page.
+ * @returns {GetQueryStringResultsAction} Get querystringsearch results action.
  */
-export function getQueryStringResults(path: any, data: any, subrequest: any, page: any): any;
+export declare function getQueryStringResults(path: string, data: QuerystringData, subrequest?: string, page?: IntegerLike): GetQueryStringResultsAction;

package/types/components/manage/Controlpanels/BlockTypes.d.ts

@@ -1,7 +1,55 @@
+import type { IntlShape } from 'react-intl';
 import type { Location } from 'history';
+import type { BlocksConfigData } from '@plone/types';
 type RouteProps = {
     history: History;
     location: Location;
 };
+/**
+ * List the configured blocks, by title.
+ *
+ * An add-on can configure a block that was never registered — enhancing one
+ * that ships with another add-on, say — which leaves an entry behind that is
+ * not a block at all, with no id or no title. `BlockConfigBase` says both are
+ * always there, but the config disagrees, so drop those entries rather than
+ * list a block that does not exist.
+ * @function sortConfigBlocks
+ * @param {BlocksConfigData} blocksConfig The blocks configuration.
+ * @param {IntlShape} intl Used to translate each block title.
+ * @returns {Array} The configured blocks, sorted by translated title.
+ */
+export declare function sortConfigBlocks(blocksConfig: BlocksConfigData, intl: IntlShape): {
+    title: string;
+    id: string;
+    icon: string;
+    group: string;
+    category?: string;
+    blockModel?: number;
+    view?: React.ComponentType<import("@plone/types").BlockViewProps>;
+    edit?: React.ComponentType<import("@plone/types").BlockEditProps>;
+    schema?: object;
+    blockSchema: import("@plone/types").JSONSchema | ((args?: import("@plone/types").BlockSchemaArgs) => import("@plone/types").JSONSchema);
+    dataAdapter?: ({ block, data, id, onChangeBlock, value, }: {
+        block: string;
+        data: import("@plone/types").BlocksFormData;
+        id: string;
+        onChangeBlock: (id: string, newData: any) => void;
+        value: any;
+    }) => void;
+    restricted: ((args: {
+        properties: import("@plone/types").Content;
+        block: import("@plone/types").BlockConfigBase;
+        navRoot: import("@plone/types").Content;
+        contentType: string;
+        user: import("@plone/types").User;
+    }) => boolean) | boolean;
+    mostUsed: boolean;
+    blockHasOwnFocusManagement?: boolean;
+    sidebarTab: boolean | 0 | 1;
+    schemaEnhancer?: (args: import("@plone/types").SchemaEnhancerArgs) => import("@plone/types").JSONSchema;
+    variations?: import("@plone/types").BlockExtension[];
+    extensions?: Record<string, import("@plone/types").BlockExtension>;
+    blocksConfig?: Partial<BlocksConfigData>;
+}[];
 declare const BlockTypesControlpanel: (props: RouteProps) => import("react/jsx-runtime").JSX.Element;
 export default BlockTypesControlpanel;

package/types/components/manage/Widgets/QuerystringWidget.d.ts

@@ -28,6 +28,12 @@ export function objectSchema({ intl, isDisabled, value }: {
             type: string;
             isDisabled: any;
         };
+        offset: {
+            title: any;
+            type: string;
+            isDisabled: any;
+            default: number;
+        };
         b_size: {
             title: any;
             type: string;

package/types/express-middleware/portraits.d.ts

@@ -0,0 +1 @@
+export default function portraitsMiddleware(): any;

package/types/helpers/Api/PloneBackendAPIResourceWithAuth.d.ts

@@ -0,0 +1 @@
+export function getPloneBackendAPIResourceWithAuth(req: any): string;

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,
-    },
-  };
-}