@gravity-ui/blog-constructor 4.0.0-alpha.0 → 4.0.0

package/build/cjs/components/Search/Search.js

@@ -25,8 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Search = void 0;
 const react_1 = __importStar(require("react"));
-const lodash_1 = require("lodash");
 const uikit_1 = require("@gravity-ui/uikit");
+const lodash_1 = require("lodash");
 const useIsIPhone_1 = require("../../hooks/useIsIPhone");
 const i18n_1 = require("../../i18n");
 const Close_1 = require("../../icons/Close");

package/build/cjs/models/common.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { IBrowser, IDevice } from 'ua-parser-js';
 import { HeaderBlockProps as PageConstructorHeaderBlockProps } from '@gravity-ui/page-constructor';
+import { IBrowser, IDevice } from 'ua-parser-js';
 import { Locale } from '../models/locale';
 export declare enum Theme {
     Light = "light",
@@ -161,3 +161,7 @@ export declare enum DefaultEventNames {
     Service = "selector-service-click",
     SaveOnly = "save-only-button-click"
 }
+export type FetchArgs = {
+    page?: number;
+    query: Query;
+};

package/build/cjs/schema/index.d.ts

@@ -295,6 +295,87 @@ export declare const schemasForCustom: {
                                         type: string;
                                     })[];
                                 };
+                                fullscreen: {
+                                    type: string;
+                                };
+                                analyticsEvents: {
+                                    anyOf: ({
+                                        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;
+                                            };
+                                        };
+                                    } | {
+                                        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;
+                                                };
+                                            };
+                                        };
+                                    })[];
+                                };
                             };
                         } | {
                             type: string;
@@ -1088,6 +1169,87 @@ export declare const schemasForCustom: {
                             type: string;
                         })[];
                     };
