# Input Group

Add addons, buttons, and helper content to inputs.

Source: https://webjs.dev/ui/docs/components/input-group

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupInputClass,
} from '#components/ui/input-group.ts';
import { SearchIcon } from '#lib/ui/lucide.ts';

export default function InputGroupDemo() {
  return html`
    <div data-slot="input-group" role="group" class=${cn(inputGroupClass(), 'max-w-xs')}>
      <input data-slot="input-group-control" id="input-group-demo" type="text" placeholder="Search..." aria-label="Search" class=${inputGroupInputClass()}>
      <label data-slot="input-group-addon" data-align="inline-start" for="input-group-demo" class=${inputGroupAddonClass()}>
        ${SearchIcon()}
      </label>
      <label data-slot="input-group-addon" data-align="inline-end" for="input-group-demo" class=${inputGroupAddonClass({ align: 'inline-end' })}>12 results</label>
    </div>
  `;
}
```

## Installation

```bash
npx @webjsdev/ui add input-group
```

### Copy and paste the following code into your project.

````ts title="components/ui/input-group.ts"
/**
 * Input group: an input or textarea with addons inside its border (an icon, a
 * prefix such as "https://", a button, a counter), sharing one focus ring.
 * Tier-1 class helper; compose with a real `<input>` or `<textarea>`.
 *
 * shadcn parity:
 *   InputGroup                 → inputGroupClass()
 *   InputGroupAddon (align: inline-start | inline-end | block-start | block-end)
 *                              → inputGroupAddonClass({ align }), alias inputGroupAddonVariants,
 *                                plus the same `data-align` on the addon (the styles pad the
 *                                control beside it by it)
 *   InputGroupButton (size)    → inputGroupButtonClass({ size }) with buttonClass({ variant })
 *   InputGroupText             → inputGroupTextClass()
 *   InputGroupInput / InputGroupTextarea
 *                              → inputGroupInputClass() / inputGroupTextareaClass()
 *
 * The group draws the border and the focus ring, so the control inside drops
 * its own. Clicking an addon focuses the control through a `<label for>`, with
 * no script: make the addon a `<label>` pointing at the control's id.
 *
 * A11y (required for accessible output): the control still needs its own
 * accessible name, from a visible `<label for>` outside the group or an
 * `aria-label` on the control; an addon's text is not its name. A decorative
 * icon addon takes `aria-hidden="true"`. An addon button is a real
 * `<button type="button">` with its own name.
 *
 * Design tokens used: --input, --ring, --muted-foreground, --destructive.
 *
 * @example
 * ```html
 * <div class=${inputGroupClass()} data-slot="input-group" role="group">
 *   <label class=${inputGroupAddonClass()} data-slot="input-group-addon" data-align="inline-start" for="site">https://</label>
 *   <input class=${inputGroupInputClass()} data-slot="input-group-control" id="site" name="site" aria-label="Website">
 * </div>
 * ```
 */
import { cn } from '../lib/utils.ts';
import { inputClass } from './input.ts';
import { textareaClass } from './textarea.ts';
import { buttonClass, type ButtonVariant } from './button.ts';

/** Set `data-slot="input-group"` on the element. */
export function inputGroupClass(): string {
  return 'rounded-md border border-input shadow-xs transition-[color,box-shadow] dark:bg-input/30 has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-end]]:[&>input]:pt-3 group/input-group relative flex w-full min-w-0 items-center outline-none has-[>textarea]:h-auto';
}

const INPUT_GROUP_ADDON_BASE =
  "h-auto gap-2 py-1.5 text-sm font-medium text-muted-foreground group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4 flex cursor-text items-center justify-center select-none";

const INPUT_GROUP_ADDON_ALIGNS = {
  'inline-start': 'ps-3 has-[>button]:ms-[-0.45rem] has-[>kbd]:ms-[-0.35rem] order-first',
  'inline-end': 'pe-3 has-[>button]:me-[-0.45rem] has-[>kbd]:me-[-0.35rem] order-last',
  'block-start': 'px-3 pt-3 group-has-[>input]/input-group:pt-2.5 [.border-b]:pb-3 order-first w-full justify-start',
  'block-end': 'px-3 pb-3 group-has-[>input]/input-group:pb-2.5 [.border-t]:pt-3 order-last w-full justify-start',
} as const;

/** The part, with its variant options. Set its `data-slot` and any `data-variant` / `data-size` to match. */
export function inputGroupAddonClass(opts: { align?: keyof typeof INPUT_GROUP_ADDON_ALIGNS } & { className?: string } = {}): string {
  return cn(INPUT_GROUP_ADDON_BASE, INPUT_GROUP_ADDON_ALIGNS[opts.align ?? 'inline-start'], opts.className);
}

/**
 * shadcn's name for {@link inputGroupAddonClass}, so shadcn code ports verbatim. Like cva,
 * it merges a `className` into the result.
 */
export function inputGroupAddonVariants(opts: { align?: keyof typeof INPUT_GROUP_ADDON_ALIGNS } & { className?: string } = {}): string {
  return inputGroupAddonClass(opts);
}

const INPUT_GROUP_BUTTON_BASE =
  'gap-2 text-sm flex items-center shadow-none';

const INPUT_GROUP_BUTTON_SIZES = {
  xs: "h-6 gap-1 rounded-[calc(var(--radius)-5px)] px-2 has-[>svg]:px-2 [&>svg:not([class*='size-'])]:size-3.5",
  sm: 'h-8 gap-1.5 rounded-md px-2.5 has-[>svg]:px-2.5',
  'icon-xs': 'size-6 rounded-[calc(var(--radius)-5px)] p-0 has-[>svg]:p-0',
  'icon-sm': 'size-8 p-0 has-[>svg]:p-0',
} as const;

/**
 * The part, with its variant options. Set its `data-slot` and any `data-variant` / `data-size` to match.
 *
 * shadcn's InputGroupButton IS its Button (`variant` defaulting to ghost)
 * with these classes on top, so the button's own classes come first and the
 * group's size wins a conflict.
 */
export function inputGroupButtonClass(opts: { size?: keyof typeof INPUT_GROUP_BUTTON_SIZES; variant?: ButtonVariant } & { className?: string } = {}): string {
  return cn(buttonClass({ variant: opts.variant ?? 'ghost' }), INPUT_GROUP_BUTTON_BASE, INPUT_GROUP_BUTTON_SIZES[opts.size ?? 'xs'], opts.className);
}

/**
 * shadcn's name for {@link inputGroupButtonClass}, so shadcn code ports verbatim. Like cva,
 * it merges a `className` into the result.
 */
export function inputGroupButtonVariants(opts: { size?: keyof typeof INPUT_GROUP_BUTTON_SIZES; variant?: ButtonVariant } & { className?: string } = {}): string {
  return inputGroupButtonClass(opts);
}

/** A part with no `data-slot` of its own. */
export function inputGroupTextClass(): string {
  return "gap-2 text-sm text-muted-foreground [&_svg:not([class*='size-'])]:size-4 flex items-center [&_svg]:pointer-events-none";
}

/**
 * Set `data-slot="input-group-control"` on the element. shadcn's
 * InputGroupInput is its Input with these classes on top, so the input's own
 * base (its `outline-none` and focus treatment included) comes first and the
 * group's resets win a conflict. Without it a focused control shows the
 * browser's own outline inside the group's ring.
 */
export function inputGroupInputClass(): string {
  return cn(inputClass(), 'rounded-none border-0 bg-transparent shadow-none focus-visible:ring-0 dark:bg-transparent flex-1');
}

/** Set `data-slot="input-group-control"` on the element. The Textarea's classes, then the group's, as shadcn composes it. */
export function inputGroupTextareaClass(): string {
  return cn(textareaClass(), 'rounded-none border-0 bg-transparent py-3 shadow-none focus-visible:ring-0 dark:bg-transparent flex-1 resize-none');
}
````

### Update the import paths to match your project setup.

## Usage

```ts
import {
  inputGroupClass,
  inputGroupAddonClass,
  inputGroupButtonClass,
  inputGroupInputClass,
  inputGroupTextClass,
  inputGroupTextareaClass,
} from '#components/ui/input-group.ts';
```

```ts
<div data-slot="input-group" role="group" class=${inputGroupClass()}>
  <input data-slot="input-group-control" id="search" placeholder="Search..." aria-label="Search" class=${inputGroupInputClass()}>
  <label data-slot="input-group-addon" data-align="inline-start" for="search" class=${inputGroupAddonClass()}>
    <svg aria-hidden="true"><!-- search icon --></svg>
  </label>
