npm - @gravity-ui/page-constructor - Versions diffs - 1.13.0 → 1.14.0-alpha.1 - Mend

@gravity-ui/page-constructor 1.13.0 → 1.14.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (63) hide show

package/build/cjs/blocks/Banner/schema.d.ts CHANGED Viewed

@@ -173,6 +173,113 @@ export declare const BannerCardProps: {
                         };
                     };
                 };
+                events: {
+                    anyOf: ({
+                        type: {
+                            type: string;
+                            additionalProperties: boolean;
+                            required: string[];
+                            properties: {
+                                name: {
+                                    type: string;
+                                };
+                                type: {
+                                    type: string;
+                                };
+                                counters: {
+                                    type: string;
+                                    additionalProperties: boolean;
+                                    required: never[];
+                                    properties: {
+                                        include: {
+                                            type: string;
+                                            items: string;
+                                        };
+                                        exclude: {
+                                            type: string;
+                                            items: string;
+                                        };
+                                    };
+                                };
+                                category: {
+                                    type: string;
+                                };
+                                label: {
+                                    type: string;
+                                };
+                                params: {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: string[];
+                                        properties: {
+                                            key: {
+                                                type: string;
+                                            };
+                                            value: {
+                                                type: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        items?: undefined;
+                    } | {
+                        type: string;
+                        items: {
+                            type: string;
+                            additionalProperties: boolean;
+                            required: string[];
+                            properties: {
+                                name: {
+                                    type: string;
+                                };
+                                type: {
+                                    type: string;
+                                };
+                                counters: {
+                                    type: string;
+                                    additionalProperties: boolean;
+                                    required: never[];
+                                    properties: {
+                                        include: {
+                                            type: string;
+                                            items: string;
+                                        };
+                                        exclude: {
+                                            type: string;
+                                            items: string;
+                                        };
+                                    };
+                                };
+                                category: {
+                                    type: string;
+                                };
+                                label: {
+                                    type: string;
+                                };
+                                params: {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: string[];
+                                        properties: {
+                                            key: {
+                                                type: string;
+                                            };
+                                            value: {
+                                                type: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    })[];
+                };
                 target: {
                     type: string;
                     enum: string[];
@@ -375,6 +482,113 @@ export declare const BannerBlock: {
                             };
                         };
                     };
+                    events: {
+                        anyOf: ({
+                            type: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                    };
+                                    counters: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: never[];
+                                        properties: {
+                                            include: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                            exclude: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                        };
+                                    };
+                                    category: {
+                                        type: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                    };
+                                    params: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                            required: string[];
+                                            properties: {
+                                                key: {
+                                                    type: string;
+                                                };
+                                                value: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                    };
+                                    counters: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: never[];
+                                        properties: {
+                                            include: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                            exclude: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                        };
+                                    };
+                                    category: {
+                                        type: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                    };
+                                    params: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                            required: string[];
+                                            properties: {
+                                                key: {
+                                                    type: string;
+                                                };
+                                                value: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        })[];
+                    };
                     target: {
                         type: string;
                         enum: string[];
@@ -578,6 +792,113 @@ export declare const BannerCard: {
                             };
                         };
                     };
+                    events: {
+                        anyOf: ({
+                            type: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                    };
+                                    counters: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: never[];
+                                        properties: {
+                                            include: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                            exclude: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                        };
+                                    };
+                                    category: {
+                                        type: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                    };
+                                    params: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                            required: string[];
+                                            properties: {
+                                                key: {
+                                                    type: string;
+                                                };
+                                                value: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                    };
+                                    counters: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: never[];
+                                        properties: {
+                                            include: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                            exclude: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                        };
+                                    };
+                                    category: {
+                                        type: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                    };
+                                    params: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                            required: string[];
+                                            properties: {
+                                                key: {
+                                                    type: string;
+                                                };
+                                                value: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        })[];
+                    };
                     target: {
                         type: string;
                         enum: string[];

package/build/cjs/blocks/Media/schema.d.ts CHANGED Viewed

@@ -426,6 +426,113 @@ export declare const MediaBlock: {
                             };
                         };
                     };
+                    events: {
+                        anyOf: ({
+                            type: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                    };
+                                    counters: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: never[];
+                                        properties: {
+                                            include: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                            exclude: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                        };
+                                    };
+                                    category: {
+                                        type: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                    };
+                                    params: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                            required: string[];
+                                            properties: {
+                                                key: {
+                                                    type: string;
+                                                };
+                                                value: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                    type: {
+                                        type: string;
+                                    };
+                                    counters: {
+                                        type: string;
+                                        additionalProperties: boolean;
+                                        required: never[];
+                                        properties: {
+                                            include: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                            exclude: {
+                                                type: string;
+                                                items: string;
+                                            };
+                                        };
+                                    };
+                                    category: {
+                                        type: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                    };
+                                    params: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                            required: string[];
+                                            properties: {
+                                                key: {
+                                                    type: string;
+                                                };
+                                                value: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        })[];
+                    };
                     target: {
                         type: string;
                         enum: string[];

package/build/cjs/components/Button/Button.js CHANGED Viewed

@@ -7,19 +7,22 @@ const utils_1 = require("../../utils");
 const utils_2 = require("./utils");
 const localeContext_1 = require("../../context/localeContext/localeContext");
 const useMetrika_1 = require("../../hooks/useMetrika");
+const useAnalytics_1 = require("../../hooks/useAnalytics");
 const icons_1 = require("../../icons");
 const b = (0, utils_1.block)('button-block');
 const Button = (props) => {
     const handleMetrika = (0, useMetrika_1.useMetrika)();
+    const handleAnalytics = (0, useAnalytics_1.useAnalytics)();
     const { lang, tld } = (0, react_1.useContext)(localeContext_1.LocaleContext);
-    const { className, metrikaGoals, pixelEvents, size = 'l', theme = 'normal', url, img, onClick: onClickOrigin, text } = props, rest = tslib_1.__rest(props, ["className", "metrikaGoals", "pixelEvents", "size", "theme", "url", "img", "onClick", "text"]);
+    const { className, metrikaGoals, pixelEvents, analyticsEvents, size = 'l', theme = 'normal', url, img, onClick: onClickOrigin, text } = props, rest = tslib_1.__rest(props, ["className", "metrikaGoals", "pixelEvents", "analyticsEvents", "size", "theme", "url", "img", "onClick", "text"]);
     const defaultImgPosition = 'left';
     const onClick = (0, react_1.useCallback)(() => {
         handleMetrika({ metrikaGoals, pixelEvents });
+        handleAnalytics(analyticsEvents);
         if (onClickOrigin) {
             onClickOrigin();
         }
-    }, [handleMetrika, metrikaGoals, pixelEvents, onClickOrigin]);
+    }, [handleMetrika, metrikaGoals, pixelEvents, handleAnalytics, analyticsEvents, onClickOrigin]);
     const buttonImg = img instanceof Object
         ? { url: img.url, position: img.position || defaultImgPosition, alt: img.alt }
         : { url: img, position: defaultImgPosition };

package/build/cjs/components/CardBase/CardBase.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import React, { ReactElement, HTMLAttributeAnchorTarget } from 'react';
 import { ButtonPixel, CardBaseProps as CardBaseParams, ImageProps, MetrikaGoal, WithChildren } from '../../models';
+import { AnalyticsEvent } from '../../models/common';
 export interface CardBaseProps extends CardBaseParams {
     className?: string;
     bodyClassName?: string;
@@ -9,6 +10,7 @@ export interface CardBaseProps extends CardBaseParams {
     target?: HTMLAttributeAnchorTarget;
     metrikaGoals?: MetrikaGoal;
     pixelEvents?: ButtonPixel;
+    analyticsEvents?: AnalyticsEvent | AnalyticsEvent[];
 }
 export interface CardHeaderBaseProps {
     className?: string;

package/build/cjs/components/CardBase/CardBase.js CHANGED Viewed

@@ -7,13 +7,15 @@ const utils_1 = require("../../utils");
 const BackgroundImage_1 = tslib_1.__importDefault(require("../BackgroundImage/BackgroundImage"));
 const RouterLink_1 = tslib_1.__importDefault(require("../RouterLink/RouterLink"));
 const useMetrika_1 = require("../../hooks/useMetrika");
+const useAnalytics_1 = require("../../hooks/useAnalytics");
 const b = (0, utils_1.block)('card-base-block');
 const Header = () => null;
 const Content = () => null;
 const Footer = () => null;
 const Layout = (props) => {
-    const { className, bodyClassName, metrikaGoals, pixelEvents, contentClassName, children, url, target, border = 'shadow', } = props;
+    const { className, bodyClassName, metrikaGoals, pixelEvents, analyticsEvents, contentClassName, children, url, target, border = 'shadow', } = props;
     const handleMetrika = (0, useMetrika_1.useMetrika)();
+    const handleAnalytics = (0, useAnalytics_1.useAnalytics)();
     let header, content, footer, image, headerClass, footerClass;
     function handleChild(child) {
         switch (child.type) {
@@ -46,6 +48,7 @@ const Layout = (props) => {
     const fullClassName = b({ border }, className);
     const onClick = () => {
         handleMetrika({ metrikaGoals, pixelEvents });
+        handleAnalytics(analyticsEvents);
     };
     return url ? (react_1.default.createElement(RouterLink_1.default, { href: url },
         react_1.default.createElement("a", { href: url, target: target, rel: target === '_blank' ? 'noopener noreferrer' : undefined, className: fullClassName, draggable: false, onDragStart: (e) => e.preventDefault(), onClick: onClick }, cardContent))) : (react_1.default.createElement("div", { className: fullClassName }, cardContent));

package/build/cjs/components/HeaderBreadcrumbs/HeaderBreadcrumbs.js CHANGED Viewed

@@ -4,12 +4,15 @@ const tslib_1 = require("tslib");
 const react_1 = tslib_1.__importDefault(require("react"));
 const utils_1 = require("../../utils");
 const useMetrika_1 = require("../../hooks/useMetrika");
+const useAnalytics_1 = require("../../hooks/useAnalytics");
 const b = (0, utils_1.block)('header-breadcrumbs');
 function HeaderBreadcrumbs(props) {
-    const { items, metrikaGoals, pixelEvents, theme = 'light', className } = props;
+    const { items, metrikaGoals, pixelEvents, analyticsEvents, theme = 'light', className } = props;
     const handleMetrika = (0, useMetrika_1.useMetrika)();
+    const handleAnalytics = (0, useAnalytics_1.useAnalytics)();
     const onClick = () => {
         handleMetrika({ metrikaGoals, pixelEvents });
+        handleAnalytics(analyticsEvents);
     };
     return (react_1.default.createElement("div", { className: b({ theme }, className) }, items.map((item) => (react_1.default.createElement("div", { className: b('item'), key: item.url },
         react_1.default.createElement("a", { href: item.url, className: b('text'), onClick: onClick }, item.text))))));

package/build/cjs/components/Link/Link.js CHANGED Viewed

@@ -10,6 +10,7 @@ const BackLink_1 = tslib_1.__importDefault(require("../BackLink/BackLink"));
 const localeContext_1 = require("../../context/localeContext/localeContext");
 const locationContext_1 = require("../../context/locationContext/locationContext");
 const useMetrika_1 = require("../../hooks/useMetrika");
+const useAnalytics_1 = require("../../hooks/useAnalytics");
 const b = (0, utils_1.block)('link-block');
 const WORD_JOINER_SYM = '\u200b';
 function getArrowSize(size) {
@@ -25,14 +26,16 @@ function getArrowSize(size) {
     }
 }
 const LinkBlock = (props) => {
-    const { text, url, arrow, metrikaGoals, pixelEvents, theme = 'file-link', colorTheme = 'light', textSize = 'm', className, target, children, } = props;
+    const { text, url, arrow, metrikaGoals, pixelEvents, analyticsEvents, theme = 'file-link', colorTheme = 'light', textSize = 'm', className, target, children, } = props;
     const handleMetrika = (0, useMetrika_1.useMetrika)();
+    const handleAnalytics = (0, useAnalytics_1.useAnalytics)();
     const { hostname } = (0, react_1.useContext)(locationContext_1.LocationContext);
     const { tld } = (0, react_1.useContext)(localeContext_1.LocaleContext);
     const href = (0, utils_1.setUrlTld)(props.url, tld);
     const defaultTextSize = theme === 'back' ? 'l' : 'm';
     const onClick = () => {
         handleMetrika({ metrikaGoals, pixelEvents });
+        handleAnalytics(analyticsEvents);
     };
     const getLinkByType = () => {
         switch (theme) {

package/build/cjs/components/YandexForm/YandexForm.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import { PixelEvent } from '../../models';
+import { AnalyticsEvent } from '../../models/common';
 export declare const YANDEX_FORM_ORIGIN = "https://forms.yandex.ru";
 export interface YandexFormProps {
     id: number | string;
@@ -14,6 +15,7 @@ export interface YandexFormProps {
     onLoad?: () => void;
     metrikaGoals?: string | string[];
     pixelEvents?: string | string[] | PixelEvent | PixelEvent[];
+    analyticsEvents?: AnalyticsEvent | AnalyticsEvent[];
 }
 declare const YandexForm: (props: YandexFormProps) => JSX.Element;
 export default YandexForm;

package/build/cjs/components/YandexForm/YandexForm.js CHANGED Viewed

@@ -8,15 +8,17 @@ const localeContext_1 = require("../../context/localeContext");
 const mobileContext_1 = require("../../context/mobileContext");
 const utils_1 = require("../../utils");
 const useMetrika_1 = require("../../hooks/useMetrika");
+const useAnalytics_1 = require("../..//hooks/useAnalytics");
 exports.YANDEX_FORM_ORIGIN = 'https://forms.yandex.ru';
 const CONTAINER_ID = 'pc-yandex-form-container';
 const b = (0, utils_1.block)('yandex-form');
 const YandexForm = (props) => {
-    const { onLoad, id, params, className, theme, containerId = CONTAINER_ID, headerHeight = constants_1.HEADER_HEIGHT, onSubmit, metrikaGoals, pixelEvents, customFormOrigin, } = props;
+    const { onLoad, id, params, className, theme, containerId = CONTAINER_ID, headerHeight = constants_1.HEADER_HEIGHT, onSubmit, metrikaGoals, pixelEvents, analyticsEvents, customFormOrigin, } = props;
     const formContainerRef = (0, react_1.useRef)(null);
     const iframeRef = (0, react_1.useRef)();
     const yaFormOrigin = customFormOrigin || exports.YANDEX_FORM_ORIGIN;
     const handleMetrika = (0, useMetrika_1.useMetrika)();
+    const handleAnalytics = (0, useAnalytics_1.useAnalytics)();
     const isMobile = (0, react_1.useContext)(mobileContext_1.MobileContext);
     const locale = (0, react_1.useContext)(localeContext_1.LocaleContext);
     const updateFormIframe = (0, react_1.useCallback)((container) => {
@@ -57,10 +59,19 @@ const YandexForm = (props) => {
             window.scrollBy(0, top - headerHeight);
         }
         handleMetrika({ metrikaGoals, pixelEvents });
+        handleAnalytics(analyticsEvents);
         if (onSubmit) {
             onSubmit();
         }
-    }, [handleMetrika, metrikaGoals, pixelEvents, onSubmit, headerHeight]);
+    }, [
+        handleMetrika,
+        metrikaGoals,
+        pixelEvents,
+        handleAnalytics,
+        analyticsEvents,
+        onSubmit,
+        headerHeight,
+    ]);
     const handleMessage = (0, react_1.useCallback)(({ origin, data }) => {
         if (origin !== yaFormOrigin) {
             return;

package/build/cjs/containers/PageConstructor/Provider.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import { MetrikaContextProps } from '../../context/metrikaContext';
+import { AnalyticsContextProps } from '../../context/analyticsContext';
 import { ProjectSettingsContextProps } from '../../context/projectSettingsContext';
 import { SSRContextProps } from '../../context/ssrContext';
 import { LocaleContextProps } from '../../context/localeContext';
@@ -13,5 +14,6 @@ export interface PageConstructorProviderProps {
     ssrConfig?: SSRContextProps;
     theme?: ConstructorTheme;
     projectSettings?: ProjectSettingsContextProps;
+    analytics?: AnalyticsContextProps;
 }
 export declare const PageConstructorProvider: (props: WithChildren<PageConstructorProviderProps>) => JSX.Element;

package/build/cjs/containers/PageConstructor/Provider.js CHANGED Viewed

@@ -4,6 +4,7 @@ exports.PageConstructorProvider = void 0;
 const tslib_1 = require("tslib");
 const react_1 = tslib_1.__importStar(require("react"));
 const metrikaContext_1 = require("../../context/metrikaContext");
+const analyticsContext_1 = require("../../context/analyticsContext");
 const mobileContext_1 = require("../../context/mobileContext");
 const projectSettingsContext_1 = require("../../context/projectSettingsContext");
 const ssrContext_1 = require("../../context/ssrContext");
@@ -12,7 +13,7 @@ const locationContext_1 = require("../../context/locationContext");
 const ThemeValueContext_1 = require("../../context/theme/ThemeValueContext");
 const constants_1 = require("../../components/constants");
 const PageConstructorProvider = (props) => {
-    const { isMobile, locale = {}, location = {}, metrika = {}, ssrConfig = {}, projectSettings = {}, theme = constants_1.DEFAULT_THEME, children, } = props;
+    const { isMobile, locale = {}, location = {}, metrika = {}, analytics = {}, ssrConfig = {}, projectSettings = {}, theme = constants_1.DEFAULT_THEME, children, } = props;
     /* eslint-disable react/jsx-key */
     const context = [
         react_1.default.createElement(ThemeValueContext_1.ThemeValueContext.Provider, { value: { themeValue: theme } }),
@@ -21,6 +22,7 @@ const PageConstructorProvider = (props) => {
         react_1.default.createElement(locationContext_1.LocationContext.Provider, { value: location }),
         react_1.default.createElement(mobileContext_1.MobileContext.Provider, { value: Boolean(isMobile) }),
         react_1.default.createElement(metrikaContext_1.MetrikaContext.Provider, { value: metrika }),
+        react_1.default.createElement(analyticsContext_1.AnalyticsContext.Provider, { value: analytics }),
         react_1.default.createElement(ssrContext_1.SSRContext.Provider, { value: { isServer: ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.isServer } }),
     ].reduceRight((prev, provider) => react_1.default.cloneElement(provider, {}, prev), children);
     /* eslint-enable react/jsx-key */