@infomaximum/ui-kit 0.9.1

package/dist/components/Input/Input.js

@@ -0,0 +1,163 @@
+import { jsx, jsxs } from "@emotion/react/jsx-runtime";
+import { forwardRef, useRef, memo, Fragment } from "react";
+import { InputPassword } from "./components/InputPassword/InputPassword.js";
+import { InputTextArea } from "./components/InputTextArea/InputTextArea.js";
+import { isString } from "lodash-es";
+import { CloseCircleFilled } from "@infomaximum/icons";
+import { emptyString } from "../../utils/const/index.js";
+import { prefixStyle, prefixSuffixStyle, suffixStyle, getClearIconWrapperStyle, getAddonStyle, nonStringAddonStyle, inputGroupClassName, addonWrapperStyle, getAffixWrapperStyle, affixedInputStyle, getSharedInputStyle, getBaseInputStyle } from "./Input.styles.js";
+import { getInputTokens } from "./Input.tokens.js";
+import { useMergeRefs } from "@floating-ui/react";
+import { useTheme } from "../../hooks/useTheme/useTheme.js";
+import { useRemovePasswordTimeout } from "./hooks/useRemovePasswordTimeout/useRemovePasswordTimeout.js";
+import { useKeyboardEvents } from "./hooks/useKeyboardEvents/useKeyboardEvents.js";
+import { useMergedState } from "./hooks/useMergeState/useMergeState.js";
+import { resolveOnChange } from "./utils/resolveOnChange/resolveOnChange.js";
+const InputComponent = forwardRef((props, ref) => {
+  const {
+    type = "text",
+    disabled,
+    readOnly,
+    prefix: prefixProp,
+    suffix: suffixProp,
+    allowClear,
+    addonBefore: addonBeforeProp,
+    addonAfter: addonAfterProp,
+    status,
+    defaultValue,
+    value: valueProp,
+    style,
+    onChange,
+    onClear,
+    onFocus,
+    onBlur: onBlurProp,
+    onPressEnter,
+    onKeyDown: onKeyDownProp,
+    onKeyUp: onKeyUpProp,
+    ...restProps
+  } = props;
+  const theme = useTheme();
+  const inputTokens = getInputTokens(theme);
+  const inputRef = useRef(null);
+  const affixWrapperRef = useRef(null);
+  const mergedRef = useMergeRefs([inputRef, ref]);
+  const errorStatus = status === "error";
+  const hasAffix = Boolean(prefixProp) || Boolean(suffixProp) || allowClear;
+  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);
+  const AffixWrapper = hasAffix ? "span" : Fragment;
+  const AddonWrapper = hasAddon ? "span" : Fragment;
+  const {
+    removePasswordTimeout
+  } = useRemovePasswordTimeout({
+    inputRef,
+    type
+  });
+  const {
+    onKeyDown,
+    onKeyUp,
+    onBlur
+  } = useKeyboardEvents({
+    onPressEnter,
+    onKeyDown: onKeyDownProp,
+    onKeyUp: onKeyUpProp,
+    onBlur: onBlurProp,
+    disabled
+  });
+  const [value, setValue] = useMergedState(defaultValue, {
+    value: valueProp
+  });
+  const formattedValue = value === void 0 || value === null ? emptyString : value;
+  const handleClearIconWrapperClick = (e) => {
+    handleReset(e);
+    onClear == null ? void 0 : onClear();
+  };
+  const handleReset = (e) => {
+    setValue(emptyString);
+    resolveOnChange(inputRef.current, e, onChange);
+  };
+  const handleAffixWrapperClick = (e) => {
+    var _a, _b;
+    if (e.target instanceof Node && ((_a = affixWrapperRef.current) == null ? void 0 : _a.contains(e.target))) {
+      (_b = inputRef.current) == null ? void 0 : _b.focus();
+    }
+  };
+  const handleFocus = (e) => {
+    removePasswordTimeout();
+    onFocus == null ? void 0 : onFocus(e);
+  };
+  const handleBlur = (e) => {
+    removePasswordTimeout();
+    onBlur(e);
+  };
+  const handleChange = (e) => {
+    setValue(e.target.value);
+    removePasswordTimeout();
+    resolveOnChange(inputRef.current, e, onChange, e.target.value);
+  };
+  const prefix = (() => {
+    if (!prefixProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [prefixStyle(theme), isString(prefixProp) ? {} : prefixSuffixStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:prefix;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx"],"names":[],"mappings":"AAgIY","file":"/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx","sourcesContent":["import {\n  type MouseEventHandler,\n  type ChangeEventHandler,\n  memo,\n  Fragment,\n  useRef,\n  forwardRef,\n  type MemoExoticComponent,\n  type ForwardRefExoticComponent,\n  type RefAttributes,\n  type FocusEventHandler,\n} from \"react\";\nimport type { InputProps, WithPassword, WithTextArea } from \"./Input.types\";\nimport { InputPassword } from \"./components/InputPassword/InputPassword\";\nimport { InputTextArea } from \"./components/InputTextArea/InputTextArea\";\nimport { useMergedState } from \"./hooks/useMergeState\";\nimport { isString } from \"lodash-es\";\nimport { CloseCircleFilled } from \"@infomaximum/icons\";\nimport { emptyString } from \"utils\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  addonWrapperStyle,\n  affixedInputStyle,\n  getAddonStyle,\n  getAffixWrapperStyle,\n  getBaseInputStyle,\n  getClearIconWrapperStyle,\n  getSharedInputStyle,\n  inputGroupClassName,\n  nonStringAddonStyle,\n  prefixStyle,\n  prefixSuffixStyle,\n  suffixStyle,\n} from \"./Input.styles\";\nimport { getInputTokens } from \"./Input.tokens\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useRemovePasswordTimeout } from \"./hooks/useRemovePasswordTimeout\";\nimport { resolveOnChange } from \"./utils/resolveOnChange\";\n\nconst InputComponent = forwardRef<HTMLInputElement, InputProps>((props, ref) => {\n  const {\n    type = \"text\",\n    disabled,\n    readOnly,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    allowClear,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    defaultValue,\n    value: valueProp,\n    style,\n    onChange,\n    onClear,\n    onFocus,\n    onBlur: onBlurProp,\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputTokens = getInputTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const affixWrapperRef = useRef<HTMLSpanElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const errorStatus = status === \"error\";\n  const hasAffix = Boolean(prefixProp) || Boolean(suffixProp) || allowClear;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AffixWrapper = hasAffix ? \"span\" : Fragment;\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { removePasswordTimeout } = useRemovePasswordTimeout({\n    inputRef,\n    type,\n  });\n  const { onKeyDown, onKeyUp, onBlur } = useKeyboardEvents({\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    onBlur: onBlurProp,\n    disabled,\n  });\n\n  const [value, setValue] = useMergedState(defaultValue, {\n    value: valueProp,\n  });\n  const formattedValue = value === undefined || value === null ? emptyString : value;\n\n  const handleClearIconWrapperClick: MouseEventHandler<HTMLButtonElement> = (e) => {\n    handleReset(e);\n    onClear?.();\n  };\n\n  const handleReset: MouseEventHandler<HTMLButtonElement> = (e) => {\n    setValue(emptyString);\n    resolveOnChange(inputRef.current, e, onChange);\n  };\n\n  const handleAffixWrapperClick: MouseEventHandler<HTMLSpanElement> = (e) => {\n    if (e.target instanceof Node && affixWrapperRef.current?.contains(e.target)) {\n      inputRef.current?.focus();\n    }\n  };\n\n  const handleFocus: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onFocus?.(e);\n  };\n\n  const handleBlur: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onBlur(e);\n  };\n\n  const handleChange: ChangeEventHandler<HTMLInputElement> = (e) => {\n    setValue(e.target.value);\n    removePasswordTimeout();\n    resolveOnChange(inputRef.current, e, onChange, e.target.value);\n  };\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span css={[prefixStyle(theme), isString(prefixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span css={[suffixStyle(theme), isString(suffixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const clearIcon = (() => {\n    if (!allowClear) {\n      return;\n    }\n\n    const needClear = !disabled && !readOnly && Boolean(formattedValue);\n\n    return (\n      <button\n        type=\"button\"\n        tabIndex={-1}\n        onClick={handleClearIconWrapperClick}\n        // Do not trigger onBlur when clear input\n        // https://github.com/ant-design/ant-design/issues/31200\n        onMouseDown={(e) => e.preventDefault()}\n        css={getClearIconWrapperStyle(needClear)(theme)}\n      >\n        <CloseCircleFilled />\n      </button>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputGroupClassName,\n            css: addonWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <AffixWrapper\n        {...(hasAffix\n          ? {\n              ref: affixWrapperRef,\n              css: getAffixWrapperStyle(inputTokens, errorStatus, disabled)(theme),\n              onClick: handleAffixWrapperClick,\n              style: hasAddon ? undefined : style,\n            }\n          : {})}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          style={hasAddon || hasAffix ? undefined : style}\n          type={type}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={formattedValue}\n          onChange={handleChange}\n          onFocus={handleFocus}\n          onBlur={handleBlur}\n          onKeyDown={onKeyDown}\n          onKeyUp={onKeyUp}\n          css={[\n            hasAffix\n              ? affixedInputStyle\n              : getSharedInputStyle(inputTokens, errorStatus, disabled, theme),\n            getBaseInputStyle(inputTokens, disabled),\n          ]}\n        />\n        {clearIcon}\n        {suffix}\n      </AffixWrapper>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const Input = memo(InputComponent) as MemoExoticComponent<\n  ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>\n> &\n  WithPassword &\n  WithTextArea;\n\nInput.Password = InputPassword;\nInput.TextArea = InputTextArea;\n"]} */"], children: prefixProp });
+  })();
+  const suffix = (() => {
+    if (!suffixProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [suffixStyle(theme), isString(suffixProp) ? {} : prefixSuffixStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:suffix;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx"],"names":[],"mappings":"AA4IY","file":"/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx","sourcesContent":["import {\n  type MouseEventHandler,\n  type ChangeEventHandler,\n  memo,\n  Fragment,\n  useRef,\n  forwardRef,\n  type MemoExoticComponent,\n  type ForwardRefExoticComponent,\n  type RefAttributes,\n  type FocusEventHandler,\n} from \"react\";\nimport type { InputProps, WithPassword, WithTextArea } from \"./Input.types\";\nimport { InputPassword } from \"./components/InputPassword/InputPassword\";\nimport { InputTextArea } from \"./components/InputTextArea/InputTextArea\";\nimport { useMergedState } from \"./hooks/useMergeState\";\nimport { isString } from \"lodash-es\";\nimport { CloseCircleFilled } from \"@infomaximum/icons\";\nimport { emptyString } from \"utils\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  addonWrapperStyle,\n  affixedInputStyle,\n  getAddonStyle,\n  getAffixWrapperStyle,\n  getBaseInputStyle,\n  getClearIconWrapperStyle,\n  getSharedInputStyle,\n  inputGroupClassName,\n  nonStringAddonStyle,\n  prefixStyle,\n  prefixSuffixStyle,\n  suffixStyle,\n} from \"./Input.styles\";\nimport { getInputTokens } from \"./Input.tokens\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useRemovePasswordTimeout } from \"./hooks/useRemovePasswordTimeout\";\nimport { resolveOnChange } from \"./utils/resolveOnChange\";\n\nconst InputComponent = forwardRef<HTMLInputElement, InputProps>((props, ref) => {\n  const {\n    type = \"text\",\n    disabled,\n    readOnly,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    allowClear,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    defaultValue,\n    value: valueProp,\n    style,\n    onChange,\n    onClear,\n    onFocus,\n    onBlur: onBlurProp,\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputTokens = getInputTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const affixWrapperRef = useRef<HTMLSpanElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const errorStatus = status === \"error\";\n  const hasAffix = Boolean(prefixProp) || Boolean(suffixProp) || allowClear;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AffixWrapper = hasAffix ? \"span\" : Fragment;\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { removePasswordTimeout } = useRemovePasswordTimeout({\n    inputRef,\n    type,\n  });\n  const { onKeyDown, onKeyUp, onBlur } = useKeyboardEvents({\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    onBlur: onBlurProp,\n    disabled,\n  });\n\n  const [value, setValue] = useMergedState(defaultValue, {\n    value: valueProp,\n  });\n  const formattedValue = value === undefined || value === null ? emptyString : value;\n\n  const handleClearIconWrapperClick: MouseEventHandler<HTMLButtonElement> = (e) => {\n    handleReset(e);\n    onClear?.();\n  };\n\n  const handleReset: MouseEventHandler<HTMLButtonElement> = (e) => {\n    setValue(emptyString);\n    resolveOnChange(inputRef.current, e, onChange);\n  };\n\n  const handleAffixWrapperClick: MouseEventHandler<HTMLSpanElement> = (e) => {\n    if (e.target instanceof Node && affixWrapperRef.current?.contains(e.target)) {\n      inputRef.current?.focus();\n    }\n  };\n\n  const handleFocus: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onFocus?.(e);\n  };\n\n  const handleBlur: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onBlur(e);\n  };\n\n  const handleChange: ChangeEventHandler<HTMLInputElement> = (e) => {\n    setValue(e.target.value);\n    removePasswordTimeout();\n    resolveOnChange(inputRef.current, e, onChange, e.target.value);\n  };\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span css={[prefixStyle(theme), isString(prefixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span css={[suffixStyle(theme), isString(suffixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const clearIcon = (() => {\n    if (!allowClear) {\n      return;\n    }\n\n    const needClear = !disabled && !readOnly && Boolean(formattedValue);\n\n    return (\n      <button\n        type=\"button\"\n        tabIndex={-1}\n        onClick={handleClearIconWrapperClick}\n        // Do not trigger onBlur when clear input\n        // https://github.com/ant-design/ant-design/issues/31200\n        onMouseDown={(e) => e.preventDefault()}\n        css={getClearIconWrapperStyle(needClear)(theme)}\n      >\n        <CloseCircleFilled />\n      </button>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputGroupClassName,\n            css: addonWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <AffixWrapper\n        {...(hasAffix\n          ? {\n              ref: affixWrapperRef,\n              css: getAffixWrapperStyle(inputTokens, errorStatus, disabled)(theme),\n              onClick: handleAffixWrapperClick,\n              style: hasAddon ? undefined : style,\n            }\n          : {})}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          style={hasAddon || hasAffix ? undefined : style}\n          type={type}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={formattedValue}\n          onChange={handleChange}\n          onFocus={handleFocus}\n          onBlur={handleBlur}\n          onKeyDown={onKeyDown}\n          onKeyUp={onKeyUp}\n          css={[\n            hasAffix\n              ? affixedInputStyle\n              : getSharedInputStyle(inputTokens, errorStatus, disabled, theme),\n            getBaseInputStyle(inputTokens, disabled),\n          ]}\n        />\n        {clearIcon}\n        {suffix}\n      </AffixWrapper>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const Input = memo(InputComponent) as MemoExoticComponent<\n  ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>\n> &\n  WithPassword &\n  WithTextArea;\n\nInput.Password = InputPassword;\nInput.TextArea = InputTextArea;\n"]} */"], children: suffixProp });
+  })();
+  const clearIcon = (() => {
+    if (!allowClear) {
+      return;
+    }
+    const needClear = !disabled && !readOnly && Boolean(formattedValue);
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        tabIndex: -1,
+        onClick: handleClearIconWrapperClick,
+        onMouseDown: (e) => e.preventDefault(),
+        css: getClearIconWrapperStyle(needClear)(theme),
+        children: /* @__PURE__ */ jsx(CloseCircleFilled, {})
+      }
+    );
+  })();
+  const addonBefore = (() => {
+    if (!addonBeforeProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [getAddonStyle(inputTokens, disabled)(theme), isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:addonBefore;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx"],"names":[],"mappings":"AA+KQ","file":"/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx","sourcesContent":["import {\n  type MouseEventHandler,\n  type ChangeEventHandler,\n  memo,\n  Fragment,\n  useRef,\n  forwardRef,\n  type MemoExoticComponent,\n  type ForwardRefExoticComponent,\n  type RefAttributes,\n  type FocusEventHandler,\n} from \"react\";\nimport type { InputProps, WithPassword, WithTextArea } from \"./Input.types\";\nimport { InputPassword } from \"./components/InputPassword/InputPassword\";\nimport { InputTextArea } from \"./components/InputTextArea/InputTextArea\";\nimport { useMergedState } from \"./hooks/useMergeState\";\nimport { isString } from \"lodash-es\";\nimport { CloseCircleFilled } from \"@infomaximum/icons\";\nimport { emptyString } from \"utils\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  addonWrapperStyle,\n  affixedInputStyle,\n  getAddonStyle,\n  getAffixWrapperStyle,\n  getBaseInputStyle,\n  getClearIconWrapperStyle,\n  getSharedInputStyle,\n  inputGroupClassName,\n  nonStringAddonStyle,\n  prefixStyle,\n  prefixSuffixStyle,\n  suffixStyle,\n} from \"./Input.styles\";\nimport { getInputTokens } from \"./Input.tokens\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useRemovePasswordTimeout } from \"./hooks/useRemovePasswordTimeout\";\nimport { resolveOnChange } from \"./utils/resolveOnChange\";\n\nconst InputComponent = forwardRef<HTMLInputElement, InputProps>((props, ref) => {\n  const {\n    type = \"text\",\n    disabled,\n    readOnly,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    allowClear,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    defaultValue,\n    value: valueProp,\n    style,\n    onChange,\n    onClear,\n    onFocus,\n    onBlur: onBlurProp,\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputTokens = getInputTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const affixWrapperRef = useRef<HTMLSpanElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const errorStatus = status === \"error\";\n  const hasAffix = Boolean(prefixProp) || Boolean(suffixProp) || allowClear;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AffixWrapper = hasAffix ? \"span\" : Fragment;\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { removePasswordTimeout } = useRemovePasswordTimeout({\n    inputRef,\n    type,\n  });\n  const { onKeyDown, onKeyUp, onBlur } = useKeyboardEvents({\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    onBlur: onBlurProp,\n    disabled,\n  });\n\n  const [value, setValue] = useMergedState(defaultValue, {\n    value: valueProp,\n  });\n  const formattedValue = value === undefined || value === null ? emptyString : value;\n\n  const handleClearIconWrapperClick: MouseEventHandler<HTMLButtonElement> = (e) => {\n    handleReset(e);\n    onClear?.();\n  };\n\n  const handleReset: MouseEventHandler<HTMLButtonElement> = (e) => {\n    setValue(emptyString);\n    resolveOnChange(inputRef.current, e, onChange);\n  };\n\n  const handleAffixWrapperClick: MouseEventHandler<HTMLSpanElement> = (e) => {\n    if (e.target instanceof Node && affixWrapperRef.current?.contains(e.target)) {\n      inputRef.current?.focus();\n    }\n  };\n\n  const handleFocus: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onFocus?.(e);\n  };\n\n  const handleBlur: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onBlur(e);\n  };\n\n  const handleChange: ChangeEventHandler<HTMLInputElement> = (e) => {\n    setValue(e.target.value);\n    removePasswordTimeout();\n    resolveOnChange(inputRef.current, e, onChange, e.target.value);\n  };\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span css={[prefixStyle(theme), isString(prefixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span css={[suffixStyle(theme), isString(suffixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const clearIcon = (() => {\n    if (!allowClear) {\n      return;\n    }\n\n    const needClear = !disabled && !readOnly && Boolean(formattedValue);\n\n    return (\n      <button\n        type=\"button\"\n        tabIndex={-1}\n        onClick={handleClearIconWrapperClick}\n        // Do not trigger onBlur when clear input\n        // https://github.com/ant-design/ant-design/issues/31200\n        onMouseDown={(e) => e.preventDefault()}\n        css={getClearIconWrapperStyle(needClear)(theme)}\n      >\n        <CloseCircleFilled />\n      </button>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputGroupClassName,\n            css: addonWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <AffixWrapper\n        {...(hasAffix\n          ? {\n              ref: affixWrapperRef,\n              css: getAffixWrapperStyle(inputTokens, errorStatus, disabled)(theme),\n              onClick: handleAffixWrapperClick,\n              style: hasAddon ? undefined : style,\n            }\n          : {})}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          style={hasAddon || hasAffix ? undefined : style}\n          type={type}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={formattedValue}\n          onChange={handleChange}\n          onFocus={handleFocus}\n          onBlur={handleBlur}\n          onKeyDown={onKeyDown}\n          onKeyUp={onKeyUp}\n          css={[\n            hasAffix\n              ? affixedInputStyle\n              : getSharedInputStyle(inputTokens, errorStatus, disabled, theme),\n            getBaseInputStyle(inputTokens, disabled),\n          ]}\n        />\n        {clearIcon}\n        {suffix}\n      </AffixWrapper>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const Input = memo(InputComponent) as MemoExoticComponent<\n  ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>\n> &\n  WithPassword &\n  WithTextArea;\n\nInput.Password = InputPassword;\nInput.TextArea = InputTextArea;\n"]} */"], children: addonBeforeProp });
+  })();
+  const addonAfter = (() => {
+    if (!addonAfterProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [getAddonStyle(inputTokens, disabled)(theme), isString(addonAfterProp) ? {} : nonStringAddonStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:addonAfter;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx"],"names":[],"mappings":"AAgMQ","file":"/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx","sourcesContent":["import {\n  type MouseEventHandler,\n  type ChangeEventHandler,\n  memo,\n  Fragment,\n  useRef,\n  forwardRef,\n  type MemoExoticComponent,\n  type ForwardRefExoticComponent,\n  type RefAttributes,\n  type FocusEventHandler,\n} from \"react\";\nimport type { InputProps, WithPassword, WithTextArea } from \"./Input.types\";\nimport { InputPassword } from \"./components/InputPassword/InputPassword\";\nimport { InputTextArea } from \"./components/InputTextArea/InputTextArea\";\nimport { useMergedState } from \"./hooks/useMergeState\";\nimport { isString } from \"lodash-es\";\nimport { CloseCircleFilled } from \"@infomaximum/icons\";\nimport { emptyString } from \"utils\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  addonWrapperStyle,\n  affixedInputStyle,\n  getAddonStyle,\n  getAffixWrapperStyle,\n  getBaseInputStyle,\n  getClearIconWrapperStyle,\n  getSharedInputStyle,\n  inputGroupClassName,\n  nonStringAddonStyle,\n  prefixStyle,\n  prefixSuffixStyle,\n  suffixStyle,\n} from \"./Input.styles\";\nimport { getInputTokens } from \"./Input.tokens\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useRemovePasswordTimeout } from \"./hooks/useRemovePasswordTimeout\";\nimport { resolveOnChange } from \"./utils/resolveOnChange\";\n\nconst InputComponent = forwardRef<HTMLInputElement, InputProps>((props, ref) => {\n  const {\n    type = \"text\",\n    disabled,\n    readOnly,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    allowClear,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    defaultValue,\n    value: valueProp,\n    style,\n    onChange,\n    onClear,\n    onFocus,\n    onBlur: onBlurProp,\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputTokens = getInputTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const affixWrapperRef = useRef<HTMLSpanElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const errorStatus = status === \"error\";\n  const hasAffix = Boolean(prefixProp) || Boolean(suffixProp) || allowClear;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AffixWrapper = hasAffix ? \"span\" : Fragment;\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { removePasswordTimeout } = useRemovePasswordTimeout({\n    inputRef,\n    type,\n  });\n  const { onKeyDown, onKeyUp, onBlur } = useKeyboardEvents({\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    onBlur: onBlurProp,\n    disabled,\n  });\n\n  const [value, setValue] = useMergedState(defaultValue, {\n    value: valueProp,\n  });\n  const formattedValue = value === undefined || value === null ? emptyString : value;\n\n  const handleClearIconWrapperClick: MouseEventHandler<HTMLButtonElement> = (e) => {\n    handleReset(e);\n    onClear?.();\n  };\n\n  const handleReset: MouseEventHandler<HTMLButtonElement> = (e) => {\n    setValue(emptyString);\n    resolveOnChange(inputRef.current, e, onChange);\n  };\n\n  const handleAffixWrapperClick: MouseEventHandler<HTMLSpanElement> = (e) => {\n    if (e.target instanceof Node && affixWrapperRef.current?.contains(e.target)) {\n      inputRef.current?.focus();\n    }\n  };\n\n  const handleFocus: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onFocus?.(e);\n  };\n\n  const handleBlur: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onBlur(e);\n  };\n\n  const handleChange: ChangeEventHandler<HTMLInputElement> = (e) => {\n    setValue(e.target.value);\n    removePasswordTimeout();\n    resolveOnChange(inputRef.current, e, onChange, e.target.value);\n  };\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span css={[prefixStyle(theme), isString(prefixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span css={[suffixStyle(theme), isString(suffixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const clearIcon = (() => {\n    if (!allowClear) {\n      return;\n    }\n\n    const needClear = !disabled && !readOnly && Boolean(formattedValue);\n\n    return (\n      <button\n        type=\"button\"\n        tabIndex={-1}\n        onClick={handleClearIconWrapperClick}\n        // Do not trigger onBlur when clear input\n        // https://github.com/ant-design/ant-design/issues/31200\n        onMouseDown={(e) => e.preventDefault()}\n        css={getClearIconWrapperStyle(needClear)(theme)}\n      >\n        <CloseCircleFilled />\n      </button>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputGroupClassName,\n            css: addonWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <AffixWrapper\n        {...(hasAffix\n          ? {\n              ref: affixWrapperRef,\n              css: getAffixWrapperStyle(inputTokens, errorStatus, disabled)(theme),\n              onClick: handleAffixWrapperClick,\n              style: hasAddon ? undefined : style,\n            }\n          : {})}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          style={hasAddon || hasAffix ? undefined : style}\n          type={type}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={formattedValue}\n          onChange={handleChange}\n          onFocus={handleFocus}\n          onBlur={handleBlur}\n          onKeyDown={onKeyDown}\n          onKeyUp={onKeyUp}\n          css={[\n            hasAffix\n              ? affixedInputStyle\n              : getSharedInputStyle(inputTokens, errorStatus, disabled, theme),\n            getBaseInputStyle(inputTokens, disabled),\n          ]}\n        />\n        {clearIcon}\n        {suffix}\n      </AffixWrapper>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const Input = memo(InputComponent) as MemoExoticComponent<\n  ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>\n> &\n  WithPassword &\n  WithTextArea;\n\nInput.Password = InputPassword;\nInput.TextArea = InputTextArea;\n"]} */"], children: addonAfterProp });
+  })();
+  return /* @__PURE__ */ jsxs(AddonWrapper, { ...hasAddon ? {
+    className: inputGroupClassName,
+    css: addonWrapperStyle,
+    style
+  } : {}, children: [
+    addonBefore,
+    /* @__PURE__ */ jsxs(AffixWrapper, { ...hasAffix ? {
+      ref: affixWrapperRef,
+      css: getAffixWrapperStyle(inputTokens, errorStatus, disabled)(theme),
+      onClick: handleAffixWrapperClick,
+      style: hasAddon ? void 0 : style
+    } : {}, children: [
+      prefix,
+      /* @__PURE__ */ jsx("input", { ...restProps, ref: mergedRef, style: hasAddon || hasAffix ? void 0 : style, type, disabled, readOnly, value: formattedValue, onChange: handleChange, onFocus: handleFocus, onBlur: handleBlur, onKeyDown, onKeyUp, css: [hasAffix ? affixedInputStyle : getSharedInputStyle(inputTokens, errorStatus, disabled, theme), getBaseInputStyle(inputTokens, disabled), process.env.NODE_ENV === "production" ? "" : ";label:InputComponent;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx"],"names":[],"mappings":"AA6OU","file":"/builds/frontend/libs/ui-kit/src/components/Input/Input.tsx","sourcesContent":["import {\n  type MouseEventHandler,\n  type ChangeEventHandler,\n  memo,\n  Fragment,\n  useRef,\n  forwardRef,\n  type MemoExoticComponent,\n  type ForwardRefExoticComponent,\n  type RefAttributes,\n  type FocusEventHandler,\n} from \"react\";\nimport type { InputProps, WithPassword, WithTextArea } from \"./Input.types\";\nimport { InputPassword } from \"./components/InputPassword/InputPassword\";\nimport { InputTextArea } from \"./components/InputTextArea/InputTextArea\";\nimport { useMergedState } from \"./hooks/useMergeState\";\nimport { isString } from \"lodash-es\";\nimport { CloseCircleFilled } from \"@infomaximum/icons\";\nimport { emptyString } from \"utils\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  addonWrapperStyle,\n  affixedInputStyle,\n  getAddonStyle,\n  getAffixWrapperStyle,\n  getBaseInputStyle,\n  getClearIconWrapperStyle,\n  getSharedInputStyle,\n  inputGroupClassName,\n  nonStringAddonStyle,\n  prefixStyle,\n  prefixSuffixStyle,\n  suffixStyle,\n} from \"./Input.styles\";\nimport { getInputTokens } from \"./Input.tokens\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useRemovePasswordTimeout } from \"./hooks/useRemovePasswordTimeout\";\nimport { resolveOnChange } from \"./utils/resolveOnChange\";\n\nconst InputComponent = forwardRef<HTMLInputElement, InputProps>((props, ref) => {\n  const {\n    type = \"text\",\n    disabled,\n    readOnly,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    allowClear,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    defaultValue,\n    value: valueProp,\n    style,\n    onChange,\n    onClear,\n    onFocus,\n    onBlur: onBlurProp,\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputTokens = getInputTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const affixWrapperRef = useRef<HTMLSpanElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const errorStatus = status === \"error\";\n  const hasAffix = Boolean(prefixProp) || Boolean(suffixProp) || allowClear;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AffixWrapper = hasAffix ? \"span\" : Fragment;\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { removePasswordTimeout } = useRemovePasswordTimeout({\n    inputRef,\n    type,\n  });\n  const { onKeyDown, onKeyUp, onBlur } = useKeyboardEvents({\n    onPressEnter,\n    onKeyDown: onKeyDownProp,\n    onKeyUp: onKeyUpProp,\n    onBlur: onBlurProp,\n    disabled,\n  });\n\n  const [value, setValue] = useMergedState(defaultValue, {\n    value: valueProp,\n  });\n  const formattedValue = value === undefined || value === null ? emptyString : value;\n\n  const handleClearIconWrapperClick: MouseEventHandler<HTMLButtonElement> = (e) => {\n    handleReset(e);\n    onClear?.();\n  };\n\n  const handleReset: MouseEventHandler<HTMLButtonElement> = (e) => {\n    setValue(emptyString);\n    resolveOnChange(inputRef.current, e, onChange);\n  };\n\n  const handleAffixWrapperClick: MouseEventHandler<HTMLSpanElement> = (e) => {\n    if (e.target instanceof Node && affixWrapperRef.current?.contains(e.target)) {\n      inputRef.current?.focus();\n    }\n  };\n\n  const handleFocus: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onFocus?.(e);\n  };\n\n  const handleBlur: FocusEventHandler<HTMLInputElement> = (e) => {\n    removePasswordTimeout();\n    onBlur(e);\n  };\n\n  const handleChange: ChangeEventHandler<HTMLInputElement> = (e) => {\n    setValue(e.target.value);\n    removePasswordTimeout();\n    resolveOnChange(inputRef.current, e, onChange, e.target.value);\n  };\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span css={[prefixStyle(theme), isString(prefixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span css={[suffixStyle(theme), isString(suffixProp) ? {} : prefixSuffixStyle(theme)]}>\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const clearIcon = (() => {\n    if (!allowClear) {\n      return;\n    }\n\n    const needClear = !disabled && !readOnly && Boolean(formattedValue);\n\n    return (\n      <button\n        type=\"button\"\n        tabIndex={-1}\n        onClick={handleClearIconWrapperClick}\n        // Do not trigger onBlur when clear input\n        // https://github.com/ant-design/ant-design/issues/31200\n        onMouseDown={(e) => e.preventDefault()}\n        css={getClearIconWrapperStyle(needClear)(theme)}\n      >\n        <CloseCircleFilled />\n      </button>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputGroupClassName,\n            css: addonWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <AffixWrapper\n        {...(hasAffix\n          ? {\n              ref: affixWrapperRef,\n              css: getAffixWrapperStyle(inputTokens, errorStatus, disabled)(theme),\n              onClick: handleAffixWrapperClick,\n              style: hasAddon ? undefined : style,\n            }\n          : {})}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          style={hasAddon || hasAffix ? undefined : style}\n          type={type}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={formattedValue}\n          onChange={handleChange}\n          onFocus={handleFocus}\n          onBlur={handleBlur}\n          onKeyDown={onKeyDown}\n          onKeyUp={onKeyUp}\n          css={[\n            hasAffix\n              ? affixedInputStyle\n              : getSharedInputStyle(inputTokens, errorStatus, disabled, theme),\n            getBaseInputStyle(inputTokens, disabled),\n          ]}\n        />\n        {clearIcon}\n        {suffix}\n      </AffixWrapper>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const Input = memo(InputComponent) as MemoExoticComponent<\n  ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>\n> &\n  WithPassword &\n  WithTextArea;\n\nInput.Password = InputPassword;\nInput.TextArea = InputTextArea;\n"]} */"] }),
+      clearIcon,
+      suffix
+    ] }),
+    addonAfter
+  ] });
+});
+const Input = memo(InputComponent);
+Input.Password = InputPassword;
+Input.TextArea = InputTextArea;
+export {
+  Input
+};

