@plone/volto 17.2.0 → 17.4.0

package/types/helpers/AsyncConnect/AsyncConnect.d.ts

@@ -0,0 +1,49 @@
+export class AsyncConnect extends Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        previousLocation: any;
+    };
+    mounted: boolean;
+    loadDataCounter: number;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentWillUnmount(): void;
+    isLoaded(): any;
+    loadAsyncData({ reduxConnectStore, ...otherProps }: {
+        [x: string]: any;
+        reduxConnectStore: any;
+    }): any;
+    render(): JSX.Element;
+}
+export namespace AsyncConnect {
+    namespace propTypes {
+        let render: any;
+        let beginGlobalLoad: any;
+        let endGlobalLoad: any;
+        let reloadOnPropsChange: any;
+        let routes: any;
+        let location: any;
+        let match: any;
+        let helpers: any;
+        let reduxConnectStore: any;
+    }
+    namespace defaultProps {
+        let helpers_1: {};
+        export { helpers_1 as helpers };
+        export function reloadOnPropsChange(): boolean;
+        export function render({ routes }: {
+            routes: any;
+        }): any;
+    }
+}
+export function AsyncConnectWithContext({ context, ...otherProps }: {
+    [x: string]: any;
+    context: any;
+}): JSX.Element;
+export namespace AsyncConnectWithContext {
+    export namespace propTypes_1 {
+        let context: any;
+    }
+    export { propTypes_1 as propTypes };
+}
+import { Component } from 'react';

package/types/helpers/AsyncConnect/AsyncConnect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/helpers/AsyncConnect/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A replacement for redux-connect's asyncConnect.
+ *
+ * It was needed because asyncConnect works as a direct wrapper on top of
+ * a Component, so the config registry is not yet initialized. To solve this
+ * problem we replace the original reduxAsyncConnect implementation (which was
+ * a list of asyncConnected "object promises") with as single promise exposed
+ * as { key: 'voltoLoadAsyncProps', promise: ... }.
+ *
+ * In more details, the original asyncConnect worked by replacing all our
+ * "object promises" with a special version that's integrated with its own
+ * Redux actions. We do another wrap, which takes the initial passed "object
+ * promises", finds registered, per route, "extenders", calls these extenders
+ * with the "object promises" and that's our "object promises" (which it calls
+ * internally "asyncItems").
+ */
+export function asyncConnect(asyncItems: any, mapStateToProps: any, mapDispatchToProps: any, mergeProps: any, options: any): (Component: any) => import("react-redux").ConnectedComponent<any, any>;
+export const ReduxAsyncConnect: import("react-redux").ConnectedComponent<any, any>;
+export { loadOnServer, loadAsyncConnect } from "./ssr";

package/types/helpers/AsyncConnect/ssr.d.ts

@@ -0,0 +1,8 @@
+export function filterComponents(branch: any): any;
+export function loadAsyncConnect({ location, routes, filter, ...rest }: {
+    [x: string]: any;
+    location: any;
+    routes?: any[];
+    filter?: () => boolean;
+}): any;
+export function loadOnServer(args: any): any;

package/types/helpers/AsyncConnect/utils.d.ts

@@ -0,0 +1,5 @@
+export function isPromise(obj: any): boolean;
+export const mapSeries: any;
+export function getImmutableState(state: any): any;
+export function getMutableState(state: any): any;
+export function matchAllRoutes(routes: any, pathname: any): any;

package/types/helpers/AuthToken/AuthToken.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get auth token method (does not work in SSR)
+ * @method getAuthToken
+ * @returns {undefined}
+ */
+export function getAuthToken(): undefined;
+/**
+ * Persist auth token method.
+ * @method persistAuthToken
+ * @param {object} store Redux store.
+ * @returns {undefined}
+ */
+export function persistAuthToken(store: object, req: any): undefined;

