@ultraviolet/ui 1.51.1 → 1.51.3

package/dist/components/Text/index.js

@@ -0,0 +1,82 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { useRef } from "react";
+import recursivelyGetChildrenString from "../../helpers/recursivelyGetChildrenString.js";
+import { useIsOverflowing } from "../../hooks/useIsOverflowing.js";
+import capitalize from "../../utils/capitalize.js";
+import { Tooltip } from "../Tooltip/index.js";
+const PROMINENCES = {
+  default: "",
+  strong: "strong",
+  stronger: "stronger",
+  weak: "weak"
+};
+const generateStyles = ({
+  placement,
+  prominence,
+  sentiment,
+  variant,
+  theme,
+  oneLine,
+  disabled,
+  italic,
+  underline
+}) => {
+  const definedProminence = sentiment !== "neutral" && prominence === "stronger" ? capitalize(PROMINENCES.default) : capitalize(PROMINENCES[prominence]);
+  sentiment ? theme.colors[sentiment] : void 0;
+  const text = `text${definedProminence}${disabled ? "Disabled" : ""}`;
+  const textColor = sentiment ? theme.colors[sentiment][text] : void 0;
+  return `
+    ${sentiment ? `color: ${textColor};` : ""}
+
+    font-size: ${theme.typography[variant].fontSize};
+    font-family: ${theme.typography[variant].fontFamily};
+    font-weight: ${theme.typography[variant].weight};
+    letter-spacing: ${theme.typography[variant].letterSpacing};
+    line-height: ${theme.typography[variant].lineHeight};
+    text-transform: ${theme.typography[variant].textCase};
+    text-decoration: ${theme.typography[variant].textDecoration};
+    ${placement ? ` text-align: ${placement};` : ""}
+
+    ${oneLine ? `white-space: nowrap;
+    text-overflow: ellipsis;
+    overflow: hidden;` : ""}
+    ${italic ? `font-style: italic;` : ""}
+    ${underline ? `text-decoration: underline;` : ""}
+  `;
+};
+const StyledText = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["as", "placement", "variant", "sentiment", "prominence", "oneLine", "disabled", "italic", "underline"].includes(prop),
+  target: "e13y3mga0"
+} : {
+  shouldForwardProp: (prop) => !["as", "placement", "variant", "sentiment", "prominence", "oneLine", "disabled", "italic", "underline"].includes(prop),
+  target: "e13y3mga0",
+  label: "StyledText"
+})(generateStyles, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const Text = ({
+  variant,
+  children,
+  as,
+  color,
+  sentiment,
+  oneLine = false,
+  placement,
+  prominence = "default",
+  className,
+  disabled = false,
+  italic = false,
+  underline = false,
+  id,
+  dir,
+  htmlFor,
+  "data-testid": dataTestId
+}) => {
+  const computedSentiment = sentiment ?? color;
+  const elementRef = useRef(null);
+  const isOverflowing = useIsOverflowing(elementRef);
+  const finalStringChildren = recursivelyGetChildrenString(children);
+  return /* @__PURE__ */ jsx(Tooltip, { text: oneLine && isOverflowing ? finalStringChildren : "", children: /* @__PURE__ */ jsx(StyledText, { ref: elementRef, as, placement, prominence, sentiment: computedSentiment, variant, oneLine, className, disabled, italic, underline, id, dir, htmlFor, "data-testid": dataTestId, children }) });
+};
+export {
+  Text
+};

package/dist/components/TextArea/index.d.ts

@@ -0,0 +1,50 @@
+import type { DOMAttributes, ReactNode } from 'react';
+type TextAreaProps = {
+    id?: string;
+    className?: string;
+    tabIndex?: number;
+    autoFocus?: boolean;
+    label: string;
+    value?: string;
+    onChange: (newValue: string) => void;
+    placeholder?: string;
+    /**
+     * Override others properties : readyOnly, success, error.
+     */
+    disabled?: boolean;
+    /**
+     * Override others properties : success, error.
+     * Ignored if following props are provided : disabled.
+     */
+    readOnly?: boolean;
+    /**
+     * Override others properties : error, helper.
+     * Ignored if following props are provided : disabled, readyOnly.
+     */
+    success?: string;
+    /**
+     * Override others properties : helper.
+     * Ignored if following props are provided : disabled, readyOnly, success.
+     */
+    error?: string;
+    /**
+     * Ignored if following props are provided : readyOnly, success.
+     */
+    helper?: ReactNode;
+    rows?: number;
+    minLength?: number;
+    maxLength?: number;
+    tooltip?: string;
+    required?: boolean;
+    'data-testid'?: string;
+    name?: string;
+    onFocus?: DOMAttributes<HTMLTextAreaElement>['onFocus'];
+    onBlur?: DOMAttributes<HTMLTextAreaElement>['onBlur'];
+    clearable?: boolean;
+    labelDescription?: ReactNode;
+};
+/**
+ * This component offers an extended textarea HTML
+ */
+export declare const TextArea: import("react").ForwardRefExoticComponent<TextAreaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+export {};

package/dist/components/TextArea/index.js

@@ -0,0 +1,158 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { Icon } from "@ultraviolet/icons";
+import { forwardRef, useId, useMemo } from "react";
+import { SIZE_HEIGHT, Button } from "../Button/index.js";
+import { Row } from "../Row/index.js";
+import { Stack } from "../Stack/index.js";
+import { Text } from "../Text/index.js";
+import { Tooltip } from "../Tooltip/index.js";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+const STATE_ICON_SIZE = 16;
+const StyledTextAreaWrapper = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "enu776d2"
+} : {
+  target: "enu776d2",
+  label: "StyledTextAreaWrapper"
+})(process.env.NODE_ENV === "production" ? {
+  name: "8k1832",
+  styles: "position:relative;display:flex"
+} : {
+  name: "8k1832",
+  styles: "position:relative;display:flex",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TextArea/index.tsx"],"names":[],"mappings":"AAYwC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TextArea/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { DOMAttributes, ReactNode } from 'react'\nimport { forwardRef, useId, useMemo } from 'react'\nimport { Button, SIZE_HEIGHT as ButtonSizeHeight } from '../Button'\nimport { Row } from '../Row'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport { Tooltip } from '../Tooltip'\n\nconst STATE_ICON_SIZE = 16\n\nconst StyledTextAreaWrapper = styled.div`\n  position: relative;\n  display: flex;\n`\n\nconst StyledTextAreaAbsoluteStack = styled(Stack)`\n  position: absolute;\n  top: ${({ theme }) => theme.space['1.5']};\n  right: ${({ theme }) => theme.space['1']};\n`\n\ntype StyledTextAreaProps = {\n  hasSentimentIcon: boolean\n  isClearable: boolean\n}\nconst StyledTextArea = styled('textarea', {\n  shouldForwardProp: prop =>\n    !['hasSentimentIcon', 'isClearable'].includes(prop),\n})<StyledTextAreaProps>`\n  width: 100%;\n  resize: vertical;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  color: ${({ theme }) => theme.colors.neutral.text};\n  &::placeholder {\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n  border-radius: ${({ theme }) => theme.radii.default};\n  padding: ${({ theme }) =>\n    `${theme.space['1.5']} ${theme.space['1']} ${theme.space['1.5']} ${theme.space['2']}`};\n  padding-right: ${({ theme, isClearable, hasSentimentIcon }) =>\n    /* including 1 optional if both element is visible + 1 because content is absolute 1space unit from right */\n    `calc(${theme.space[isClearable && hasSentimentIcon ? '4' : '3']} + ${\n      isClearable ? `${ButtonSizeHeight.xsmall}px` : '0px'\n    } + ${hasSentimentIcon ? `${STATE_ICON_SIZE}px` : '0px'})`};\n\n  &[data-success='true'] {\n    border-color: ${({ theme }) => theme.colors.success.border};\n  }\n\n  &[data-error='true'] {\n    border-color: ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &[data-readOnly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n\n    &::placeholder {\n      color: ${({ theme }) => theme.colors.neutral.textWeakDisabled};\n    }\n  }\n\n  &:not([data-disabled='true']):hover {\n    &:hover {\n      border-color: ${({ theme }) => theme.colors.primary.border};\n    }\n\n    &:focus {\n      outline: none;\n      border-color: ${({ theme }) => theme.colors.primary.border};\n      box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n    }\n  }\n`\n\ntype TextAreaProps = {\n  id?: string\n  className?: string\n  tabIndex?: number\n  autoFocus?: boolean\n  label: string\n  value?: string\n  onChange: (newValue: string) => void\n  placeholder?: string\n  /**\n   * Override others properties : readyOnly, success, error.\n   */\n  disabled?: boolean\n  /**\n   * Override others properties : success, error.\n   * Ignored if following props are provided : disabled.\n   */\n  readOnly?: boolean\n  /**\n   * Override others properties : error, helper.\n   * Ignored if following props are provided : disabled, readyOnly.\n   */\n  success?: string\n  /**\n   * Override others properties : helper.\n   * Ignored if following props are provided : disabled, readyOnly, success.\n   */\n  error?: string\n  /**\n   * Ignored if following props are provided : readyOnly, success.\n   */\n  helper?: ReactNode\n  rows?: number\n  minLength?: number\n  maxLength?: number\n  tooltip?: string\n  required?: boolean\n  'data-testid'?: string\n  name?: string\n  onFocus?: DOMAttributes<HTMLTextAreaElement>['onFocus']\n  onBlur?: DOMAttributes<HTMLTextAreaElement>['onBlur']\n  clearable?: boolean\n  labelDescription?: ReactNode\n}\n\n/**\n * This component offers an extended textarea HTML\n */\nexport const TextArea = forwardRef<HTMLTextAreaElement, TextAreaProps>(\n  (\n    {\n      id,\n      className,\n      tabIndex,\n      value,\n      onChange,\n      placeholder,\n      rows = 3,\n      disabled = false,\n      readOnly = false,\n      success,\n      error,\n      helper,\n      minLength,\n      maxLength,\n      tooltip,\n      label,\n      autoFocus,\n      required = false,\n      'data-testid': dataTestId,\n      name,\n      onFocus,\n      onBlur,\n      clearable = false,\n      labelDescription,\n    },\n    ref,\n  ) => {\n    const localId = useId()\n\n    const sentiment = useMemo(() => {\n      if (error) {\n        return 'danger'\n      }\n\n      if (success) {\n        return 'success'\n      }\n\n      return 'neutral'\n    }, [error, success])\n    const notice = success || error || helper\n\n    const computedClearable = clearable && !!value\n\n    return (\n      <Stack gap=\"0.5\" className={className}>\n        {label || labelDescription ? (\n          <Stack direction=\"row\" gap=\"1\" alignItems=\"center\">\n            {label ? (\n              <Stack direction=\"row\" gap=\"0.5\" alignItems=\"start\">\n                <Text\n                  as=\"label\"\n                  variant=\"bodyStrong\"\n                  sentiment=\"neutral\"\n                  htmlFor={id ?? localId}\n                >\n                  {label}\n                </Text>\n                {required ? (\n                  <Icon name=\"asterisk\" color=\"danger\" size={8} />\n                ) : null}\n              </Stack>\n            ) : null}\n            {labelDescription ?? null}\n          </Stack>\n        ) : null}\n        <Tooltip text={tooltip}>\n          <StyledTextAreaWrapper>\n            <StyledTextArea\n              aria-invalid={!!error}\n              id={id ?? localId}\n              tabIndex={tabIndex}\n              autoFocus={autoFocus}\n              disabled={disabled}\n              rows={rows}\n              ref={ref}\n              value={value}\n              onChange={event => {\n                onChange(event.currentTarget.value)\n              }}\n              hasSentimentIcon={!!success || !!error}\n              data-disabled={disabled}\n              data-readOnly={readOnly}\n              data-success={!!success}\n              data-error={!!error}\n              isClearable={!!computedClearable}\n              minLength={minLength}\n              maxLength={maxLength}\n              placeholder={placeholder}\n              data-testid={dataTestId}\n              name={name}\n              onFocus={onFocus}\n              onBlur={onBlur}\n            />\n            <StyledTextAreaAbsoluteStack\n              direction=\"row\"\n              alignItems=\"center\"\n              gap=\"1\"\n            >\n              {computedClearable ? (\n                <Button\n                  aria-label=\"clear value\"\n                  variant=\"ghost\"\n                  size=\"xsmall\"\n                  icon=\"close\"\n                  onClick={() => {\n                    onChange('')\n                  }}\n                  sentiment=\"neutral\"\n                />\n              ) : null}\n              {success ? (\n                <Icon\n                  name=\"checkbox-circle-outline\"\n                  color=\"success\"\n                  size={STATE_ICON_SIZE}\n                />\n              ) : null}\n              {error ? (\n                <Icon name=\"alert\" color=\"danger\" variant=\"outlined\" />\n              ) : null}\n            </StyledTextAreaAbsoluteStack>\n          </StyledTextAreaWrapper>\n        </Tooltip>\n\n        {notice || maxLength ? (\n          <Row templateColumns=\"minmax(0, 1fr) min-content\" gap=\"1\">\n            <div>\n              {error || success || typeof helper === 'string' ? (\n                <Text\n                  as=\"p\"\n                  variant=\"caption\"\n                  sentiment={sentiment}\n                  prominence={!error && !success ? 'weak' : 'default'}\n                  disabled={disabled}\n                >\n                  {error || success || helper}\n                </Text>\n              ) : null}\n              {!error && !success && typeof helper !== 'string' && helper\n                ? helper\n                : null}\n            </div>\n            {maxLength ? (\n              <Text\n                as=\"div\"\n                sentiment=\"neutral\"\n                prominence=\"weak\"\n                variant=\"caption\"\n              >\n                {value?.length ?? 0}/{maxLength}\n              </Text>\n            ) : null}\n          </Row>\n        ) : null}\n      </Stack>\n    )\n  },\n)\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const StyledTextAreaAbsoluteStack = /* @__PURE__ */ _styled(Stack, process.env.NODE_ENV === "production" ? {
+  target: "enu776d1"
+} : {
+  target: "enu776d1",
+  label: "StyledTextAreaAbsoluteStack"
+})("position:absolute;top:", ({
+  theme
+}) => theme.space["1.5"], ";right:", ({
+  theme
+}) => theme.space["1"], ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TextArea/index.tsx"],"names":[],"mappings":"AAiBiD","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TextArea/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { DOMAttributes, ReactNode } from 'react'\nimport { forwardRef, useId, useMemo } from 'react'\nimport { Button, SIZE_HEIGHT as ButtonSizeHeight } from '../Button'\nimport { Row } from '../Row'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport { Tooltip } from '../Tooltip'\n\nconst STATE_ICON_SIZE = 16\n\nconst StyledTextAreaWrapper = styled.div`\n  position: relative;\n  display: flex;\n`\n\nconst StyledTextAreaAbsoluteStack = styled(Stack)`\n  position: absolute;\n  top: ${({ theme }) => theme.space['1.5']};\n  right: ${({ theme }) => theme.space['1']};\n`\n\ntype StyledTextAreaProps = {\n  hasSentimentIcon: boolean\n  isClearable: boolean\n}\nconst StyledTextArea = styled('textarea', {\n  shouldForwardProp: prop =>\n    !['hasSentimentIcon', 'isClearable'].includes(prop),\n})<StyledTextAreaProps>`\n  width: 100%;\n  resize: vertical;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  color: ${({ theme }) => theme.colors.neutral.text};\n  &::placeholder {\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n  border-radius: ${({ theme }) => theme.radii.default};\n  padding: ${({ theme }) =>\n    `${theme.space['1.5']} ${theme.space['1']} ${theme.space['1.5']} ${theme.space['2']}`};\n  padding-right: ${({ theme, isClearable, hasSentimentIcon }) =>\n    /* including 1 optional if both element is visible + 1 because content is absolute 1space unit from right */\n    `calc(${theme.space[isClearable && hasSentimentIcon ? '4' : '3']} + ${\n      isClearable ? `${ButtonSizeHeight.xsmall}px` : '0px'\n    } + ${hasSentimentIcon ? `${STATE_ICON_SIZE}px` : '0px'})`};\n\n  &[data-success='true'] {\n    border-color: ${({ theme }) => theme.colors.success.border};\n  }\n\n  &[data-error='true'] {\n    border-color: ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &[data-readOnly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n\n    &::placeholder {\n      color: ${({ theme }) => theme.colors.neutral.textWeakDisabled};\n    }\n  }\n\n  &:not([data-disabled='true']):hover {\n    &:hover {\n      border-color: ${({ theme }) => theme.colors.primary.border};\n    }\n\n    &:focus {\n      outline: none;\n      border-color: ${({ theme }) => theme.colors.primary.border};\n      box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n    }\n  }\n`\n\ntype TextAreaProps = {\n  id?: string\n  className?: string\n  tabIndex?: number\n  autoFocus?: boolean\n  label: string\n  value?: string\n  onChange: (newValue: string) => void\n  placeholder?: string\n  /**\n   * Override others properties : readyOnly, success, error.\n   */\n  disabled?: boolean\n  /**\n   * Override others properties : success, error.\n   * Ignored if following props are provided : disabled.\n   */\n  readOnly?: boolean\n  /**\n   * Override others properties : error, helper.\n   * Ignored if following props are provided : disabled, readyOnly.\n   */\n  success?: string\n  /**\n   * Override others properties : helper.\n   * Ignored if following props are provided : disabled, readyOnly, success.\n   */\n  error?: string\n  /**\n   * Ignored if following props are provided : readyOnly, success.\n   */\n  helper?: ReactNode\n  rows?: number\n  minLength?: number\n  maxLength?: number\n  tooltip?: string\n  required?: boolean\n  'data-testid'?: string\n  name?: string\n  onFocus?: DOMAttributes<HTMLTextAreaElement>['onFocus']\n  onBlur?: DOMAttributes<HTMLTextAreaElement>['onBlur']\n  clearable?: boolean\n  labelDescription?: ReactNode\n}\n\n/**\n * This component offers an extended textarea HTML\n */\nexport const TextArea = forwardRef<HTMLTextAreaElement, TextAreaProps>(\n  (\n    {\n      id,\n      className,\n      tabIndex,\n      value,\n      onChange,\n      placeholder,\n      rows = 3,\n      disabled = false,\n      readOnly = false,\n      success,\n      error,\n      helper,\n      minLength,\n      maxLength,\n      tooltip,\n      label,\n      autoFocus,\n      required = false,\n      'data-testid': dataTestId,\n      name,\n      onFocus,\n      onBlur,\n      clearable = false,\n      labelDescription,\n    },\n    ref,\n  ) => {\n    const localId = useId()\n\n    const sentiment = useMemo(() => {\n      if (error) {\n        return 'danger'\n      }\n\n      if (success) {\n        return 'success'\n      }\n\n      return 'neutral'\n    }, [error, success])\n    const notice = success || error || helper\n\n    const computedClearable = clearable && !!value\n\n    return (\n      <Stack gap=\"0.5\" className={className}>\n        {label || labelDescription ? (\n          <Stack direction=\"row\" gap=\"1\" alignItems=\"center\">\n            {label ? (\n              <Stack direction=\"row\" gap=\"0.5\" alignItems=\"start\">\n                <Text\n                  as=\"label\"\n                  variant=\"bodyStrong\"\n                  sentiment=\"neutral\"\n                  htmlFor={id ?? localId}\n                >\n                  {label}\n                </Text>\n                {required ? (\n                  <Icon name=\"asterisk\" color=\"danger\" size={8} />\n                ) : null}\n              </Stack>\n            ) : null}\n            {labelDescription ?? null}\n          </Stack>\n        ) : null}\n        <Tooltip text={tooltip}>\n          <StyledTextAreaWrapper>\n            <StyledTextArea\n              aria-invalid={!!error}\n              id={id ?? localId}\n              tabIndex={tabIndex}\n              autoFocus={autoFocus}\n              disabled={disabled}\n              rows={rows}\n              ref={ref}\n              value={value}\n              onChange={event => {\n                onChange(event.currentTarget.value)\n              }}\n              hasSentimentIcon={!!success || !!error}\n              data-disabled={disabled}\n              data-readOnly={readOnly}\n              data-success={!!success}\n              data-error={!!error}\n              isClearable={!!computedClearable}\n              minLength={minLength}\n              maxLength={maxLength}\n              placeholder={placeholder}\n              data-testid={dataTestId}\n              name={name}\n              onFocus={onFocus}\n              onBlur={onBlur}\n            />\n            <StyledTextAreaAbsoluteStack\n              direction=\"row\"\n              alignItems=\"center\"\n              gap=\"1\"\n            >\n              {computedClearable ? (\n                <Button\n                  aria-label=\"clear value\"\n                  variant=\"ghost\"\n                  size=\"xsmall\"\n                  icon=\"close\"\n                  onClick={() => {\n                    onChange('')\n                  }}\n                  sentiment=\"neutral\"\n                />\n              ) : null}\n              {success ? (\n                <Icon\n                  name=\"checkbox-circle-outline\"\n                  color=\"success\"\n                  size={STATE_ICON_SIZE}\n                />\n              ) : null}\n              {error ? (\n                <Icon name=\"alert\" color=\"danger\" variant=\"outlined\" />\n              ) : null}\n            </StyledTextAreaAbsoluteStack>\n          </StyledTextAreaWrapper>\n        </Tooltip>\n\n        {notice || maxLength ? (\n          <Row templateColumns=\"minmax(0, 1fr) min-content\" gap=\"1\">\n            <div>\n              {error || success || typeof helper === 'string' ? (\n                <Text\n                  as=\"p\"\n                  variant=\"caption\"\n                  sentiment={sentiment}\n                  prominence={!error && !success ? 'weak' : 'default'}\n                  disabled={disabled}\n                >\n                  {error || success || helper}\n                </Text>\n              ) : null}\n              {!error && !success && typeof helper !== 'string' && helper\n                ? helper\n                : null}\n            </div>\n            {maxLength ? (\n              <Text\n                as=\"div\"\n                sentiment=\"neutral\"\n                prominence=\"weak\"\n                variant=\"caption\"\n              >\n                {value?.length ?? 0}/{maxLength}\n              </Text>\n            ) : null}\n          </Row>\n        ) : null}\n      </Stack>\n    )\n  },\n)\n"]} */"));
+const StyledTextArea = /* @__PURE__ */ _styled("textarea", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["hasSentimentIcon", "isClearable"].includes(prop),
+  target: "enu776d0"
+} : {
+  shouldForwardProp: (prop) => !["hasSentimentIcon", "isClearable"].includes(prop),
+  target: "enu776d0",
+  label: "StyledTextArea"
+})("width:100%;resize:vertical;background:", ({
+  theme
+}) => theme.colors.neutral.background, ";border:1px solid ", ({
+  theme
+}) => theme.colors.neutral.border, ";color:", ({
+  theme
+}) => theme.colors.neutral.text, ";&::placeholder{color:", ({
+  theme
+}) => theme.colors.neutral.textWeak, ";}border-radius:", ({
+  theme
+}) => theme.radii.default, ";padding:", ({
+  theme
+}) => `${theme.space["1.5"]} ${theme.space["1"]} ${theme.space["1.5"]} ${theme.space["2"]}`, ";padding-right:", ({
+  theme,
+  isClearable,
+  hasSentimentIcon
+}) => (
+  /* including 1 optional if both element is visible + 1 because content is absolute 1space unit from right */
+  `calc(${theme.space[isClearable && hasSentimentIcon ? "4" : "3"]} + ${isClearable ? `${SIZE_HEIGHT.xsmall}px` : "0px"} + ${hasSentimentIcon ? `${STATE_ICON_SIZE}px` : "0px"})`
+), ";&[data-success='true']{border-color:", ({
+  theme
+}) => theme.colors.success.border, ";}&[data-error='true']{border-color:", ({
+  theme
+}) => theme.colors.danger.border, ";}&[data-readOnly='true']{background:", ({
+  theme
+}) => theme.colors.neutral.backgroundWeak, ";border-color:", ({
+  theme
+}) => theme.colors.neutral.border, ";}&[data-disabled='true']{background:", ({
+  theme
+}) => theme.colors.neutral.backgroundDisabled, ";border-color:", ({
+  theme
+}) => theme.colors.neutral.borderDisabled, ";&::placeholder{color:", ({
+  theme
+}) => theme.colors.neutral.textWeakDisabled, ";}}&:not([data-disabled='true']):hover{&:hover{border-color:", ({
+  theme
+}) => theme.colors.primary.border, ";}&:focus{outline:none;border-color:", ({
+  theme
+}) => theme.colors.primary.border, ";box-shadow:", ({
+  theme
+}) => theme.shadows.focusPrimary, ";}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TextArea/index.tsx"],"names":[],"mappings":"AA8BuB","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TextArea/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { DOMAttributes, ReactNode } from 'react'\nimport { forwardRef, useId, useMemo } from 'react'\nimport { Button, SIZE_HEIGHT as ButtonSizeHeight } from '../Button'\nimport { Row } from '../Row'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport { Tooltip } from '../Tooltip'\n\nconst STATE_ICON_SIZE = 16\n\nconst StyledTextAreaWrapper = styled.div`\n  position: relative;\n  display: flex;\n`\n\nconst StyledTextAreaAbsoluteStack = styled(Stack)`\n  position: absolute;\n  top: ${({ theme }) => theme.space['1.5']};\n  right: ${({ theme }) => theme.space['1']};\n`\n\ntype StyledTextAreaProps = {\n  hasSentimentIcon: boolean\n  isClearable: boolean\n}\nconst StyledTextArea = styled('textarea', {\n  shouldForwardProp: prop =>\n    !['hasSentimentIcon', 'isClearable'].includes(prop),\n})<StyledTextAreaProps>`\n  width: 100%;\n  resize: vertical;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  color: ${({ theme }) => theme.colors.neutral.text};\n  &::placeholder {\n    color: ${({ theme }) => theme.colors.neutral.textWeak};\n  }\n  border-radius: ${({ theme }) => theme.radii.default};\n  padding: ${({ theme }) =>\n    `${theme.space['1.5']} ${theme.space['1']} ${theme.space['1.5']} ${theme.space['2']}`};\n  padding-right: ${({ theme, isClearable, hasSentimentIcon }) =>\n    /* including 1 optional if both element is visible + 1 because content is absolute 1space unit from right */\n    `calc(${theme.space[isClearable && hasSentimentIcon ? '4' : '3']} + ${\n      isClearable ? `${ButtonSizeHeight.xsmall}px` : '0px'\n    } + ${hasSentimentIcon ? `${STATE_ICON_SIZE}px` : '0px'})`};\n\n  &[data-success='true'] {\n    border-color: ${({ theme }) => theme.colors.success.border};\n  }\n\n  &[data-error='true'] {\n    border-color: ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &[data-readOnly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n\n    &::placeholder {\n      color: ${({ theme }) => theme.colors.neutral.textWeakDisabled};\n    }\n  }\n\n  &:not([data-disabled='true']):hover {\n    &:hover {\n      border-color: ${({ theme }) => theme.colors.primary.border};\n    }\n\n    &:focus {\n      outline: none;\n      border-color: ${({ theme }) => theme.colors.primary.border};\n      box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n    }\n  }\n`\n\ntype TextAreaProps = {\n  id?: string\n  className?: string\n  tabIndex?: number\n  autoFocus?: boolean\n  label: string\n  value?: string\n  onChange: (newValue: string) => void\n  placeholder?: string\n  /**\n   * Override others properties : readyOnly, success, error.\n   */\n  disabled?: boolean\n  /**\n   * Override others properties : success, error.\n   * Ignored if following props are provided : disabled.\n   */\n  readOnly?: boolean\n  /**\n   * Override others properties : error, helper.\n   * Ignored if following props are provided : disabled, readyOnly.\n   */\n  success?: string\n  /**\n   * Override others properties : helper.\n   * Ignored if following props are provided : disabled, readyOnly, success.\n   */\n  error?: string\n  /**\n   * Ignored if following props are provided : readyOnly, success.\n   */\n  helper?: ReactNode\n  rows?: number\n  minLength?: number\n  maxLength?: number\n  tooltip?: string\n  required?: boolean\n  'data-testid'?: string\n  name?: string\n  onFocus?: DOMAttributes<HTMLTextAreaElement>['onFocus']\n  onBlur?: DOMAttributes<HTMLTextAreaElement>['onBlur']\n  clearable?: boolean\n  labelDescription?: ReactNode\n}\n\n/**\n * This component offers an extended textarea HTML\n */\nexport const TextArea = forwardRef<HTMLTextAreaElement, TextAreaProps>(\n  (\n    {\n      id,\n      className,\n      tabIndex,\n      value,\n      onChange,\n      placeholder,\n      rows = 3,\n      disabled = false,\n      readOnly = false,\n      success,\n      error,\n      helper,\n      minLength,\n      maxLength,\n      tooltip,\n      label,\n      autoFocus,\n      required = false,\n      'data-testid': dataTestId,\n      name,\n      onFocus,\n      onBlur,\n      clearable = false,\n      labelDescription,\n    },\n    ref,\n  ) => {\n    const localId = useId()\n\n    const sentiment = useMemo(() => {\n      if (error) {\n        return 'danger'\n      }\n\n      if (success) {\n        return 'success'\n      }\n\n      return 'neutral'\n    }, [error, success])\n    const notice = success || error || helper\n\n    const computedClearable = clearable && !!value\n\n    return (\n      <Stack gap=\"0.5\" className={className}>\n        {label || labelDescription ? (\n          <Stack direction=\"row\" gap=\"1\" alignItems=\"center\">\n            {label ? (\n              <Stack direction=\"row\" gap=\"0.5\" alignItems=\"start\">\n                <Text\n                  as=\"label\"\n                  variant=\"bodyStrong\"\n                  sentiment=\"neutral\"\n                  htmlFor={id ?? localId}\n                >\n                  {label}\n                </Text>\n                {required ? (\n                  <Icon name=\"asterisk\" color=\"danger\" size={8} />\n                ) : null}\n              </Stack>\n            ) : null}\n            {labelDescription ?? null}\n          </Stack>\n        ) : null}\n        <Tooltip text={tooltip}>\n          <StyledTextAreaWrapper>\n            <StyledTextArea\n              aria-invalid={!!error}\n              id={id ?? localId}\n              tabIndex={tabIndex}\n              autoFocus={autoFocus}\n              disabled={disabled}\n              rows={rows}\n              ref={ref}\n              value={value}\n              onChange={event => {\n                onChange(event.currentTarget.value)\n              }}\n              hasSentimentIcon={!!success || !!error}\n              data-disabled={disabled}\n              data-readOnly={readOnly}\n              data-success={!!success}\n              data-error={!!error}\n              isClearable={!!computedClearable}\n              minLength={minLength}\n              maxLength={maxLength}\n              placeholder={placeholder}\n              data-testid={dataTestId}\n              name={name}\n              onFocus={onFocus}\n              onBlur={onBlur}\n            />\n            <StyledTextAreaAbsoluteStack\n              direction=\"row\"\n              alignItems=\"center\"\n              gap=\"1\"\n            >\n              {computedClearable ? (\n                <Button\n                  aria-label=\"clear value\"\n                  variant=\"ghost\"\n                  size=\"xsmall\"\n                  icon=\"close\"\n                  onClick={() => {\n                    onChange('')\n                  }}\n                  sentiment=\"neutral\"\n                />\n              ) : null}\n              {success ? (\n                <Icon\n                  name=\"checkbox-circle-outline\"\n                  color=\"success\"\n                  size={STATE_ICON_SIZE}\n                />\n              ) : null}\n              {error ? (\n                <Icon name=\"alert\" color=\"danger\" variant=\"outlined\" />\n              ) : null}\n            </StyledTextAreaAbsoluteStack>\n          </StyledTextAreaWrapper>\n        </Tooltip>\n\n        {notice || maxLength ? (\n          <Row templateColumns=\"minmax(0, 1fr) min-content\" gap=\"1\">\n            <div>\n              {error || success || typeof helper === 'string' ? (\n                <Text\n                  as=\"p\"\n                  variant=\"caption\"\n                  sentiment={sentiment}\n                  prominence={!error && !success ? 'weak' : 'default'}\n                  disabled={disabled}\n                >\n                  {error || success || helper}\n                </Text>\n              ) : null}\n              {!error && !success && typeof helper !== 'string' && helper\n                ? helper\n                : null}\n            </div>\n            {maxLength ? (\n              <Text\n                as=\"div\"\n                sentiment=\"neutral\"\n                prominence=\"weak\"\n                variant=\"caption\"\n              >\n                {value?.length ?? 0}/{maxLength}\n              </Text>\n            ) : null}\n          </Row>\n        ) : null}\n      </Stack>\n    )\n  },\n)\n"]} */"));
+const TextArea = forwardRef(({
+  id,
+  className,
+  tabIndex,
+  value,
+  onChange,
+  placeholder,
+  rows = 3,
+  disabled = false,
+  readOnly = false,
+  success,
+  error,
+  helper,
+  minLength,
+  maxLength,
+  tooltip,
+  label,
+  autoFocus,
+  required = false,
+  "data-testid": dataTestId,
+  name,
+  onFocus,
+  onBlur,
+  clearable = false,
+  labelDescription
+}, ref) => {
+  const localId = useId();
+  const sentiment = useMemo(() => {
+    if (error) {
+      return "danger";
+    }
+    if (success) {
+      return "success";
+    }
+    return "neutral";
+  }, [error, success]);
+  const notice = success || error || helper;
+  const computedClearable = clearable && !!value;
+  return /* @__PURE__ */ jsxs(Stack, { gap: "0.5", className, children: [
+    label || labelDescription ? /* @__PURE__ */ jsxs(Stack, { direction: "row", gap: "1", alignItems: "center", children: [
+      label ? /* @__PURE__ */ jsxs(Stack, { direction: "row", gap: "0.5", alignItems: "start", children: [
+        /* @__PURE__ */ jsx(Text, { as: "label", variant: "bodyStrong", sentiment: "neutral", htmlFor: id ?? localId, children: label }),
+        required ? /* @__PURE__ */ jsx(Icon, { name: "asterisk", color: "danger", size: 8 }) : null
+      ] }) : null,
+      labelDescription ?? null
+    ] }) : null,
+    /* @__PURE__ */ jsx(Tooltip, { text: tooltip, children: /* @__PURE__ */ jsxs(StyledTextAreaWrapper, { children: [
+      /* @__PURE__ */ jsx(StyledTextArea, { "aria-invalid": !!error, id: id ?? localId, tabIndex, autoFocus, disabled, rows, ref, value, onChange: (event) => {
+        onChange(event.currentTarget.value);
+      }, hasSentimentIcon: !!success || !!error, "data-disabled": disabled, "data-readOnly": readOnly, "data-success": !!success, "data-error": !!error, isClearable: !!computedClearable, minLength, maxLength, placeholder, "data-testid": dataTestId, name, onFocus, onBlur }),
+      /* @__PURE__ */ jsxs(StyledTextAreaAbsoluteStack, { direction: "row", alignItems: "center", gap: "1", children: [
+        computedClearable ? /* @__PURE__ */ jsx(Button, { "aria-label": "clear value", variant: "ghost", size: "xsmall", icon: "close", onClick: () => {
+          onChange("");
+        }, sentiment: "neutral" }) : null,
+        success ? /* @__PURE__ */ jsx(Icon, { name: "checkbox-circle-outline", color: "success", size: STATE_ICON_SIZE }) : null,
+        error ? /* @__PURE__ */ jsx(Icon, { name: "alert", color: "danger", variant: "outlined" }) : null
+      ] })
+    ] }) }),
+    notice || maxLength ? /* @__PURE__ */ jsxs(Row, { templateColumns: "minmax(0, 1fr) min-content", gap: "1", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        error || success || typeof helper === "string" ? /* @__PURE__ */ jsx(Text, { as: "p", variant: "caption", sentiment, prominence: !error && !success ? "weak" : "default", disabled, children: error || success || helper }) : null,
+        !error && !success && typeof helper !== "string" && helper ? helper : null
+      ] }),
+      maxLength ? /* @__PURE__ */ jsxs(Text, { as: "div", sentiment: "neutral", prominence: "weak", variant: "caption", children: [
+        value?.length ?? 0,
+        "/",
+        maxLength
+      ] }) : null
+    ] }) : null
+  ] });
+});
+export {
+  TextArea
+};