package/dist/components/Input/Input.styles.d.ts

@@ -0,0 +1,184 @@
+import { Theme } from 'index';
+import { InputTokens } from './Input.tokens';
+export declare const inputGroupClassName = "input-group";
+export declare const prefixStyle: (theme: Theme) => {
+    marginRight: 4;
+    display: string;
+    alignItems: string;
+    flex: string;
+};
+export declare const suffixStyle: (theme: Theme) => {
+    marginLeft: 8;
+    display: string;
+    alignItems: string;
+    flex: string;
+};
+export declare const prefixSuffixStyle: (theme: Theme) => {
+    fontSize: 16;
+};
+export declare const getClearIconWrapperStyle: (needClear: boolean) => (theme: Theme) => {
+    readonly display: "flex";
+    readonly alignItems: "center";
+    readonly alignSelf: "center";
+    readonly visibility: "hidden" | undefined;
+    readonly fontSize: 16;
+    readonly cursor: "pointer";
+    readonly border: "none";
+    readonly background: "none";
+    readonly padding: 0;
+    readonly marginLeft: 8;
+    readonly color: `rgba(${number}, ${number}, ${number}, 0.3)`;
+    readonly ":hover": {
+        readonly color: `rgba(${number}, ${number}, ${number}, 0.7)`;
+    };
+};
+export declare const nonStringAddonStyle: (theme: Theme) => {
+    fontSize: 16;
+};
+export declare const getAddonStyle: (inputTokens: InputTokens, disabled: boolean | undefined) => (theme: Theme) => {
+    color: "#262626" | "#8C8C8C";
+    backgroundColor: "#F0F0F0" | "#FAFAFA";
+    borderWidth: number;
+    borderStyle: string;
+    borderColor: "#D9D9D9";
+    borderRadius: 4;
+    paddingInline: number;
+    ":first-child": {
+        borderInlineEnd: number;
+        borderStartEndRadius: number;
+        borderEndEndRadius: number;
+    };
+    ":last-child": {
+        borderInlineStart: number;
+        borderStartStartRadius: number;
+        borderEndStartRadius: number;
+    };
+    fontFamily: "Roboto";
+    fontSize: 14;
+    lineHeight: "20px";
+    cursor: string | undefined;
+    display: string;
+    alignItems: string;
+    flex: string;
+};
+export declare const getSharedCommonStyle: (inputTokens: InputTokens, errorStatus: boolean, disabled: boolean | undefined, theme: Theme) => {
+    readonly backgroundColor: "#F0F0F0" | "#FFFFFF";
+    readonly borderRadius: 4;
+    readonly borderWidth: 1;
+    readonly borderStyle: "solid";
+    readonly borderColor: "#D9D9D9" | "#FF4D4F";
+    readonly ":focus, :focus-within": {
+        readonly outline: "none";
+        readonly borderColor: "#FF4D4F" | "#0CB3B3";
+        readonly boxShadow: `0px 0px 4px 0px rgba(${number}, ${number}, ${number}, 0.5)`;
+    };
+    readonly ":hover": {
+        readonly borderColor: "#FF7875" | "#50CCC4" | undefined;
+    };
+    readonly fontFamily: "Roboto";
+    readonly fontSize: 14;
+    readonly lineHeight: "20px";
+    readonly position: "relative";
+    readonly boxSizing: "border-box";
+    readonly minWidth: 0;
+    readonly width: "100%";
+    readonly cursor: "not-allowed" | undefined;
+    readonly paddingInline: number;
+    readonly paddingBlock: number;
+};
+export declare const getSharedInputStyle: (inputTokens: InputTokens, errorStatus: boolean, disabled: boolean | undefined, theme: Theme) => {
+    readonly color: "#8C8C8C" | "#BFBFBF" | "#FF4D4F";
+    readonly ".input-group &:first-child": {
+        readonly borderStartEndRadius: 0;
+        readonly borderEndEndRadius: 0;
+    };
+    readonly ".input-group &:last-child": {
+        readonly borderStartStartRadius: 0;
+        readonly borderEndStartRadius: 0;
+    };
+    readonly ".input-group &:not(:first-child):not(:last-child)": {
+        readonly borderRadius: 0;
+    };
+    readonly backgroundColor: "#F0F0F0" | "#FFFFFF";
+    readonly borderRadius: 4;
+    readonly borderWidth: 1;
+    readonly borderStyle: "solid";
+    readonly borderColor: "#D9D9D9" | "#FF4D4F";
+    readonly ":focus, :focus-within": {
+        readonly outline: "none";
+        readonly borderColor: "#FF4D4F" | "#0CB3B3";
+        readonly boxShadow: `0px 0px 4px 0px rgba(${number}, ${number}, ${number}, 0.5)`;
+    };
+    readonly ":hover": {
+        readonly borderColor: "#FF7875" | "#50CCC4" | undefined;
+    };
+    readonly fontFamily: "Roboto";
+    readonly fontSize: 14;
+    readonly lineHeight: "20px";
+    readonly position: "relative";
+    readonly boxSizing: "border-box";
+    readonly minWidth: 0;
+    readonly width: "100%";
+    readonly cursor: "not-allowed" | undefined;
+    readonly paddingInline: number;
+    readonly paddingBlock: number;
+};
+export declare const getAffixWrapperStyle: (inputTokens: InputTokens, errorStatus: boolean, disabled: boolean | undefined) => (theme: Theme) => {
+    color: "#8C8C8C" | "#BFBFBF" | "#FF4D4F";
+    ".input-group &:first-child": {
+        readonly borderStartEndRadius: 0;
+        readonly borderEndEndRadius: 0;
+    };
+    ".input-group &:last-child": {
+        readonly borderStartStartRadius: 0;
+        readonly borderEndStartRadius: 0;
+    };
+    ".input-group &:not(:first-child):not(:last-child)": {
+        readonly borderRadius: 0;
+    };
+    backgroundColor: "#F0F0F0" | "#FFFFFF";
+    borderRadius: 4;
+    borderWidth: 1;
+    borderStyle: "solid";
+    borderColor: "#D9D9D9" | "#FF4D4F";
+    ":focus, :focus-within": {
+        readonly outline: "none";
+        readonly borderColor: "#FF4D4F" | "#0CB3B3";
+        readonly boxShadow: `0px 0px 4px 0px rgba(${number}, ${number}, ${number}, 0.5)`;
+    };
+    ":hover": {
+        readonly borderColor: "#FF7875" | "#50CCC4" | undefined;
+    };
+    fontFamily: "Roboto";
+    fontSize: 14;
+    lineHeight: "20px";
+    position: "relative";
+    boxSizing: "border-box";
+    minWidth: 0;
+    width: "100%";
+    cursor: "not-allowed" | undefined;
+    paddingInline: number;
+    paddingBlock: number;
+    display: string;
+};
+export declare const affixedInputStyle: {
+    padding: number;
+    border: string;
+    fontFamily: string;
+    fontSize: string;
+    lineHeight: string;
+    color: string;
+    background: string;
+    cursor: string;
+    width: string;
+    outline: string;
+};
+export declare const getBaseInputStyle: (inputTokens: InputTokens, disabled: boolean | undefined) => {
+    color: "#262626" | undefined;
+    "::placeholder": {
+        color: string;
+    };
+};
+export declare const addonWrapperStyle: {
+    display: string;
+};

