@ultraviolet/ui 1.51.1 → 1.51.3

package/dist/components/Button/index.js

@@ -0,0 +1,249 @@
+import { jsx, jsxs, Fragment } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { Icon } from "@ultraviolet/icons";
+import { forwardRef } from "react";
+import { Loader } from "../Loader/index.js";
+import { Tooltip } from "../Tooltip/index.js";
+const SIZE_HEIGHT = {
+  large: 48,
+  medium: 40,
+  small: 32,
+  xsmall: 24
+};
+const SIZE_PADDING_KEY = {
+  large: 2,
+  medium: 1.5,
+  small: 1,
+  xsmall: 0.5
+};
+const SIZE_GAP_KEY = {
+  large: 1,
+  medium: 1,
+  small: 1,
+  xsmall: 0.5
+};
+const FOCUS_RING_KEY = {
+  danger: "focusDanger",
+  info: "focusInfo",
+  neutral: "focusNeutral",
+  primary: "focusPrimary",
+  // @note: no focusSecondary so far, it will be added later, so far focusPrimary sounds fine
+  secondary: "focusPrimary",
+  success: "focusSuccess",
+  warning: "focusWarning"
+};
+const coreStyle = ({
+  theme,
+  size,
+  sentiment,
+  iconPosition,
+  fullWidth,
+  disabled,
+  iconOnly
+}) => {
+  const font = size === "large" ? theme.typography.bodyStrong : theme.typography.bodySmallStrong;
+  let width = "auto";
+  if (fullWidth) {
+    width = "100%";
+  } else if (iconOnly) {
+    width = `${SIZE_HEIGHT[size]}px`;
+  }
+  return `display: inline-flex;
+  height: ${SIZE_HEIGHT[size]}px;
+  padding: 0 ${theme.space[SIZE_PADDING_KEY[size]]};
+  flex-direction: ${iconPosition === "right" ? "row-reverse" : "row"};
+  gap: ${theme.space[SIZE_GAP_KEY[size]]};
+  border-radius: ${theme.radii.default};
+  box-sizing: border-box;
+  width: ${width};
+  align-items: center;
+  cursor: ${disabled ? "not-allowed" : "pointer"};
+  justify-content: center;
+  outline-offset: 2px;
+  white-space: nowrap;
+  text-decoration: none;
+  &:hover {
+    text-decoration: none;
+  }
+
+
+  ${disabled ? "" : `
+          &:active {
+            box-shadow: ${theme.shadows[FOCUS_RING_KEY[sentiment]]};
+          }
+        `}
+
+  /* We can't use Text component because of button hover effect, so we need to duplicate */
+  font-size: ${font.fontSize};
+  font-family: ${font.fontFamily};
+  font-weight: ${font.weight};
+  letter-spacing: ${font.letterSpacing};
+  line-height: ${font.lineHeight};
+  paragraph-spacing: ${font.paragraphSpacing};
+  text-case: ${font.textCase};
+`;
+};
+const StyledFilledButton = /* @__PURE__ */ _styled("button", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["size", "sentiment", "iconPosition", "fullWidth", "iconOnly"].includes(prop),
+  target: "e112qvla2"
+} : {
+  shouldForwardProp: (prop) => !["size", "sentiment", "iconPosition", "fullWidth", "iconOnly"].includes(prop),
+  target: "e112qvla2",
+  label: "StyledFilledButton"
+})((args) => coreStyle(args), " background:", ({
+  theme,
+  sentiment
+}) => theme.colors[sentiment].backgroundStrong, ";border:none;color:", ({
+  theme,
+  sentiment
+}) => theme.colors[sentiment].textStrong, ";", ({
+  theme,
+  sentiment,
+  disabled
+}) => disabled ? `
+            background: ${theme.colors[sentiment].backgroundStrongDisabled};
+            color:
+              ${theme.colors[sentiment].textStrongDisabled};
+        ` : `
+            &:hover, &:active
+            {
+                background: ${theme.colors[sentiment].backgroundStrongHover};
+                color:
+                ${theme.colors[sentiment].textStrongHover};
+            }
+  `, ";" + (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/Button/index.tsx"],"names":[],"mappings":"AA6HqB","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Button/index.tsx","sourcesContent":["import type { Theme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  AriaRole,\n  ButtonHTMLAttributes,\n  ComponentProps,\n  MouseEventHandler,\n  ReactNode,\n  Ref,\n} from 'react'\nimport { forwardRef } from 'react'\nimport type { SENTIMENTS } from '../../theme'\nimport { Loader } from '../Loader'\nimport { Tooltip } from '../Tooltip'\n\ntype SENTIMENT = (typeof SENTIMENTS)[number]\n\n// SIZE\nexport const SIZE_HEIGHT = {\n  large: 48,\n  medium: 40,\n  small: 32,\n  xsmall: 24,\n} as const\ntype ButtonSize = keyof typeof SIZE_HEIGHT\nconst SIZE_PADDING_KEY = {\n  large: 2,\n  medium: 1.5,\n  small: 1,\n  xsmall: 0.5,\n} as const\nconst SIZE_GAP_KEY = {\n  large: 1,\n  medium: 1,\n  small: 1,\n  xsmall: 0.5,\n} as const\nexport const buttonSizes = Object.keys(SIZE_HEIGHT) as ButtonSize[]\n\n// FOCUS RING\nconst FOCUS_RING_KEY = {\n  danger: 'focusDanger',\n  info: 'focusInfo',\n  neutral: 'focusNeutral',\n  primary: 'focusPrimary',\n  // @note: no focusSecondary so far, it will be added later, so far focusPrimary sounds fine\n  secondary: 'focusPrimary',\n  success: 'focusSuccess',\n  warning: 'focusWarning',\n} as const\n\n// VARIANTS\ntype StyledButtonProps = Required<\n  Pick<\n    FinalProps,\n    'size' | 'sentiment' | 'disabled' | 'iconPosition' | 'fullWidth'\n  >\n> & { iconOnly: boolean }\nconst coreStyle = ({\n  theme,\n  size,\n  sentiment,\n  iconPosition,\n  fullWidth,\n  disabled,\n  iconOnly,\n}: { theme: Theme } & StyledButtonProps) => {\n  const font =\n    size === 'large'\n      ? theme.typography.bodyStrong\n      : theme.typography.bodySmallStrong\n\n  let width = 'auto'\n  if (fullWidth) {\n    width = '100%'\n  } else if (iconOnly) {\n    width = `${SIZE_HEIGHT[size]}px`\n  }\n\n  return `display: inline-flex;\n  height: ${SIZE_HEIGHT[size]}px;\n  padding: 0 ${theme.space[SIZE_PADDING_KEY[size]]};\n  flex-direction: ${iconPosition === 'right' ? 'row-reverse' : 'row'};\n  gap: ${theme.space[SIZE_GAP_KEY[size]]};\n  border-radius: ${theme.radii.default};\n  box-sizing: border-box;\n  width: ${width};\n  align-items: center;\n  cursor: ${disabled ? 'not-allowed' : 'pointer'};\n  justify-content: center;\n  outline-offset: 2px;\n  white-space: nowrap;\n  text-decoration: none;\n  &:hover {\n    text-decoration: none;\n  }\n\n\n  ${\n    disabled\n      ? ''\n      : `\n          &:active {\n            box-shadow: ${theme.shadows[FOCUS_RING_KEY[sentiment]]};\n          }\n        `\n  }\n\n  /* We can't use Text component because of button hover effect, so we need to duplicate */\n  font-size: ${font.fontSize};\n  font-family: ${font.fontFamily};\n  font-weight: ${font.weight};\n  letter-spacing: ${font.letterSpacing};\n  line-height: ${font.lineHeight};\n  paragraph-spacing: ${font.paragraphSpacing};\n  text-case: ${font.textCase};\n`\n}\n\nconst StyledFilledButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: ${({ theme, sentiment }) =>\n    theme.colors[sentiment].backgroundStrong};\n  border: none;\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].textStrong};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n            background: ${theme.colors[sentiment].backgroundStrongDisabled};\n            color:\n              ${theme.colors[sentiment].textStrongDisabled};\n        `\n      : `\n            &:hover, &:active\n            {\n                background: ${theme.colors[sentiment].backgroundStrongHover};\n                color:\n                ${theme.colors[sentiment].textStrongHover};\n            }\n  `}\n`\n\nconst StyledOutlinedButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: none;\n  border: 1px solid\n    ${({ theme, sentiment }) =>\n      theme.colors[sentiment][\n        sentiment === 'neutral' ? 'borderStrong' : 'border'\n      ]};\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].text};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n        color:\n          ${theme.colors[sentiment].textDisabled};\n        border: 1px solid ${\n          theme.colors[sentiment][\n            sentiment === 'neutral' ? 'borderStrongDisabled' : 'borderDisabled'\n          ]\n        };\n\n    `\n      : `\n        &:hover, &:active\n       {\n            background: ${theme.colors[sentiment].backgroundHover};\n            color:\n            ${theme.colors[sentiment].textHover};\n            border: 1px solid ${\n              theme.colors[sentiment][\n                sentiment === 'neutral' ? 'borderStrongHover' : 'borderHover'\n              ]\n            };\n\n        }\n`};\n`\n\nconst StyledGhostButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: none;\n  border: none;\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].text};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n        color:\n          ${theme.colors[sentiment].textDisabled};\n      `\n      : `\n        &:hover, &:active\n        {\n            background: ${theme.colors[sentiment].backgroundHover};\n            color:\n              ${theme.colors[sentiment].textHover};\n        }\n`}\n`\n\nconst VARIANTS_COMPONENTS = {\n  filled: {\n    button: StyledFilledButton,\n    link: StyledFilledButton.withComponent('a'),\n  },\n  outlined: {\n    button: StyledOutlinedButton,\n    link: StyledOutlinedButton.withComponent('a'),\n  },\n  ghost: {\n    button: StyledGhostButton,\n    link: StyledGhostButton.withComponent('a'),\n  },\n}\ntype ButtonVariant = keyof typeof VARIANTS_COMPONENTS\nexport const buttonVariants = Object.keys(\n  VARIANTS_COMPONENTS,\n) as ButtonVariant[]\n\ntype CommonProps = {\n  type?: ButtonHTMLAttributes<HTMLButtonElement>['type']\n  autoFocus?: ButtonHTMLAttributes<HTMLButtonElement>['autoFocus']\n  variant?: ButtonVariant\n  role?: AriaRole\n  size?: ButtonSize\n  className?: string\n  'data-testid'?: string\n  sentiment?: SENTIMENT\n  disabled?: boolean\n  iconPosition?: 'left' | 'right'\n  iconVariant?: ComponentProps<typeof Icon>['variant']\n  fullWidth?: boolean\n  isLoading?: boolean\n  'aria-label'?: string\n  'aria-current'?: boolean\n  'aria-controls'?: string\n  'aria-expanded'?: boolean\n  'aria-haspopup'?: boolean\n  onClick?: MouseEventHandler<HTMLElement>\n  tooltip?: string\n  tabIndex?: ButtonHTMLAttributes<HTMLButtonElement>['tabIndex']\n  onMouseDown?: MouseEventHandler<HTMLElement>\n  onMouseUp?: MouseEventHandler<HTMLElement>\n  onMouseOut?: MouseEventHandler<HTMLElement>\n}\n\n// @note: using XOR utility was generating some lint erros\ntype FinalProps = CommonProps &\n  (\n    | {\n        // Button : Children + optional Icon\n        children: ReactNode\n        icon?: ComponentProps<typeof Icon>['name']\n        name?: string\n        href?: never\n        target?: never\n        download?: never\n      }\n    | {\n        // Button : Icon only\n        children?: never\n        icon: ComponentProps<typeof Icon>['name']\n        name?: string\n        href?: never\n        target?: never\n        download?: never\n      }\n    | {\n        // Anchor : Children + optional Icon\n        children: ReactNode\n        icon?: ComponentProps<typeof Icon>['name']\n        name?: never\n        href: string\n        target?: string\n        download?: string\n      }\n    | {\n        // Anchor : Children + Icon Only\n        children?: never\n        icon: ComponentProps<typeof Icon>['name']\n        name?: never\n        href: string\n        target?: string\n        download?: string\n      }\n  )\n\n/**\n * Button component is used to trigger an action or event, such as submitting a form, opening a dialog,\n * canceling an action, or performing a delete operation.\n */\nexport const Button = forwardRef<Element, FinalProps>(\n  (\n    {\n      type = 'button',\n      className,\n      'data-testid': dataTestId,\n      sentiment = 'primary',\n      variant = 'filled',\n      size = 'large',\n      disabled = false,\n      icon,\n      iconPosition = 'left',\n      iconVariant,\n      fullWidth = false,\n      isLoading = false,\n      children,\n      onClick,\n      onMouseDown,\n      onMouseUp,\n      onMouseOut,\n      name,\n      'aria-label': ariaLabel,\n      'aria-current': ariaCurrent,\n      'aria-controls': ariaControls,\n      'aria-expanded': ariaExpanded,\n      'aria-haspopup': ariaHaspopup,\n      href,\n      download,\n      target,\n      role,\n      tooltip,\n      tabIndex,\n      autoFocus,\n    },\n    ref,\n  ) => {\n    const computeIsDisabled = disabled || isLoading\n    const content = (\n      <>\n        {!isLoading && icon ? (\n          <Icon name={icon} size=\"small\" variant={iconVariant} />\n        ) : null}\n        {isLoading ? (\n          <Loader\n            active\n            trailColor=\"transparent\"\n            size=\"1em\"\n            color=\"currentColor\"\n          />\n        ) : null}\n        {children && typeof children !== 'string' ? (\n          <div>{children}</div>\n        ) : (\n          children\n        )}\n      </>\n    )\n\n    // @note: an anchor can't be disabled\n    if (href && !computeIsDisabled) {\n      const Component = VARIANTS_COMPONENTS[variant].link\n\n      return (\n        <Tooltip text={tooltip} containerFullWidth={fullWidth}>\n          <Component\n            role={role}\n            className={className}\n            data-testid={dataTestId}\n            disabled={false}\n            fullWidth={fullWidth}\n            iconPosition={iconPosition}\n            sentiment={sentiment}\n            size={size}\n            type={type}\n            onClick={onClick}\n            aria-label={ariaLabel}\n            aria-current={ariaCurrent}\n            aria-controls={ariaControls}\n            aria-expanded={ariaExpanded}\n            aria-haspopup={ariaHaspopup}\n            href={href}\n            target={target}\n            download={download}\n            ref={ref as Ref<HTMLAnchorElement>}\n            iconOnly={!!icon && !children}\n            tabIndex={tabIndex}\n            autoFocus={autoFocus}\n            onMouseDown={onMouseDown}\n            onMouseUp={onMouseUp}\n            onMouseOut={onMouseOut}\n          >\n            {content}\n          </Component>\n        </Tooltip>\n      )\n    }\n\n    const Component = VARIANTS_COMPONENTS[variant].button\n\n    return (\n      <Tooltip text={tooltip} containerFullWidth={fullWidth}>\n        <Component\n          role={role}\n          className={className}\n          data-testid={dataTestId}\n          disabled={computeIsDisabled}\n          fullWidth={fullWidth}\n          iconPosition={iconPosition}\n          sentiment={sentiment}\n          size={size}\n          type={type}\n          onClick={onClick}\n          ref={ref as Ref<HTMLButtonElement>}\n          name={name}\n          aria-label={ariaLabel}\n          aria-current={ariaCurrent}\n          aria-controls={ariaControls}\n          aria-expanded={ariaExpanded}\n          aria-haspopup={ariaHaspopup}\n          iconOnly={!!icon && !children}\n          tabIndex={tabIndex}\n          autoFocus={autoFocus}\n          onMouseDown={onMouseDown}\n          onMouseUp={onMouseUp}\n          onMouseOut={onMouseOut}\n        >\n          {content}\n        </Component>\n      </Tooltip>\n    )\n  },\n)\n"]} */"));
+const StyledOutlinedButton = /* @__PURE__ */ _styled("button", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["size", "sentiment", "iconPosition", "fullWidth", "iconOnly"].includes(prop),
+  target: "e112qvla1"
+} : {
+  shouldForwardProp: (prop) => !["size", "sentiment", "iconPosition", "fullWidth", "iconOnly"].includes(prop),
+  target: "e112qvla1",
+  label: "StyledOutlinedButton"
+})((args) => coreStyle(args), " background:none;border:1px solid ", ({
+  theme,
+  sentiment
+}) => theme.colors[sentiment][sentiment === "neutral" ? "borderStrong" : "border"], ";color:", ({
+  theme,
+  sentiment
+}) => theme.colors[sentiment].text, ";", ({
+  theme,
+  sentiment,
+  disabled
+}) => disabled ? `
+        color:
+          ${theme.colors[sentiment].textDisabled};
+        border: 1px solid ${theme.colors[sentiment][sentiment === "neutral" ? "borderStrongDisabled" : "borderDisabled"]};
+
+    ` : `
+        &:hover, &:active
+       {
+            background: ${theme.colors[sentiment].backgroundHover};
+            color:
+            ${theme.colors[sentiment].textHover};
+            border: 1px solid ${theme.colors[sentiment][sentiment === "neutral" ? "borderStrongHover" : "borderHover"]};
+
+        }
+`, ";" + (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/Button/index.tsx"],"names":[],"mappings":"AA2JqB","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Button/index.tsx","sourcesContent":["import type { Theme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  AriaRole,\n  ButtonHTMLAttributes,\n  ComponentProps,\n  MouseEventHandler,\n  ReactNode,\n  Ref,\n} from 'react'\nimport { forwardRef } from 'react'\nimport type { SENTIMENTS } from '../../theme'\nimport { Loader } from '../Loader'\nimport { Tooltip } from '../Tooltip'\n\ntype SENTIMENT = (typeof SENTIMENTS)[number]\n\n// SIZE\nexport const SIZE_HEIGHT = {\n  large: 48,\n  medium: 40,\n  small: 32,\n  xsmall: 24,\n} as const\ntype ButtonSize = keyof typeof SIZE_HEIGHT\nconst SIZE_PADDING_KEY = {\n  large: 2,\n  medium: 1.5,\n  small: 1,\n  xsmall: 0.5,\n} as const\nconst SIZE_GAP_KEY = {\n  large: 1,\n  medium: 1,\n  small: 1,\n  xsmall: 0.5,\n} as const\nexport const buttonSizes = Object.keys(SIZE_HEIGHT) as ButtonSize[]\n\n// FOCUS RING\nconst FOCUS_RING_KEY = {\n  danger: 'focusDanger',\n  info: 'focusInfo',\n  neutral: 'focusNeutral',\n  primary: 'focusPrimary',\n  // @note: no focusSecondary so far, it will be added later, so far focusPrimary sounds fine\n  secondary: 'focusPrimary',\n  success: 'focusSuccess',\n  warning: 'focusWarning',\n} as const\n\n// VARIANTS\ntype StyledButtonProps = Required<\n  Pick<\n    FinalProps,\n    'size' | 'sentiment' | 'disabled' | 'iconPosition' | 'fullWidth'\n  >\n> & { iconOnly: boolean }\nconst coreStyle = ({\n  theme,\n  size,\n  sentiment,\n  iconPosition,\n  fullWidth,\n  disabled,\n  iconOnly,\n}: { theme: Theme } & StyledButtonProps) => {\n  const font =\n    size === 'large'\n      ? theme.typography.bodyStrong\n      : theme.typography.bodySmallStrong\n\n  let width = 'auto'\n  if (fullWidth) {\n    width = '100%'\n  } else if (iconOnly) {\n    width = `${SIZE_HEIGHT[size]}px`\n  }\n\n  return `display: inline-flex;\n  height: ${SIZE_HEIGHT[size]}px;\n  padding: 0 ${theme.space[SIZE_PADDING_KEY[size]]};\n  flex-direction: ${iconPosition === 'right' ? 'row-reverse' : 'row'};\n  gap: ${theme.space[SIZE_GAP_KEY[size]]};\n  border-radius: ${theme.radii.default};\n  box-sizing: border-box;\n  width: ${width};\n  align-items: center;\n  cursor: ${disabled ? 'not-allowed' : 'pointer'};\n  justify-content: center;\n  outline-offset: 2px;\n  white-space: nowrap;\n  text-decoration: none;\n  &:hover {\n    text-decoration: none;\n  }\n\n\n  ${\n    disabled\n      ? ''\n      : `\n          &:active {\n            box-shadow: ${theme.shadows[FOCUS_RING_KEY[sentiment]]};\n          }\n        `\n  }\n\n  /* We can't use Text component because of button hover effect, so we need to duplicate */\n  font-size: ${font.fontSize};\n  font-family: ${font.fontFamily};\n  font-weight: ${font.weight};\n  letter-spacing: ${font.letterSpacing};\n  line-height: ${font.lineHeight};\n  paragraph-spacing: ${font.paragraphSpacing};\n  text-case: ${font.textCase};\n`\n}\n\nconst StyledFilledButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: ${({ theme, sentiment }) =>\n    theme.colors[sentiment].backgroundStrong};\n  border: none;\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].textStrong};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n            background: ${theme.colors[sentiment].backgroundStrongDisabled};\n            color:\n              ${theme.colors[sentiment].textStrongDisabled};\n        `\n      : `\n            &:hover, &:active\n            {\n                background: ${theme.colors[sentiment].backgroundStrongHover};\n                color:\n                ${theme.colors[sentiment].textStrongHover};\n            }\n  `}\n`\n\nconst StyledOutlinedButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: none;\n  border: 1px solid\n    ${({ theme, sentiment }) =>\n      theme.colors[sentiment][\n        sentiment === 'neutral' ? 'borderStrong' : 'border'\n      ]};\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].text};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n        color:\n          ${theme.colors[sentiment].textDisabled};\n        border: 1px solid ${\n          theme.colors[sentiment][\n            sentiment === 'neutral' ? 'borderStrongDisabled' : 'borderDisabled'\n          ]\n        };\n\n    `\n      : `\n        &:hover, &:active\n       {\n            background: ${theme.colors[sentiment].backgroundHover};\n            color:\n            ${theme.colors[sentiment].textHover};\n            border: 1px solid ${\n              theme.colors[sentiment][\n                sentiment === 'neutral' ? 'borderStrongHover' : 'borderHover'\n              ]\n            };\n\n        }\n`};\n`\n\nconst StyledGhostButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: none;\n  border: none;\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].text};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n        color:\n          ${theme.colors[sentiment].textDisabled};\n      `\n      : `\n        &:hover, &:active\n        {\n            background: ${theme.colors[sentiment].backgroundHover};\n            color:\n              ${theme.colors[sentiment].textHover};\n        }\n`}\n`\n\nconst VARIANTS_COMPONENTS = {\n  filled: {\n    button: StyledFilledButton,\n    link: StyledFilledButton.withComponent('a'),\n  },\n  outlined: {\n    button: StyledOutlinedButton,\n    link: StyledOutlinedButton.withComponent('a'),\n  },\n  ghost: {\n    button: StyledGhostButton,\n    link: StyledGhostButton.withComponent('a'),\n  },\n}\ntype ButtonVariant = keyof typeof VARIANTS_COMPONENTS\nexport const buttonVariants = Object.keys(\n  VARIANTS_COMPONENTS,\n) as ButtonVariant[]\n\ntype CommonProps = {\n  type?: ButtonHTMLAttributes<HTMLButtonElement>['type']\n  autoFocus?: ButtonHTMLAttributes<HTMLButtonElement>['autoFocus']\n  variant?: ButtonVariant\n  role?: AriaRole\n  size?: ButtonSize\n  className?: string\n  'data-testid'?: string\n  sentiment?: SENTIMENT\n  disabled?: boolean\n  iconPosition?: 'left' | 'right'\n  iconVariant?: ComponentProps<typeof Icon>['variant']\n  fullWidth?: boolean\n  isLoading?: boolean\n  'aria-label'?: string\n  'aria-current'?: boolean\n  'aria-controls'?: string\n  'aria-expanded'?: boolean\n  'aria-haspopup'?: boolean\n  onClick?: MouseEventHandler<HTMLElement>\n  tooltip?: string\n  tabIndex?: ButtonHTMLAttributes<HTMLButtonElement>['tabIndex']\n  onMouseDown?: MouseEventHandler<HTMLElement>\n  onMouseUp?: MouseEventHandler<HTMLElement>\n  onMouseOut?: MouseEventHandler<HTMLElement>\n}\n\n// @note: using XOR utility was generating some lint erros\ntype FinalProps = CommonProps &\n  (\n    | {\n        // Button : Children + optional Icon\n        children: ReactNode\n        icon?: ComponentProps<typeof Icon>['name']\n        name?: string\n        href?: never\n        target?: never\n        download?: never\n      }\n    | {\n        // Button : Icon only\n        children?: never\n        icon: ComponentProps<typeof Icon>['name']\n        name?: string\n        href?: never\n        target?: never\n        download?: never\n      }\n    | {\n        // Anchor : Children + optional Icon\n        children: ReactNode\n        icon?: ComponentProps<typeof Icon>['name']\n        name?: never\n        href: string\n        target?: string\n        download?: string\n      }\n    | {\n        // Anchor : Children + Icon Only\n        children?: never\n        icon: ComponentProps<typeof Icon>['name']\n        name?: never\n        href: string\n        target?: string\n        download?: string\n      }\n  )\n\n/**\n * Button component is used to trigger an action or event, such as submitting a form, opening a dialog,\n * canceling an action, or performing a delete operation.\n */\nexport const Button = forwardRef<Element, FinalProps>(\n  (\n    {\n      type = 'button',\n      className,\n      'data-testid': dataTestId,\n      sentiment = 'primary',\n      variant = 'filled',\n      size = 'large',\n      disabled = false,\n      icon,\n      iconPosition = 'left',\n      iconVariant,\n      fullWidth = false,\n      isLoading = false,\n      children,\n      onClick,\n      onMouseDown,\n      onMouseUp,\n      onMouseOut,\n      name,\n      'aria-label': ariaLabel,\n      'aria-current': ariaCurrent,\n      'aria-controls': ariaControls,\n      'aria-expanded': ariaExpanded,\n      'aria-haspopup': ariaHaspopup,\n      href,\n      download,\n      target,\n      role,\n      tooltip,\n      tabIndex,\n      autoFocus,\n    },\n    ref,\n  ) => {\n    const computeIsDisabled = disabled || isLoading\n    const content = (\n      <>\n        {!isLoading && icon ? (\n          <Icon name={icon} size=\"small\" variant={iconVariant} />\n        ) : null}\n        {isLoading ? (\n          <Loader\n            active\n            trailColor=\"transparent\"\n            size=\"1em\"\n            color=\"currentColor\"\n          />\n        ) : null}\n        {children && typeof children !== 'string' ? (\n          <div>{children}</div>\n        ) : (\n          children\n        )}\n      </>\n    )\n\n    // @note: an anchor can't be disabled\n    if (href && !computeIsDisabled) {\n      const Component = VARIANTS_COMPONENTS[variant].link\n\n      return (\n        <Tooltip text={tooltip} containerFullWidth={fullWidth}>\n          <Component\n            role={role}\n            className={className}\n            data-testid={dataTestId}\n            disabled={false}\n            fullWidth={fullWidth}\n            iconPosition={iconPosition}\n            sentiment={sentiment}\n            size={size}\n            type={type}\n            onClick={onClick}\n            aria-label={ariaLabel}\n            aria-current={ariaCurrent}\n            aria-controls={ariaControls}\n            aria-expanded={ariaExpanded}\n            aria-haspopup={ariaHaspopup}\n            href={href}\n            target={target}\n            download={download}\n            ref={ref as Ref<HTMLAnchorElement>}\n            iconOnly={!!icon && !children}\n            tabIndex={tabIndex}\n            autoFocus={autoFocus}\n            onMouseDown={onMouseDown}\n            onMouseUp={onMouseUp}\n            onMouseOut={onMouseOut}\n          >\n            {content}\n          </Component>\n        </Tooltip>\n      )\n    }\n\n    const Component = VARIANTS_COMPONENTS[variant].button\n\n    return (\n      <Tooltip text={tooltip} containerFullWidth={fullWidth}>\n        <Component\n          role={role}\n          className={className}\n          data-testid={dataTestId}\n          disabled={computeIsDisabled}\n          fullWidth={fullWidth}\n          iconPosition={iconPosition}\n          sentiment={sentiment}\n          size={size}\n          type={type}\n          onClick={onClick}\n          ref={ref as Ref<HTMLButtonElement>}\n          name={name}\n          aria-label={ariaLabel}\n          aria-current={ariaCurrent}\n          aria-controls={ariaControls}\n          aria-expanded={ariaExpanded}\n          aria-haspopup={ariaHaspopup}\n          iconOnly={!!icon && !children}\n          tabIndex={tabIndex}\n          autoFocus={autoFocus}\n          onMouseDown={onMouseDown}\n          onMouseUp={onMouseUp}\n          onMouseOut={onMouseOut}\n        >\n          {content}\n        </Component>\n      </Tooltip>\n    )\n  },\n)\n"]} */"));
+const StyledGhostButton = /* @__PURE__ */ _styled("button", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["size", "sentiment", "iconPosition", "fullWidth", "iconOnly"].includes(prop),
+  target: "e112qvla0"
+} : {
+  shouldForwardProp: (prop) => !["size", "sentiment", "iconPosition", "fullWidth", "iconOnly"].includes(prop),
+  target: "e112qvla0",
+  label: "StyledGhostButton"
+})((args) => coreStyle(args), " background:none;border:none;color:", ({
+  theme,
+  sentiment
+}) => theme.colors[sentiment].text, ";", ({
+  theme,
+  sentiment,
+  disabled
+}) => disabled ? `
+        color:
+          ${theme.colors[sentiment].textDisabled};
+      ` : `
+        &:hover, &:active
+        {
+            background: ${theme.colors[sentiment].backgroundHover};
+            color:
+              ${theme.colors[sentiment].textHover};
+        }
+`, ";" + (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/Button/index.tsx"],"names":[],"mappings":"AAuMqB","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Button/index.tsx","sourcesContent":["import type { Theme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  AriaRole,\n  ButtonHTMLAttributes,\n  ComponentProps,\n  MouseEventHandler,\n  ReactNode,\n  Ref,\n} from 'react'\nimport { forwardRef } from 'react'\nimport type { SENTIMENTS } from '../../theme'\nimport { Loader } from '../Loader'\nimport { Tooltip } from '../Tooltip'\n\ntype SENTIMENT = (typeof SENTIMENTS)[number]\n\n// SIZE\nexport const SIZE_HEIGHT = {\n  large: 48,\n  medium: 40,\n  small: 32,\n  xsmall: 24,\n} as const\ntype ButtonSize = keyof typeof SIZE_HEIGHT\nconst SIZE_PADDING_KEY = {\n  large: 2,\n  medium: 1.5,\n  small: 1,\n  xsmall: 0.5,\n} as const\nconst SIZE_GAP_KEY = {\n  large: 1,\n  medium: 1,\n  small: 1,\n  xsmall: 0.5,\n} as const\nexport const buttonSizes = Object.keys(SIZE_HEIGHT) as ButtonSize[]\n\n// FOCUS RING\nconst FOCUS_RING_KEY = {\n  danger: 'focusDanger',\n  info: 'focusInfo',\n  neutral: 'focusNeutral',\n  primary: 'focusPrimary',\n  // @note: no focusSecondary so far, it will be added later, so far focusPrimary sounds fine\n  secondary: 'focusPrimary',\n  success: 'focusSuccess',\n  warning: 'focusWarning',\n} as const\n\n// VARIANTS\ntype StyledButtonProps = Required<\n  Pick<\n    FinalProps,\n    'size' | 'sentiment' | 'disabled' | 'iconPosition' | 'fullWidth'\n  >\n> & { iconOnly: boolean }\nconst coreStyle = ({\n  theme,\n  size,\n  sentiment,\n  iconPosition,\n  fullWidth,\n  disabled,\n  iconOnly,\n}: { theme: Theme } & StyledButtonProps) => {\n  const font =\n    size === 'large'\n      ? theme.typography.bodyStrong\n      : theme.typography.bodySmallStrong\n\n  let width = 'auto'\n  if (fullWidth) {\n    width = '100%'\n  } else if (iconOnly) {\n    width = `${SIZE_HEIGHT[size]}px`\n  }\n\n  return `display: inline-flex;\n  height: ${SIZE_HEIGHT[size]}px;\n  padding: 0 ${theme.space[SIZE_PADDING_KEY[size]]};\n  flex-direction: ${iconPosition === 'right' ? 'row-reverse' : 'row'};\n  gap: ${theme.space[SIZE_GAP_KEY[size]]};\n  border-radius: ${theme.radii.default};\n  box-sizing: border-box;\n  width: ${width};\n  align-items: center;\n  cursor: ${disabled ? 'not-allowed' : 'pointer'};\n  justify-content: center;\n  outline-offset: 2px;\n  white-space: nowrap;\n  text-decoration: none;\n  &:hover {\n    text-decoration: none;\n  }\n\n\n  ${\n    disabled\n      ? ''\n      : `\n          &:active {\n            box-shadow: ${theme.shadows[FOCUS_RING_KEY[sentiment]]};\n          }\n        `\n  }\n\n  /* We can't use Text component because of button hover effect, so we need to duplicate */\n  font-size: ${font.fontSize};\n  font-family: ${font.fontFamily};\n  font-weight: ${font.weight};\n  letter-spacing: ${font.letterSpacing};\n  line-height: ${font.lineHeight};\n  paragraph-spacing: ${font.paragraphSpacing};\n  text-case: ${font.textCase};\n`\n}\n\nconst StyledFilledButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: ${({ theme, sentiment }) =>\n    theme.colors[sentiment].backgroundStrong};\n  border: none;\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].textStrong};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n            background: ${theme.colors[sentiment].backgroundStrongDisabled};\n            color:\n              ${theme.colors[sentiment].textStrongDisabled};\n        `\n      : `\n            &:hover, &:active\n            {\n                background: ${theme.colors[sentiment].backgroundStrongHover};\n                color:\n                ${theme.colors[sentiment].textStrongHover};\n            }\n  `}\n`\n\nconst StyledOutlinedButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: none;\n  border: 1px solid\n    ${({ theme, sentiment }) =>\n      theme.colors[sentiment][\n        sentiment === 'neutral' ? 'borderStrong' : 'border'\n      ]};\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].text};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n        color:\n          ${theme.colors[sentiment].textDisabled};\n        border: 1px solid ${\n          theme.colors[sentiment][\n            sentiment === 'neutral' ? 'borderStrongDisabled' : 'borderDisabled'\n          ]\n        };\n\n    `\n      : `\n        &:hover, &:active\n       {\n            background: ${theme.colors[sentiment].backgroundHover};\n            color:\n            ${theme.colors[sentiment].textHover};\n            border: 1px solid ${\n              theme.colors[sentiment][\n                sentiment === 'neutral' ? 'borderStrongHover' : 'borderHover'\n              ]\n            };\n\n        }\n`};\n`\n\nconst StyledGhostButton = styled('button', {\n  shouldForwardProp: prop =>\n    !['size', 'sentiment', 'iconPosition', 'fullWidth', 'iconOnly'].includes(\n      prop,\n    ),\n})<StyledButtonProps>`\n  ${args => coreStyle(args)}\n\n  background: none;\n  border: none;\n  color: ${({ theme, sentiment }) => theme.colors[sentiment].text};\n\n  ${({ theme, sentiment, disabled }) =>\n    disabled\n      ? `\n        color:\n          ${theme.colors[sentiment].textDisabled};\n      `\n      : `\n        &:hover, &:active\n        {\n            background: ${theme.colors[sentiment].backgroundHover};\n            color:\n              ${theme.colors[sentiment].textHover};\n        }\n`}\n`\n\nconst VARIANTS_COMPONENTS = {\n  filled: {\n    button: StyledFilledButton,\n    link: StyledFilledButton.withComponent('a'),\n  },\n  outlined: {\n    button: StyledOutlinedButton,\n    link: StyledOutlinedButton.withComponent('a'),\n  },\n  ghost: {\n    button: StyledGhostButton,\n    link: StyledGhostButton.withComponent('a'),\n  },\n}\ntype ButtonVariant = keyof typeof VARIANTS_COMPONENTS\nexport const buttonVariants = Object.keys(\n  VARIANTS_COMPONENTS,\n) as ButtonVariant[]\n\ntype CommonProps = {\n  type?: ButtonHTMLAttributes<HTMLButtonElement>['type']\n  autoFocus?: ButtonHTMLAttributes<HTMLButtonElement>['autoFocus']\n  variant?: ButtonVariant\n  role?: AriaRole\n  size?: ButtonSize\n  className?: string\n  'data-testid'?: string\n  sentiment?: SENTIMENT\n  disabled?: boolean\n  iconPosition?: 'left' | 'right'\n  iconVariant?: ComponentProps<typeof Icon>['variant']\n  fullWidth?: boolean\n  isLoading?: boolean\n  'aria-label'?: string\n  'aria-current'?: boolean\n  'aria-controls'?: string\n  'aria-expanded'?: boolean\n  'aria-haspopup'?: boolean\n  onClick?: MouseEventHandler<HTMLElement>\n  tooltip?: string\n  tabIndex?: ButtonHTMLAttributes<HTMLButtonElement>['tabIndex']\n  onMouseDown?: MouseEventHandler<HTMLElement>\n  onMouseUp?: MouseEventHandler<HTMLElement>\n  onMouseOut?: MouseEventHandler<HTMLElement>\n}\n\n// @note: using XOR utility was generating some lint erros\ntype FinalProps = CommonProps &\n  (\n    | {\n        // Button : Children + optional Icon\n        children: ReactNode\n        icon?: ComponentProps<typeof Icon>['name']\n        name?: string\n        href?: never\n        target?: never\n        download?: never\n      }\n    | {\n        // Button : Icon only\n        children?: never\n        icon: ComponentProps<typeof Icon>['name']\n        name?: string\n        href?: never\n        target?: never\n        download?: never\n      }\n    | {\n        // Anchor : Children + optional Icon\n        children: ReactNode\n        icon?: ComponentProps<typeof Icon>['name']\n        name?: never\n        href: string\n        target?: string\n        download?: string\n      }\n    | {\n        // Anchor : Children + Icon Only\n        children?: never\n        icon: ComponentProps<typeof Icon>['name']\n        name?: never\n        href: string\n        target?: string\n        download?: string\n      }\n  )\n\n/**\n * Button component is used to trigger an action or event, such as submitting a form, opening a dialog,\n * canceling an action, or performing a delete operation.\n */\nexport const Button = forwardRef<Element, FinalProps>(\n  (\n    {\n      type = 'button',\n      className,\n      'data-testid': dataTestId,\n      sentiment = 'primary',\n      variant = 'filled',\n      size = 'large',\n      disabled = false,\n      icon,\n      iconPosition = 'left',\n      iconVariant,\n      fullWidth = false,\n      isLoading = false,\n      children,\n      onClick,\n      onMouseDown,\n      onMouseUp,\n      onMouseOut,\n      name,\n      'aria-label': ariaLabel,\n      'aria-current': ariaCurrent,\n      'aria-controls': ariaControls,\n      'aria-expanded': ariaExpanded,\n      'aria-haspopup': ariaHaspopup,\n      href,\n      download,\n      target,\n      role,\n      tooltip,\n      tabIndex,\n      autoFocus,\n    },\n    ref,\n  ) => {\n    const computeIsDisabled = disabled || isLoading\n    const content = (\n      <>\n        {!isLoading && icon ? (\n          <Icon name={icon} size=\"small\" variant={iconVariant} />\n        ) : null}\n        {isLoading ? (\n          <Loader\n            active\n            trailColor=\"transparent\"\n            size=\"1em\"\n            color=\"currentColor\"\n          />\n        ) : null}\n        {children && typeof children !== 'string' ? (\n          <div>{children}</div>\n        ) : (\n          children\n        )}\n      </>\n    )\n\n    // @note: an anchor can't be disabled\n    if (href && !computeIsDisabled) {\n      const Component = VARIANTS_COMPONENTS[variant].link\n\n      return (\n        <Tooltip text={tooltip} containerFullWidth={fullWidth}>\n          <Component\n            role={role}\n            className={className}\n            data-testid={dataTestId}\n            disabled={false}\n            fullWidth={fullWidth}\n            iconPosition={iconPosition}\n            sentiment={sentiment}\n            size={size}\n            type={type}\n            onClick={onClick}\n            aria-label={ariaLabel}\n            aria-current={ariaCurrent}\n            aria-controls={ariaControls}\n            aria-expanded={ariaExpanded}\n            aria-haspopup={ariaHaspopup}\n            href={href}\n            target={target}\n            download={download}\n            ref={ref as Ref<HTMLAnchorElement>}\n            iconOnly={!!icon && !children}\n            tabIndex={tabIndex}\n            autoFocus={autoFocus}\n            onMouseDown={onMouseDown}\n            onMouseUp={onMouseUp}\n            onMouseOut={onMouseOut}\n          >\n            {content}\n          </Component>\n        </Tooltip>\n      )\n    }\n\n    const Component = VARIANTS_COMPONENTS[variant].button\n\n    return (\n      <Tooltip text={tooltip} containerFullWidth={fullWidth}>\n        <Component\n          role={role}\n          className={className}\n          data-testid={dataTestId}\n          disabled={computeIsDisabled}\n          fullWidth={fullWidth}\n          iconPosition={iconPosition}\n          sentiment={sentiment}\n          size={size}\n          type={type}\n          onClick={onClick}\n          ref={ref as Ref<HTMLButtonElement>}\n          name={name}\n          aria-label={ariaLabel}\n          aria-current={ariaCurrent}\n          aria-controls={ariaControls}\n          aria-expanded={ariaExpanded}\n          aria-haspopup={ariaHaspopup}\n          iconOnly={!!icon && !children}\n          tabIndex={tabIndex}\n          autoFocus={autoFocus}\n          onMouseDown={onMouseDown}\n          onMouseUp={onMouseUp}\n          onMouseOut={onMouseOut}\n        >\n          {content}\n        </Component>\n      </Tooltip>\n    )\n  },\n)\n"]} */"));
+const VARIANTS_COMPONENTS = {
+  filled: {
+    button: StyledFilledButton,
+    link: StyledFilledButton.withComponent("a", process.env.NODE_ENV === "production" ? {
+      target: "e112qvla3"
+    } : {
+      target: "e112qvla3",
+      label: "link"
+    })
+  },
+  outlined: {
+    button: StyledOutlinedButton,
+    link: StyledOutlinedButton.withComponent("a", process.env.NODE_ENV === "production" ? {
+      target: "e112qvla4"
+    } : {
+      target: "e112qvla4",
+      label: "link"
+    })
+  },
+  ghost: {
+    button: StyledGhostButton,
+    link: StyledGhostButton.withComponent("a", process.env.NODE_ENV === "production" ? {
+      target: "e112qvla5"
+    } : {
+      target: "e112qvla5",
+      label: "link"
+    })
+  }
+};
+const Button = forwardRef(({
+  type = "button",
+  className,
+  "data-testid": dataTestId,
+  sentiment = "primary",
+  variant = "filled",
+  size = "large",
+  disabled = false,
+  icon,
+  iconPosition = "left",
+  iconVariant,
+  fullWidth = false,
+  isLoading = false,
+  children,
+  onClick,
+  onMouseDown,
+  onMouseUp,
+  onMouseOut,
+  name,
+  "aria-label": ariaLabel,
+  "aria-current": ariaCurrent,
+  "aria-controls": ariaControls,
+  "aria-expanded": ariaExpanded,
+  "aria-haspopup": ariaHaspopup,
+  href,
+  download,
+  target,
+  role,
+  tooltip,
+  tabIndex,
+  autoFocus
+}, ref) => {
+  const computeIsDisabled = disabled || isLoading;
+  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
+    !isLoading && icon ? /* @__PURE__ */ jsx(Icon, { name: icon, size: "small", variant: iconVariant }) : null,
+    isLoading ? /* @__PURE__ */ jsx(Loader, { active: true, trailColor: "transparent", size: "1em", color: "currentColor" }) : null,
+    children && typeof children !== "string" ? /* @__PURE__ */ jsx("div", { children }) : children
+  ] });
+  if (href && !computeIsDisabled) {
+    const Component2 = VARIANTS_COMPONENTS[variant].link;
+    return /* @__PURE__ */ jsx(Tooltip, { text: tooltip, containerFullWidth: fullWidth, children: /* @__PURE__ */ jsx(Component2, { role, className, "data-testid": dataTestId, disabled: false, fullWidth, iconPosition, sentiment, size, type, onClick, "aria-label": ariaLabel, "aria-current": ariaCurrent, "aria-controls": ariaControls, "aria-expanded": ariaExpanded, "aria-haspopup": ariaHaspopup, href, target, download, ref, iconOnly: !!icon && !children, tabIndex, autoFocus, onMouseDown, onMouseUp, onMouseOut, children: content }) });
+  }
+  const Component = VARIANTS_COMPONENTS[variant].button;
+  return /* @__PURE__ */ jsx(Tooltip, { text: tooltip, containerFullWidth: fullWidth, children: /* @__PURE__ */ jsx(Component, { role, className, "data-testid": dataTestId, disabled: computeIsDisabled, fullWidth, iconPosition, sentiment, size, type, onClick, ref, name, "aria-label": ariaLabel, "aria-current": ariaCurrent, "aria-controls": ariaControls, "aria-expanded": ariaExpanded, "aria-haspopup": ariaHaspopup, iconOnly: !!icon && !children, tabIndex, autoFocus, onMouseDown, onMouseUp, onMouseOut, children: content }) });
+});
+export {
+  Button,
+  SIZE_HEIGHT
+};

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

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+type CardProps = {
+    children: ReactNode;
+    /**
+     * Header can be a string but also a component if you need more complex header.
+     */
+    header?: ReactNode;
+    /**
+     * isActive enable a primary style on Card component for when you need to highlight it.
+     */
+    isActive?: boolean;
+    disabled?: boolean;
+    className?: string;
+    'data-testid'?: string;
+};
+/**
+ * Card component is a simple component to display content in a box with a border.
+ */
+export declare const Card: import("react").ForwardRefExoticComponent<CardProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/Card/index.js

@@ -0,0 +1,52 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { forwardRef } from "react";
+import { Stack } from "../Stack/index.js";
+import { Text } from "../Text/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 StyledStack = /* @__PURE__ */ _styled(Stack, process.env.NODE_ENV === "production" ? {
+  target: "exwxj841"
+} : {
+  target: "exwxj841",
+  label: "StyledStack"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1b3njxj",
+  styles: "&[data-disabled='true']{cursor:not-allowed;}"
+} : {
+  name: "1b3njxj",
+  styles: "&[data-disabled='true']{cursor:not-allowed;}",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const BorderedBox = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "exwxj840"
+} : {
+  target: "exwxj840",
+  label: "BorderedBox"
+})("border:1px solid ", ({
+  theme
+}) => theme.colors.neutral.border, ";border-radius:", ({
+  theme
+}) => theme.radii.default, ";padding:", ({
+  theme
+}) => theme.space["3"], ";&[data-is-active='true']{border:1px solid ", ({
+  theme
+}) => theme.colors.primary.border, ";}&[data-disabled='true']{border:1px solid ", ({
+  theme
+}) => theme.colors.neutral.borderDisabled, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const Card = forwardRef(({
+  header,
+  disabled = false,
+  isActive = false,
+  children,
+  className,
+  "data-testid": dataTestId
+}, ref) => header ? /* @__PURE__ */ jsxs(StyledStack, { gap: 1, className, "data-testid": dataTestId, "data-disabled": disabled, ref, children: [
+  typeof header === "string" ? /* @__PURE__ */ jsx(Text, { variant: "heading", as: "h2", disabled, children: header }) : header,
+  /* @__PURE__ */ jsx(BorderedBox, { "data-is-active": isActive, "data-disabled": disabled, children })
+] }) : /* @__PURE__ */ jsx(BorderedBox, { "data-is-active": isActive, "data-disabled": disabled, className, "data-testid": dataTestId, ref, children }));
+export {
+  Card
+};

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

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+type CarouselItemProps = {
+    children: ReactNode;
+    width?: string;
+};
+export declare const CarouselItem: ({ children, width, }: CarouselItemProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+type CarouselProps = {
+    className?: string;
+    children?: ReactNode;
+    'data-testid'?: string;
+};
+/**
+ * Carousel component allows you to scroll horizontally through a list of items.
+ */
+export declare const Carousel: {
+    ({ children, className, "data-testid": dataTestId, }: CarouselProps): import("@emotion/react/jsx-runtime").JSX.Element;
+    Item: ({ children, width, }: CarouselItemProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+};
+export {};