@gravity-ui/page-constructor 1.0.0

package/server/models/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constructor"), exports);
+__exportStar(require("./constructor-items"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./components"), exports);
+__exportStar(require("./guards"), exports);
+__exportStar(require("./react"), exports);

package/server/models/react.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare type WithChildren<T = {}> = T & {
+    children?: React.ReactNode;
+};

package/server/models/react.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/text-transform/blocks.d.ts

@@ -0,0 +1,16 @@
+import { Lang } from '../utils/configure';
+import { ConstructorBlock } from '../models/constructor';
+export declare type ComplexItem = {
+    [key: string]: string;
+};
+export declare type Item = string | null | ComplexItem;
+export declare type TransformerRaw = (lang: Lang, content: string) => string;
+export declare type Transformer = (text: string) => string;
+export declare type Parser<T = any> = (transformer: Transformer, block: T) => T;
+export declare const createItemsParser: (fields: string[]) => (transformer: Transformer, items: Item[]) => (string | {
+    [x: string]: string;
+} | null)[];
+export declare function yfmTransformer(lang: Lang, content: string): string;
+export declare function typografTransformer(lang: Lang, content: string): string;
+export declare function transformBlocks(blocks: ConstructorBlock[], lang: Lang, customConfig?: {}): void;
+export declare function transformFootnotes(footnotes: string[], lang: Lang): string[];

package/server/text-transform/blocks.js

@@ -0,0 +1,365 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFootnotes = exports.transformBlocks = exports.typografTransformer = exports.yfmTransformer = exports.createItemsParser = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const models_1 = require("../models");
+const utils_1 = require("./utils");
+const createItemsParser = (fields) => (transformer, items) => items.map((item) => {
+    if (!item) {
+        return item;
+    }
+    else if (typeof item === 'string') {
+        return transformer(item);
+    }
+    else {
+        return Object.assign(Object.assign({}, item), fields.reduce((acc, fieldName) => {
+            const result = Object.assign({}, acc);
+            if (item[fieldName]) {
+                result[fieldName] = transformer(item[fieldName]);
+            }
+            return result;
+        }, {}));
+    }
+});
+exports.createItemsParser = createItemsParser;
+const parseItems = (0, exports.createItemsParser)(['title', 'text']);
+function parseTableBlock(transformer, content) {
+    const legend = content === null || content === void 0 ? void 0 : content.legend;
+    return Object.assign(Object.assign({}, (content || {})), { legend: legend && legend.map((string) => transformer(string)) });
+}
+function parseFeatures(transformer, items) {
+    return items.map((_a) => {
+        var { title, text } = _a, rest = __rest(_a, ["title", "text"]);
+        return (Object.assign({ title: title && transformer(title), text: text && transformer(text) }, rest));
+    });
+}
+function parsePromoFeatures(transformer, items) {
+    return items.map((_a) => {
+        var { text } = _a, rest = __rest(_a, ["text"]);
+        return (Object.assign({ text: transformer(text) }, rest));
+    });
+}
+function parseSlider(transformer, block) {
+    const { title, description } = block;
+    block.title = Object.assign(Object.assign({}, title), { text: transformer(title ? title.text : '') });
+    if (description) {
+        block.description = transformer(description);
+    }
+}
+function parseCard(transformer, card) {
+    const { header, text } = card;
+    card.text = text && transformer(text);
+    if (header && header.title) {
+        card.header = card.header || {};
+        card.header.title = transformer(header.title);
+    }
+}
+const parseTitle = (transformer, title) => typeof title === 'object' && 'text' in title
+    ? Object.assign(Object.assign({}, title), { text: transformer(title.text) }) : title && transformer(title);
+function parsePriceDetailedBlock(transformer, block) {
+    const { priceType } = block;
+    const transformedBlockItems = block.items.map((item) => {
+        const { description, items: details = [] } = item;
+        if (priceType === 'marked-list') {
+            item.items = details.map((detail) => {
+                detail.text = detail.text && transformer(detail.text);
+                return detail;
+            });
+        }
+        else {
+            item.items = details.map((detail) => {
+                detail.description = detail.description && transformer(detail.description);
+                return detail;
+            });
+        }
+        item.description = transformer(description);
+        return item;
+    });
+    block.items = transformedBlockItems;
+    return block;
+}
+const parseContentLayout = (transformer, content) => {
+    if (content) {
+        const { text, additionalInfo } = content;
+        if (text) {
+            content.text = transformer(text);
+        }
+        if (additionalInfo) {
+            content.additionalInfo = transformer(additionalInfo);
+        }
+    }
+    return content;
+};
+function parseContentLayoutTitle(transformer, content) {
+    if (content === null || content === void 0 ? void 0 : content.title) {
+        const { title } = content;
+        content.title = title && parseTitle(transformer, title);
+    }
+    return content;
+}
+function yfmTransformer(lang, content) {
+    const { html } = (0, utils_1.fullTransform)(content, { lang });
+    return html;
+}
+exports.yfmTransformer = yfmTransformer;
+function typografTransformer(lang, content) {
+    return (0, utils_1.typografToHTML)(content, lang);
+}
+exports.typografTransformer = typografTransformer;
+const config = {
+    [models_1.SubBlockType.Partner]: {
+        fields: ['text'],
+        transformer: typografTransformer,
+    },
+    [models_1.SubBlockType.BasicCard]: [
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+        },
+        {
+            fields: ['text', 'additionalInfo'],
+            transformer: yfmTransformer,
+        },
+    ],
+    [models_1.SubBlockType.TutorialCard]: {
+        fields: ['text', 'title'],
+        transformer: typografTransformer,
+    },
+    [models_1.SubBlockType.BackgroundCard]: [
+        {
+            fields: ['text', 'additionalInfo'],
+            transformer: yfmTransformer,
+        },
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+        },
+    ],
+    [models_1.SubBlockType.CardWithImage]: [
+        {
+            fields: ['description', 'additionalInfo'],
+            transformer: yfmTransformer,
+        },
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+        },
+    ],
+    [models_1.SubBlockType.Quote]: {
+        fields: ['text'],
+        transformer: typografTransformer,
+    },
+    [models_1.SubBlockType.Card]: {
+        transformer: yfmTransformer,
+        parser: parseCard,
+    },
+    [models_1.BlockType.ExtendedFeaturesBlock]: [
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+            parser: parseTitle,
+        },
+        {
+            fields: ['description'],
+            transformer: yfmTransformer,
+        },
+        {
+            fields: ['items'],
+            transformer: typografTransformer,
+            parser: parseFeatures,
+        },
+    ],
+    [models_1.BlockType.PromoFeaturesBlock]: {
+        fields: ['items'],
+        transformer: yfmTransformer,
+        parser: parsePromoFeatures,
+    },
+    [models_1.BlockType.SliderBlock]: {
+        transformer: typografTransformer,
+        parser: parseSlider,
+    },
+    [models_1.BlockType.QuestionsBlock]: [
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+        },
+        {
+            fields: ['text', 'additionalInfo'],
+            transformer: yfmTransformer,
+        },
+        {
+            fields: ['items'],
+            transformer: yfmTransformer,
+            parser: parseFeatures,
+        },
+    ],
+    [models_1.BlockType.BannerBlock]: [
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+        },
+        {
+            fields: ['subtitle'],
+            transformer: yfmTransformer,
+        },
+    ],
+    [models_1.SubBlockType.BannerCard]: [
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+        },
+        {
+            fields: ['subtitle'],
+            transformer: yfmTransformer,
+        },
+    ],
+    [models_1.BlockType.MediaBlock]: [
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+        },
+        {
+            fields: ['description', 'title', 'additionalInfo'],
+            transformer: yfmTransformer,
+        },
+    ],
+    [models_1.BlockType.TabsBlock]: [
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+            parser: parseTitle,
+        },
+        {
+            fields: ['items'],
+            transformer: yfmTransformer,
+            parser: parseItems,
+        },
+    ],
+    [models_1.BlockType.TableBlock]: [
+        {
+            fields: ['table'],
+            transformer: yfmTransformer,
+            parser: parseTableBlock,
+        },
+    ],
+    [models_1.BlockType.HeaderSliderBlock]: [
+        {
+            fields: ['items'],
+            transformer: typografTransformer,
+            parser: (0, exports.createItemsParser)(['title', 'overtitle']),
+        },
+        {
+            fields: ['items'],
+            transformer: yfmTransformer,
+            parser: (0, exports.createItemsParser)(['description']),
+        },
+    ],
+    [models_1.BlockType.SimpleBlock]: [
+        {
+            fields: ['description'],
+            transformer: yfmTransformer,
+        },
+    ],
+    [models_1.SubBlockType.PriceDetailed]: [
+        {
+            transformer: yfmTransformer,
+            parser: parsePriceDetailedBlock,
+        },
+    ],
+    [models_1.BlockType.HeaderBlock]: [
+        {
+            fields: ['description'],
+            transformer: yfmTransformer,
+        },
+    ],
+    [models_1.BlockType.ContentLayoutBlock]: [
+        {
+            fields: ['textContent'],
+            transformer: yfmTransformer,
+            parser: parseContentLayout,
+        },
+        {
+            fields: ['textContent'],
+            transformer: typografTransformer,
+            parser: parseContentLayoutTitle,
+        },
+    ],
+    [models_1.SubBlockType.Content]: [
+        {
+            fields: ['text', 'additionalInfo'],
+            transformer: yfmTransformer,
+        },
+        {
+            fields: ['title'],
+            transformer: typografTransformer,
+            parser: parseTitle,
+        },
+    ],
+    [models_1.BlockType.PreviewBlock]: [
+        {
+            fields: ['description'],
+            transformer: yfmTransformer,
+        },
+    ],
+};
+function addRandomOrder(block) {
+    if (block) {
+        if ('randomOrder' in block && block.randomOrder && 'children' in block && block.children) {
+            block.children = lodash_1.default.shuffle(block.children);
+        }
+    }
+}
+function transformBlock(lang, blocksConfig, block) {
+    const blockConfig = blocksConfig[block.type];
+    addRandomOrder(block);
+    if (blockConfig) {
+        const configs = Array.isArray(blockConfig) ? blockConfig : [blockConfig];
+        configs.forEach((transformConfig) => {
+            const { fields, transformer: transformerRaw, parser } = transformConfig;
+            const transformer = transformerRaw.bind(null, lang);
+            if (fields) {
+                fields.forEach((field) => {
+                    if (block[field]) {
+                        if (parser) {
+                            block[field] = parser(transformer, block[field]);
+                        }
+                        else if (typeof block[field] === 'string') {
+                            block[field] = transformer(block[field]);
+                        }
+                    }
+                });
+            }
+            else if (parser) {
+                parser(transformer, block);
+            }
+        });
+    }
+    if ('children' in block && block.children) {
+        transformBlocks(block.children, lang, blocksConfig);
+    }
+}
+function transformBlocks(blocks, lang, customConfig = {}) {
+    const fullConfig = Object.assign(Object.assign({}, config), customConfig);
+    blocks.forEach(transformBlock.bind(null, lang, fullConfig));
+}
+exports.transformBlocks = transformBlocks;
+function transformFootnotes(footnotes, lang) {
+    return footnotes
+        .map((footnote) => (0, utils_1.fullTransform)(footnote, { path: __dirname, lang, allowHTML: true }).html)
+        .filter(Boolean);
+}
+exports.transformFootnotes = transformFootnotes;

