@doyourjob/gravity-ui-page-constructor 5.31.76 → 5.31.78

package/build/cjs/blocks/RelevantReportsCards/schema.d.ts

@@ -0,0 +1,297 @@
+export declare const RelevantReportsCardsBlock: {
+    'relevant-reports-cards-block': {
+        additionalProperties: boolean;
+        required: never[];
+        properties: {
+            typeKey: {
+                type: string;
+            };
+            link: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    text: {
+                        type: string;
+                        contentType: string;
+                    };
+                    url: {
+                        type: string;
+                    };
+                    urlTitle: {
+                        type: string;
+                    };
+                    arrow: {
+                        type: string;
+                    };
+                    theme: {
+                        type: string;
+                        enum: string[];
+                    };
+                    textSize: {
+                        type: string;
+                        enum: string[];
+                    };
+                    target: {
+                        type: string;
+                        enum: string[];
+                    };
+                    analyticsEvents: {
+                        oneOf: ({
+                            optionName: string;
+                            type: string;
+                            additionalProperties: {
+                                type: string;
+                            };
+                            required: string[];
+                            properties: {
+                                name: {
+                                    type: string;
+                                };
+                                type: {
+                                    type: string;
+                                };
+                                counters: {
+                                    type: string;
+                                    additionalProperties: boolean;
+                                    required: never[];
+                                    properties: {
+                                        include: {
+                                            type: string;
+                                            items: {
+                                                type: string;
+                                            };
+                                        };
+                                        exclude: {
+                                            type: string;
+                                            items: {
+                                                type: string;
+                                            };
+                                        };
+                                    };
+                                };
+                                context: {
+                                    type: string;
+                                };
+                            };
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                type: string;
+                                additionalProperties: {
+                                    type: string;
+                                };
+                                required: string[];
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                    };
+                                    counters: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: never[];
+                                        properties: {
+                                            include: {
+                                                type: string;
+                                                items: {
+                                                    type: string;
+                                                };
+                                            };
+                                            exclude: {
+                                                type: string;
+                                                items: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                    context: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                            optionName: string;
+                        })[];
+                    };
+                    type: {};
+                    when: {
+                        type: string;
+                    };
+                };
+            };
+            slider: {
+                type: string;
+            };
+            date: {
+                type: string;
+                enum: string[];
+            };
+            dateStart: {
+                type: string;
+            };
+            dateEnd: {
+                type: string;
+            };
+            title: {
+                oneOf: ({
+                    type: string;
+                    optionName: string;
+                } | {
+                    optionName: string;
+                    type: string;
+                    additionalProperties: boolean;
+                    required: string[];
+                    properties: {
+                        text: {
+                            type: string;
+                            contentType: string;
+                        };
+                        link: {
+                            type: string;
+                            additionalProperties: boolean;
+                            required: string[];
+                            properties: {
+                                text: {
+                                    type: string;
+                                    contentType: string;
+                                };
+                                url: {
+                                    type: string;
+                                };
+                                urlTitle: {
+                                    type: string;
+                                };
+                                arrow: {
+                                    type: string;
+                                };
+                                theme: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                textSize: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                target: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                analyticsEvents: {
+                                    oneOf: ({
+                                        optionName: string;
+                                        type: string;
+                                        additionalProperties: {
+                                            type: string;
+                                        };
+                                        required: string[];
+                                        properties: {
+                                            name: {
+                                                type: string;
+                                            };
+                                            type: {
+                                                type: string;
+                                            };
+                                            counters: {
+                                                type: string;
+                                                additionalProperties: boolean;
+                                                required: never[];
+                                                properties: {
+                                                    include: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                    exclude: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            context: {
+                                                type: string;
+                                            };
+                                        };
+                                        items?: undefined;
+                                    } | {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: {
+                                                type: string;
+                                            };
+                                            required: string[];
+                                            properties: {
+                                                name: {
+                                                    type: string;
+                                                };
+                                                type: {
+                                                    type: string;
+                                                };
+                                                counters: {
+                                                    type: string;
+                                                    additionalProperties: boolean;
+                                                    required: never[];
+                                                    properties: {
+                                                        include: {
+                                                            type: string;
+                                                            items: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                        exclude: {
+                                                            type: string;
+                                                            items: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                context: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                        optionName: string;
+                                    })[];
+                                };
+                                type: {};
+                                when: {
+                                    type: string;
+                                };
+                            };
+                        };
+                        textSize: {
+                            type: string;
+                            enum: string[];
+                        };
+                        url: {
+                            type: string;
+                        };
+                        urlTitle: {
+                            type: string;
+                        };
+                        resetMargin: {
+                            type: string;
+                        };
+                    };
+                })[];
+            };
+            description: {
+                type: string;
+                contentType: string;
+                inputType: string;
+            };
+            type: {};
+            when: {
+                type: string;
+            };
+        };
+    };
+};

package/build/cjs/blocks/RelevantReportsCards/schema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelevantReportsCardsBlock = void 0;
+const common_1 = require("./../../schema/validators/common");
+exports.RelevantReportsCardsBlock = {
+    'relevant-reports-cards-block': {
+        additionalProperties: false,
+        required: [],
+        properties: Object.assign(Object.assign(Object.assign({}, common_1.BaseProps), common_1.BlockHeaderProps), { typeKey: {
+                type: 'string',
+            }, link: common_1.LinkProps, slider: {
+                type: 'boolean',
+            }, date: {
+                type: 'string',
+                enum: ['today', 'week', 'month'],
+            }, dateStart: {
+                type: 'string',
+            }, dateEnd: {
+                type: 'string',
+            } }),
+    },
+};

package/build/cjs/blocks/Reports/Reports.js

@@ -14,7 +14,7 @@ const titleColSizes = {
 const ReportsBlock = ({ title, typeKey, empty }) => {
     const data = (0, react_1.useContext)(reportsContext_1.ReportsContext);
     const [page, setPage] = (0, react_1.useState)(1);
-    const { selects, items, itemsPerPage, filesOutline } = (0, react_1.useMemo)(() => data[typeKey], [data, typeKey]);
+    const { selects, loading, items, itemsPerPage, filesOutline } = (0, react_1.useMemo)(() => data[typeKey], [data, typeKey]);
     const initFilters = (0, react_1.useMemo)(() => (selects === null || selects === void 0 ? void 0 : selects.reduce((acc, select) => (Object.assign(Object.assign({}, acc), { [select.name]: select.init })), {})) || {}, [selects]);
     const [localFilters, setLocalFilters] = (0, react_1.useState)(initFilters);
     const handleChange = (0, react_1.useCallback)((name, value) => setLocalFilters((prev) => (Object.assign(Object.assign({}, prev), { [name]: value }))), []);
@@ -33,10 +33,19 @@ const ReportsBlock = ({ title, typeKey, empty }) => {
     const titleProps = !title || typeof title === 'string'
         ? { text: title, textSize: 'm' }
         : title;
+    const renderItems = (0, react_1.useMemo)(() => {
+        if (loading) {
+            return react_1.default.createElement(components_1.ProgressCircular, { size: 48, strokeWidth: 2, color: "#262626" });
+        }
+        if (!paginatedItems.length) {
+            return react_1.default.createElement("div", { className: b('empty') }, empty);
+        }
+        return paginatedItems.map((item, index) => (react_1.default.createElement(ReportsItem_1.default, Object.assign({ key: index }, item, { filesOutline: filesOutline }))));
+    }, [loading, empty, filesOutline, paginatedItems]);
     return (react_1.default.createElement("div", { className: b() },
         title && react_1.default.createElement(components_1.Title, { className: b('title'), title: titleProps, colSizes: titleColSizes }),
         (selects === null || selects === void 0 ? void 0 : selects.length) && (react_1.default.createElement("div", { className: b('select') }, selects.map(({ name, options }) => (react_1.default.createElement(components_1.Select, { key: name, name: name, options: options, onChange: handleChange }))))),
-        paginatedItems.length ? (paginatedItems.map((item, index) => (react_1.default.createElement(ReportsItem_1.default, Object.assign({ key: index }, item, { filesOutline: filesOutline }))))) : (react_1.default.createElement("div", { className: b('empty') }, empty)),
+        renderItems,
         itemsPerPage && (react_1.default.createElement(components_1.Paginator, { page: page, itemsPerPage: itemsPerPage, totalItems: filteredItems.length, maxPages: Infinity, onPageChange: setPage }))));
 };
 exports.ReportsBlock = ReportsBlock;

package/build/cjs/blocks/Reports/schema.d.ts

@@ -18,6 +18,123 @@ export declare const ReportsBlock: {
                             type: string;
                             contentType: string;
                         };
+                        link: {
+                            type: string;
+                            additionalProperties: boolean;
+                            required: string[];
+                            properties: {
+                                text: {
+                                    type: string;
+                                    contentType: string;
+                                };
+                                url: {
+                                    type: string;
+                                };
+                                urlTitle: {
+                                    type: string;
+                                };
+                                arrow: {
+                                    type: string;
+                                };
+                                theme: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                textSize: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                target: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                analyticsEvents: {
+                                    oneOf: ({
+                                        optionName: string;
+                                        type: string;
+                                        additionalProperties: {
+                                            type: string;
+                                        };
+                                        required: string[];
+                                        properties: {
+                                            name: {
+                                                type: string;
+                                            };
+                                            type: {
+                                                type: string;
+                                            };
+                                            counters: {
+                                                type: string;
+                                                additionalProperties: boolean;
+                                                required: never[];
+                                                properties: {
+                                                    include: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                    exclude: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            context: {
+                                                type: string;
+                                            };
+                                        };
+                                        items?: undefined;
+                                    } | {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: {
+                                                type: string;
+                                            };
+                                            required: string[];
+                                            properties: {
+                                                name: {
+                                                    type: string;
+                                                };
+                                                type: {
+                                                    type: string;
+                                                };
+                                                counters: {
+                                                    type: string;
+                                                    additionalProperties: boolean;
+                                                    required: never[];
+                                                    properties: {
+                                                        include: {
+                                                            type: string;
+                                                            items: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                        exclude: {
+                                                            type: string;
+                                                            items: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                context: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                        optionName: string;
+                                    })[];
+                                };
+                                type: {};
+                                when: {
+                                    type: string;
+                                };
+                            };
+                        };
                         textSize: {
                             type: string;
                             enum: string[];

package/build/cjs/blocks/ReportsCards/schema.d.ts

@@ -18,6 +18,123 @@ export declare const ReportsCardsBlock: {
                             type: string;
                             contentType: string;
                         };
+                        link: {
+                            type: string;
+                            additionalProperties: boolean;
+                            required: string[];
+                            properties: {
+                                text: {
+                                    type: string;
+                                    contentType: string;
+                                };
+                                url: {
+                                    type: string;
+                                };
+                                urlTitle: {
+                                    type: string;
+                                };
+                                arrow: {
+                                    type: string;
+                                };
+                                theme: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                textSize: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                target: {
+                                    type: string;
+                                    enum: string[];
+                                };
+                                analyticsEvents: {
+                                    oneOf: ({
+                                        optionName: string;
+                                        type: string;
+                                        additionalProperties: {
+                                            type: string;
+                                        };
+                                        required: string[];
+                                        properties: {
+                                            name: {
+                                                type: string;
+                                            };
+                                            type: {
+                                                type: string;
+                                            };
+                                            counters: {
+                                                type: string;
+                                                additionalProperties: boolean;
+                                                required: never[];
+                                                properties: {
+                                                    include: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                    exclude: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            context: {
+                                                type: string;
+                                            };
+                                        };
+                                        items?: undefined;
+                                    } | {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: {
+                                                type: string;
+                                            };
+                                            required: string[];
+                                            properties: {
+                                                name: {
+                                                    type: string;
+                                                };
+                                                type: {
+                                                    type: string;
+                                                };
+                                                counters: {
+                                                    type: string;
+                                                    additionalProperties: boolean;
+                                                    required: never[];
+                                                    properties: {
+                                                        include: {
+                                                            type: string;
+                                                            items: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                        exclude: {
+                                                            type: string;
+                                                            items: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                context: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                        optionName: string;
+                                    })[];
+                                };
+                                type: {};
+                                when: {
+                                    type: string;
+                                };
+                            };
+                        };
                         textSize: {
                             type: string;
                             enum: string[];