</div>
```

## Composition

Use the following composition to build an input group:

```text
inputGroupClass()
├── inputGroupInputClass() or inputGroupTextareaClass()
├── inputGroupAddonClass()
├── inputGroupButtonClass()
└── inputGroupTextClass()
```

## Align

Use the `align` option of `inputGroupAddonClass()`, with a matching `data-align` attribute, to position the addon relative to the input.

For proper focus management, the addon should always be placed after the input or textarea in the DOM. Use the `align` option to visually position the addon.

### inline-start

Use `align: 'inline-start'` to position the addon at the start of the input. This is the default.

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import { fieldClass, fieldLabelClass, fieldDescriptionClass } from '#components/ui/field.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupInputClass,
} from '#components/ui/input-group.ts';
import { SearchIcon } from '#lib/ui/lucide.ts';

export default function InputGroupInlineStart() {
  return html`
    <div role="group" data-slot="field" data-orientation="vertical" class=${cn(fieldClass(), 'max-w-sm')}>
      <label data-slot="field-label" for="inline-start-input" class=${fieldLabelClass()}>Input</label>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="inline-start-input" placeholder="Search..." class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="inline-start-input" class=${inputGroupAddonClass({ align: 'inline-start' })}>
          ${SearchIcon('text-muted-foreground')}
        </label>
      </div>
      <p data-slot="field-description" class=${fieldDescriptionClass()}>Icon positioned at the start.</p>
    </div>
  `;
}
```