package/server/text-transform/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './blocks';

package/server/text-transform/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./blocks"), exports);

package/server/text-transform/utils.d.ts

@@ -0,0 +1,30 @@
+import sanitize from 'sanitize-html';
+import { Options, Output } from '@doc-tools/transform';
+import { Lang } from '../utils/configure';
+export declare enum TransformType {
+    Text = "text",
+    Html = "html"
+}
+interface TransformOptions extends Options {
+    lang: Lang;
+}
+export declare const DEFAULT_ALLOWED_TAGS: string[];
+export declare const typografConfig: {
+    enabled: string[];
+    disabled: string[];
+};
+export declare const sanitizeStripOptions: sanitize.IOptions;
+export declare function typograf(text: string, lang?: Lang): string;
+export declare function sanitizeHtml(html: string, options?: sanitize.IOptions): string;
+export declare function typografToHTML(text: string, lang: Lang, allowedTags?: string[]): string;
+export declare function typografToText(text: string, lang: Lang): string;
+export declare const transformMarkdown: (input: string, options: TransformOptions) => Output['result'];
+export declare function fullTransform(input: string, { lang, ...options }: TransformOptions): Output['result'];
+export interface TypografEntityParams {
+    entity: Record<string, string>;
+    fields: string[];
+    lang: Lang;
+    transformType: TransformType;
+}
+export declare function typografEntity({ entity, fields, lang, transformType, }: TypografEntityParams): Record<string, string>;
+export {};