package/types/helpers/AuthToken/AuthToken.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/helpers/Blocks/Blocks.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Get blocks field.
+ * @function getBlocksFieldname
+ * @param {Object} props Properties.
+ * @return {string} Field name of the blocks
+ */
+export function getBlocksFieldname(props: any): string;
+/**
+ * Get blocks layout field.
+ * @function getBlocksLayoutFieldname
+ * @param {Object} props Properties.
+ * @return {string} Field name of the blocks layout
+ */
+export function getBlocksLayoutFieldname(props: any): string;
+/**
+ * Has blocks data.
+ * @function hasBlocksData
+ * @param {Object} props Properties.
+ * @return {boolean} True if it has blocks data.
+ */
+export function hasBlocksData(props: any): boolean;
+/**
+ * Pluggable method to test if a block has a set value (any non-empty value)
+ * @function blockHasValue
+ * @param {Object} data Block data
+ * @return {boolean} True if block has a non-empty value
+ */
+export function blockHasValue(data: any): boolean;
+/**
+ * Move block to different location index within blocks_layout
+ * @function moveBlock
+ * @param {Object} formData Form data
+ * @param {number} source index within form blocks_layout items
+ * @param {number} destination index within form blocks_layout items
+ * @return {Object} New form data
+ */
+export function moveBlock(formData: any, source: number, destination: number): any;
+/**
+ * Delete block by id
+ * @function deleteBlock
+ * @param {Object} formData Form data
+ * @param {string} blockId Block uid
+ * @return {Object} New form data
+ */
+export function deleteBlock(formData: any, blockId: string): any;
+/**
+ * Adds a block to the blocks form
+ * @function addBlock
+ * @param {Object} formData Form data
+ * @param {string} type Block type
+ * @param {number} index Destination index
+ * @return {Array} New block id, New form data
+ */
+export function addBlock(formData: any, type: string, index: number, blocksConfig: any): any[];
+/**
+ * Mutate block, changes the block @type
+ * @function mutateBlock
+ * @param {Object} formData Form data
+ * @param {string} id Block uid to mutate
+ * @param {number} value Block's new value
+ * @return {Object} New form data
+ */
+export function mutateBlock(formData: any, id: string, value: number, blocksConfig: any): any;
+/**
+ * Insert new block before another block
+ * @function insertBlock
+ * @param {Object} formData Form data
+ * @param {string} id Insert new block before the block with this id
+ * @param {number} value New block's value
+ * @return {Array} New block id, New form data
+ */
+export function insertBlock(formData: any, id: string, value: number, current: {}, offset: number, blocksConfig: any): any[];
+/**
+ * Change block
+ * @function changeBlock
+ * @param {Object} formData Form data
+ * @param {string} id Block uid to change
+ * @param {number} value Block's new value
+ * @return {Object} New form data
+ */
+export function changeBlock(formData: any, id: string, value: number): any;
+/**
+ * Get the next block UID within form
+ * @function nextBlockId
+ * @param {Object} formData Form data
+ * @param {string} currentBlock Block uid
+ * @return {string} Next block uid
+ */
+export function nextBlockId(formData: any, currentBlock: string): string;
+/**
+ * Get the previous block UID within form
+ * @function previousBlockId
+ * @param {Object} formData Form data
+ * @param {string} currentBlock Block uid
+ * @return {string} Previous block uid
+ */
+export function previousBlockId(formData: any, currentBlock: string): string;
+/**
+ * Generate empty block form
+ * @function emptyBlocksForm
+ * @param {Object} formData Form data
+ * @return {Object} Empty blocks form with one defaultBlockType block
+ */
+export function emptyBlocksForm(): any;
+/**
+ * Generate empty blocks blocks/blocks_layout pair given the type
+ * (could be empty, if not type given) and the number of blocks
+ * @function blocksFormGenerator
+ * @param {number} number How many blocks to generate of the type (could be "empty", if no type provided)
+ * @param {number} type The type of the blocks
+ * @return {Object} blocks/blocks_layout pair filled with the generated blocks
+ */
+export function blocksFormGenerator(number: number, type: number): any;
+/**
+ * Recursively discover blocks in data and call the provided callback
+ * @function visitBlocks
+ * @param {Object} content A content data structure (an object with blocks and blocks_layout)
+ * @param {Function} callback A function to call on each discovered block
+ */
+export function visitBlocks(content: any, callback: Function): void;
+/**
+ * Initializes data with the default values coming from schema
+ */
+export function applySchemaDefaults({ data, schema, intl }: {
+    data?: {};
+    schema: any;
+    intl: any;
+}): any;
+/**
+ * Apply the block's default (as defined in schema) to the block data.
+ *
+ * @function applyBlockDefaults
+ * @param {Object} params An object with data, intl and anything else
+ * @return {Object} Derived data, with the defaults extracted from the schema
+ */
+export function applyBlockDefaults({ data, intl, ...rest }: any, blocksConfig: any): any;
+/**
+ * Given a `block` object and a list of block types, return a list of block ids matching the types
+ *
+ * @function findBlocks
+ * @param {Object} types A list with the list of types to be matched
+ * @return {Array} An array of block ids
+ */
+export function findBlocks(blocks: any, types: any, result?: any[]): any[];
+export function getBlocks(properties: any): any[];
+export function styleToClassName(key: any, value: any, prefix?: string): any;
+export function buildStyleClassNamesFromData(obj?: {}, prefix?: string): any;
+export function buildStyleClassNamesExtenders({ block, content, data, classNames, }: any): any[];
+export function getPreviousNextBlock({ content, block }: any): any[];

