@ultraviolet/ui 1.51.1 → 1.51.3

package/dist/components/TagInput/index.js

@@ -0,0 +1,253 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { Icon } from "@ultraviolet/icons";
+import { useState, useId, useEffect, useRef, useMemo } from "react";
+import { Button } from "../Button/index.js";
+import { Stack } from "../Stack/index.js";
+import { Tag } from "../Tag/index.js";
+import { Text } from "../Text/index.js";
+import { Tooltip } from "../Tooltip/index.js";
+import { getUUID } from "../../utils/ids.js";
+const TAGINPUT_SIZE_PADDING = {
+  large: "1.5",
+  medium: "1",
+  small: "0.5"
+};
+const STATUS = {
+  IDLE: "idle",
+  LOADING: "loading"
+};
+const TagInputContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["size"].includes(prop),
+  target: "ea7vc6o3"
+} : {
+  shouldForwardProp: (prop) => !["size"].includes(prop),
+  target: "ea7vc6o3",
+  label: "TagInputContainer"
+})("display:flex;gap:", ({
+  theme
+}) => theme.space["1"], ";background-color:", ({
+  theme: {
+    colors
+  }
+}) => colors.neutral.background, ";padding:", ({
+  theme,
+  size
+}) => `calc(${theme.space[TAGINPUT_SIZE_PADDING[size]]} - 1px) ${theme.space["2"]}`, ";cursor:text;background:", ({
+  theme
+}) => theme.colors.neutral.background, ";border:1px solid ", ({
+  theme
+}) => theme.colors.neutral.border, ";border-radius:", ({
+  theme
+}) => theme.radii.default, ";&:focus-within{border-color:", ({
+  theme
+}) => theme.colors.primary.borderHover, ";box-shadow:", ({
+  theme
+}) => theme.shadows.focusPrimary, ";}&[data-success='true']{border-color:", ({
+  theme
+}) => theme.colors.success.border, ";}&[data-error='true']{border-color:", ({
+  theme
+}) => theme.colors.danger.border, ";}&:hover{border-color:", ({
+  theme
+}) => theme.colors.primary.borderHover, ";}&[data-readonly='true']{border-color:", ({
+  theme
+}) => theme.colors.neutral.border, ";background:", ({
+  theme
+}) => theme.colors.neutral.backgroundWeak, ";}&[data-disabled='true']{border-color:", ({
+  theme
+}) => theme.colors.neutral.borderDisabled, ";background:", ({
+  theme
+}) => theme.colors.neutral.backgroundDisabled, ";cursor:not-allowed;}" + (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/TagInput/index.tsx"],"names":[],"mappings":"AAqC2B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TagInput/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ChangeEvent,\n  ClipboardEventHandler,\n  KeyboardEventHandler,\n  ReactNode,\n} from 'react'\nimport { useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { getUUID } from '../../utils'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { Tooltip } from '../Tooltip'\n\n// Size & Padding\nexport const TAGINPUT_SIZE_PADDING = {\n  large: '1.5',\n  medium: '1',\n  small: '0.5',\n} as const\ntype TagInputSize = keyof typeof TAGINPUT_SIZE_PADDING\n\nconst STATUS = {\n  IDLE: 'idle',\n  LOADING: 'loading',\n} as const\n\ntype Keys = keyof typeof STATUS\ntype StatusValue = (typeof STATUS)[Keys]\n\ntype TagInputContainersProps = {\n  size: TagInputSize\n}\nconst TagInputContainer = styled('div', {\n  shouldForwardProp: prop => !['size'].includes(prop),\n})<TagInputContainersProps>`\n  display: flex;\n  gap: ${({ theme }) => theme.space['1']};\n  background-color: ${({ theme: { colors } }) => colors.neutral.background};\n\n  padding: ${({ theme, size }) =>\n    `calc(${theme.space[TAGINPUT_SIZE_PADDING[size]]} - 1px) ${theme.space['2']}`};\n  cursor: text;\n\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\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  &:hover {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-readonly='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n  }\n\n  &[data-disabled='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    cursor: not-allowed;\n  }\n`\n\nconst DataContainer = styled('div')`\n  height: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n  flex: 1;\n`\n\nconst StateContainer = styled('div')`\n  display: flex;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n`\n\nconst StyledInput = styled.input`\n  display: flex;\n  flex: 1;\n  font-size: ${({ theme }) => theme.typography.body.fontSize};\n  background: inherit;\n  color: ${({ theme: { colors } }) => colors.neutral.text};\n  border: none;\n  outline: none;\n  &::placeholder {\n    color: ${({ theme: { colors } }) => colors.neutral.textWeak};\n  }\n  height: 100%;\n`\n\nconst convertTagArrayToTagStateArray = (tags?: TagInputProp) =>\n  (tags || [])?.map((tag, index) =>\n    typeof tag === 'object'\n      ? { ...tag, index: getUUID(`tag-${index}`) }\n      : { index: getUUID(`tag-${index}`), label: tag },\n  )\n\ntype TagInputProp = (string | { label: string; index: string })[]\n\ntype TagInputProps = {\n  disabled?: boolean\n  id?: string\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  manualInput?: boolean\n  name?: string\n  onChange?: (tags: string[]) => void\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  onChangeError?: (error: Error | string) => void\n  placeholder?: string\n  /**\n   * @deprecated use `value` property instead, both properties work the same way\n   */\n  tags?: TagInputProp\n  value?: TagInputProp\n  /**\n   * @deprecated there is only one variant now, this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  variant?: string\n  className?: string\n  'data-testid'?: string\n  label?: string\n  /**\n   * Label description displayed right next to the label. It allows you to customize the label content.\n   */\n  labelDescription?: ReactNode\n  required?: boolean\n  size?: TagInputSize\n  error?: string\n  success?: string | boolean\n  helper?: ReactNode\n  readOnly?: boolean\n  tooltip?: string\n  clearable?: boolean\n}\n\n/**\n * TagInput is a component that allows users to input tags.\n */\nexport const TagInput = ({\n  disabled = false,\n  id,\n  name,\n  onChange,\n  placeholder,\n  tags,\n  value,\n  className,\n  'data-testid': dataTestId,\n  label,\n  labelDescription,\n  required = false,\n  size = 'large',\n  error,\n  success,\n  helper,\n  readOnly = false,\n  tooltip,\n  clearable = false,\n}: TagInputProps) => {\n  const tagsProp = value ?? tags\n\n  const [tagInputState, setTagInput] = useState(\n    convertTagArrayToTagStateArray(tagsProp ?? []),\n  )\n  const [input, setInput] = useState<string>('')\n  const [status, setStatus] = useState<{ [key: string]: StatusValue }>({})\n\n  const uniqueId = useId()\n  const localId = id ?? uniqueId\n\n  useEffect(() => {\n    setTagInput(convertTagArrayToTagStateArray(tagsProp))\n  }, [tagsProp, setTagInput])\n\n  const inputRef = useRef<HTMLInputElement>(null)\n\n  const dispatchOnChange = (newState: TagInputProp) => {\n    const changes = newState.map(tag =>\n      typeof tag === 'object' ? tag?.label : tag,\n    )\n\n    onChange?.(changes)\n  }\n\n  const handleContainerClick = () => {\n    if (inputRef.current) {\n      inputRef?.current?.focus()\n    }\n  }\n\n  const onInputChange = (e: ChangeEvent<HTMLInputElement>) =>\n    setInput(e.target.value)\n\n  const addTag = () => {\n    const newTagInput = input\n      ? [...tagInputState, { index: getUUID('tag'), label: input }]\n      : tagInputState\n    setInput('')\n    setTagInput(newTagInput)\n    if (newTagInput.length !== tagInputState.length) {\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.LOADING })\n    }\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const deleteTag = (tagIndex: string) => {\n    setStatus({ [tagIndex]: STATUS.LOADING })\n    const findIndex = tagInputState.findIndex(({ index }) => index === tagIndex)\n    const newTagInput = [...tagInputState]\n    newTagInput.splice(findIndex, 1)\n    try {\n      dispatchOnChange(newTagInput)\n      setTagInput(newTagInput)\n      setStatus({ [tagIndex]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const handleInputKeydown: KeyboardEventHandler<HTMLInputElement> = event => {\n    if (event.key === ' ' || event.key === 'Enter') {\n      addTag()\n      event.preventDefault()\n    }\n    if (\n      event.key === 'Backspace' &&\n      inputRef?.current?.selectionStart === 0 &&\n      tagInputState.length\n    ) {\n      event.preventDefault()\n      deleteTag(tagInputState[tagInputState.length - 1].index)\n    }\n  }\n\n  const handlePaste: ClipboardEventHandler<HTMLInputElement> = e => {\n    e.preventDefault()\n    const newTagInput = [\n      ...tagInputState,\n      { index: getUUID('tag'), label: e?.clipboardData?.getData('Text') },\n    ]\n    setTagInput(newTagInput)\n    setStatus({ [newTagInput.length - 1]: STATUS.LOADING })\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput.length - 1]: STATUS.IDLE })\n    } catch (err) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const clearAll = () => {\n    setInput('')\n    setTagInput([])\n    dispatchOnChange([])\n  }\n\n  const helperSentiment = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  const computedClearable = clearable && !!tagInputState.length\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      <div>\n        <Tooltip text={tooltip}>\n          <TagInputContainer\n            onClick={handleContainerClick}\n            className={className}\n            data-testid={dataTestId}\n            size={size}\n            data-disabled={disabled}\n            data-readonly={readOnly}\n            data-error={!!error}\n            data-success={!!success}\n          >\n            <DataContainer>\n              {tagInputState.map(tag => (\n                <Tag\n                  sentiment=\"neutral\"\n                  disabled={disabled}\n                  key={tag.index}\n                  isLoading={status[tag.index] === STATUS.LOADING}\n                  onClose={\n                    !readOnly\n                      ? e => {\n                          e.stopPropagation()\n                          deleteTag(tag.index)\n                        }\n                      : undefined\n                  }\n                >\n                  {tag.label}\n                </Tag>\n              ))}\n              {!disabled ? (\n                <StyledInput\n                  id={localId}\n                  name={name}\n                  aria-label={name}\n                  type=\"text\"\n                  placeholder={!tagInputState.length ? placeholder : ''}\n                  value={input}\n                  onBlur={addTag}\n                  onChange={onInputChange}\n                  onKeyDown={handleInputKeydown}\n                  onPaste={handlePaste}\n                  ref={inputRef}\n                  readOnly={readOnly}\n                />\n              ) : null}\n            </DataContainer>\n            {computedClearable || success || error ? (\n              <StateContainer>\n                {computedClearable ? (\n                  <Button\n                    aria-label=\"clear value\"\n                    disabled={disabled}\n                    variant=\"ghost\"\n                    size=\"xsmall\"\n                    icon=\"close\"\n                    onClick={clearAll}\n                    sentiment=\"neutral\"\n                  />\n                ) : null}\n                {success ? (\n                  <Icon\n                    name=\"checkbox-circle-outline\"\n                    color=\"success\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n                {error ? (\n                  <Icon\n                    name=\"alert\"\n                    color=\"danger\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n              </StateContainer>\n            ) : null}\n          </TagInputContainer>\n        </Tooltip>\n      </div>\n      {error || typeof success === 'string' || helper ? (\n        <Text\n          variant=\"caption\"\n          as=\"span\"\n          prominence={!error && !success ? 'weak' : undefined}\n          sentiment={helperSentiment}\n          disabled={disabled || readOnly}\n        >\n          {error || success || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const DataContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "ea7vc6o2"
+} : {
+  target: "ea7vc6o2",
+  label: "DataContainer"
+})("height:100%;display:flex;flex-wrap:wrap;align-items:center;gap:", ({
+  theme
+}) => theme.space["1"], ";flex: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/TagInput/index.tsx"],"names":[],"mappings":"AA+EmC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TagInput/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ChangeEvent,\n  ClipboardEventHandler,\n  KeyboardEventHandler,\n  ReactNode,\n} from 'react'\nimport { useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { getUUID } from '../../utils'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { Tooltip } from '../Tooltip'\n\n// Size & Padding\nexport const TAGINPUT_SIZE_PADDING = {\n  large: '1.5',\n  medium: '1',\n  small: '0.5',\n} as const\ntype TagInputSize = keyof typeof TAGINPUT_SIZE_PADDING\n\nconst STATUS = {\n  IDLE: 'idle',\n  LOADING: 'loading',\n} as const\n\ntype Keys = keyof typeof STATUS\ntype StatusValue = (typeof STATUS)[Keys]\n\ntype TagInputContainersProps = {\n  size: TagInputSize\n}\nconst TagInputContainer = styled('div', {\n  shouldForwardProp: prop => !['size'].includes(prop),\n})<TagInputContainersProps>`\n  display: flex;\n  gap: ${({ theme }) => theme.space['1']};\n  background-color: ${({ theme: { colors } }) => colors.neutral.background};\n\n  padding: ${({ theme, size }) =>\n    `calc(${theme.space[TAGINPUT_SIZE_PADDING[size]]} - 1px) ${theme.space['2']}`};\n  cursor: text;\n\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\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  &:hover {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-readonly='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n  }\n\n  &[data-disabled='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    cursor: not-allowed;\n  }\n`\n\nconst DataContainer = styled('div')`\n  height: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n  flex: 1;\n`\n\nconst StateContainer = styled('div')`\n  display: flex;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n`\n\nconst StyledInput = styled.input`\n  display: flex;\n  flex: 1;\n  font-size: ${({ theme }) => theme.typography.body.fontSize};\n  background: inherit;\n  color: ${({ theme: { colors } }) => colors.neutral.text};\n  border: none;\n  outline: none;\n  &::placeholder {\n    color: ${({ theme: { colors } }) => colors.neutral.textWeak};\n  }\n  height: 100%;\n`\n\nconst convertTagArrayToTagStateArray = (tags?: TagInputProp) =>\n  (tags || [])?.map((tag, index) =>\n    typeof tag === 'object'\n      ? { ...tag, index: getUUID(`tag-${index}`) }\n      : { index: getUUID(`tag-${index}`), label: tag },\n  )\n\ntype TagInputProp = (string | { label: string; index: string })[]\n\ntype TagInputProps = {\n  disabled?: boolean\n  id?: string\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  manualInput?: boolean\n  name?: string\n  onChange?: (tags: string[]) => void\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  onChangeError?: (error: Error | string) => void\n  placeholder?: string\n  /**\n   * @deprecated use `value` property instead, both properties work the same way\n   */\n  tags?: TagInputProp\n  value?: TagInputProp\n  /**\n   * @deprecated there is only one variant now, this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  variant?: string\n  className?: string\n  'data-testid'?: string\n  label?: string\n  /**\n   * Label description displayed right next to the label. It allows you to customize the label content.\n   */\n  labelDescription?: ReactNode\n  required?: boolean\n  size?: TagInputSize\n  error?: string\n  success?: string | boolean\n  helper?: ReactNode\n  readOnly?: boolean\n  tooltip?: string\n  clearable?: boolean\n}\n\n/**\n * TagInput is a component that allows users to input tags.\n */\nexport const TagInput = ({\n  disabled = false,\n  id,\n  name,\n  onChange,\n  placeholder,\n  tags,\n  value,\n  className,\n  'data-testid': dataTestId,\n  label,\n  labelDescription,\n  required = false,\n  size = 'large',\n  error,\n  success,\n  helper,\n  readOnly = false,\n  tooltip,\n  clearable = false,\n}: TagInputProps) => {\n  const tagsProp = value ?? tags\n\n  const [tagInputState, setTagInput] = useState(\n    convertTagArrayToTagStateArray(tagsProp ?? []),\n  )\n  const [input, setInput] = useState<string>('')\n  const [status, setStatus] = useState<{ [key: string]: StatusValue }>({})\n\n  const uniqueId = useId()\n  const localId = id ?? uniqueId\n\n  useEffect(() => {\n    setTagInput(convertTagArrayToTagStateArray(tagsProp))\n  }, [tagsProp, setTagInput])\n\n  const inputRef = useRef<HTMLInputElement>(null)\n\n  const dispatchOnChange = (newState: TagInputProp) => {\n    const changes = newState.map(tag =>\n      typeof tag === 'object' ? tag?.label : tag,\n    )\n\n    onChange?.(changes)\n  }\n\n  const handleContainerClick = () => {\n    if (inputRef.current) {\n      inputRef?.current?.focus()\n    }\n  }\n\n  const onInputChange = (e: ChangeEvent<HTMLInputElement>) =>\n    setInput(e.target.value)\n\n  const addTag = () => {\n    const newTagInput = input\n      ? [...tagInputState, { index: getUUID('tag'), label: input }]\n      : tagInputState\n    setInput('')\n    setTagInput(newTagInput)\n    if (newTagInput.length !== tagInputState.length) {\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.LOADING })\n    }\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const deleteTag = (tagIndex: string) => {\n    setStatus({ [tagIndex]: STATUS.LOADING })\n    const findIndex = tagInputState.findIndex(({ index }) => index === tagIndex)\n    const newTagInput = [...tagInputState]\n    newTagInput.splice(findIndex, 1)\n    try {\n      dispatchOnChange(newTagInput)\n      setTagInput(newTagInput)\n      setStatus({ [tagIndex]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const handleInputKeydown: KeyboardEventHandler<HTMLInputElement> = event => {\n    if (event.key === ' ' || event.key === 'Enter') {\n      addTag()\n      event.preventDefault()\n    }\n    if (\n      event.key === 'Backspace' &&\n      inputRef?.current?.selectionStart === 0 &&\n      tagInputState.length\n    ) {\n      event.preventDefault()\n      deleteTag(tagInputState[tagInputState.length - 1].index)\n    }\n  }\n\n  const handlePaste: ClipboardEventHandler<HTMLInputElement> = e => {\n    e.preventDefault()\n    const newTagInput = [\n      ...tagInputState,\n      { index: getUUID('tag'), label: e?.clipboardData?.getData('Text') },\n    ]\n    setTagInput(newTagInput)\n    setStatus({ [newTagInput.length - 1]: STATUS.LOADING })\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput.length - 1]: STATUS.IDLE })\n    } catch (err) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const clearAll = () => {\n    setInput('')\n    setTagInput([])\n    dispatchOnChange([])\n  }\n\n  const helperSentiment = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  const computedClearable = clearable && !!tagInputState.length\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      <div>\n        <Tooltip text={tooltip}>\n          <TagInputContainer\n            onClick={handleContainerClick}\n            className={className}\n            data-testid={dataTestId}\n            size={size}\n            data-disabled={disabled}\n            data-readonly={readOnly}\n            data-error={!!error}\n            data-success={!!success}\n          >\n            <DataContainer>\n              {tagInputState.map(tag => (\n                <Tag\n                  sentiment=\"neutral\"\n                  disabled={disabled}\n                  key={tag.index}\n                  isLoading={status[tag.index] === STATUS.LOADING}\n                  onClose={\n                    !readOnly\n                      ? e => {\n                          e.stopPropagation()\n                          deleteTag(tag.index)\n                        }\n                      : undefined\n                  }\n                >\n                  {tag.label}\n                </Tag>\n              ))}\n              {!disabled ? (\n                <StyledInput\n                  id={localId}\n                  name={name}\n                  aria-label={name}\n                  type=\"text\"\n                  placeholder={!tagInputState.length ? placeholder : ''}\n                  value={input}\n                  onBlur={addTag}\n                  onChange={onInputChange}\n                  onKeyDown={handleInputKeydown}\n                  onPaste={handlePaste}\n                  ref={inputRef}\n                  readOnly={readOnly}\n                />\n              ) : null}\n            </DataContainer>\n            {computedClearable || success || error ? (\n              <StateContainer>\n                {computedClearable ? (\n                  <Button\n                    aria-label=\"clear value\"\n                    disabled={disabled}\n                    variant=\"ghost\"\n                    size=\"xsmall\"\n                    icon=\"close\"\n                    onClick={clearAll}\n                    sentiment=\"neutral\"\n                  />\n                ) : null}\n                {success ? (\n                  <Icon\n                    name=\"checkbox-circle-outline\"\n                    color=\"success\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n                {error ? (\n                  <Icon\n                    name=\"alert\"\n                    color=\"danger\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n              </StateContainer>\n            ) : null}\n          </TagInputContainer>\n        </Tooltip>\n      </div>\n      {error || typeof success === 'string' || helper ? (\n        <Text\n          variant=\"caption\"\n          as=\"span\"\n          prominence={!error && !success ? 'weak' : undefined}\n          sentiment={helperSentiment}\n          disabled={disabled || readOnly}\n        >\n          {error || success || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const StateContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "ea7vc6o1"
+} : {
+  target: "ea7vc6o1",
+  label: "StateContainer"
+})("display:flex;align-items:center;gap:", ({
+  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/TagInput/index.tsx"],"names":[],"mappings":"AAwFoC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TagInput/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ChangeEvent,\n  ClipboardEventHandler,\n  KeyboardEventHandler,\n  ReactNode,\n} from 'react'\nimport { useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { getUUID } from '../../utils'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { Tooltip } from '../Tooltip'\n\n// Size & Padding\nexport const TAGINPUT_SIZE_PADDING = {\n  large: '1.5',\n  medium: '1',\n  small: '0.5',\n} as const\ntype TagInputSize = keyof typeof TAGINPUT_SIZE_PADDING\n\nconst STATUS = {\n  IDLE: 'idle',\n  LOADING: 'loading',\n} as const\n\ntype Keys = keyof typeof STATUS\ntype StatusValue = (typeof STATUS)[Keys]\n\ntype TagInputContainersProps = {\n  size: TagInputSize\n}\nconst TagInputContainer = styled('div', {\n  shouldForwardProp: prop => !['size'].includes(prop),\n})<TagInputContainersProps>`\n  display: flex;\n  gap: ${({ theme }) => theme.space['1']};\n  background-color: ${({ theme: { colors } }) => colors.neutral.background};\n\n  padding: ${({ theme, size }) =>\n    `calc(${theme.space[TAGINPUT_SIZE_PADDING[size]]} - 1px) ${theme.space['2']}`};\n  cursor: text;\n\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\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  &:hover {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-readonly='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n  }\n\n  &[data-disabled='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    cursor: not-allowed;\n  }\n`\n\nconst DataContainer = styled('div')`\n  height: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n  flex: 1;\n`\n\nconst StateContainer = styled('div')`\n  display: flex;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n`\n\nconst StyledInput = styled.input`\n  display: flex;\n  flex: 1;\n  font-size: ${({ theme }) => theme.typography.body.fontSize};\n  background: inherit;\n  color: ${({ theme: { colors } }) => colors.neutral.text};\n  border: none;\n  outline: none;\n  &::placeholder {\n    color: ${({ theme: { colors } }) => colors.neutral.textWeak};\n  }\n  height: 100%;\n`\n\nconst convertTagArrayToTagStateArray = (tags?: TagInputProp) =>\n  (tags || [])?.map((tag, index) =>\n    typeof tag === 'object'\n      ? { ...tag, index: getUUID(`tag-${index}`) }\n      : { index: getUUID(`tag-${index}`), label: tag },\n  )\n\ntype TagInputProp = (string | { label: string; index: string })[]\n\ntype TagInputProps = {\n  disabled?: boolean\n  id?: string\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  manualInput?: boolean\n  name?: string\n  onChange?: (tags: string[]) => void\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  onChangeError?: (error: Error | string) => void\n  placeholder?: string\n  /**\n   * @deprecated use `value` property instead, both properties work the same way\n   */\n  tags?: TagInputProp\n  value?: TagInputProp\n  /**\n   * @deprecated there is only one variant now, this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  variant?: string\n  className?: string\n  'data-testid'?: string\n  label?: string\n  /**\n   * Label description displayed right next to the label. It allows you to customize the label content.\n   */\n  labelDescription?: ReactNode\n  required?: boolean\n  size?: TagInputSize\n  error?: string\n  success?: string | boolean\n  helper?: ReactNode\n  readOnly?: boolean\n  tooltip?: string\n  clearable?: boolean\n}\n\n/**\n * TagInput is a component that allows users to input tags.\n */\nexport const TagInput = ({\n  disabled = false,\n  id,\n  name,\n  onChange,\n  placeholder,\n  tags,\n  value,\n  className,\n  'data-testid': dataTestId,\n  label,\n  labelDescription,\n  required = false,\n  size = 'large',\n  error,\n  success,\n  helper,\n  readOnly = false,\n  tooltip,\n  clearable = false,\n}: TagInputProps) => {\n  const tagsProp = value ?? tags\n\n  const [tagInputState, setTagInput] = useState(\n    convertTagArrayToTagStateArray(tagsProp ?? []),\n  )\n  const [input, setInput] = useState<string>('')\n  const [status, setStatus] = useState<{ [key: string]: StatusValue }>({})\n\n  const uniqueId = useId()\n  const localId = id ?? uniqueId\n\n  useEffect(() => {\n    setTagInput(convertTagArrayToTagStateArray(tagsProp))\n  }, [tagsProp, setTagInput])\n\n  const inputRef = useRef<HTMLInputElement>(null)\n\n  const dispatchOnChange = (newState: TagInputProp) => {\n    const changes = newState.map(tag =>\n      typeof tag === 'object' ? tag?.label : tag,\n    )\n\n    onChange?.(changes)\n  }\n\n  const handleContainerClick = () => {\n    if (inputRef.current) {\n      inputRef?.current?.focus()\n    }\n  }\n\n  const onInputChange = (e: ChangeEvent<HTMLInputElement>) =>\n    setInput(e.target.value)\n\n  const addTag = () => {\n    const newTagInput = input\n      ? [...tagInputState, { index: getUUID('tag'), label: input }]\n      : tagInputState\n    setInput('')\n    setTagInput(newTagInput)\n    if (newTagInput.length !== tagInputState.length) {\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.LOADING })\n    }\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const deleteTag = (tagIndex: string) => {\n    setStatus({ [tagIndex]: STATUS.LOADING })\n    const findIndex = tagInputState.findIndex(({ index }) => index === tagIndex)\n    const newTagInput = [...tagInputState]\n    newTagInput.splice(findIndex, 1)\n    try {\n      dispatchOnChange(newTagInput)\n      setTagInput(newTagInput)\n      setStatus({ [tagIndex]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const handleInputKeydown: KeyboardEventHandler<HTMLInputElement> = event => {\n    if (event.key === ' ' || event.key === 'Enter') {\n      addTag()\n      event.preventDefault()\n    }\n    if (\n      event.key === 'Backspace' &&\n      inputRef?.current?.selectionStart === 0 &&\n      tagInputState.length\n    ) {\n      event.preventDefault()\n      deleteTag(tagInputState[tagInputState.length - 1].index)\n    }\n  }\n\n  const handlePaste: ClipboardEventHandler<HTMLInputElement> = e => {\n    e.preventDefault()\n    const newTagInput = [\n      ...tagInputState,\n      { index: getUUID('tag'), label: e?.clipboardData?.getData('Text') },\n    ]\n    setTagInput(newTagInput)\n    setStatus({ [newTagInput.length - 1]: STATUS.LOADING })\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput.length - 1]: STATUS.IDLE })\n    } catch (err) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const clearAll = () => {\n    setInput('')\n    setTagInput([])\n    dispatchOnChange([])\n  }\n\n  const helperSentiment = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  const computedClearable = clearable && !!tagInputState.length\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      <div>\n        <Tooltip text={tooltip}>\n          <TagInputContainer\n            onClick={handleContainerClick}\n            className={className}\n            data-testid={dataTestId}\n            size={size}\n            data-disabled={disabled}\n            data-readonly={readOnly}\n            data-error={!!error}\n            data-success={!!success}\n          >\n            <DataContainer>\n              {tagInputState.map(tag => (\n                <Tag\n                  sentiment=\"neutral\"\n                  disabled={disabled}\n                  key={tag.index}\n                  isLoading={status[tag.index] === STATUS.LOADING}\n                  onClose={\n                    !readOnly\n                      ? e => {\n                          e.stopPropagation()\n                          deleteTag(tag.index)\n                        }\n                      : undefined\n                  }\n                >\n                  {tag.label}\n                </Tag>\n              ))}\n              {!disabled ? (\n                <StyledInput\n                  id={localId}\n                  name={name}\n                  aria-label={name}\n                  type=\"text\"\n                  placeholder={!tagInputState.length ? placeholder : ''}\n                  value={input}\n                  onBlur={addTag}\n                  onChange={onInputChange}\n                  onKeyDown={handleInputKeydown}\n                  onPaste={handlePaste}\n                  ref={inputRef}\n                  readOnly={readOnly}\n                />\n              ) : null}\n            </DataContainer>\n            {computedClearable || success || error ? (\n              <StateContainer>\n                {computedClearable ? (\n                  <Button\n                    aria-label=\"clear value\"\n                    disabled={disabled}\n                    variant=\"ghost\"\n                    size=\"xsmall\"\n                    icon=\"close\"\n                    onClick={clearAll}\n                    sentiment=\"neutral\"\n                  />\n                ) : null}\n                {success ? (\n                  <Icon\n                    name=\"checkbox-circle-outline\"\n                    color=\"success\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n                {error ? (\n                  <Icon\n                    name=\"alert\"\n                    color=\"danger\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n              </StateContainer>\n            ) : null}\n          </TagInputContainer>\n        </Tooltip>\n      </div>\n      {error || typeof success === 'string' || helper ? (\n        <Text\n          variant=\"caption\"\n          as=\"span\"\n          prominence={!error && !success ? 'weak' : undefined}\n          sentiment={helperSentiment}\n          disabled={disabled || readOnly}\n        >\n          {error || success || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const StyledInput = /* @__PURE__ */ _styled("input", process.env.NODE_ENV === "production" ? {
+  target: "ea7vc6o0"
+} : {
+  target: "ea7vc6o0",
+  label: "StyledInput"
+})("display:flex;flex:1;font-size:", ({
+  theme
+}) => theme.typography.body.fontSize, ";background:inherit;color:", ({
+  theme: {
+    colors
+  }
+}) => colors.neutral.text, ";border:none;outline:none;&::placeholder{color:", ({
+  theme: {
+    colors
+  }
+}) => colors.neutral.textWeak, ";}height:100%;" + (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/TagInput/index.tsx"],"names":[],"mappings":"AA8FgC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/TagInput/index.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ChangeEvent,\n  ClipboardEventHandler,\n  KeyboardEventHandler,\n  ReactNode,\n} from 'react'\nimport { useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { getUUID } from '../../utils'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { Tooltip } from '../Tooltip'\n\n// Size & Padding\nexport const TAGINPUT_SIZE_PADDING = {\n  large: '1.5',\n  medium: '1',\n  small: '0.5',\n} as const\ntype TagInputSize = keyof typeof TAGINPUT_SIZE_PADDING\n\nconst STATUS = {\n  IDLE: 'idle',\n  LOADING: 'loading',\n} as const\n\ntype Keys = keyof typeof STATUS\ntype StatusValue = (typeof STATUS)[Keys]\n\ntype TagInputContainersProps = {\n  size: TagInputSize\n}\nconst TagInputContainer = styled('div', {\n  shouldForwardProp: prop => !['size'].includes(prop),\n})<TagInputContainersProps>`\n  display: flex;\n  gap: ${({ theme }) => theme.space['1']};\n  background-color: ${({ theme: { colors } }) => colors.neutral.background};\n\n  padding: ${({ theme, size }) =>\n    `calc(${theme.space[TAGINPUT_SIZE_PADDING[size]]} - 1px) ${theme.space['2']}`};\n  cursor: text;\n\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &:focus-within {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\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  &:hover {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n\n  &[data-readonly='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n  }\n\n  &[data-disabled='true'] {\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    cursor: not-allowed;\n  }\n`\n\nconst DataContainer = styled('div')`\n  height: 100%;\n  display: flex;\n  flex-wrap: wrap;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n  flex: 1;\n`\n\nconst StateContainer = styled('div')`\n  display: flex;\n  align-items: center;\n  gap: ${({ theme }) => theme.space['1']};\n`\n\nconst StyledInput = styled.input`\n  display: flex;\n  flex: 1;\n  font-size: ${({ theme }) => theme.typography.body.fontSize};\n  background: inherit;\n  color: ${({ theme: { colors } }) => colors.neutral.text};\n  border: none;\n  outline: none;\n  &::placeholder {\n    color: ${({ theme: { colors } }) => colors.neutral.textWeak};\n  }\n  height: 100%;\n`\n\nconst convertTagArrayToTagStateArray = (tags?: TagInputProp) =>\n  (tags || [])?.map((tag, index) =>\n    typeof tag === 'object'\n      ? { ...tag, index: getUUID(`tag-${index}`) }\n      : { index: getUUID(`tag-${index}`), label: tag },\n  )\n\ntype TagInputProp = (string | { label: string; index: string })[]\n\ntype TagInputProps = {\n  disabled?: boolean\n  id?: string\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  manualInput?: boolean\n  name?: string\n  onChange?: (tags: string[]) => void\n  /**\n   * @deprecated this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  onChangeError?: (error: Error | string) => void\n  placeholder?: string\n  /**\n   * @deprecated use `value` property instead, both properties work the same way\n   */\n  tags?: TagInputProp\n  value?: TagInputProp\n  /**\n   * @deprecated there is only one variant now, this prop has no more effect\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  variant?: string\n  className?: string\n  'data-testid'?: string\n  label?: string\n  /**\n   * Label description displayed right next to the label. It allows you to customize the label content.\n   */\n  labelDescription?: ReactNode\n  required?: boolean\n  size?: TagInputSize\n  error?: string\n  success?: string | boolean\n  helper?: ReactNode\n  readOnly?: boolean\n  tooltip?: string\n  clearable?: boolean\n}\n\n/**\n * TagInput is a component that allows users to input tags.\n */\nexport const TagInput = ({\n  disabled = false,\n  id,\n  name,\n  onChange,\n  placeholder,\n  tags,\n  value,\n  className,\n  'data-testid': dataTestId,\n  label,\n  labelDescription,\n  required = false,\n  size = 'large',\n  error,\n  success,\n  helper,\n  readOnly = false,\n  tooltip,\n  clearable = false,\n}: TagInputProps) => {\n  const tagsProp = value ?? tags\n\n  const [tagInputState, setTagInput] = useState(\n    convertTagArrayToTagStateArray(tagsProp ?? []),\n  )\n  const [input, setInput] = useState<string>('')\n  const [status, setStatus] = useState<{ [key: string]: StatusValue }>({})\n\n  const uniqueId = useId()\n  const localId = id ?? uniqueId\n\n  useEffect(() => {\n    setTagInput(convertTagArrayToTagStateArray(tagsProp))\n  }, [tagsProp, setTagInput])\n\n  const inputRef = useRef<HTMLInputElement>(null)\n\n  const dispatchOnChange = (newState: TagInputProp) => {\n    const changes = newState.map(tag =>\n      typeof tag === 'object' ? tag?.label : tag,\n    )\n\n    onChange?.(changes)\n  }\n\n  const handleContainerClick = () => {\n    if (inputRef.current) {\n      inputRef?.current?.focus()\n    }\n  }\n\n  const onInputChange = (e: ChangeEvent<HTMLInputElement>) =>\n    setInput(e.target.value)\n\n  const addTag = () => {\n    const newTagInput = input\n      ? [...tagInputState, { index: getUUID('tag'), label: input }]\n      : tagInputState\n    setInput('')\n    setTagInput(newTagInput)\n    if (newTagInput.length !== tagInputState.length) {\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.LOADING })\n    }\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput[newTagInput.length - 1].index]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const deleteTag = (tagIndex: string) => {\n    setStatus({ [tagIndex]: STATUS.LOADING })\n    const findIndex = tagInputState.findIndex(({ index }) => index === tagIndex)\n    const newTagInput = [...tagInputState]\n    newTagInput.splice(findIndex, 1)\n    try {\n      dispatchOnChange(newTagInput)\n      setTagInput(newTagInput)\n      setStatus({ [tagIndex]: STATUS.IDLE })\n    } catch (e) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const handleInputKeydown: KeyboardEventHandler<HTMLInputElement> = event => {\n    if (event.key === ' ' || event.key === 'Enter') {\n      addTag()\n      event.preventDefault()\n    }\n    if (\n      event.key === 'Backspace' &&\n      inputRef?.current?.selectionStart === 0 &&\n      tagInputState.length\n    ) {\n      event.preventDefault()\n      deleteTag(tagInputState[tagInputState.length - 1].index)\n    }\n  }\n\n  const handlePaste: ClipboardEventHandler<HTMLInputElement> = e => {\n    e.preventDefault()\n    const newTagInput = [\n      ...tagInputState,\n      { index: getUUID('tag'), label: e?.clipboardData?.getData('Text') },\n    ]\n    setTagInput(newTagInput)\n    setStatus({ [newTagInput.length - 1]: STATUS.LOADING })\n    try {\n      dispatchOnChange(newTagInput)\n      setStatus({ [newTagInput.length - 1]: STATUS.IDLE })\n    } catch (err) {\n      setTagInput(tagInputState)\n    }\n  }\n\n  const clearAll = () => {\n    setInput('')\n    setTagInput([])\n    dispatchOnChange([])\n  }\n\n  const helperSentiment = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  const computedClearable = clearable && !!tagInputState.length\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      <div>\n        <Tooltip text={tooltip}>\n          <TagInputContainer\n            onClick={handleContainerClick}\n            className={className}\n            data-testid={dataTestId}\n            size={size}\n            data-disabled={disabled}\n            data-readonly={readOnly}\n            data-error={!!error}\n            data-success={!!success}\n          >\n            <DataContainer>\n              {tagInputState.map(tag => (\n                <Tag\n                  sentiment=\"neutral\"\n                  disabled={disabled}\n                  key={tag.index}\n                  isLoading={status[tag.index] === STATUS.LOADING}\n                  onClose={\n                    !readOnly\n                      ? e => {\n                          e.stopPropagation()\n                          deleteTag(tag.index)\n                        }\n                      : undefined\n                  }\n                >\n                  {tag.label}\n                </Tag>\n              ))}\n              {!disabled ? (\n                <StyledInput\n                  id={localId}\n                  name={name}\n                  aria-label={name}\n                  type=\"text\"\n                  placeholder={!tagInputState.length ? placeholder : ''}\n                  value={input}\n                  onBlur={addTag}\n                  onChange={onInputChange}\n                  onKeyDown={handleInputKeydown}\n                  onPaste={handlePaste}\n                  ref={inputRef}\n                  readOnly={readOnly}\n                />\n              ) : null}\n            </DataContainer>\n            {computedClearable || success || error ? (\n              <StateContainer>\n                {computedClearable ? (\n                  <Button\n                    aria-label=\"clear value\"\n                    disabled={disabled}\n                    variant=\"ghost\"\n                    size=\"xsmall\"\n                    icon=\"close\"\n                    onClick={clearAll}\n                    sentiment=\"neutral\"\n                  />\n                ) : null}\n                {success ? (\n                  <Icon\n                    name=\"checkbox-circle-outline\"\n                    color=\"success\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n                {error ? (\n                  <Icon\n                    name=\"alert\"\n                    color=\"danger\"\n                    size={16}\n                    disabled={disabled}\n                  />\n                ) : null}\n              </StateContainer>\n            ) : null}\n          </TagInputContainer>\n        </Tooltip>\n      </div>\n      {error || typeof success === 'string' || helper ? (\n        <Text\n          variant=\"caption\"\n          as=\"span\"\n          prominence={!error && !success ? 'weak' : undefined}\n          sentiment={helperSentiment}\n          disabled={disabled || readOnly}\n        >\n          {error || success || helper}\n        </Text>\n      ) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const convertTagArrayToTagStateArray = (tags) => (tags || [])?.map((tag, index) => typeof tag === "object" ? {
+  ...tag,
+  index: getUUID(`tag-${index}`)
+} : {
+  index: getUUID(`tag-${index}`),
+  label: tag
+});
+const TagInput = ({
+  disabled = false,
+  id,
+  name,
+  onChange,
+  placeholder,
+  tags,
+  value,
+  className,
+  "data-testid": dataTestId,
+  label,
+  labelDescription,
+  required = false,
+  size = "large",
+  error,
+  success,
+  helper,
+  readOnly = false,
+  tooltip,
+  clearable = false
+}) => {
+  const tagsProp = value ?? tags;
+  const [tagInputState, setTagInput] = useState(convertTagArrayToTagStateArray(tagsProp ?? []));
+  const [input, setInput] = useState("");
+  const [status, setStatus] = useState({});
+  const uniqueId = useId();
+  const localId = id ?? uniqueId;
+  useEffect(() => {
+    setTagInput(convertTagArrayToTagStateArray(tagsProp));
+  }, [tagsProp, setTagInput]);
+  const inputRef = useRef(null);
+  const dispatchOnChange = (newState) => {
+    const changes = newState.map((tag) => typeof tag === "object" ? tag?.label : tag);
+    onChange?.(changes);
+  };
+  const handleContainerClick = () => {
+    if (inputRef.current) {
+      inputRef?.current?.focus();
+    }
+  };
+  const onInputChange = (e) => setInput(e.target.value);
+  const addTag = () => {
+    const newTagInput = input ? [...tagInputState, {
+      index: getUUID("tag"),
+      label: input
+    }] : tagInputState;
+    setInput("");
+    setTagInput(newTagInput);
+    if (newTagInput.length !== tagInputState.length) {
+      setStatus({
+        [newTagInput[newTagInput.length - 1].index]: STATUS.LOADING
+      });
+    }
+    try {
+      dispatchOnChange(newTagInput);
+      setStatus({
+        [newTagInput[newTagInput.length - 1].index]: STATUS.IDLE
+      });
+    } catch (e) {
+      setTagInput(tagInputState);
+    }
+  };
+  const deleteTag = (tagIndex) => {
+    setStatus({
+      [tagIndex]: STATUS.LOADING
+    });
+    const findIndex = tagInputState.findIndex(({
+      index
+    }) => index === tagIndex);
+    const newTagInput = [...tagInputState];
+    newTagInput.splice(findIndex, 1);
+    try {
+      dispatchOnChange(newTagInput);
+      setTagInput(newTagInput);
+      setStatus({
+        [tagIndex]: STATUS.IDLE
+      });
+    } catch (e) {
+      setTagInput(tagInputState);
+    }
+  };
+  const handleInputKeydown = (event) => {
+    if (event.key === " " || event.key === "Enter") {
+      addTag();
+      event.preventDefault();
+    }
+    if (event.key === "Backspace" && inputRef?.current?.selectionStart === 0 && tagInputState.length) {
+      event.preventDefault();
+      deleteTag(tagInputState[tagInputState.length - 1].index);
+    }
+  };
+  const handlePaste = (e) => {
+    e.preventDefault();
+    const newTagInput = [...tagInputState, {
+      index: getUUID("tag"),
+      label: e?.clipboardData?.getData("Text")
+    }];
+    setTagInput(newTagInput);
+    setStatus({
+      [newTagInput.length - 1]: STATUS.LOADING
+    });
+    try {
+      dispatchOnChange(newTagInput);
+      setStatus({
+        [newTagInput.length - 1]: STATUS.IDLE
+      });
+    } catch (err) {
+      setTagInput(tagInputState);
+    }
+  };
+  const clearAll = () => {
+    setInput("");
+    setTagInput([]);
+    dispatchOnChange([]);
+  };
+  const helperSentiment = useMemo(() => {
+    if (error) {
+      return "danger";
+    }
+    if (success) {
+      return "success";
+    }
+    return "neutral";
+  }, [error, success]);
+  const computedClearable = clearable && !!tagInputState.length;
+  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("div", { children: /* @__PURE__ */ jsx(Tooltip, { text: tooltip, children: /* @__PURE__ */ jsxs(TagInputContainer, { onClick: handleContainerClick, className, "data-testid": dataTestId, size, "data-disabled": disabled, "data-readonly": readOnly, "data-error": !!error, "data-success": !!success, children: [
+      /* @__PURE__ */ jsxs(DataContainer, { children: [
+        tagInputState.map((tag) => /* @__PURE__ */ jsx(Tag, { sentiment: "neutral", disabled, isLoading: status[tag.index] === STATUS.LOADING, onClose: !readOnly ? (e) => {
+          e.stopPropagation();
+          deleteTag(tag.index);
+        } : void 0, children: tag.label }, tag.index)),
+        !disabled ? /* @__PURE__ */ jsx(StyledInput, { id: localId, name, "aria-label": name, type: "text", placeholder: !tagInputState.length ? placeholder : "", value: input, onBlur: addTag, onChange: onInputChange, onKeyDown: handleInputKeydown, onPaste: handlePaste, ref: inputRef, readOnly }) : null
+      ] }),
+      computedClearable || success || error ? /* @__PURE__ */ jsxs(StateContainer, { children: [
+        computedClearable ? /* @__PURE__ */ jsx(Button, { "aria-label": "clear value", disabled, variant: "ghost", size: "xsmall", icon: "close", onClick: clearAll, sentiment: "neutral" }) : null,
+        success ? /* @__PURE__ */ jsx(Icon, { name: "checkbox-circle-outline", color: "success", size: 16, disabled }) : null,
+        error ? /* @__PURE__ */ jsx(Icon, { name: "alert", color: "danger", size: 16, disabled }) : null
+      ] }) : null
+    ] }) }) }),
+    error || typeof success === "string" || helper ? /* @__PURE__ */ jsx(Text, { variant: "caption", as: "span", prominence: !error && !success ? "weak" : void 0, sentiment: helperSentiment, disabled: disabled || readOnly, children: error || success || helper }) : null
+  ] });
+};
+export {
+  TAGINPUT_SIZE_PADDING,
+  TagInput
+};

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