package/server/text-transform/utils.js

@@ -0,0 +1,128 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typografEntity = exports.fullTransform = exports.transformMarkdown = exports.typografToText = exports.typografToHTML = exports.sanitizeHtml = exports.typograf = exports.sanitizeStripOptions = exports.typografConfig = exports.DEFAULT_ALLOWED_TAGS = exports.TransformType = void 0;
+const typograf_1 = __importDefault(require("typograf"));
+const sanitize_html_1 = __importDefault(require("sanitize-html"));
+const transform_1 = __importDefault(require("@doc-tools/transform"));
+const configure_1 = require("../utils/configure");
+var TransformType;
+(function (TransformType) {
+    TransformType["Text"] = "text";
+    TransformType["Html"] = "html";
+})(TransformType = exports.TransformType || (exports.TransformType = {}));
+exports.DEFAULT_ALLOWED_TAGS = [
+    'br',
+    'b',
+    'i',
+    'strong',
+    'em',
+    'sup',
+    'sub',
+    'a',
+    'ul',
+    'ol',
+    'li',
+];
+exports.typografConfig = {
+    enabled: ['common/nbsp/afterNumber', 'common/nbsp/afterParagraphMark'],
+    disabled: ['common/symbols/cf'],
+};
+exports.sanitizeStripOptions = {
+    allowedTags: [],
+    allowedAttributes: {},
+};
+typograf_1.default.addRule({
+    name: 'common/html/sup',
+    queue: 'end',
+    /* TODO mange with it: in typograf types AddRuleOptions.handler takes only one param: text.
+    But in cloud-www was used this notation with 3 params */
+    //@ts-ignore
+    handler: function (text, settings, context) {
+        const { prefs: { htmlEntity: { type = '' } = {} } = {} } = context;
+        let symbols;
+        switch (type) {
+            case 'digit':
+                symbols = '&#174;|&#169;|&#8482;';
+                break;
+            case 'name':
+                symbols = '&reg;|&copy;|&trade;';
+                break;
+            default:
+                symbols = '®|©|™';
+                break;
+        }
+        const symbolsRegex = new RegExp(`(?<!<sup>\\s*)(${symbols})|(${symbols})(?!\\s*<\\/sup>)`, 'gi');
+        return text.replace(symbolsRegex, '<sup>$1</sup>');
+    },
+    htmlAttrs: false,
+});
+function enableRules(tp) {
+    const { disabled, enabled } = exports.typografConfig;
+    enabled.forEach((rule) => tp.enableRule(rule));
+    disabled.forEach((rule) => tp.disableRule(rule));
+}
+function typograf(text, lang = configure_1.Lang.Ru) {
+    const localeByLang = {
+        [configure_1.Lang.Ru]: ['ru', 'en-US'],
+        [configure_1.Lang.En]: ['en-US', 'ru'],
+    };
+    const tp = new typograf_1.default({
+        locale: localeByLang[lang],
+        htmlEntity: { type: 'name' },
+    });
+    enableRules(tp);
+    return tp.execute(text);
+}
+exports.typograf = typograf;
+function sanitizeHtml(html, options = exports.sanitizeStripOptions) {
+    return html && (0, sanitize_html_1.default)(html, options || exports.sanitizeStripOptions);
+}
+exports.sanitizeHtml = sanitizeHtml;
+function typografToHTML(text, lang, allowedTags = exports.DEFAULT_ALLOWED_TAGS) {
+    return text && typograf(sanitizeHtml(text, { allowedTags }), lang);
+}
+exports.typografToHTML = typografToHTML;
+function typografToText(text, lang) {
+    return text && sanitizeHtml(typograf(text, lang));
+}
+exports.typografToText = typografToText;
+const transformMarkdown = (input, options) => {
+    const { result } = (0, transform_1.default)(input !== null && input !== void 0 ? input : '', options);
+    return result;
+};
+exports.transformMarkdown = transformMarkdown;
+function fullTransform(input, _a) {
+    var { lang } = _a, options = __rest(_a, ["lang"]);
+    const result = (0, exports.transformMarkdown)(input, Object.assign({ lang }, options));
+    const { html, title } = result;
+    return Object.assign(Object.assign({}, result), { html: typograf(html, lang), title: title && typograf(title, lang) });
+}
+exports.fullTransform = fullTransform;
+function typografEntity({ entity, fields, lang = configure_1.Lang.Ru, transformType = TransformType.Text, }) {
+    const transformTypeMap = {
+        text: typografToText,
+        html: typografToHTML,
+    };
+    const transformer = transformTypeMap[transformType];
+    fields.forEach((fieldName) => {
+        if (entity[fieldName]) {
+            entity[fieldName] = transformer(entity[fieldName], lang);
+        }
+    });
+    return entity;
+}
+exports.typografEntity = typografEntity;