package/types/helpers/Blocks/Blocks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/helpers/BodyClass/BodyClass.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/types/helpers/Content/Content.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Nest content.
+ * @function nestContent
+ * @param {Object} props Properties.
+ * @return {string} Field name of the block
+ */
+export function nestContent(props: any): string;
+/**
+ * Get layout field.
+ * @function getLayoutFieldname
+ * @param {Object} props Properties.
+ * @return {string} Field name of the layout
+ */
+export function getLayoutFieldname(props: any): string;
+/**
+ * Get content icon.
+ * @description Configurable in config
+ * @function getContentIcon
+ * @param {string} type Content type
+ * @param {boolean} isFolderish
+ * @returns {Object} Icon component
+ */
+export function getContentIcon(type: string, isFolderish: boolean): any;
+/**
+ * Get the language independent fields presents in a schema.
+ * @description Configurable in config
+ * @function getLanguageIndependentFields
+ * @param {string} schema content type JSON Schema serialization
+ * @returns {array} List of language independent fields
+ */
+export function getLanguageIndependentFields(schema: string): any[];

package/types/helpers/Content/Content.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/helpers/Cookies/cookies.d.ts

@@ -0,0 +1,5 @@
+export function getCookieOptions(options?: {}): {
+    path: any;
+    expires: Date;
+    secure: any;
+};

package/types/helpers/Extensions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./withBlockSchemaEnhancer";
+export { default as withBlockExtensions, resolveExtension, resolveBlockExtensions } from "./withBlockExtensions";

package/types/helpers/Extensions/withBlockExtensions.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Retrieves the extension (variation) settings from the provided
+ * configuration, based on incoming data.
+ */
+export function resolveExtension(name: any, extensions: any, data: any): any;
+/**
+ * A block can declare extensions and variations like:
+ *
+ * {
+ *  variations: [
+ *    {
+ *      id: "summary",
+ *      isDefault: true,
+ *      template: Something
+ *    }
+ *  ],
+ *  extensions: {
+ *    'extensionA': {
+ *      items: [
+ *        // something similar to variations
+ *      ]
+ *    }
+ *  }
+ * }
+ *
+ * Exactly what an extension and what a variation represent is only up to the
+ * block. A block should incorporate these extension mechanisms and it should
+ * define what information is needed from them.
+ *
+ * resolveBlockExtensions will return an object with
+ * `{ extensions, resolvedExtensions}`, where:
+ *
+ * - extensions is the blocksConfig extensions object for that block
+ * - resolvedExtensions is an object with
+ *   `{ variation, <someExtensionA>, <someExtensionB> }` and each of these
+ *   fields hold the coresponding definition object from the block's
+ *   configuration.
+ */
+export function resolveBlockExtensions(data: any, blocksConfig: any): {
+    extensions: any;
+    resolvedExtensions: any;
+};
+export default withBlockExtensions;
+declare function withBlockExtensions(WrappedComponent: any): (props: any) => JSX.Element;