### inline-end

Use `align: 'inline-end'` to position the addon at the end of the input.

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import { fieldClass, fieldLabelClass, fieldDescriptionClass } from '#components/ui/field.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupInputClass,
} from '#components/ui/input-group.ts';
import { EyeOffIcon } from '#lib/ui/lucide.ts';

export default function InputGroupInlineEnd() {
  return html`
    <div role="group" data-slot="field" data-orientation="vertical" class=${cn(fieldClass(), 'max-w-sm')}>
      <label data-slot="field-label" for="inline-end-input" class=${fieldLabelClass()}>Input</label>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="inline-end-input" type="password" placeholder="Enter password" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="inline-end-input" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          ${EyeOffIcon()}
        </label>
      </div>
      <p data-slot="field-description" class=${fieldDescriptionClass()}>Icon positioned at the end.</p>
    </div>
  `;
}
```

### block-start

Use `align: 'block-start'` to position the addon above the input.

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  fieldGroupClass, fieldClass, fieldLabelClass, fieldDescriptionClass,
} from '#components/ui/field.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupButtonClass, inputGroupInputClass,
  inputGroupTextClass, inputGroupTextareaClass,
} from '#components/ui/input-group.ts';
import { CopyIcon, FileCodeIcon } from '#lib/ui/lucide.ts';

export default function InputGroupBlockStart() {
  return html`
    <div data-slot="field-group" class=${cn(fieldGroupClass(), 'max-w-sm')}>
      <div role="group" data-slot="field" data-orientation="vertical" class=${fieldClass()}>
        <label data-slot="field-label" for="block-start-input" class=${fieldLabelClass()}>Input</label>
        <div data-slot="input-group" role="group" class=${cn(inputGroupClass(), 'h-auto')}>
          <input data-slot="input-group-control" id="block-start-input" placeholder="Enter your name" class=${inputGroupInputClass()}>
          <label data-slot="input-group-addon" data-align="block-start" for="block-start-input" class=${inputGroupAddonClass({ align: 'block-start' })}>
            <span class=${inputGroupTextClass()}>Full Name</span>
          </label>
        </div>
        <p data-slot="field-description" class=${fieldDescriptionClass()}>Header positioned above the input.</p>
      </div>
      <div role="group" data-slot="field" data-orientation="vertical" class=${fieldClass()}>
        <label data-slot="field-label" for="block-start-textarea" class=${fieldLabelClass()}>Textarea</label>
        <div data-slot="input-group" role="group" class=${inputGroupClass()}>
          <textarea data-slot="input-group-control" id="block-start-textarea" placeholder="console.log('Hello, world!');" class=${cn(inputGroupTextareaClass(), 'font-mono text-sm')}></textarea>
          <div role="group" data-slot="input-group-addon" data-align="block-start" class=${inputGroupAddonClass({ align: 'block-start' })}>
            ${FileCodeIcon('text-muted-foreground')}
            <span class=${cn(inputGroupTextClass(), 'font-mono')}>script.js</span>
            <button type="button" data-slot="button" data-variant="ghost" data-size="icon-xs" class=${cn(inputGroupButtonClass({ size: 'icon-xs' }), 'ml-auto')}>
              ${CopyIcon()}
              <span class="sr-only">Copy</span>
            </button>
          </div>
        </div>
        <p data-slot="field-description" class=${fieldDescriptionClass()}>
          Header positioned above the textarea.
        </p>
      </div>
    </div>
  `;
}
```

### block-end

Use `align: 'block-end'` to position the addon below the input.

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  fieldGroupClass, fieldClass, fieldLabelClass, fieldDescriptionClass,
} from '#components/ui/field.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupButtonClass, inputGroupInputClass,
  inputGroupTextClass, inputGroupTextareaClass,
} from '#components/ui/input-group.ts';