package/dist/components/Input/Input.styles.js

@@ -0,0 +1,138 @@
+const inputGroupClassName = "input-group";
+const commonAffixStyle = {
+  display: "flex",
+  alignItems: "center",
+  flex: "none"
+};
+const prefixStyle = (theme) => ({
+  ...commonAffixStyle,
+  marginRight: theme.marginXS
+});
+const suffixStyle = (theme) => ({
+  ...commonAffixStyle,
+  marginLeft: theme.marginM
+});
+const prefixSuffixStyle = (theme) => ({
+  fontSize: theme.iconM
+});
+const getClearIconWrapperStyle = (needClear) => (theme) => ({
+  display: "flex",
+  alignItems: "center",
+  alignSelf: "center",
+  visibility: needClear ? void 0 : "hidden",
+  fontSize: theme.iconM,
+  cursor: "pointer",
+  border: "none",
+  background: "none",
+  padding: 0,
+  marginLeft: theme.marginM,
+  color: theme.transparentBlack30,
+  ":hover": {
+    color: theme.transparentBlack70
+  }
+});
+const nonStringAddonStyle = (theme) => ({
+  fontSize: theme.iconM
+});
+const getAddonStyle = (inputTokens, disabled) => (theme) => ({
+  cursor: disabled ? "not-allowed" : void 0,
+  display: "flex",
+  alignItems: "center",
+  flex: "none",
+  ...theme.typography.body2,
+  color: disabled ? inputTokens.inputTextDisabled : inputTokens.inputText,
+  backgroundColor: disabled ? inputTokens.inputBgDisabled : inputTokens.inputAddonBg,
+  borderWidth: 1,
+  borderStyle: "solid",
+  borderColor: inputTokens.inputBorder,
+  borderRadius: theme.borderRadiusM,
+  paddingInline: inputTokens.inputPaddingHorizontal - 1,
+  ":first-child": {
+    borderInlineEnd: 0,
+    borderStartEndRadius: 0,
+    borderEndEndRadius: 0
+  },
+  ":last-child": {
+    borderInlineStart: 0,
+    borderStartStartRadius: 0,
+    borderEndStartRadius: 0
+  }
+});
+const getSharedCommonStyle = (inputTokens, errorStatus, disabled, theme) => ({
+  position: "relative",
+  boxSizing: "border-box",
+  minWidth: 0,
+  width: "100%",
+  cursor: disabled ? "not-allowed" : void 0,
+  paddingInline: inputTokens.inputPaddingHorizontal - 1,
+  paddingBlock: inputTokens.inputPaddingVertical - 1,
+  ...theme.typography.body2,
+  backgroundColor: disabled ? inputTokens.inputBgDisabled : inputTokens.inputBg,
+  borderRadius: theme.borderRadiusM,
+  borderWidth: 1,
+  borderStyle: "solid",
+  borderColor: errorStatus ? inputTokens.inputBorderDanger : inputTokens.inputBorder,
+  ":focus, :focus-within": {
+    outline: "none",
+    borderColor: errorStatus ? inputTokens.inputBorderDanger : inputTokens.inputBorderActive,
+    boxShadow: `0px 0px 4px 0px ${errorStatus ? theme.fieldFocusedDanger : theme.fieldFocused}`
+  },
+  ":hover": {
+    borderColor: disabled ? void 0 : errorStatus ? inputTokens.inputBorderDangerHover : inputTokens.inputBorderHover
+  }
+});
+const getSharedInputStyle = (inputTokens, errorStatus, disabled, theme) => ({
+  ...getSharedCommonStyle(inputTokens, errorStatus, disabled, theme),
+  color: disabled ? inputTokens.inputTextDisabled : errorStatus ? inputTokens.inputTextDanger : inputTokens.inputPlaceholder,
+  [`.${inputGroupClassName} &:first-child`]: {
+    borderStartEndRadius: 0,
+    borderEndEndRadius: 0
+  },
+  [`.${inputGroupClassName} &:last-child`]: {
+    borderStartStartRadius: 0,
+    borderEndStartRadius: 0
+  },
+  [`.${inputGroupClassName} &:not(:first-child):not(:last-child)`]: {
+    borderRadius: 0
+  }
+});
+const getAffixWrapperStyle = (inputTokens, errorStatus, disabled) => (theme) => ({
+  display: "inline-flex",
+  ...getSharedInputStyle(inputTokens, errorStatus, disabled, theme)
+});
+const affixedInputStyle = {
+  padding: 0,
+  border: "none",
+  fontFamily: "inherit",
+  fontSize: "inherit",
+  lineHeight: "inherit",
+  color: "inherit",
+  background: "inherit",
+  cursor: "inherit",
+  width: "100%",
+  outline: "none"
+};
+const getBaseInputStyle = (inputTokens, disabled) => ({
+  color: disabled ? void 0 : inputTokens.inputText,
+  "::placeholder": {
+    color: disabled ? "inherit" : inputTokens.inputPlaceholder
+  }
+});
+const addonWrapperStyle = {
+  display: "inline-flex"
+};
+export {
+  addonWrapperStyle,
+  affixedInputStyle,
+  getAddonStyle,
+  getAffixWrapperStyle,
+  getBaseInputStyle,
+  getClearIconWrapperStyle,
+  getSharedCommonStyle,
+  getSharedInputStyle,
+  inputGroupClassName,
+  nonStringAddonStyle,
+  prefixStyle,
+  prefixSuffixStyle,
+  suffixStyle
+};

