@salutejs/plasma-new-hope 0.384.0-dev.0 → 0.385.0

package/dist/styled-components/cjs/plasmaCore/components/Typography/Headline.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get H1 () {
+        return H1;
+    },
+    get H2 () {
+        return H2;
+    },
+    get H3 () {
+        return H3;
+    },
+    get H4 () {
+        return H4;
+    },
+    get Headline1 () {
+        return Headline1;
+    },
+    get Headline2 () {
+        return Headline2;
+    },
+    get Headline3 () {
+        return Headline3;
+    },
+    get Headline4 () {
+        return Headline4;
+    }
+});
+const _styledcomponents = /*#__PURE__*/ _interop_require_default(require("styled-components"));
+const _tokens = require("../../utils/tokens");
+const _mixins = require("../../utils/mixins");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const Headline1 = _styledcomponents.default.div.withConfig({
+    displayName: "Headline__Headline1",
+    componentId: "sc-e53c7be7-0"
+})([
+    ``,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline1);
+const Headline2 = _styledcomponents.default.div.withConfig({
+    displayName: "Headline__Headline2",
+    componentId: "sc-e53c7be7-1"
+})([
+    ``,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline2);
+const Headline3 = _styledcomponents.default.div.withConfig({
+    displayName: "Headline__Headline3",
+    componentId: "sc-e53c7be7-2"
+})([
+    ``,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline3);
+const Headline4 = _styledcomponents.default.div.withConfig({
+    displayName: "Headline__Headline4",
+    componentId: "sc-e53c7be7-3"
+})([
+    ``,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline4);
+const H1 = _styledcomponents.default.h1.withConfig({
+    displayName: "Headline__H1",
+    componentId: "sc-e53c7be7-4"
+})([
+    `margin:0;`,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline1);
+const H2 = _styledcomponents.default.h2.withConfig({
+    displayName: "Headline__H2",
+    componentId: "sc-e53c7be7-5"
+})([
+    `margin:0;`,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline2);
+const H3 = _styledcomponents.default.h3.withConfig({
+    displayName: "Headline__H3",
+    componentId: "sc-e53c7be7-6"
+})([
+    `margin:0;`,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline3);
+const H4 = _styledcomponents.default.h4.withConfig({
+    displayName: "Headline__H4",
+    componentId: "sc-e53c7be7-7"
+})([
+    `margin:0;`,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.headline4);

package/dist/styled-components/cjs/plasmaCore/components/Typography/Paragraph.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get P () {
+        return P;
+    },
+    get P1 () {
+        return P1;
+    },
+    get P2 () {
+        return P2;
+    },
+    get ParagraphText1 () {
+        return ParagraphText1;
+    },
+    get ParagraphText2 () {
+        return ParagraphText2;
+    }
+});
+const _styledcomponents = /*#__PURE__*/ _interop_require_default(require("styled-components"));
+const _tokens = require("../../utils/tokens");
+const _mixins = require("../../utils/mixins");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const ParagraphText1 = _styledcomponents.default.div.withConfig({
+    displayName: "Paragraph__ParagraphText1",
+    componentId: "sc-52505f4f-0"
+})([
+    ``,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.paragraph1);
+const ParagraphText2 = _styledcomponents.default.div.withConfig({
+    displayName: "Paragraph__ParagraphText2",
+    componentId: "sc-52505f4f-1"
+})([
+    ``,
+    ` `,
+    ` `,
+    ``
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.paragraph2);
+const P1 = _styledcomponents.default.p.withConfig({
+    displayName: "Paragraph__P1",
+    componentId: "sc-52505f4f-2"
+})([
+    ``,
+    ` `,
+    ` `,
+    ` margin:0;`
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.paragraph1);
+const P = P1;
+const P2 = _styledcomponents.default.p.withConfig({
+    displayName: "Paragraph__P2",
+    componentId: "sc-52505f4f-3"
+})([
+    ``,
+    ` `,
+    ` `,
+    ` margin:0;`
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.paragraph2);

package/dist/styled-components/cjs/plasmaCore/components/Typography/Underline.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Underline", {
+    enumerable: true,
+    get: function() {
+        return Underline;
+    }
+});
+const _styledcomponents = /*#__PURE__*/ _interop_require_default(require("styled-components"));
+const _tokens = require("../../utils/tokens");
+const _mixins = require("../../utils/mixins");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const Underline = _styledcomponents.default.div.withConfig({
+    displayName: "Underline",
+    componentId: "sc-ac4d786-0"
+})([
+    ``,
+    ` `,
+    ` `,
+    ` text-transform:uppercase;`
+], _mixins.applyHyphens, _mixins.applySpacing, _tokens.underline);

package/dist/styled-components/cjs/plasmaCore/components/Typography/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./Body"), exports);
+_export_star(require("./Button"), exports);
+_export_star(require("./Caption"), exports);
+_export_star(require("./Display"), exports);
+_export_star(require("./Footnote"), exports);
+_export_star(require("./Headline"), exports);
+_export_star(require("./Paragraph"), exports);
+_export_star(require("./Underline"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/styled-components/cjs/plasmaCore/components/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./Card"), exports);
+_export_star(require("./Field"), exports);
+_export_star(require("./Image"), exports);
+_export_star(require("./Price"), exports);
+_export_star(require("./SSRProvider"), exports);
+_export_star(require("./Typography"), exports);
+_export_star(require("./Badge"), exports);
+_export_star(require("./Button"), exports);
+_export_star(require("./Spinner"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/styled-components/cjs/plasmaCore/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./components"), exports);
+_export_star(require("./utils"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/styled-components/cjs/plasmaCore/utils/hooks/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get useDebouncedFunction () {
+        return _useDebouncedFunction.useDebouncedFunction;
+    },
+    get useFocusTrap () {
+        return _useFocusTrap.useFocusTrap;
+    },
+    get useForkRef () {
+        return _useForkRef.useForkRef;
+    },
+    get useIsomorphicLayoutEffect () {
+        return _useIsomorphicLayoutEffect.useIsomorphicLayoutEffect;
+    },
+    get useResizeObserver () {
+        return _useResizeObserver.useResizeObserver;
+    },
+    get useUniqId () {
+        return _useUniqId.useUniqId;
+    }
+});
+const _useDebouncedFunction = require("./useDebouncedFunction");
+const _useForkRef = require("./useForkRef");
+const _useIsomorphicLayoutEffect = require("./useIsomorphicLayoutEffect");
+const _useUniqId = require("./useUniqId");
+const _useResizeObserver = require("./useResizeObserver");
+const _useFocusTrap = require("./useFocusTrap");

package/dist/styled-components/cjs/plasmaCore/utils/hooks/useDebouncedFunction.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useDebouncedFunction", {
+    enumerable: true,
+    get: function() {
+        return useDebouncedFunction;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function useDebouncedFunction(func, delay, cleanUp) {
+    const timeoutRef = _react.default.useRef();
+    /**
+     * Очистка таймера
+     */ function clearTimer() {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+            timeoutRef.current = undefined;
+        }
+    }
+    /**
+     * Очищаем таймер при анмаунте компонента, если cleanUp выставлен в true
+     * и тем самым отменяем последний запланированный вызов
+     */ _react.default.useEffect(()=>cleanUp ? clearTimer : undefined, [
+        cleanUp
+    ]);
+    return (...args)=>{
+        clearTimer();
+        timeoutRef.current = setTimeout(()=>func(...args), delay);
+    };
+}

package/dist/styled-components/cjs/plasmaCore/utils/hooks/useFocusTrap.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useFocusTrap", {
+    enumerable: true,
+    get: function() {
+        return useFocusTrap;
+    }
+});
+const _react = require("react");
+const _focusManager = require("../utils/focusManager");
+const _tabbable = require("../utils/tabbable");
+const _scopeTab = require("../utils/scopeTab");
+// Находим элемент для фокуса
+const getFocusElement = (node, firstFocusSelector)=>{
+    let focusElement = null;
+    if (firstFocusSelector) {
+        if (typeof firstFocusSelector === 'string') {
+            focusElement = node.querySelector(firstFocusSelector);
+        } else if (firstFocusSelector.current) {
+            focusElement = firstFocusSelector.current;
+        }
+    }
+    if (!focusElement) {
+        const children = Array.from(node.querySelectorAll(_tabbable.focusSelector));
+        focusElement = children.find((el)=>(0, _tabbable.isTabble)(el)) || null;
+    }
+    // Если ничего не нашлось, то может ли сама нода быть под фокусом
+    if (!focusElement && (0, _tabbable.isFocusable)(node)) {
+        focusElement = node;
+    }
+    return focusElement;
+};
+const processNode = (node, firstFocusSelector, ref)=>{
+    if (ref?.current) {
+        ref.current.removeEventListener('animationend', ()=>{
+            processNode(node, firstFocusSelector, ref);
+        });
+    }
+    const focusElement = getFocusElement(node, firstFocusSelector);
+    if (focusElement) {
+        focusElement.focus();
+    }
+};
+const focusManager = new _focusManager.FocusManager();
+const useFocusTrap = (active = true, firstFocusSelector, focusAfterNode, focusAfterAnimation)=>{
+    const ref = (0, _react.useRef)();
+    const setRef = (0, _react.useCallback)((node)=>{
+        if (ref.current) {
+            focusManager.teardownScopedFocus();
+            focusManager.returnFocus();
+        }
+        if (active && node) {
+            focusManager.setupScopedFocus(node);
+            focusManager.markForFocusAfter(focusAfterNode);
+            // Delay processing the HTML node by a frame. This ensures focus is assigned correctly.
+            setTimeout(()=>{
+                if (ref?.current && node.ownerDocument && focusAfterAnimation) {
+                    ref.current.addEventListener('animationend', ()=>{
+                        processNode(node, firstFocusSelector, ref);
+                    });
+                } else if (node.ownerDocument) {
+                    processNode(node, firstFocusSelector);
+                }
+            });
+            ref.current = node;
+            return;
+        }
+        ref.current = null;
+    }, [
+        active,
+        firstFocusSelector
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (!active) {
+            return;
+        }
+        const handleKeyDown = (event)=>{
+            if (event.key === 'Tab' && ref.current) {
+                (0, _scopeTab.scopeTab)(ref.current, event);
+            }
+        };
+        document.addEventListener('keydown', handleKeyDown);
+        return ()=>{
+            document.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [
+        active
+    ]);
+    return setRef;
+};

package/dist/styled-components/cjs/plasmaCore/utils/hooks/useForkRef.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useForkRef", {
+    enumerable: true,
+    get: function() {
+        return useForkRef;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _utils = require("../utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const useForkRef = (refOne, refTwo)=>{
+    return _react.default.useMemo(()=>{
+        if (refOne == null && refTwo === null) {
+            return null;
+        }
+        return (refOb)=>{
+            (0, _utils.setRef)(refOne, refOb);
+            (0, _utils.setRef)(refTwo, refOb);
+        };
+    }, [
+        refOne,
+        refTwo
+    ]);
+};

package/dist/styled-components/cjs/plasmaCore/utils/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useIsomorphicLayoutEffect", {
+    enumerable: true,
+    get: function() {
+        return useIsomorphicLayoutEffect;
+    }
+});
+const _react = require("react");
+const _utils = require("../utils");
+const useIsomorphicLayoutEffect = _utils.canUseDOM ? _react.useLayoutEffect : _react.useEffect;

package/dist/styled-components/cjs/plasmaCore/utils/hooks/useResizeObserver.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useResizeObserver", {
+    enumerable: true,
+    get: function() {
+        return useResizeObserver;
+    }
+});
+const _react = require("react");
+const useResizeObserver = (ref, callback)=>{
+    (0, _react.useEffect)(()=>{
+        /* istanbul ignore if: убираем проверку на рефы из покрытия */ if (!ref?.current) {
+            return;
+        }
+        const { current } = ref;
+        const resizeObserver = new window.ResizeObserver(()=>{
+            window.requestAnimationFrame(()=>{
+                callback(current);
+            });
+        });
+        resizeObserver.observe(ref.current);
+        return ()=>{
+            /* istanbul ignore if: убираем проверку на рефы из покрытия */ if (!ref?.current) {
+                return;
+            }
+            resizeObserver.unobserve(ref.current);
+        };
+    }, [
+        ref
+    ]);
+};

package/dist/styled-components/cjs/plasmaCore/utils/hooks/useUniqId.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useUniqId", {
+    enumerable: true,
+    get: function() {
+        return useUniqId;
+    }
+});
+const _react = require("react");
+const _SSRProvider = require("../../components/SSRProvider");
+let noSSRId = 0;
+function useUniqId() {
+    const context = (0, _react.useContext)(_SSRProvider.SSRContext);
+    const [id] = (0, _react.useState)(()=>{
+        if (context.uniqId !== null) {
+            return `plasma-uniq-id-ssr-${++context.uniqId}`;
+        }
+        return `plasma-uniq-id-${++noSSRId}`;
+    });
+    return id;
+}

package/dist/styled-components/cjs/plasmaCore/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./hooks"), exports);
+_export_star(require("./mixins"), exports);
+_export_star(require("./tokens"), exports);
+_export_star(require("./types"), exports);
+_export_star(require("./utils"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/styled-components/cjs/plasmaCore/utils/mixins/addFocus.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get addFocus () {
+        return addFocus;
+    },
+    get syntheticFocus () {
+        return syntheticFocus;
+    }
+});
+const _styledcomponents = require("styled-components");
+const _tokens = require("../tokens");
+require("focus-visible");
+const syntheticFocus = (ruleset, focused)=>(0, _styledcomponents.css)([
+        `&.focus-visible:focus,&[data-focus-visible-added]{outline:none;`,
+        `}`,
+        `;`
+    ], ruleset, focused && ruleset);
+const addFocus = ({ lowPerformance, focused, outlined = true, outlineSize = '0.125rem', outlineOffset = outlineSize, outlineColor = _tokens.buttonFocused, outlineRadius = 0, synthesizeFocus = syntheticFocus })=>outlined && (0, _styledcomponents.css)([
+        `position:relative;&::before{content:'';position:absolute;top:-`,
+        `;left:-`,
+        `;right:-`,
+        `;bottom:-`,
+        `;display:block;box-sizing:content-box;border:`,
+        ` solid transparent;border-radius:`,
+        `;transition:`,
+        `;pointer-events:none;}`,
+        ``
+    ], outlineOffset, outlineOffset, outlineOffset, outlineOffset, outlineSize, outlineRadius, lowPerformance ? 'unset' : 'box-shadow 0.2s ease-in-out', synthesizeFocus((0, _styledcomponents.css)([
+        `&::before{box-shadow:0 0 0 `,
+        ` `,
+        `;}`
+    ], outlineSize, outlineColor), focused));

package/dist/styled-components/cjs/plasmaCore/utils/mixins/applyDisabled.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "applyDisabled", {
+    enumerable: true,
+    get: function() {
+        return applyDisabled;
+    }
+});
+const _styledcomponents = require("styled-components");
+const disabledCss = (0, _styledcomponents.css)([
+    `opacity:0.4;cursor:not-allowed;&:hover,&:active{transform:none;}`
+]);
+const applyDisabled = ({ disabled, $disabled })=>(0, _styledcomponents.css)([
+        `&:disabled{`,
+        `}`,
+        ``
+    ], disabledCss, (disabled || $disabled) && disabledCss);

package/dist/styled-components/cjs/plasmaCore/utils/mixins/applyEllipsis.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "applyEllipsis", {
+    enumerable: true,
+    get: function() {
+        return applyEllipsis;
+    }
+});
+const _styledcomponents = require("styled-components");
+const applyEllipsis = ()=>(0, _styledcomponents.css)([
+        `overflow:hidden;text-overflow:ellipsis;white-space:nowrap;`
+    ]);

package/dist/styled-components/cjs/plasmaCore/utils/mixins/applyMaxLines.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "applyMaxLines", {
+    enumerable: true,
+    get: function() {
+        return applyMaxLines;
+    }
+});
+const _styledcomponents = require("styled-components");
+const applyMaxLines = ({ maxLines })=>maxLines && (0, _styledcomponents.css)([
+        `display:-webkit-box;overflow:hidden;box-sizing:border-box;white-space:normal;-webkit-box-orient:vertical;-webkit-line-clamp:`,
+        `;`
+    ], maxLines);