export default function InputGroupBlockEnd() {
  return html`
    <div data-slot="field-group" class=${cn(fieldGroupClass(), 'max-w-sm')}>
      <div role="group" data-slot="field" data-orientation="vertical" class=${fieldClass()}>
        <label data-slot="field-label" for="block-end-input" class=${fieldLabelClass()}>Input</label>
        <div data-slot="input-group" role="group" class=${cn(inputGroupClass(), 'h-auto')}>
          <input data-slot="input-group-control" id="block-end-input" placeholder="Enter amount" class=${inputGroupInputClass()}>
          <label data-slot="input-group-addon" data-align="block-end" for="block-end-input" class=${inputGroupAddonClass({ align: 'block-end' })}>
            <span class=${inputGroupTextClass()}>USD</span>
          </label>
        </div>
        <p data-slot="field-description" class=${fieldDescriptionClass()}>Footer positioned below the input.</p>
      </div>
      <div role="group" data-slot="field" data-orientation="vertical" class=${fieldClass()}>
        <label data-slot="field-label" for="block-end-textarea" class=${fieldLabelClass()}>Textarea</label>
        <div data-slot="input-group" role="group" class=${inputGroupClass()}>
          <textarea data-slot="input-group-control" id="block-end-textarea" placeholder="Write a comment..." class=${inputGroupTextareaClass()}></textarea>
          <div role="group" data-slot="input-group-addon" data-align="block-end" class=${inputGroupAddonClass({ align: 'block-end' })}>
            <span class=${inputGroupTextClass()}>0/280</span>
            <button type="button" data-slot="button" data-variant="default" data-size="sm" class=${cn(inputGroupButtonClass({ variant: 'default', size: 'sm' }), 'ml-auto')}>
              Post
            </button>
          </div>
        </div>
        <p data-slot="field-description" class=${fieldDescriptionClass()}>
          Footer positioned below the textarea.
        </p>
      </div>
    </div>
  `;
}
```

## Icon

```ts
import { html } from '@webjsdev/core';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupInputClass,
} from '#components/ui/input-group.ts';
import {
  CheckIcon, CreditCardIcon, InfoIcon, MailIcon, SearchIcon, StarIcon,
} from '#lib/ui/lucide.ts';

export default function InputGroupIcon() {
  return html`
    <div class="grid w-full max-w-sm gap-6">
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-icon-search" placeholder="Search..." aria-label="Search" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-icon-search" class=${inputGroupAddonClass()}>
          ${SearchIcon()}
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-icon-email" type="email" placeholder="Enter your email" aria-label="Email" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-icon-email" class=${inputGroupAddonClass()}>
          ${MailIcon()}
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-icon-card" placeholder="Card number" aria-label="Card number" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-icon-card" class=${inputGroupAddonClass()}>
          ${CreditCardIcon()}
        </label>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-icon-card" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          ${CheckIcon()}
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-icon-card-2" placeholder="Card number" aria-label="Card number" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-icon-card-2" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          ${StarIcon()}
          ${InfoIcon()}
        </label>
      </div>
    </div>
  `;
}
```

## Text

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupInputClass,
  inputGroupTextClass, inputGroupTextareaClass,
} from '#components/ui/input-group.ts';

export default function InputGroupTextExample() {
  return html`
    <div class="grid w-full max-w-sm gap-6">
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-text-price" class=${inputGroupAddonClass()}>
          <span class=${inputGroupTextClass()}>$</span>
        </label>
        <input data-slot="input-group-control" id="input-group-text-price" placeholder="0.00" aria-label="Price" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-text-price" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <span class=${inputGroupTextClass()}>USD</span>
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-text-url" class=${inputGroupAddonClass()}>
          <span class=${inputGroupTextClass()}>https://</span>
        </label>
        <input data-slot="input-group-control" id="input-group-text-url" placeholder="example.com" aria-label="Website" class=${cn(inputGroupInputClass(), 'pl-0.5!')}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-text-url" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <span class=${inputGroupTextClass()}>.com</span>
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-text-username" placeholder="Enter your username" aria-label="Username" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-text-username" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <span class=${inputGroupTextClass()}>@company.com</span>
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <textarea data-slot="input-group-control" id="input-group-text-message" placeholder="Enter your message" aria-label="Message" class=${inputGroupTextareaClass()}></textarea>
        <label data-slot="input-group-addon" data-align="block-end" for="input-group-text-message" class=${inputGroupAddonClass({ align: 'block-end' })}>
          <span class=${cn(inputGroupTextClass(), 'text-xs text-muted-foreground')}>
            120 characters left
          </span>
        </label>
      </div>
    </div>
  `;
}
```

## Button

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupButtonClass, inputGroupInputClass,
} from '#components/ui/input-group.ts';
import { popoverContentClass } from '#components/ui/popover.ts';
import { IconCopy, IconInfoCircle, IconStar } from '#lib/ui/tabler.ts';