package/types/helpers/Extensions/withBlockExtensions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/helpers/Extensions/withBlockSchemaEnhancer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Allows compose-like declaration of schema enhancers
+ *
+ * Example usage:
+ * const schemaEnhancer = composeSchema(schemaEnhancerA, schemaEnhancerB)
+ *
+ * where each enhancer is a function with signature
+ * ({schema, formData, ...rest}) => schema
+ *
+ */
+export function composeSchema(...args: any[]): (args: any) => any;
+export function addExtensionFieldToSchema({ schema, name, items, intl, title, description, insertFieldToOrder, }: {
+    schema: any;
+    name: any;
+    items: any;
+    intl: any;
+    title: any;
+    description: any;
+    insertFieldToOrder?: typeof _addField;
+}): any;
+export function withBlockSchemaEnhancer(FormComponent: any, extensionName?: string, insertFieldToOrder?: typeof _addField): ({ ...props }: {
+    [x: string]: any;
+}) => JSX.Element;
+export function applySchemaEnhancer({ schema: originalSchema, formData, intl, blocksConfig, }: {
+    schema: any;
+    formData: any;
+    intl: any;
+    blocksConfig?: any;
+}): any;
+export function withVariationSchemaEnhancer(FormComponent: any): (props: any) => JSX.Element;
+export namespace EMPTY_STYLES_SCHEMA {
+    let fieldsets: {
+        id: string;
+        title: string;
+        fields: any[];
+    }[];
+    let properties: {};
+    let required: any[];
+}
+export function addStyling({ schema, formData, intl }: {
+    schema: any;
+    formData: any;
+    intl: any;
+}): any;
+/**
+ * Sets the field name as first field in schema
+ */
+declare function _addField(schema: any, name: any): void;
+export {};

package/types/helpers/Extensions/withBlockSchemaEnhancer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/helpers/FormValidation/FormValidation.d.ts

@@ -0,0 +1,26 @@
+export default FormValidation;
+export function validateFileUploadSize(file: File, intlFunc: Function): boolean;
+declare class FormValidation {
+    /**
+     * The first Fieldset (Tab) that has any errors
+     * will be selected
+     * @param {Object} errors
+     * @param {Object} schema
+     * @returns {number} activeIndex
+     */
+    static showFirstTabWithErrors({ errors, schema, }?: any): number;
+    /**
+     * Create the errors object from backend the same way it is done on Frontend validation
+     * @param {string} requestError form the server
+     * @returns {Object}
+     */
+    static giveServerErrorsToCorrespondingFields(requestError?: string): any;
+    /**
+     * Return validation result
+     * @param {Object} schema
+     * @param {Object} formData
+     * @param {function} formatMessage
+     * @returns {Object} errors
+     */
+    static validateFieldsPerFieldset({ schema, formData, formatMessage, touchedField, }?: any): any;
+}

package/types/helpers/FormValidation/FormValidation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/helpers/Helmet/Helmet.d.ts

@@ -0,0 +1,72 @@
+export { HelmetExport as Helmet };
+export default HelmetExport;
+declare const HelmetExport: {
+    new (): {
+        shouldComponentUpdate(nextProps: any): boolean;
+        mapNestedChildrenToProps(child: any, nestedChildren: any): {
+            innerHTML: any;
+            cssText?: undefined;
+        } | {
+            cssText: any;
+            innerHTML?: undefined;
+        };
+        flattenArrayTypeChildren({ child, arrayTypeChildren, newChildProps, nestedChildren, }: {
+            child: any;
+            arrayTypeChildren: any;
+            newChildProps: any;
+            nestedChildren: any;
+        }): any;
+        mapObjectTypeChildren({ child, newProps, newChildProps, nestedChildren }: {
+            child: any;
+            newProps: any;
+            newChildProps: any;
+            nestedChildren: any;
+        }): any;
+        mapArrayTypeChildrenToProps(arrayTypeChildren: any, newProps: any): any;
+        warnOnInvalidChildren(child: any, nestedChildren: any): true | void;
+        mapChildrenToProps(children: any, newProps: any): any;
+        render(): JSX.Element;
+    };
+    /**
+     * @param {Object} base: {"target": "_blank", "href": "http://mysite.com/"}
+     * @param {Object} bodyAttributes: {"className": "root"}
+     * @param {String} defaultTitle: "Default Title"
+     * @param {Boolean} defer: true
+     * @param {Boolean} encodeSpecialCharacters: true
+     * @param {Object} htmlAttributes: {"lang": "en", "amp": undefined}
+     * @param {Array} link: [{"rel": "canonical", "href": "http://mysite.com/example"}]
+     * @param {Array} meta: [{"name": "description", "content": "Test description"}]
+     * @param {Array} noscript: [{"innerHTML": "<img src='http://mysite.com/js/test.js'"}]
+     * @param {Function} onChangeClientState: "(newState) => console.log(newState)"
+     * @param {Array} script: [{"type": "text/javascript", "src": "http://mysite.com/js/test.js"}]
+     * @param {Array} style: [{"type": "text/css", "cssText": "div { display: block; color: blue; }"}]
+     * @param {String} title: "Title"
+     * @param {Object} titleAttributes: {"itemprop": "name"}
+     * @param {String} titleTemplate: "MySite.com - %s"
+     */
+    propTypes: {
+        base: any;
+        bodyAttributes: any;
+        children: any;
+        defaultTitle: any;
+        defer: any;
+        encodeSpecialCharacters: any;
+        htmlAttributes: any;
+        link: any;
+        meta: any;
+        noscript: any;
+        onChangeClientState: any;
+        script: any;
+        style: any;
+        title: any;
+        titleAttributes: any;
+        titleTemplate: any;
+    };
+    defaultProps: {
+        defer: boolean;
+        encodeSpecialCharacters: boolean;
+    };
+    peek: any;
+    rewind: () => any;
+    canUseDOM: any;
+};