package/server/utils/blocks.d.ts

@@ -0,0 +1,9 @@
+import { ConstructorBlock } from '../models/constructor';
+import { TextSize, CustomConfig } from '../models';
+export declare function getHeaderTag(size: TextSize): "h1" | "h4" | "h2";
+export declare function getBlockKey(block: ConstructorBlock, index: number): string;
+export declare const getCustomBlockTypes: ({ blocks, headers }?: CustomConfig) => string[];
+export declare const getCustomItems: ({ blocks, headers, subBlocks }?: CustomConfig) => {
+    [x: string]: any;
+};
+export declare const getCustomHeaderTypes: (customBlocks?: CustomConfig) => string[];

package/server/utils/blocks.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomHeaderTypes = exports.getCustomItems = exports.getCustomBlockTypes = exports.getBlockKey = exports.getHeaderTag = void 0;
+function getHeaderTag(size) {
+    switch (size) {
+        case 'l':
+            return 'h1';
+        case 's':
+            return 'h4';
+        case 'm':
+        default:
+            return 'h2';
+    }
+}
+exports.getHeaderTag = getHeaderTag;
+function getBlockKey(block, index) {
+    return `${block.type}-${index}`;
+}
+exports.getBlockKey = getBlockKey;
+const getCustomBlockTypes = ({ blocks = {}, headers = {} } = {}) => [
+    ...Object.keys(blocks),
+    ...Object.keys(headers),
+];
+exports.getCustomBlockTypes = getCustomBlockTypes;
+const getCustomItems = ({ blocks = {}, headers = {}, subBlocks = {} } = {}) => (Object.assign(Object.assign(Object.assign({}, blocks), headers), subBlocks));
+exports.getCustomItems = getCustomItems;
+const getCustomHeaderTypes = (customBlocks = {}) => {
+    const { headers = {} } = customBlocks;
+    return Object.keys(headers);
+};
+exports.getCustomHeaderTypes = getCustomHeaderTypes;

package/server/utils/cn.d.ts

@@ -0,0 +1,4 @@
+import blockOrigin from 'bem-cn-lite';
+export declare const NAMESPACE = "pc-";
+export declare type CnBlock = ReturnType<typeof blockOrigin>;
+export declare function block(name: string): CnBlock;

package/server/utils/cn.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.block = exports.NAMESPACE = void 0;
+const bem_cn_lite_1 = __importDefault(require("bem-cn-lite"));
+exports.NAMESPACE = 'pc-';
+function block(name) {
+    return (0, bem_cn_lite_1.default)(`${exports.NAMESPACE}${name}`);
+}
+exports.block = block;

package/server/utils/configure.d.ts

@@ -0,0 +1,12 @@
+export declare enum Lang {
+    Ru = "ru",
+    En = "en"
+}
+interface Config {
+    lang?: Lang;
+}
+declare type Subscriber = (config: Config) => void;
+export declare const configure: (newConfig: Config) => void;
+export declare const subscribeConfigure: (sub: Subscriber) => () => void;
+export declare const getConfig: () => Config;
+export {};