// shadcn's demo copies the url and toggles the star with React state. Here
// the buttons are shown at rest; wire a click listener to give them work.
export default function InputGroupButtonExample() {
  const isFavorite = false;

  return html`
    <div class="grid w-full max-w-sm gap-6">
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" placeholder="https://x.com/shadcn" readonly aria-label="Profile link" class=${inputGroupInputClass()}>
        <div role="group" data-slot="input-group-addon" data-align="inline-end" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <button type="button" aria-label="Copy" title="Copy" data-slot="button" data-variant="ghost" data-size="icon-xs" class=${inputGroupButtonClass({ size: 'icon-xs' })}>
            ${IconCopy()}
          </button>
        </div>
      </div>
      <div data-slot="input-group" role="group" class=${cn(inputGroupClass(), '[--radius:9999px]')}>
        <div role="group" data-slot="input-group-addon" data-align="inline-start" class=${inputGroupAddonClass()}>
          <button type="button" popovertarget="input-group-button-info" aria-haspopup="dialog" aria-expanded="false" aria-label="Connection info" data-slot="button" data-variant="secondary" data-size="icon-xs" class=${inputGroupButtonClass({ variant: 'secondary', size: 'icon-xs' })}>
            ${IconInfoCircle()}
          </button>
        </div>
        <div id="input-group-button-info" popover role="dialog" aria-labelledby="input-group-button-info-title" data-slot="popover-content" data-side="bottom" data-align="start" class=${cn(popoverContentClass({ align: 'start' }), 'rounded-xl text-sm')}>
          <div class="flex flex-col gap-1">
            <p id="input-group-button-info-title" class="font-medium">Your connection is not secure.</p>
            <p>You should not enter any sensitive information on this site.</p>
          </div>
        </div>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-secure-19" class=${cn(inputGroupAddonClass(), 'pl-1.5 text-muted-foreground')}>
          https://
        </label>
        <input data-slot="input-group-control" id="input-secure-19" aria-label="Website" class=${inputGroupInputClass()}>
        <div role="group" data-slot="input-group-addon" data-align="inline-end" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <button type="button" aria-label="Favorite" aria-pressed="false" data-slot="button" data-variant="ghost" data-size="icon-xs" class=${inputGroupButtonClass({ size: 'icon-xs' })}>
            ${IconStar(isFavorite ? 'fill-blue-600 stroke-blue-600' : '')}
          </button>
        </div>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" placeholder="Type to search..." aria-label="Search" class=${inputGroupInputClass()}>
        <div role="group" data-slot="input-group-addon" data-align="inline-end" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <button type="button" data-slot="button" data-variant="secondary" data-size="xs" class=${inputGroupButtonClass({ variant: 'secondary' })}>Search</button>
        </div>
      </div>
    </div>
  `;
}
```

## Kbd

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupInputClass,
} from '#components/ui/input-group.ts';
import { kbdClass } from '#components/ui/kbd.ts';
import { SearchIcon } from '#lib/ui/lucide.ts';

export default function InputGroupKbd() {
  return html`
    <div data-slot="input-group" role="group" class=${cn(inputGroupClass(), 'max-w-sm')}>
      <input data-slot="input-group-control" id="input-group-kbd" placeholder="Search..." aria-label="Search" class=${inputGroupInputClass()}>
      <label data-slot="input-group-addon" data-align="inline-start" for="input-group-kbd" class=${inputGroupAddonClass()}>
        ${SearchIcon('text-muted-foreground')}
      </label>
      <label data-slot="input-group-addon" data-align="inline-end" for="input-group-kbd" class=${inputGroupAddonClass({ align: 'inline-end' })}>
        <kbd data-slot="kbd" class=${kbdClass()}><span aria-hidden="true">⌘K</span><span class="sr-only">Command K</span></kbd>
      </label>
    </div>
  `;
}
```

## Dropdown

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupButtonClass, inputGroupInputClass,
} from '#components/ui/input-group.ts';
import { ChevronDownIcon, MoreHorizontal } from '#lib/ui/lucide.ts';