package/types/helpers/Helmet/HelmetConstants.d.ts

@@ -0,0 +1,54 @@
+export namespace ATTRIBUTE_NAMES {
+    let BODY: string;
+    let HTML: string;
+    let TITLE: string;
+}
+export namespace TAG_NAMES {
+    export let BASE: string;
+    let BODY_1: string;
+    export { BODY_1 as BODY };
+    export let HEAD: string;
+    let HTML_1: string;
+    export { HTML_1 as HTML };
+    export let LINK: string;
+    export let META: string;
+    export let NOSCRIPT: string;
+    export let SCRIPT: string;
+    export let STYLE: string;
+    let TITLE_1: string;
+    export { TITLE_1 as TITLE };
+}
+export const VALID_TAG_NAMES: any[];
+export namespace TAG_PROPERTIES {
+    let CHARSET: string;
+    let CSS_TEXT: string;
+    let HREF: string;
+    let HTTPEQUIV: string;
+    let INNER_HTML: string;
+    let ITEM_PROP: string;
+    let NAME: string;
+    let PROPERTY: string;
+    let REL: string;
+    let SRC: string;
+    let TARGET: string;
+}
+export const REACT_TAG_MAP: {
+    accesskey: string;
+    charset: string;
+    class: string;
+    contenteditable: string;
+    contextmenu: string;
+    'http-equiv': string;
+    itemprop: string;
+    tabindex: string;
+};
+export namespace HELMET_PROPS {
+    let DEFAULT_TITLE: string;
+    let DEFER: string;
+    let ENCODE_SPECIAL_CHARACTERS: string;
+    let ON_CHANGE_CLIENT_STATE: string;
+    let TITLE_TEMPLATE: string;
+}
+export const HTML_TAG_MAP: {};
+export const SELF_CLOSING_TAGS: string[];
+export const HELMET_ATTRIBUTE: "data-react-helmet";

package/types/helpers/Helmet/HelmetUtils.d.ts

@@ -0,0 +1,69 @@
+export function convertReactPropstoHtmlAttributes(props: any, initAttributes?: {}): {};
+export function handleClientStateChange(newState: any): void;
+export function mapStateOnServer({ baseTag, bodyAttributes, encode, htmlAttributes, linkTags, metaTags, noscriptTags, scriptTags, styleTags, title, titleAttributes, }: {
+    baseTag: any;
+    bodyAttributes: any;
+    encode: any;
+    htmlAttributes: any;
+    linkTags: any;
+    metaTags: any;
+    noscriptTags: any;
+    scriptTags: any;
+    styleTags: any;
+    title?: string;
+    titleAttributes: any;
+}): {
+    base: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    bodyAttributes: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    htmlAttributes: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    link: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    meta: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    noscript: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    script: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    style: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+    title: {
+        toComponent: () => any;
+        toString: () => any;
+    };
+};
+export function reducePropsToState(propsList: any): {
+    baseTag: any;
+    bodyAttributes: any;
+    defer: any;
+    encode: any;
+    htmlAttributes: any;
+    linkTags: any;
+    metaTags: any;
+    noscriptTags: any;
+    onChangeClientState: any;
+    scriptTags: any;
+    styleTags: any;
+    title: any;
+    titleAttributes: any;
+};
+export const requestAnimationFrame: any;
+export function warn(msg: any): void;