package/dist/components/Input/Input.tokens.d.ts

@@ -0,0 +1,18 @@
+import { Theme } from 'themes';
+export declare const getInputTokens: (theme: Theme) => {
+    inputBorder: "#D9D9D9";
+    inputBorderHover: "#50CCC4";
+    inputBorderActive: "#0CB3B3";
+    inputBorderDanger: "#FF4D4F";
+    inputBorderDangerHover: "#FF7875";
+    inputBg: "#FFFFFF";
+    inputBgDisabled: "#F0F0F0";
+    inputPlaceholder: "#BFBFBF";
+    inputText: "#262626";
+    inputTextDisabled: "#8C8C8C";
+    inputTextDanger: "#FF4D4F";
+    inputAddonBg: "#FAFAFA";
+    inputPaddingVertical: 4;
+    inputPaddingHorizontal: 12;
+};
+export type InputTokens = ReturnType<typeof getInputTokens>;

package/dist/components/Input/Input.tokens.js

@@ -0,0 +1,19 @@
+const getInputTokens = (theme) => ({
+  inputBorder: theme.lineBorder,
+  inputBorderHover: theme.primaryHover,
+  inputBorderActive: theme.primaryBase,
+  inputBorderDanger: theme.dangerBase,
+  inputBorderDangerHover: theme.dangerHover,
+  inputBg: theme.bgContainer,
+  inputBgDisabled: theme.bgContainerDisabled,
+  inputPlaceholder: theme.textHint,
+  inputText: theme.textPrimary,
+  inputTextDisabled: theme.textDisabled,
+  inputTextDanger: theme.dangerBase,
+  inputAddonBg: theme.bgContainerComplimentary,
+  inputPaddingVertical: theme.x1,
+  inputPaddingHorizontal: theme.x3
+});
+export {
+  getInputTokens
+};