+                    fullscreen: {
+                        type: string;
+                    };
+                    analyticsEvents: {
+                        anyOf: ({
+                            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;
+                                };
+                            };
+                        } | {
+                            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;
+                                    };
+                                };
+                            };
+                        })[];
+                    };
                     paddingTop: {
                         type: string;
                         enum: string[];

package/build/cjs/utils/common.js

@@ -13,8 +13,8 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scrollOnPageChange = exports.getFeedQueryParams = exports.getBlogElementMetrika = exports.isMetrikaExist = exports.getBreadcrumbs = exports.getBlogPath = exports.updateContentSizes = exports.getTagFilterUrl = exports.postLikeStatus = exports.getTags = exports.scrollToHash = exports.getPageSearchParams = exports.getAbsolutePath = void 0;
 const url_1 = require("url");
-const lodash_1 = require("lodash");
 const page_constructor_1 = require("@gravity-ui/page-constructor");
+const lodash_1 = require("lodash");
 const constants_1 = require("../blocks/constants");
 const i18n_1 = require("../i18n");
 function getAbsolutePath(router, url) {

package/build/esm/blocks/Feed/Feed.js

@@ -27,11 +27,10 @@ export const Feed = ({ image }) => {
     const { posts, totalCount, tags, services, pinnedPost, getPosts, pageCountForShowSupportButtons, } = useContext(FeedContext);
     const router = useContext(RouterContext);
     const handleAnalytics = useAnalytics(DefaultEventNames.ShowMore);
-    const [{ errorLoad, errorShowMore, isFetching, isShowMoreFetching, isShowMoreVisible, lastLoadedCount, postCountOnPage, postsOnPage, pinnedPostOnPage, currentPage, queryParams, }, dispatch,] = useReducer(reducer, {
+    const [{ errorLoad, errorShowMore, isFetching, isShowMoreVisible, lastLoadedCount, postCountOnPage, postsOnPage, pinnedPostOnPage, currentPage, queryParams, }, dispatch,] = useReducer(reducer, {
         errorLoad: false,
         errorShowMore: false,
         isFetching: false,
-        isShowMoreFetching: false,
         isShowMoreVisible: true,
         lastLoadedCount: (posts === null || posts === void 0 ? void 0 : posts.length) || 0,
         postCountOnPage: totalCount || 0,
@@ -46,36 +45,36 @@ export const Feed = ({ image }) => {
     const pageChange = (value) => {
         dispatch({ type: ActionTypes.PageChange, payload: value });
     };
-    const handleChangeQueryParams = (value) => {
-        dispatch({ type: ActionTypes.QueryParamsChange, payload: value });
-        const hasFirstPageQuery = Object.keys(value).some((queryKey) => queryKey === PAGE_QUERY && value[queryKey] === FIRST_PAGE);
-        if (hasFirstPageQuery) {
-            // eslint-disable-next-line no-not-accumulator-reassign/no-not-accumulator-reassign
-            value[PAGE_QUERY] = null;
-        }
-        router.updateQueryCallback(value);
+    const setIsFetching = (value) => {
+        dispatch({ type: ActionTypes.SetIsFetching, payload: value });
     };
-    const handlePageChange = async (value) => {
-        pageChange(value);
-        handleChangeQueryParams({ page: value });
+    const setErrorLoad = (value) => {
+        dispatch({ type: ActionTypes.SetErrorLoad, payload: value });
     };
-    const fetchData = useCallback(async (pageNumber) => {
-        if (queryParams && getPosts) {
-            const query = getFeedQueryParams(queryParams, pageNumber);
-            const data = await getPosts(query);
+    const handleChangeQueryParams = useCallback((value) => {
+        dispatch({ type: ActionTypes.QueryParamsChange, payload: value });
+        const hasFirstPageQuery = Object.keys(value).some((queryKey) => queryKey === PAGE_QUERY && value[queryKey] === FIRST_PAGE);
+        const result = hasFirstPageQuery
+            ? Object.assign(Object.assign({}, value), { [PAGE_QUERY]: null }) : Object.assign({}, value);
+        router.updateQueryCallback(result);
+    }, [router]);
+    const fetchData = useCallback(async ({ page, query }) => {
+        if (query && getPosts) {
+            const queryParamsForRequest = getFeedQueryParams(Object.assign(Object.assign({}, queryParams), query), page);
+            const data = await getPosts(queryParamsForRequest);
             return data;
         }
         else {
             throw new Error('cant get request');
         }
     }, [getPosts, queryParams]);
-    const setIsFetching = (value) => {
-        dispatch({ type: ActionTypes.SetIsFetching, payload: value });
-    };
-    const fetchAndReplaceData = useCallback(async (pageNumber) => {
+    const handleLoad = useCallback(async ({ page, query }) => {
+        const pageNumber = Number(page || queryParams.page || DEFAULT_PAGE);
+        handleChangeQueryParams(query);
         try {
-            dispatch({ type: ActionTypes.SetErrorLoad, payload: false });
-            const fetchedData = await fetchData(pageNumber);
+            setErrorLoad(false);
+            setIsFetching(true);
+            const fetchedData = await fetchData({ page: pageNumber, query });
             if (fetchedData) {
                 dispatch({
                     type: ActionTypes.SetPosts,
@@ -89,22 +88,35 @@ export const Feed = ({ image }) => {
             }
         }
         catch (err) {
-            dispatch({ type: ActionTypes.SetErrorLoad, payload: true });
+            setErrorLoad(true);
         }
         scrollOnPageChange(CONTAINER_ID);
         setIsFetching(false);
-    }, [fetchData]);
+    }, [fetchData, handleChangeQueryParams, queryParams]);
+    const handlePageChange = async (value) => {
+        pageChange(value);
+        handleLoad({
+            page: value,
+            query: Object.assign(Object.assign({}, queryParams), { page: value }),
+        });
+    };
     const handleShowMore = async () => {
-        dispatch({ type: ActionTypes.SetIsShowMoreFetching, payload: true });
         /**
          * @deprecated Metrika will be deleted after launch of analyticsEvents
          */
         metrika.reachGoal(MetrikaCounter.CrossSite, BlogMetrikaGoalIds.showMore);
         handleAnalytics();
+        const nextPage = currentPage + 1;
         try {
-            const fetchedData = await fetchData(currentPage + 1);
+            setIsFetching(true);
+            const fetchedData = await fetchData({
+                page: nextPage,
+                query: {
+                    page: nextPage,
+                },
+            });
             handleChangeQueryParams({
-                page: currentPage + 1,
+                page: nextPage,
             });
             if (fetchedData) {
                 dispatch({
@@ -112,7 +124,7 @@ export const Feed = ({ image }) => {
                     payload: {
                         posts: (postsOnPage !== null && postsOnPage !== void 0 ? postsOnPage : []).concat(fetchedData.posts),
                         count: fetchedData.count,
-                        currentPage: currentPage + 1,
+                        currentPage: nextPage,
                         lastLoadedCount: fetchedData.posts.length,
                     },
                 });
@@ -121,13 +133,11 @@ export const Feed = ({ image }) => {
         catch (err) {
             dispatch({ type: ActionTypes.SetErrorShowMore, payload: true });
         }
-        dispatch({ type: ActionTypes.SetIsShowMoreFetching, payload: false });
+        setIsFetching(false);
     };
-    useEffect(() => {
-        if (isFetching) {
-            fetchAndReplaceData(Number(queryParams.page || DEFAULT_PAGE));
-        }
-    }, [fetchAndReplaceData, isFetching, queryParams.page]);
+    const handleOnErrorReload = useCallback(() => {
+        handleLoad({ page: currentPage, query: queryParams });
+    }, [currentPage, handleLoad, queryParams]);
     useEffect(() => {
         const loadedPostsCount = currentPage * perPageInQuery;
         dispatch({
@@ -145,10 +155,10 @@ export const Feed = ({ image }) => {
         icon: tag.icon && React.createElement(Icon, { data: tag.icon }),
     })), [tags]);
     return (React.createElement("div", null,
-        React.createElement(FeedHeader, { verticalOffset: "s", tags: tagItems, services: serviceItems, setIsFetching: setIsFetching, handleChangeQuery: handleChangeQueryParams, queryParams: queryParams, background: {
+        React.createElement(FeedHeader, { verticalOffset: "s", tags: tagItems, services: serviceItems, handleLoadData: handleLoad, queryParams: queryParams, background: {
                 fullWidth: true,
                 url: image,
                 disableCompress: true,
             } }),
-        errorLoad ? (React.createElement(PostsError, { onButtonClick: () => fetchAndReplaceData(Number(queryParams.page || DEFAULT_PAGE)) })) : (React.createElement(Posts, { containerId: CONTAINER_ID, currentPage: currentPage, isShowMoreVisible: isShowMoreVisible, errorShowMore: errorShowMore, postCountOnPage: postCountOnPage, perPageInQuery: perPageInQuery, handleShowMore: handleShowMore, handlePageChange: handlePageChange, postsOnPage: postsOnPage, pinnedPostOnPage: pinnedPostOnPage, isFetching: isFetching, isShowMoreFetching: isShowMoreFetching, pageCountForShowSupportButtons: pageCountForShowSupportButtons }))));
+        errorLoad ? (React.createElement(PostsError, { onButtonClick: handleOnErrorReload })) : (React.createElement(Posts, { containerId: CONTAINER_ID, currentPage: currentPage, isShowMoreVisible: isShowMoreVisible, errorShowMore: errorShowMore, postCountOnPage: postCountOnPage, perPageInQuery: perPageInQuery, handleShowMore: handleShowMore, handlePageChange: handlePageChange, postsOnPage: postsOnPage, pinnedPostOnPage: pinnedPostOnPage, isFetching: isFetching, pageCountForShowSupportButtons: pageCountForShowSupportButtons }))));
 };

package/build/esm/blocks/Feed/reducer.d.ts

@@ -6,7 +6,6 @@ export declare enum ActionTypes {
     SetPosts = "setPosts",
     SetShowMore = "setShowMore",
     SetIsFetching = "setIsFetching",
-    SetIsShowMoreFetching = "setIsShowMoreFetching",
     PageChange = "pageChange",
     QueryParamsChange = "queryParamsChange"
 }
@@ -15,7 +14,6 @@ export type State = {
     errorLoad: boolean;
     errorShowMore: boolean;
     isFetching: boolean;
-    isShowMoreFetching: boolean;
     isShowMoreVisible: boolean;
     lastLoadedCount: number;
     pinnedPostOnPage?: PostData;
@@ -29,9 +27,6 @@ type Action = {
 } | {
     type: ActionTypes.SetIsFetching;
     payload: boolean;
-} | {
-    type: ActionTypes.SetIsShowMoreFetching;
-    payload: boolean;
 } | {
     type: ActionTypes.SetPosts;
     payload: {

package/build/esm/blocks/Feed/reducer.js

@@ -6,7 +6,6 @@ export var ActionTypes;
     ActionTypes["SetPosts"] = "setPosts";
     ActionTypes["SetShowMore"] = "setShowMore";
     ActionTypes["SetIsFetching"] = "setIsFetching";
-    ActionTypes["SetIsShowMoreFetching"] = "setIsShowMoreFetching";
     ActionTypes["PageChange"] = "pageChange";
     ActionTypes["QueryParamsChange"] = "queryParamsChange";
 })(ActionTypes || (ActionTypes = {}));
@@ -17,11 +16,9 @@ export const reducer = (state, { type, payload }) => {
         case ActionTypes.SetPosts:
             return Object.assign(Object.assign({}, state), { lastLoadedCount: payload.count, postCountOnPage: payload.count, pinnedPostOnPage: payload.pinnedPost, postsOnPage: payload.posts, currentPage: payload.page });
         case ActionTypes.SetShowMore:
-            return Object.assign(Object.assign({}, state), { lastLoadedCount: payload.lastLoadedCount, postCountOnPage: payload.count, currentPage: payload.currentPage, postsOnPage: payload.posts, errorShowMore: false, isShowMoreFetching: true });
+            return Object.assign(Object.assign({}, state), { lastLoadedCount: payload.lastLoadedCount, postCountOnPage: payload.count, currentPage: payload.currentPage, postsOnPage: payload.posts, errorShowMore: false });
         case ActionTypes.SetIsFetching:
             return Object.assign(Object.assign({}, state), { isFetching: payload });
-        case ActionTypes.SetIsShowMoreFetching:
-            return Object.assign(Object.assign({}, state), { isShowMoreFetching: payload });
         case ActionTypes.PageChange:
             return Object.assign(Object.assign({}, state), { currentPage: payload, isFetching: true });
         case ActionTypes.SetErrorLoad:

package/build/esm/blocks/Header/schema.d.ts

@@ -287,6 +287,87 @@ export declare const Header: {
                                 type: string;
                             })[];
                         };
+                        fullscreen: {
+                            type: string;
+                        };
+                        analyticsEvents: {
+                            anyOf: ({
+                                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;
+                                    };
+                                };
+                            } | {
+                                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;
+                                        };
+                                    };
+                                };
+                            })[];
+                        };
                     };
                 } | {
                     type: string;

package/build/esm/blocks/Media/schema.d.ts

@@ -135,6 +135,87 @@ export declare const Media: {
                     type: string;
                 })[];
             };
+            fullscreen: {
+                type: string;
+            };
+            analyticsEvents: {
+                anyOf: ({
+                    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;
+                        };
+                    };
+                } | {
+                    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;
+                            };
+                        };
+                    };
+                })[];
+            };
             paddingTop: {
                 type: string;
                 enum: string[];

package/build/esm/blocks/YFM/YFM.js

@@ -1,6 +1,6 @@
 import React from 'react';
-import block from 'bem-cn-lite';
 import { YFMWrapper } from '@gravity-ui/page-constructor';
+import block from 'bem-cn-lite';
 import { Wrapper } from '../../components/Wrapper/Wrapper';
 import { PaddingsDirections } from '../../models/paddings';
 const b = block('yfm');

package/build/esm/components/FeedHeader/FeedHeader.js

@@ -4,7 +4,7 @@ import { block } from '../../utils/cn';
 import { Controls } from './components/Controls/Controls';
 import './FeedHeader.css';
 const b = block('feed-header');
-export const FeedHeader = ({ tags, services, setIsFetching, offset = 'default', background, theme = 'default', verticalOffset = 'l', className, handleChangeQuery, queryParams, }) => {
+export const FeedHeader = ({ tags, services, handleLoadData, offset = 'default', background, theme = 'default', verticalOffset = 'l', className, queryParams, }) => {
     const backgroundThemed = background && getThemedValue(background, theme);
     return (React.createElement("header", { className: b('header', { ['has-background']: Boolean(background) }, className) },
         (backgroundThemed === null || backgroundThemed === void 0 ? void 0 : backgroundThemed.color) ? (React.createElement(FullWidthBackground, { style: { backgroundColor: backgroundThemed === null || backgroundThemed === void 0 ? void 0 : backgroundThemed.color }, theme: "rounded" })) : null,
@@ -14,5 +14,5 @@ export const FeedHeader = ({ tags, services, setIsFetching, offset = 'default',
                         ? ''
                         : backgroundThemed === null || backgroundThemed === void 0 ? void 0 : backgroundThemed.color,
                 }, disableCompress: backgroundThemed === null || backgroundThemed === void 0 ? void 0 : backgroundThemed.disableCompress })) : null,
-            React.createElement(Controls, { tags: tags, services: services, setIsFetching: setIsFetching, handleChangeQuery: handleChangeQuery, queryParams: queryParams }))));
+            React.createElement(Controls, { tags: tags, services: services, handleLoadData: handleLoadData, queryParams: queryParams }))));
 };

package/build/esm/components/FeedHeader/components/Controls/Controls.d.ts

@@ -1,5 +1,5 @@
 import React, { ReactNode } from 'react';
-import { HandleChangeQueryParams, Query, SetQueryType } from '../../../../models/common';
+import { FetchArgs, Query, SetQueryType } from '../../../../models/common';
 import './Controls.css';
 export type SelectItem = {
     content: string;
@@ -7,10 +7,9 @@ export type SelectItem = {
     icon?: ReactNode;
 };
 export type ControlsProps = {
-    setIsFetching: (value: boolean) => void;
+    handleLoadData: (props: FetchArgs) => void;
     tags?: SelectItem[];
     services?: SelectItem[];
-    handleChangeQuery: HandleChangeQueryParams;
     queryParams: Query;
     setQuery?: SetQueryType;
 };