package/dist/components/TextInput/index.d.ts

@@ -0,0 +1,75 @@
+import type { FocusEventHandler, InputHTMLAttributes, KeyboardEventHandler, TextareaHTMLAttributes } from 'react';
+declare const inputSizes: {
+    medium: {
+        default: string;
+        full: string;
+    };
+    small: {
+        default: string;
+        full: string;
+    };
+};
+type TextInputSizes = keyof typeof inputSizes;
+export declare const textInputSizes: ("small" | "medium")[];
+type StyledInputProps = {
+    disabled?: boolean;
+    error?: boolean;
+    fillAvailable?: boolean;
+    hasLabel?: boolean;
+    paddingRightFactor: number;
+    isPlaceholderVisible?: boolean;
+    multiline?: boolean;
+    resizable?: boolean;
+    inputSize: TextInputSizes;
+    unit?: string;
+    rightComponentLength: number;
+} & (InputHTMLAttributes<HTMLInputElement> | TextareaHTMLAttributes<HTMLTextAreaElement>);
+type InputProps = Omit<Exclude<StyledInputProps, TextareaHTMLAttributes<HTMLTextAreaElement>>, 'inputSize'>;
+type TextInputProps = {
+    'data-testid'?: string;
+    ariaControls?: string;
+    autoComplete?: string;
+    autoFocus?: boolean;
+    className?: string;
+    cols?: number;
+    defaultValue?: string;
+    disabled?: boolean;
+    edit?: boolean;
+    error?: string;
+    fillAvailable?: boolean;
+    generated?: boolean;
+    height?: string | number;
+    id?: string;
+    label?: string;
+    multiline?: boolean;
+    name?: string;
+    notice?: string;
+    noTopLabel?: boolean;
+    onBlur?: FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onChange?: (value: string) => void;
+    onFocus?: FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onKeyUp?: KeyboardEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    placeholder?: string;
+    random?: string;
+    readOnly?: boolean;
+    required?: boolean;
+    resizable?: boolean;
+    rows?: number;
+    size?: TextInputSizes;
+    tabIndex?: number;
+    type?: string;
+    unit?: string;
+    valid?: boolean;
+    value?: string | number;
+    wrap?: string;
+    inputProps?: InputProps;
+    max?: InputHTMLAttributes<HTMLInputElement>['max'];
+    min?: InputHTMLAttributes<HTMLInputElement>['min'];
+} & (Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> | Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange'>);
+/**
+ * TextInput component allows users to input text, with options for customization and validation.
+ * It supports various input types and should be appropriately sized with clear labeling.
+ */
+export declare const TextInput: import("react").ForwardRefExoticComponent<TextInputProps & import("react").RefAttributes<HTMLInputElement | HTMLTextAreaElement | null>>;
+export {};