@@ -0,0 +1,37 @@
+import type { ComponentProps } from 'react';
+import { Popover } from '../Popover';
+import { Tag } from '../Tag';
+type TagListProps = {
+    /**
+     * This property define maximum characters length of all tags until it hide tags into tooltip.
+     */
+    maxLength?: number;
+    tags?: (string | {
+        label: string;
+        icon: NonNullable<ComponentProps<typeof Tag>['icon']>;
+    })[];
+    /**
+     * This property define maximum characters length of all tags until it hide tags into tooltip.
+     */
+    threshold?: number;
+    /**
+     * This property define maximum width of each tag. This doesn't apply for tags in tooltip.
+     */
+    multiline?: boolean;
+    /**
+     * This property define the title of the Popover, when some tags are hidden because of the threshold.
+     */
+    popoverTitle: string;
+    /**
+     * The popover will be placed automatically by default. You can also specify the placement of the popover through
+     * this property.
+     */
+    popoverPlacement?: ComponentProps<typeof Popover>['placement'];
+    className?: string;
+    'data-testid'?: string;
+} & Pick<ComponentProps<typeof Tag>, 'copiable' | 'copyText' | 'copiedText'>;
+/**
+ * This component is used to display a list of tags with a threshold and a popover when there are too many tags.
+ */
+export declare const TagList: ({ maxLength, tags, threshold, multiline, popoverTitle, popoverPlacement, copiable, copyText, copiedText, className, "data-testid": dataTestId, }: TagListProps) => import("@emotion/react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/TagList/index.js

@@ -0,0 +1,98 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { useState } from "react";
+import { Popover } from "../Popover/index.js";
+import { Tag } from "../Tag/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 StyledContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "eb6op482"
+} : {
+  target: "eb6op482",
+  label: "StyledContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "zjik7",
+  styles: "display:flex"
+} : {
+  name: "zjik7",
+  styles: "display:flex",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const TagsWrapper = /* @__PURE__ */ _styled("span", process.env.NODE_ENV === "production" ? {
+  target: "eb6op481"
+} : {
+  target: "eb6op481",
+  label: "TagsWrapper"
+})("cursor:pointer;color:", ({
+  theme
+}) => theme.colors.primary.text, ";border:none;font-size:14px;align-self:center;max-width:350px;overflow:hidden;white-space:pre;text-overflow:ellipsis;background-color:transparent;padding-left:8px;padding-right:8px;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const StyledTagContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "eb6op480"
+} : {
+  target: "eb6op480",
+  label: "StyledTagContainer"
+})("display:flex;align-items:center;color:", ({
+  theme
+}) => theme.colors.neutral.text, ";gap:", ({
+  theme
+}) => theme.space["1"], ";", ({
+  multiline
+}) => multiline && `flex-wrap: wrap;`, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const DEFAULT_TAGS = [];
+const getTagLabel = (tag) => typeof tag === "object" ? tag.label : tag;
+const TagList = ({
+  maxLength = 600,
+  tags = DEFAULT_TAGS,
+  threshold = 1,
+  multiline = false,
+  popoverTitle,
+  popoverPlacement,
+  copiable,
+  copyText,
+  copiedText,
+  className,
+  "data-testid": dataTestId
+}) => {
+  let tmpThreshold = threshold;
+  if (tags.length > 0 && tags.slice(0, tmpThreshold).reduce((acc, tag) => acc + getTagLabel(tag), "").length > maxLength) {
+    tmpThreshold -= 1;
+  }
+  const hasManyTags = tags.length > tmpThreshold || false;
+  const visibleTagsCount = hasManyTags ? tmpThreshold : tags.length;
+  const [isVisible, setIsVisible] = useState(false);
+  if (!tags.length) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(StyledContainer, { className, "data-testid": dataTestId, children: [
+    /* @__PURE__ */ jsx(StyledTagContainer, { multiline, children: tags.slice(0, visibleTagsCount).map((tag, index) => /* @__PURE__ */ jsx(
+      Tag,
+      {
+        copiable,
+        copyText,
+        copiedText,
+        icon: typeof tag === "object" ? tag.icon : void 0,
+        children: getTagLabel(tag)
+      },
+      `${getTagLabel(tag)}-${index}`
+    )) }),
+    hasManyTags ? /* @__PURE__ */ jsx(Popover, { title: popoverTitle, visible: isVisible, size: "small", onClose: () => setIsVisible(false), placement: popoverPlacement, content: /* @__PURE__ */ jsx(StyledTagContainer, { multiline: true, children: tags.slice(visibleTagsCount).map((tag, index) => /* @__PURE__ */ jsx(
+      Tag,
+      {
+        copiable,
+        copyText,
+        copiedText,
+        icon: typeof tag === "object" ? tag.icon : void 0,
+        children: getTagLabel(tag)
+      },
+      `${getTagLabel(tag)}-${index}`
+    )) }), children: /* @__PURE__ */ jsxs(TagsWrapper, { "data-testid": `${dataTestId ?? "taglist"}-open`, onClick: () => setIsVisible(true), children: [
+      "+",
+      tags.length - tmpThreshold
+    ] }) }) : null
+  ] });
+};
+export {
+  TagList
+};

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

@@ -0,0 +1,40 @@
+import type React from 'react';
+import type { ElementType, ReactNode } from 'react';
+import type { Color } from '../../theme';
+import { typography } from '../../theme';
+declare const PROMINENCES: {
+    default: string;
+    strong: string;
+    stronger: string;
+    weak: string;
+};
+type ProminenceProps = keyof typeof PROMINENCES;
+type PlacementProps = React.CSSProperties['textAlign'];
+type TextVariant = keyof typeof typography;
+export declare const textVariants: ("body" | "bodySmall" | "bodySmallStrong" | "bodySmallStronger" | "bodyStrong" | "bodyStronger" | "caption" | "captionSmall" | "captionSmallStrong" | "captionSmallStronger" | "captionStrong" | "captionStronger" | "code" | "codeStrong" | "codeStronger" | "heading" | "headingLarge" | "headingLargeStrong" | "headingLargeStronger" | "headingSmall" | "headingSmallStrong" | "headingSmallStronger" | "headingStrong" | "headingStronger")[];
+type TextProps = {
+    className?: string;
+    children: ReactNode;
+    placement?: PlacementProps;
+    variant: TextVariant;
+    /**
+     * @deprecated use `sentiment` property instead
+     */
+    color?: Color;
+    sentiment?: Color;
+    prominence?: ProminenceProps;
+    as: ElementType;
+    oneLine?: boolean;
+    disabled?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    id?: string;
+    dir?: 'ltr' | 'rtl' | 'auto';
+    htmlFor?: string;
+    'data-testid'?: string;
+};
+/**
+ * Text component is used to display text with different variants and sentiments.
+ */
+export declare const Text: ({ variant, children, as, color, sentiment, oneLine, placement, prominence, className, disabled, italic, underline, id, dir, htmlFor, "data-testid": dataTestId, }: TextProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};