@salutejs/plasma-new-hope 0.149.0-canary.1445.10942800137.0 → 0.150.0-canary.1443.10955942474.0

package/emotion/cjs/components/Steps/Steps.template-doc.mdx

@@ -0,0 +1,82 @@
+---
+id: steps
+title: Steps
+---
+
+# Steps
+Шаги могут отображаться в нескольких размерах, в упрощенном виде и в горизонтальной/вертикальной ориентации
+
+```tsx live
+import React, { ReactNode, useState } from "react";
+
+interface StepItemSimple {
+  indicator?: number | string | ReactNode;
+  progress?: "notStarted" | "completed" | "inProgress";
+  disabled?: boolean;
+}
+
+interface StepItem {
+  title?: string;
+  content?: string | ReactNode;
+  indicator?: number | string | ReactNode;
+  progress?: "notStarted" | "completed" | "inProgress";
+  disabled?: boolean;
+}
+
+type StepItemType = StepItemSimple | StepItem;
+
+interface Steps {
+  orientation?: "horizontal" | "vertical";
+  /* выравнивание заголовков и контента
+   * @default 'left' */
+  contentAlign?: "left" | "center"; //
+  size?: "xs" | "s" | "m" | "l";
+  indicatorSize?: 8 | 16 | 24 | 36;
+  /* наличие разделительной линии
+   * @default 'left' */
+  hasLine?: boolean;
+  /* включает упрощенное отображение, то есть без title и content
+   * даже если они есть в items */
+  simple?: boolean;
+  /* обработчик кликов по StepItem
+    при наличии onClick у полей появляется :hover
+    без onClick можно разместить в content кнопки и обрабатывать переходы через них
+  */
+  onClick?: (item: StepItemType, index: number) => void;
+  items: StepItemType[];
+}
+
+export const fullItems = [
+  {
+    title: 'Просто заголовок',
+    indicator: 1,
+    content: text,
+    progress: 'completed',
+  },
+  {
+    title: 'Очень длинный и неприятный заголовок',
+    indicator: 2,
+    content: text,
+    progress: 'inProgress',
+  },
+  {
+    title: 'СамыйДлинныйИзНеприятныхЗаголовковЕщеИБезПробелов',
+    indicator: 3,
+    content: text,
+    progress: 'notStarted',
+  },
+];
+
+// пример использования
+const [exampleItems, setExampleItems] = useState<StepItem>(() =>
+  fullItems.map((item) => ({ ...item, progress: "notStarted" })),
+);
+
+<Steps
+  onClick={(item, index) => {
+    exampleItems[index].progress = "completed";
+    setExampleItems([...exampleItems]);
+  }}
+  items={exampleItems}
+/>;
+```

package/emotion/cjs/components/TextField/TextField.js