// Each trigger stays a direct child of its addon (the addon's spacing rules
// select a direct button child), so the menu names it with trigger="<id>".
export default function InputGroupDropdown() {
  return html`
    <div class="grid w-full max-w-sm gap-4">
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" placeholder="Enter file name" aria-label="File name" class=${inputGroupInputClass()}>
        <div role="group" data-slot="input-group-addon" data-align="inline-end" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <button type="button" id="input-group-dropdown-more" aria-label="More" data-slot="button" data-variant="ghost" data-size="icon-xs" class=${inputGroupButtonClass({ variant: 'ghost', size: 'icon-xs' })}>
            ${MoreHorizontal()}
          </button>
        </div>
      </div>
      <ui-dropdown-menu trigger="input-group-dropdown-more" class="absolute">
        <ui-dropdown-menu-content align="end">
          <ui-dropdown-menu-group>
            <ui-dropdown-menu-item>Settings</ui-dropdown-menu-item>
            <ui-dropdown-menu-item>Copy path</ui-dropdown-menu-item>
            <ui-dropdown-menu-item>Open location</ui-dropdown-menu-item>
          </ui-dropdown-menu-group>
        </ui-dropdown-menu-content>
      </ui-dropdown-menu>
      <div data-slot="input-group" role="group" class=${cn(inputGroupClass(), '[--radius:1rem]')}>
        <input data-slot="input-group-control" placeholder="Enter search query" aria-label="Search query" class=${inputGroupInputClass()}>
        <div role="group" data-slot="input-group-addon" data-align="inline-end" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <button type="button" id="input-group-dropdown-scope" data-slot="button" data-variant="ghost" data-size="xs" class=${cn(inputGroupButtonClass({ variant: 'ghost' }), 'pr-1.5! text-xs')}>
            Search In... ${ChevronDownIcon('size-3')}
          </button>
        </div>
      </div>
      <ui-dropdown-menu trigger="input-group-dropdown-scope" class="absolute">
        <ui-dropdown-menu-content align="end" class="[--radius:0.95rem]">
          <ui-dropdown-menu-group>
            <ui-dropdown-menu-item>Documentation</ui-dropdown-menu-item>
            <ui-dropdown-menu-item>Blog Posts</ui-dropdown-menu-item>
            <ui-dropdown-menu-item>Changelog</ui-dropdown-menu-item>
          </ui-dropdown-menu-group>
        </ui-dropdown-menu-content>
      </ui-dropdown-menu>
    </div>
  `;
}
```

## Spinner

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupInputClass, inputGroupTextClass,
} from '#components/ui/input-group.ts';
import { spinner } from '#components/ui/spinner.ts';
import { LoaderIcon } from '#lib/ui/lucide.ts';

export default function InputGroupSpinner() {
  return html`
    <div class="grid w-full max-w-sm gap-4">
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-spinner-1" placeholder="Searching..." aria-label="Search" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-spinner-1" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          ${spinner()}
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-spinner-2" placeholder="Processing..." aria-label="Process" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-spinner-2" class=${inputGroupAddonClass()}>
          ${spinner()}
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-spinner-3" placeholder="Saving changes..." aria-label="Changes" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-spinner-3" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <span class=${inputGroupTextClass()}>Saving...</span>
          ${spinner({ decorative: true })}
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-spinner-4" placeholder="Refreshing data..." aria-label="Data" class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-spinner-4" class=${inputGroupAddonClass()}>
          ${LoaderIcon('animate-spin')}
        </label>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-spinner-4" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <span class=${cn(inputGroupTextClass(), 'text-muted-foreground')}>
            Please wait...
          </span>
        </label>
      </div>
    </div>
  `;
}
```

## Textarea

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupButtonClass,
  inputGroupTextClass, inputGroupTextareaClass,
} from '#components/ui/input-group.ts';
import {
  IconBrandJavascript, IconCopy, IconCornerDownLeft, IconRefresh,
} from '#lib/ui/tabler.ts';

export default function InputGroupTextareaExample() {
  return html`
    <div class="grid w-full max-w-md gap-4">
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <textarea data-slot="input-group-control" id="textarea-code-32" placeholder="console.log('Hello, world!');" aria-label="Code" class=${cn(inputGroupTextareaClass(), 'min-h-[200px]')}></textarea>
        <div role="group" data-slot="input-group-addon" data-align="block-end" class=${cn(inputGroupAddonClass({ align: 'block-end' }), 'border-t')}>
          <span class=${inputGroupTextClass()}>Line 1, Column 1</span>
          <button type="button" data-slot="button" data-variant="default" data-size="sm" class=${cn(inputGroupButtonClass({ variant: 'default', size: 'sm' }), 'ml-auto')}>
            Run ${IconCornerDownLeft()}
          </button>
        </div>
        <div role="group" data-slot="input-group-addon" data-align="block-start" class=${cn(inputGroupAddonClass({ align: 'block-start' }), 'border-b')}>
          <span class=${cn(inputGroupTextClass(), 'font-mono font-medium')}>
            ${IconBrandJavascript()}
            script.js
          </span>
          <button type="button" aria-label="Refresh" data-slot="button" data-variant="ghost" data-size="icon-xs" class=${cn(inputGroupButtonClass({ size: 'icon-xs' }), 'ml-auto')}>
            ${IconRefresh()}
          </button>
          <button type="button" aria-label="Copy" data-slot="button" data-variant="ghost" data-size="icon-xs" class=${inputGroupButtonClass({ variant: 'ghost', size: 'icon-xs' })}>
            ${IconCopy()}
          </button>
        </div>
      </div>
    </div>
  `;
}
```

## Custom Input

Add the `data-slot="input-group-control"` attribute to your custom input for automatic focus state handling.

Here's an example of a textarea that grows with its text through `field-sizing-content`, with its own classes in place of `inputGroupTextareaClass()`.

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupButtonClass,
} from '#components/ui/input-group.ts';

// shadcn's demo reaches for react-textarea-autosize. A plain textarea with
// field-sizing-content grows with its text in the browser, no library needed.
// Its own classes stand in for the group's, and data-slot="input-group-control"
// is what gives it the group's focus ring.
export default function InputGroupCustom() {
  return html`
    <div class="grid w-full max-w-sm gap-6">
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <textarea data-slot="input-group-control" placeholder="Autoresize textarea..." aria-label="Message" class="flex field-sizing-content min-h-16 w-full resize-none rounded-md bg-transparent px-3 py-2.5 text-base transition-[color,box-shadow] outline-none md:text-sm"></textarea>
        <div role="group" data-slot="input-group-addon" data-align="block-end" class=${inputGroupAddonClass({ align: 'block-end' })}>
          <button type="button" data-slot="button" data-variant="default" data-size="sm" class=${cn(inputGroupButtonClass({ variant: 'default', size: 'sm' }), 'ml-auto')}>
            Submit
          </button>
        </div>
      </div>
    </div>
  `;
}
```