package/dist/components/Input/Input.types.d.ts

@@ -0,0 +1,19 @@
+import { ComponentType, InputHTMLAttributes, KeyboardEventHandler, ReactNode } from 'react';
+import { InputPasswordProps } from './components/InputPassword/InputPassword.types';
+import { InputTextAreaProps } from './components/InputTextArea/InputTextArea.types';
+export interface InputProps extends Pick<InputHTMLAttributes<HTMLInputElement>, "autoFocus" | "placeholder" | "disabled" | "readOnly" | "type" | "name" | "defaultValue" | "value" | "onChange" | "maxLength" | "id" | "style" | "onFocus" | "onBlur" | "onKeyDown" | "onKeyUp"> {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    allowClear?: boolean;
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+    status?: "error";
+    onClear?: () => void;
+    onPressEnter?: KeyboardEventHandler<HTMLInputElement>;
+}
+export interface WithPassword {
+    Password: ComponentType<InputPasswordProps>;
+}
+export interface WithTextArea {
+    TextArea: ComponentType<InputTextAreaProps>;
+}

package/dist/components/Input/components/InputPassword/InputPassword.d.ts

@@ -0,0 +1,2 @@
+import { InputPasswordProps } from './InputPassword.types';
+export declare const InputPassword: import('react').MemoExoticComponent<import('react').ForwardRefExoticComponent<InputPasswordProps & import('react').RefAttributes<HTMLInputElement>>>;