@@ -38,7 +38,7 @@ var base = exports.base = process.env.NODE_ENV === "production" ? {
 } : {
   name: "121o0v2-plasma-new-hope__base",
   styles: "display:block;label:plasma-new-hope__base;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src-emotion/components/TextField/TextField.tsx"],"names":[],"mappings":"AAoCuB","file":"../../../../src-emotion/components/TextField/TextField.tsx","sourcesContent":["import React, { forwardRef, useEffect, useRef, useState } from 'react';\nimport type { FormEventHandler, ChangeEventHandler, KeyboardEvent, ChangeEvent } from 'react';\nimport { safeUseId, useForkRef } from '@salutejs/plasma-core';\nimport { css } from '@emotion/react';\n\nimport type { RootProps } from '../../engines';\nimport { cx } from '../../utils';\n\nimport type { ChipValues, TextFieldPrimitiveValue, TextFieldProps } from './TextField.types';\nimport { base as sizeCSS } from './variations/_size/base';\nimport { base as viewCSS } from './variations/_view/base';\nimport { base as disabledCSS } from './variations/_disabled/base';\nimport { base as readOnlyCSS } from './variations/_read-only/base';\nimport { base as labelPlacementCSS } from './variations/_label-placement/base';\nimport {\n    Input,\n    InputContainer,\n    LeftHelper,\n    Label,\n    InputWrapper,\n    InputLabelWrapper,\n    StyledContentLeft,\n    StyledContentRight,\n    StyledChips,\n    StyledTextBefore,\n    StyledTextAfter,\n    StyledIndicator,\n    StyledOptionalText,\n    InputPlaceholder,\n} from './TextField.styles';\nimport { classes } from './TextField.tokens';\nimport { TextFieldChip } from './ui';\nimport { useKeyNavigation } from './hooks';\n\nconst optionalText = 'optional';\n\nexport const base = css`\n    /* NOTE: Webkit не применяет opacity к inline тегам */\n    display: block;\n`;\n\nexport const textFieldRoot = (Root: RootProps<HTMLDivElement, TextFieldProps>) =>\n    forwardRef<HTMLInputElement, TextFieldProps>(\n        (\n            {\n                id,\n                className,\n                style,\n\n                // layout\n                contentLeft,\n                contentRight,\n                label,\n                labelPlacement,\n                textBefore,\n                textAfter,\n                placeholder,\n                leftHelper,\n                enumerationType = 'plain',\n                requiredPlacement = 'right',\n\n                // variations\n                view,\n                size,\n                readOnly = false,\n                disabled = false,\n                required = false,\n                optional,\n\n                // controlled\n                value: outerValue,\n                chips: values,\n\n                // events\n                onChange,\n                onChangeChips,\n                onSearch,\n                onKeyDown,\n\n                ...rest\n            },\n            ref,\n        ) => {\n            const contentRef = useRef<HTMLDivElement>(null);\n            const inputRef = useRef<HTMLInputElement>(null);\n            const inputForkRef = useForkRef(inputRef, ref);\n            const chipsRefs = useRef<Array<HTMLButtonElement>>([]);\n\n            const controlledRefs = { contentRef, inputRef, chipsRefs };\n\n            const [hasValue, setHasValue] = useState(\n                Boolean(outerValue) || Boolean(inputRef?.current?.value) || Boolean(rest?.defaultValue),\n            );\n            const [chips, setChips] = useState<Array<ChipValues>>([]);\n\n            const uniqId = safeUseId();\n            const innerId = id || uniqId;\n            const labelId = safeUseId();\n            const helperTextId = safeUseId();\n\n            const isChipEnumeration = enumerationType === 'chip';\n            const isChipsVisible = isChipEnumeration && Boolean(chips?.length);\n            const withHasChips = isChipsVisible ? classes.hasChips : undefined;\n\n            const hasLabelValue = Boolean(label);\n            const hasInnerLabel = size !== 'xs' && labelPlacement === 'inner' && !isChipsVisible && hasLabelValue;\n            const hasOuterLabel = labelPlacement === 'outer' && hasLabelValue;\n            const hasPlaceholder = Boolean(placeholder) && !hasInnerLabel;\n\n            const innerLabelValue = hasInnerLabel || hasOuterLabel ? label : undefined;\n            const innerLabelPlacementValue = labelPlacement === 'inner' && !hasInnerLabel ? undefined : labelPlacement;\n\n            const innerPlaceholderValue = hasPlaceholder ? placeholder : undefined;\n            const placeholderShown = Boolean(innerPlaceholderValue) && !hasValue;\n\n            const requiredPlacementClass = requiredPlacement === 'right' ? 'align-right ' : undefined;\n            const labelPlacementClass = innerLabelPlacementValue\n                ? classes[`${innerLabelPlacementValue}LabelPlacement` as keyof typeof classes]\n                : undefined;\n            const hasValueClass = hasValue ? classes.hasValue : undefined;\n\n            const wrapperWithoutLeftContent = !contentLeft && isChipsVisible ? classes.hasEmptyContentLeft : undefined;\n            const wrapperWithoutRightContent =\n                !contentRight && isChipsVisible ? classes.hasEmptyContentRight : undefined;\n\n            const handleInput: FormEventHandler<HTMLInputElement> = (event) => {\n                setHasValue(Boolean((event.target as HTMLInputElement).value));\n            };\n\n            const handleChange: ChangeEventHandler<HTMLInputElement> = (event) => {\n                if (disabled || readOnly) {\n                    return;\n                }\n\n                const { maxLength, value } = event.target;\n\n                if (maxLength !== -1 && value.length > maxLength) {\n                    return;\n                }\n\n                onChange?.(event);\n            };\n\n            const updateChips = (newChips: Array<ChipValues>, newValues: Array<TextFieldPrimitiveValue>) => {\n                setChips(newChips);\n                onChangeChips?.(newValues);\n            };\n\n            const { handleInputKeydown, handleChipKeyDown, onChipClear, handleContentKeyDown } = useKeyNavigation({\n                controlledRefs,\n                disabled,\n                readOnly,\n                chips,\n                enumerationType,\n                updateChips,\n                onSearch,\n                onChange,\n                onEnterDisabled: (rest as any).onEnterDisabled,\n            });\n\n            const onChipClick = (event: React.MouseEvent<HTMLButtonElement>) => event.stopPropagation();\n\n            const handleInputFocus = () => {\n                if (readOnly || disabled || !inputRef?.current) {\n                    return;\n                }\n\n                inputRef.current.scrollTo({\n                    top: 0,\n                    left: inputRef.current.offsetLeft,\n                    behavior: 'smooth',\n                });\n\n                inputRef.current.focus();\n            };\n\n            const getRef = (element: HTMLButtonElement | null, index: number) => {\n                if (element && chipsRefs?.current) {\n                    chipsRefs.current[index] = element;\n                }\n            };\n\n            const handleOnKeyDown = (event: ChangeEvent<HTMLInputElement> & KeyboardEvent<HTMLInputElement>) => {\n                handleInputKeydown(event);\n                onKeyDown && onKeyDown(event);\n            };\n\n            useEffect(() => {\n                if (!isChipEnumeration && !values?.length) {\n                    return;\n                }\n\n                const newChips =\n                    values?.map((value, index) => ({\n                        id: `${index}_${value}`,\n                        text: value,\n                    })) || [];\n\n                setChips(newChips);\n            }, [isChipEnumeration, values]);\n\n            useEffect(() => {\n                setHasValue(Boolean(rest?.defaultValue));\n            }, [rest.defaultValue]);\n\n            useEffect(() => {\n                setHasValue(Boolean(outerValue) || Boolean(inputRef?.current?.value));\n            }, [outerValue, inputRef?.current?.value]);\n\n            const innerOptional = Boolean(required ? false : optional);\n            const hasPlaceholderOptional = innerOptional && !innerLabelValue && !hasOuterLabel;\n            const optionalTextNode = innerOptional ? (\n                <StyledOptionalText>\n                    {Boolean(hasPlaceholderOptional ? innerPlaceholderValue : innerLabelValue) && '\\xa0'}\n                    {optionalText}\n                </StyledOptionalText>\n            ) : null;\n\n            return (\n                <Root\n                    view={view}\n                    size={size}\n                    disabled={disabled}\n                    readOnly={!disabled && readOnly}\n                    labelPlacement={innerLabelPlacementValue}\n                    onClick={handleInputFocus}\n                    className={cx(labelPlacementClass, classes.textFieldGroupItem, className)}\n                    style={style}\n                >\n                    {hasOuterLabel && (\n                        <Label id={labelId} htmlFor={id}>\n                            {required && (\n                                <StyledIndicator className={cx(classes.outerLabelPlacement, requiredPlacementClass)} />\n                            )}\n                            {innerLabelValue}\n                            {optionalTextNode}\n                        </Label>\n                    )}\n                    <InputWrapper\n                        // Ref для внутреннего использования. Не отдается наружу.\n                        ref={(rest as any).inputWrapperRef}\n                        className={cx(withHasChips, wrapperWithoutLeftContent, wrapperWithoutRightContent)}\n                    >\n                        {!hasOuterLabel && required && (\n                            <StyledIndicator className={cx(classes.innerLabelPlacement, requiredPlacementClass)} />\n                        )}\n                        {contentLeft && <StyledContentLeft>{contentLeft}</StyledContentLeft>}\n                        <InputLabelWrapper\n                            tabIndex={-1}\n                            ref={contentRef}\n                            onKeyDown={handleContentKeyDown}\n                            className={withHasChips}\n                        >\n                            {textBefore && <StyledTextBefore>{textBefore}</StyledTextBefore>}\n                            {isChipEnumeration && Boolean(chips?.length) && (\n                                <StyledChips>\n                                    {chips?.map(({ id: chipId, text }, index) => {\n                                        return (\n                                            <TextFieldChip\n                                                id={chipId}\n                                                ref={(element) => getRef(element, index)}\n                                                key={`${chipId}_${index}`}\n                                                disabled={disabled}\n                                                readOnly={readOnly}\n                                                value={text}\n                                                text={text}\n                                                onKeyDown={(event) => handleChipKeyDown(event, chipId, index)}\n                                                onClear={() => onChipClear(chipId, index)}\n                                                onClick={onChipClick}\n                                            />\n                                        );\n                                    })}\n                                </StyledChips>\n                            )}\n                            <InputContainer>\n                                <Input\n                                    ref={inputForkRef}\n                                    id={innerId}\n                                    value={outerValue}\n                                    aria-labelledby={labelId}\n                                    aria-describedby={helperTextId}\n                                    placeholder={innerPlaceholderValue}\n                                    className={cx(hasValueClass)}\n                                    disabled={disabled}\n                                    readOnly={!disabled && readOnly}\n                                    onInput={handleInput}\n                                    onChange={handleChange}\n                                    onKeyDown={handleOnKeyDown}\n                                    {...rest}\n                                />\n                                {hasInnerLabel && (\n                                    <Label id={labelId} htmlFor={innerId}>\n                                        {innerLabelValue}\n                                        {optionalTextNode}\n                                    </Label>\n                                )}\n                                {placeholderShown && !hasValue && (\n                                    <InputPlaceholder>\n                                        {innerPlaceholderValue}\n                                        {hasPlaceholderOptional && optionalTextNode}\n                                    </InputPlaceholder>\n                                )}\n                            </InputContainer>\n                            {textAfter && <StyledTextAfter>{textAfter}</StyledTextAfter>}\n                        </InputLabelWrapper>\n                        {contentRight && <StyledContentRight>{contentRight}</StyledContentRight>}\n                    </InputWrapper>\n                    {leftHelper && <LeftHelper id={helperTextId}>{leftHelper}</LeftHelper>}\n                </Root>\n            );\n        },\n    );\n\nexport const textFieldConfig = {\n    name: 'TextField',\n    tag: 'div',\n    layout: textFieldRoot,\n    base,\n    variations: {\n        view: {\n            css: viewCSS,\n        },\n        size: {\n            css: sizeCSS,\n        },\n        disabled: {\n            css: disabledCSS,\n            attrs: true,\n        },\n        readOnly: {\n            css: readOnlyCSS,\n            attrs: true,\n        },\n        labelPlacement: {\n            css: labelPlacementCSS,\n        },\n    },\n    defaults: {\n        size: 'm',\n        view: 'default',\n    },\n};\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src-emotion/components/TextField/TextField.tsx"],"names":[],"mappings":"AAoCuB","file":"../../../../src-emotion/components/TextField/TextField.tsx","sourcesContent":["import React, { forwardRef, useEffect, useRef, useState } from 'react';\nimport type { FormEventHandler, ChangeEventHandler, KeyboardEvent, ChangeEvent } from 'react';\nimport { safeUseId, useForkRef } from '@salutejs/plasma-core';\nimport { css } from '@emotion/react';\n\nimport type { RootProps } from '../../engines';\nimport { cx } from '../../utils';\n\nimport type { ChipValues, TextFieldPrimitiveValue, TextFieldProps } from './TextField.types';\nimport { base as sizeCSS } from './variations/_size/base';\nimport { base as viewCSS } from './variations/_view/base';\nimport { base as disabledCSS } from './variations/_disabled/base';\nimport { base as readOnlyCSS } from './variations/_read-only/base';\nimport { base as labelPlacementCSS } from './variations/_label-placement/base';\nimport {\n    Input,\n    InputContainer,\n    LeftHelper,\n    Label,\n    InputWrapper,\n    InputLabelWrapper,\n    StyledContentLeft,\n    StyledContentRight,\n    StyledChips,\n    StyledTextBefore,\n    StyledTextAfter,\n    StyledIndicator,\n    StyledOptionalText,\n    InputPlaceholder,\n} from './TextField.styles';\nimport { classes } from './TextField.tokens';\nimport { TextFieldChip } from './ui';\nimport { useKeyNavigation } from './hooks';\n\nconst optionalText = 'optional';\n\nexport const base = css`\n    /* NOTE: Webkit не применяет opacity к inline тегам */\n    display: block;\n`;\n\nexport const textFieldRoot = (Root: RootProps<HTMLDivElement, TextFieldProps>) =>\n    forwardRef<HTMLInputElement, TextFieldProps>(\n        (\n            {\n                id,\n                className,\n                style,\n\n                // layout\n                contentLeft,\n                contentRight,\n                label,\n                labelPlacement,\n                textBefore,\n                textAfter,\n                placeholder,\n                leftHelper,\n                enumerationType = 'plain',\n                requiredPlacement = 'right',\n\n                // variations\n                view,\n                size,\n                readOnly = false,\n                disabled = false,\n                required = false,\n                optional,\n\n                // controlled\n                value: outerValue,\n                chips: values,\n\n                // events\n                onChange,\n                onChangeChips,\n                onSearch,\n                onKeyDown,\n\n                ...rest\n            },\n            ref,\n        ) => {\n            const contentRef = useRef<HTMLDivElement>(null);\n            const inputRef = useRef<HTMLInputElement>(null);\n            const inputForkRef = useForkRef(inputRef, ref);\n            const chipsRefs = useRef<Array<HTMLButtonElement>>([]);\n\n            const controlledRefs = { contentRef, inputRef, chipsRefs };\n\n            const [hasValue, setHasValue] = useState(\n                Boolean(outerValue) || Boolean(inputRef?.current?.value) || Boolean(rest?.defaultValue),\n            );\n            const [chips, setChips] = useState<Array<ChipValues>>([]);\n\n            const uniqId = safeUseId();\n            const innerId = id || uniqId;\n            const labelId = safeUseId();\n            const helperTextId = safeUseId();\n\n            const isChipEnumeration = enumerationType === 'chip';\n            const isChipsVisible = isChipEnumeration && Boolean(chips?.length);\n            const withHasChips = isChipsVisible ? classes.hasChips : undefined;\n\n            const hasLabelValue = Boolean(label);\n            const hasInnerLabel = size !== 'xs' && labelPlacement === 'inner' && !isChipsVisible && hasLabelValue;\n            const hasOuterLabel = labelPlacement === 'outer' && hasLabelValue;\n            const hasPlaceholder = Boolean(placeholder) && !hasInnerLabel;\n\n            const innerLabelValue = hasInnerLabel || hasOuterLabel ? label : undefined;\n            const innerLabelPlacementValue = labelPlacement === 'inner' && !hasInnerLabel ? undefined : labelPlacement;\n\n            const innerPlaceholderValue = hasPlaceholder ? placeholder : undefined;\n            const placeholderShown = Boolean(innerPlaceholderValue) && !hasValue;\n\n            const requiredPlacementClass = requiredPlacement === 'right' ? 'align-right ' : undefined;\n            const labelPlacementClass = innerLabelPlacementValue\n                ? classes[`${innerLabelPlacementValue}LabelPlacement` as keyof typeof classes]\n                : undefined;\n            const hasValueClass = hasValue ? classes.hasValue : undefined;\n\n            const wrapperWithoutLeftContent = !contentLeft && isChipsVisible ? classes.hasEmptyContentLeft : undefined;\n            const wrapperWithoutRightContent =\n                !contentRight && isChipsVisible ? classes.hasEmptyContentRight : undefined;\n\n            const handleInput: FormEventHandler<HTMLInputElement> = (event) => {\n                setHasValue(Boolean((event.target as HTMLInputElement).value));\n            };\n\n            const handleChange: ChangeEventHandler<HTMLInputElement> = (event) => {\n                if (disabled || readOnly) {\n                    return;\n                }\n\n                const { maxLength, value } = event.target;\n\n                if (maxLength !== -1 && value.length > maxLength) {\n                    return;\n                }\n\n                onChange?.(event);\n            };\n\n            const updateChips = (newChips: Array<ChipValues>, newValues: Array<TextFieldPrimitiveValue>) => {\n                setChips(newChips);\n                onChangeChips?.(newValues);\n            };\n\n            const { handleInputKeydown, handleChipKeyDown, onChipClear, handleContentKeyDown } = useKeyNavigation({\n                controlledRefs,\n                disabled,\n                readOnly,\n                chips,\n                enumerationType,\n                updateChips,\n                onSearch,\n                onChange,\n                onEnterDisabled: (rest as any).onEnterDisabled,\n            });\n\n            const onChipClick = (event: React.MouseEvent<HTMLButtonElement>) => event.stopPropagation();\n\n            const handleInputFocus = () => {\n                if (readOnly || disabled || !inputRef?.current) {\n                    return;\n                }\n\n                inputRef.current.scrollTo({\n                    top: 0,\n                    left: inputRef.current.offsetLeft,\n                    behavior: 'smooth',\n                });\n\n                inputRef.current.focus();\n            };\n\n            const getRef = (element: HTMLButtonElement | null, index: number) => {\n                if (element && chipsRefs?.current) {\n                    chipsRefs.current[index] = element;\n                }\n            };\n\n            const handleOnKeyDown = (event: ChangeEvent<HTMLInputElement> & KeyboardEvent<HTMLInputElement>) => {\n                handleInputKeydown(event);\n\n                if (onKeyDown) {\n                    onKeyDown(event);\n                }\n            };\n\n            useEffect(() => {\n                if (!isChipEnumeration && !values?.length) {\n                    return;\n                }\n\n                const newChips =\n                    values?.map((value, index) => ({\n                        id: `${index}_${value}`,\n                        text: value,\n                    })) || [];\n\n                setChips(newChips);\n            }, [isChipEnumeration, values]);\n\n            useEffect(() => {\n                setHasValue(Boolean(rest?.defaultValue));\n            }, [rest.defaultValue]);\n\n            useEffect(() => {\n                setHasValue(Boolean(outerValue) || Boolean(inputRef?.current?.value));\n            }, [outerValue, inputRef?.current?.value]);\n\n            const innerOptional = Boolean(required ? false : optional);\n            const hasPlaceholderOptional = innerOptional && !innerLabelValue && !hasOuterLabel;\n            const optionalTextNode = innerOptional ? (\n                <StyledOptionalText>\n                    {Boolean(hasPlaceholderOptional ? innerPlaceholderValue : innerLabelValue) && '\\xa0'}\n                    {optionalText}\n                </StyledOptionalText>\n            ) : null;\n\n            return (\n                <Root\n                    view={view}\n                    size={size}\n                    disabled={disabled}\n                    readOnly={!disabled && readOnly}\n                    labelPlacement={innerLabelPlacementValue}\n                    onClick={handleInputFocus}\n                    className={cx(labelPlacementClass, classes.textFieldGroupItem, className)}\n                    style={style}\n                >\n                    {hasOuterLabel && (\n                        <Label id={labelId} htmlFor={id}>\n                            {required && (\n                                <StyledIndicator className={cx(classes.outerLabelPlacement, requiredPlacementClass)} />\n                            )}\n                            {innerLabelValue}\n                            {optionalTextNode}\n                        </Label>\n                    )}\n                    <InputWrapper\n                        // Ref для внутреннего использования. Не отдается наружу.\n                        ref={(rest as any).inputWrapperRef}\n                        className={cx(withHasChips, wrapperWithoutLeftContent, wrapperWithoutRightContent)}\n                    >\n                        {!hasOuterLabel && required && (\n                            <StyledIndicator className={cx(classes.innerLabelPlacement, requiredPlacementClass)} />\n                        )}\n                        {contentLeft && <StyledContentLeft>{contentLeft}</StyledContentLeft>}\n                        <InputLabelWrapper\n                            tabIndex={-1}\n                            ref={contentRef}\n                            onKeyDown={handleContentKeyDown}\n                            className={withHasChips}\n                        >\n                            {textBefore && <StyledTextBefore>{textBefore}</StyledTextBefore>}\n                            {isChipEnumeration && Boolean(chips?.length) && (\n                                <StyledChips>\n                                    {chips?.map(({ id: chipId, text }, index) => {\n                                        return (\n                                            <TextFieldChip\n                                                id={chipId}\n                                                ref={(element) => getRef(element, index)}\n                                                key={`${chipId}_${index}`}\n                                                disabled={disabled}\n                                                readOnly={readOnly}\n                                                value={text}\n                                                text={text}\n                                                onKeyDown={(event) => handleChipKeyDown(event, chipId, index)}\n                                                onClear={() => onChipClear(chipId, index)}\n                                                onClick={onChipClick}\n                                            />\n                                        );\n                                    })}\n                                </StyledChips>\n                            )}\n                            <InputContainer>\n                                <Input\n                                    ref={inputForkRef}\n                                    id={innerId}\n                                    value={outerValue}\n                                    aria-labelledby={labelId}\n                                    aria-describedby={helperTextId}\n                                    placeholder={innerPlaceholderValue}\n                                    className={cx(hasValueClass)}\n                                    disabled={disabled}\n                                    readOnly={!disabled && readOnly}\n                                    onInput={handleInput}\n                                    onChange={handleChange}\n                                    onKeyDown={handleOnKeyDown}\n                                    {...rest}\n                                />\n                                {hasInnerLabel && (\n                                    <Label id={labelId} htmlFor={innerId}>\n                                        {innerLabelValue}\n                                        {optionalTextNode}\n                                    </Label>\n                                )}\n                                {placeholderShown && !hasValue && (\n                                    <InputPlaceholder>\n                                        {innerPlaceholderValue}\n                                        {hasPlaceholderOptional && optionalTextNode}\n                                    </InputPlaceholder>\n                                )}\n                            </InputContainer>\n                            {textAfter && <StyledTextAfter>{textAfter}</StyledTextAfter>}\n                        </InputLabelWrapper>\n                        {contentRight && <StyledContentRight>{contentRight}</StyledContentRight>}\n                    </InputWrapper>\n                    {leftHelper && <LeftHelper id={helperTextId}>{leftHelper}</LeftHelper>}\n                </Root>\n            );\n        },\n    );\n\nexport const textFieldConfig = {\n    name: 'TextField',\n    tag: 'div',\n    layout: textFieldRoot,\n    base,\n    variations: {\n        view: {\n            css: viewCSS,\n        },\n        size: {\n            css: sizeCSS,\n        },\n        disabled: {\n            css: disabledCSS,\n            attrs: true,\n        },\n        readOnly: {\n            css: readOnlyCSS,\n            attrs: true,\n        },\n        labelPlacement: {\n            css: labelPlacementCSS,\n        },\n    },\n    defaults: {\n        size: 'm',\n        view: 'default',\n    },\n};\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__
 };
 var textFieldRoot = exports.textFieldRoot = function textFieldRoot(Root) {
@@ -167,7 +167,9 @@ var textFieldRoot = exports.textFieldRoot = function textFieldRoot(Root) {
     };
     var handleOnKeyDown = function handleOnKeyDown(event) {
       handleInputKeydown(event);
-      onKeyDown && onKeyDown(event);
+      if (onKeyDown) {
+        onKeyDown(event);
+      }
     };
     (0, _react.useEffect)(function () {
       if (!isChipEnumeration && !(values !== null && values !== void 0 && values.length)) {

package/emotion/cjs/examples/plasma_b2c/components/Mask/Mask.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Mask = void 0;
+var _Mask = /*#__PURE__*/require("../../../../components/Mask");
+var _TextField = /*#__PURE__*/require("../TextField/TextField");
+var Mask = exports.Mask = /*#__PURE__*/(0, _Mask.composeMask)(_TextField.TextField);

package/emotion/cjs/examples/plasma_b2c/components/Mask/Mask.stories.tsx

@@ -0,0 +1,127 @@
+import React, { useEffect, useRef } from 'react';
+import type { ComponentProps } from 'react';
+import type { StoryObj, Meta } from '@storybook/react';
+import { action } from '@storybook/addon-actions';
+
+import { WithTheme } from '../../../_helpers';
+
+import { Mask } from './Mask';
+
+const onChange = action('onChange');
+
+const sizes = ['l', 'm', 's', 'xs'];
+const views = ['default', 'positive', 'warning', 'negative'];
+
+const meta: Meta<typeof Mask> = {
+    title: 'plasma_b2c/Mask',
+    component: Mask,
+    decorators: [WithTheme],
+    argTypes: {
+        view: {
+            options: views,
+            control: {
+                type: 'select',
+            },
+        },
+        size: {
+            options: sizes,
+            control: {
+                type: 'inline-radio',
+            },
+        },
+    },
+};
+
+export default meta;
+
+type StoryPropsDefault = Omit<
+    ComponentProps<typeof Mask>,
+    | 'helperBlock'
+    | 'contentLeft'
+    | 'htmlSize'
+    | 'contentRight'
+    | 'type'
+    | 'name'
+    | 'onFocus'
+    | 'onBlur'
+    | 'onChange'
+    | 'value'
+    | 'checked'
+    | 'maxLength'
+    | 'minLength'
+    | 'required'
+    | 'enumerationType'
+    | 'chips'
+    | 'onChangeChips'
+>;
+
+const StoryDemo = ({ view, ...rest }: StoryPropsDefault) => {
+    return (
+        <div style={{ display: 'flex', flexDirection: 'column', gap: '2rem', width: '50%' }}>
+            <Mask
+                label="Маска телефона"
+                mask="+7 (000) 000 - 00 - 00"
+                maskChar="_"
+                showStartChars={false}
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+
+            <Mask
+                label="Маска телефона: отображается всегда"
+                mask="+7 (000) 000 - 00 - 00"
+                maskChar="_"
+                view={view}
+                alwaysShowMask
+                onChange={onChange}
+                {...rest}
+                value="+79123"
+                name="example"
+            />
+
+            <Mask
+                label="Маска даты"
+                mask="00/00/0000"
+                maskString="DD/MM/YYYY"
+                alwaysShowMask
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+
+            <Mask
+                label="Маска даты: значения по умолчанию"
+                // eslint-disable-next-line no-octal-escape
+                mask="12.\04.0000"
+                maskChar="_"
+                alwaysShowMask
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+
+            <Mask
+                label="Маска времени"
+                mask="00:00"
+                maskChar="_"
+                alwaysShowMask
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+        </div>
+    );
+};
+
+export const Default: StoryObj<StoryPropsDefault> = {
+    args: {
+        size: 'l',
+        view: 'default',
+        labelPlacement: 'outer',
+        placeholder: 'Заполните поле',
+        disabled: false,
+        readOnly: false,
+    },
+    render: (args) => <StoryDemo {...args} />,
+};

package/emotion/cjs/examples/plasma_web/components/Mask/Mask.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Mask = void 0;
+var _Mask = /*#__PURE__*/require("../../../../components/Mask");
+var _TextField = /*#__PURE__*/require("../TextField/TextField");
+var Mask = exports.Mask = /*#__PURE__*/(0, _Mask.composeMask)(_TextField.TextField);

package/emotion/cjs/examples/plasma_web/components/Mask/Mask.stories.tsx

@@ -0,0 +1,125 @@
+import React from 'react';
+import type { ComponentProps } from 'react';
+import type { StoryObj, Meta } from '@storybook/react';
+import { action } from '@storybook/addon-actions';
+
+import { WithTheme } from '../../../_helpers';
+
+import { Mask } from './Mask';
+
+const onChange = action('onChange');
+
+const sizes = ['l', 'm', 's', 'xs'];
+const views = ['default', 'positive', 'warning', 'negative'];
+
+const meta: Meta<typeof Mask> = {
+    title: 'plasma_web/Mask',
+    component: Mask,
+    decorators: [WithTheme],
+    argTypes: {
+        view: {
+            options: views,
+            control: {
+                type: 'select',
+            },
+        },
+        size: {
+            options: sizes,
+            control: {
+                type: 'inline-radio',
+            },
+        },
+    },
+};
+
+export default meta;
+
+type StoryPropsDefault = Omit<
+    ComponentProps<typeof Mask>,
+    | 'helperBlock'
+    | 'contentLeft'
+    | 'htmlSize'
+    | 'contentRight'
+    | 'type'
+    | 'name'
+    | 'onFocus'
+    | 'onBlur'
+    | 'onChange'
+    | 'value'
+    | 'checked'
+    | 'maxLength'
+    | 'minLength'
+    | 'required'
+    | 'enumerationType'
+    | 'chips'
+    | 'onChangeChips'
+>;
+
+const StoryDemo = ({ view, ...rest }: StoryPropsDefault) => {
+    return (
+        <div style={{ display: 'flex', flexDirection: 'column', gap: '2rem', width: '50%' }}>
+            <Mask
+                label="Маска телефона"
+                mask="+7 (000) 000 - 00 - 00"
+                maskChar="_"
+                showStartChars={false}
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+
+            <Mask
+                label="Маска телефона: отображается всегда"
+                mask="+7 (000) 000 - 00 - 00"
+                maskChar="_"
+                view={view}
+                alwaysShowMask
+                onChange={onChange}
+                {...rest}
+            />
+
+            <Mask
+                label="Маска даты"
+                mask="00/00/0000"
+                maskString="DD/MM/YYYY"
+                alwaysShowMask
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+
+            <Mask
+                label="Маска даты: значения по умолчанию"
+                // eslint-disable-next-line no-octal-escape
+                mask="12.\04.0000"
+                maskChar="_"
+                alwaysShowMask
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+
+            <Mask
+                label="Маска времени"
+                mask="00:00"
+                maskChar="_"
+                alwaysShowMask
+                view={view}
+                onChange={onChange}
+                {...rest}
+            />
+        </div>
+    );
+};
+
+export const Default: StoryObj<StoryPropsDefault> = {
+    args: {
+        size: 'l',
+        view: 'default',
+        labelPlacement: 'outer',
+        placeholder: 'Заполните поле',
+        disabled: false,
+        readOnly: false,
+    },
+    render: (args) => <StoryDemo {...args} />,
+};

package/emotion/cjs/index.js

@@ -102,17 +102,6 @@ Object.keys(_Chip).forEach(function (key) {
     }
   });
 });
-var _ChipGroup = /*#__PURE__*/require("./components/ChipGroup");
-Object.keys(_ChipGroup).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _ChipGroup[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _ChipGroup[key];
-    }
-  });
-});
 var _Cell = /*#__PURE__*/require("./components/Cell");
 Object.keys(_Cell).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -640,4 +629,15 @@ Object.keys(_Editable).forEach(function (key) {
       return _Editable[key];
     }
   });