## RTL

To enable RTL support, see the [RTL configuration guide](https://webjs.dev/ui/docs/rtl).

```ts
import { html } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  fieldGroupClass, fieldClass, fieldLabelClass, fieldDescriptionClass,
} from '#components/ui/field.ts';
import {
  inputGroupClass, inputGroupAddonClass, inputGroupButtonClass, inputGroupInputClass,
  inputGroupTextClass, inputGroupTextareaClass,
} from '#components/ui/input-group.ts';
import { spinner } from '#components/ui/spinner.ts';
import { SearchIcon } from '#lib/ui/lucide.ts';

const translations = {
  en: {
    dir: 'ltr',
    values: {
      placeholder: 'Search...',
      results: '12 results',
      searching: 'Searching...',
      saving: 'Saving...',
      savingChanges: 'Saving changes...',
      textareaLabel: 'Textarea',
      textareaPlaceholder: 'Write a comment...',
      characterCount: '0/280',
      post: 'Post',
      textareaDescription: 'Footer positioned below the textarea.',
    },
  },
  ar: {
    dir: 'rtl',
    values: {
      placeholder: 'بحث...',
      results: '١٢ نتيجة',
      searching: 'جاري البحث...',
      saving: 'جاري الحفظ...',
      savingChanges: 'جاري حفظ التغييرات...',
      textareaLabel: 'منطقة النص',
      textareaPlaceholder: 'اكتب تعليقًا...',
      characterCount: '٠/٢٨٠',
      post: 'نشر',
      textareaDescription: 'تذييل موضع أسفل منطقة النص.',
    },
  },
  he: {
    dir: 'rtl',
    values: {
      placeholder: 'חפש...',
      results: '12 תוצאות',
      searching: 'מחפש...',
      saving: 'שומר...',
      savingChanges: 'שומר שינויים...',
      textareaLabel: 'אזור טקסט',
      textareaPlaceholder: 'כתוב תגובה...',
      characterCount: '0/280',
      post: 'פרסם',
      textareaDescription: 'כותרת תחתונה ממוקמת מתחת לאזור הטקסט.',
    },
  },
};

export default function InputGroupRtl() {
  const lang = 'ar';
  const { dir, values: t } = translations[lang];

  return html`
    <div class="grid w-full max-w-sm gap-6" dir=${dir} lang=${lang}>
      <div data-slot="input-group" role="group" class=${cn(inputGroupClass(), 'max-w-xs')}>
        <input data-slot="input-group-control" id="input-group-rtl-search" placeholder=${t.placeholder} aria-label=${t.placeholder} class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-start" for="input-group-rtl-search" class=${inputGroupAddonClass()}>
          ${SearchIcon()}
        </label>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-rtl-search" class=${inputGroupAddonClass({ align: 'inline-end' })}>${t.results}</label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-rtl-searching" placeholder=${t.searching} aria-label=${t.searching} class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-rtl-searching" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          ${spinner()}
        </label>
      </div>
      <div data-slot="input-group" role="group" class=${inputGroupClass()}>
        <input data-slot="input-group-control" id="input-group-rtl-saving" placeholder=${t.savingChanges} aria-label=${t.savingChanges} class=${inputGroupInputClass()}>
        <label data-slot="input-group-addon" data-align="inline-end" for="input-group-rtl-saving" class=${inputGroupAddonClass({ align: 'inline-end' })}>
          <span class=${inputGroupTextClass()}>${t.saving}</span>
          ${spinner({ decorative: true })}
        </label>
      </div>
      <div data-slot="field-group" class=${cn(fieldGroupClass(), 'max-w-sm')}>
        <div role="group" data-slot="field" data-orientation="vertical" class=${fieldClass()}>
          <label data-slot="field-label" for="rtl-textarea" class=${fieldLabelClass()}>${t.textareaLabel}</label>
          <div data-slot="input-group" role="group" class=${inputGroupClass()}>
            <textarea data-slot="input-group-control" id="rtl-textarea" placeholder=${t.textareaPlaceholder} class=${inputGroupTextareaClass()}></textarea>
            <div role="group" data-slot="input-group-addon" data-align="block-end" class=${inputGroupAddonClass({ align: 'block-end' })}>
              <span class=${inputGroupTextClass()}>${t.characterCount}</span>
              <button type="button" data-slot="button" data-variant="default" data-size="sm" class=${cn(inputGroupButtonClass({ variant: 'default', size: 'sm' }), 'ml-auto')}>
                ${t.post}
              </button>
            </div>
          </div>
          <p data-slot="field-description" class=${fieldDescriptionClass()}>${t.textareaDescription}</p>
        </div>
      </div>
    </div>
  `;
}
```

## API Reference

### inputGroupClass

The classes for the element that wraps inputs and addons. Put `data-slot="input-group"` and `role="group"` on it. It takes no options.

```ts
<div data-slot="input-group" role="group" class=${inputGroupClass()}>
  <input data-slot="input-group-control" class=${inputGroupInputClass()}>
  <label data-slot="input-group-addon" class=${inputGroupAddonClass()}></label>
</div>
```

### inputGroupAddonClass

Displays icons, text, buttons, or other content alongside inputs. Set `data-slot="input-group-addon"` and a `data-align` that matches the `align` option, since the group reads it to lay itself out. An addon holding only icons or text can be a `<label for>` pointing at the control, so a click on it focuses the control with no script. An addon holding a button is a `<div role="group">`, because a label may not contain a second control. `inputGroupAddonVariants()` is an alias of `inputGroupAddonClass()` that also merges a `className`.

Focus Navigation

For proper focus navigation, the addon should be placed after the input. Set the `align` option to position the addon.

| Option | Type | Default |
| --- | --- | --- |
| `align` | `"inline-start" \| "inline-end" \| "block-start" \| "block-end"` | `"inline-start"` |

```ts
<label data-slot="input-group-addon" data-align="inline-end" for="search" class=${inputGroupAddonClass({ align: 'inline-end' })}>
  <svg aria-hidden="true"><!-- search icon --></svg>
</label>
```

**For an input, use the `inline-start` or `inline-end` alignment. For a textarea, use the `block-start` or `block-end` alignment.**

An addon can hold several buttons and icons.

```ts
<div role="group" data-slot="input-group-addon" data-align="inline-start" class=${inputGroupAddonClass()}>
  <button type="button" class=${inputGroupButtonClass()}>Button</button>
  <button type="button" class=${inputGroupButtonClass()}>Button</button>
</div>
```

### inputGroupButtonClass

Displays buttons within input groups. It is the button's own classes with the group's size on top, so put it on a real `<button type="button">`, and give an icon-only button an `aria-label`. `inputGroupButtonVariants()` is an alias of `inputGroupButtonClass()` that also merges a `className`.

| Option | Type | Default |
| --- | --- | --- |
| `size` | `"xs" \| "icon-xs" \| "sm" \| "icon-sm"` | `"xs"` |
| `variant` | `"default" \| "destructive" \| "outline" \| "secondary" \| "ghost" \| "link"` | `"ghost"` |

```ts
<button type="button" class=${inputGroupButtonClass()}>Button</button>
<button type="button" aria-label="Copy" class=${inputGroupButtonClass({ size: 'icon-xs' })}>
  <svg aria-hidden="true"><!-- copy icon --></svg>
</button>
```

### inputGroupInputClass

The classes for an `<input>` inside an input group: the input's own classes with the group styles on top. Set the unified `data-slot="input-group-control"` on it, which the group reads for its focus state. It takes no options, and every native input attribute works as usual.

```ts
<div data-slot="input-group" role="group" class=${inputGroupClass()}>
  <input data-slot="input-group-control" id="q" placeholder="Enter text..." aria-label="Query" class=${inputGroupInputClass()}>
  <label data-slot="input-group-addon" data-align="inline-start" for="q" class=${inputGroupAddonClass()}>
    <svg aria-hidden="true"><!-- search icon --></svg>
  </label>
</div>
```

### inputGroupTextareaClass

The classes for a `<textarea>` inside an input group: the textarea's own classes with the group styles on top. Set `data-slot="input-group-control"` on it for the focus state. It takes no options, and every native textarea attribute works as usual.

```ts
<div data-slot="input-group" role="group" class=${inputGroupClass()}>
  <textarea data-slot="input-group-control" placeholder="Enter message..." aria-label="Message" class=${inputGroupTextareaClass()}></textarea>
  <div role="group" data-slot="input-group-addon" data-align="block-end" class=${inputGroupAddonClass({ align: 'block-end' })}>
    <button type="button" class=${inputGroupButtonClass()}>Send</button>
  </div>
</div>
```

## Changelog

### 2025-10-06 InputGroup

Add the `min-w-0` class to `inputGroupClass()`. See [diff](https://github.com/shadcn-ui/ui/pull/8341/files#diff-0e2ee95d0050ca4c5d82339df86c54e14a6739dc4638fdda0eec8f73aebc2da9).
