@plone/volto 17.3.0 → 17.5.0

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;

package/types/helpers/Html/Html.d.ts

@@ -0,0 +1,52 @@
+export function loadReducers(state?: {}): any;
+export default Html;
+/**
+ * Html class.
+ * Wrapper component containing HTML metadata and boilerplate tags.
+ * Used in server-side code only to wrap the string output of the
+ * rendered route component.
+ *
+ * The only thing this component doesn't (and can't) include is the
+ * HTML doctype declaration, which is added to the rendered output
+ * by the server.js file.
+ *
+ * Critical.css behaviour: when a file `public/critical.css` is present, the
+ * loading of stylesheets is changed. The styles in critical.css are inlined in
+ * the generated HTML, and the whole story needs to change completely: instead
+ * of treating stylesheets as priority for rendering, we want to defer their
+ * loading as much as possible. So we change the stylesheets to be prefetched
+ * and we switch their rel back to stylesheets at document ready event.
+ *
+ * @function Html
+ * @param {Object} props Component properties.
+ * @param {Object} props.assets Assets to be rendered.
+ * @param {Object} props.component Content to be rendered as child node.
+ * @param {Object} props.store Store object.
+ * @returns {string} Markup of the not found page.
+ */
+/**
+ * Html class.
+ * @class Html
+ * @extends Component
+ */
+declare class Html extends Component<any, any, any> {
+    /**
+     * Property types.
+     * @property {Object} propTypes Property types.
+     * @static
+     */
+    static propTypes: {
+        extractor: any;
+        markup: any;
+        store: any;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    /**
+     * Render method.
+     * @method render
+     * @returns {string} Markup for the component.
+     */
+    render(): string;
+}
+import { Component } from 'react';

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

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