+});
+var _Mask = /*#__PURE__*/require("./components/Mask");
+Object.keys(_Mask).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Mask[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Mask[key];
+    }
+  });
 });

package/emotion/es/components/Chip/Chip.js

@@ -51,7 +51,7 @@ export var chipRoot = function chipRoot(Root) {
     return /*#__PURE__*/React.createElement(Root, _extends({
       type: "button",
       ref: ref,
-      className: cx(pilledClass, classes.chipItem, className),
+      className: cx(pilledClass, className),
       tabIndex: readOnly ? -1 : 0,
       onClick: handleClick,
       disabled: disabled,

package/emotion/es/components/Chip/Chip.tokens.js

@@ -1,6 +1,5 @@
 export var classes = {
-  pilled: 'chip-pilled',
-  chipItem: 'chip-item'
+  pilled: 'chip-pilled'
 };
 export var tokens = {
   background: '--plasma-chip-background',

package/emotion/es/components/Chip/index.js

@@ -1,2 +1,2 @@
 export { chipRoot, chipConfig } from './Chip';
-export { tokens as chipTokens, classes as chipClasses } from './Chip.tokens';
+export { tokens as chipTokens } from './Chip.tokens';

package/emotion/es/components/Mask/Mask.js

@@ -0,0 +1,45 @@
+var _excluded = ["maskFormat"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { forwardRef, useImperativeHandle, useState } from 'react';
+import maskInputCompose from '@salutejs/react-maskinput';
+var defaultFormatChars = [{
+  str: '0',
+  regexp: /[0-9]/
+}, {
+  str: '*',
+  regexp: /./
+}, {
+  str: 'a',
+  regexp: /[a-zA-Z]/
+}, {
+  str: 'я',
+  regexp: /[а-яА-ЯёЁ]/
+}];
+export var composeMask = function composeMask(InputComponent) {
+  var MaskedInput = maskInputCompose(InputComponent);
+  return /*#__PURE__*/forwardRef(function (_ref, outerRef) {
+    var _ref$maskFormat = _ref.maskFormat,
+      maskFormat = _ref$maskFormat === void 0 ? defaultFormatChars : _ref$maskFormat,
+      rest = _objectWithoutProperties(_ref, _excluded);
+    // TODO: replace inside react-maskinput 'getReference' on 'forwardRef'
+    var _useState = useState(null),
+      _useState2 = _slicedToArray(_useState, 2),
+      ref = _useState2[0],
+      setRef = _useState2[1];
+    useImperativeHandle(outerRef, function () {
+      return ref;
+    }, [ref]);
+    return /*#__PURE__*/React.createElement(MaskedInput, _extends({
+      getReference: setRef,
+      maskFormat: maskFormat
+    }, rest));
+  });
+};