> To build a Wix site agentically, or add Wix features like bookings or a store to a site you already have, follow https://www.wix.com/headless/skill.md
> 
> Portal Navigation:
> 
> - Append `.md` to any URL under `https://dev.wix.com/docs/` to get its markdown version.
> - Pages are either content pages (article or reference text) or menu pages (a list of links to child pages).
> - To get a menu page, truncate any URL to a parent path and append `.md` (e.g. `https://dev.wix.com/docs/sdk.md`, `https://dev.wix.com/docs/sdk/core-modules.md`).
> - If a reference page seems to be missing its schema (parameters, return types, or type definitions), append `?schema=true` to its `.md` URL (e.g. `https://dev.wix.com/docs/contexts/contexts/stores/category-info/use-category-info-context.md?schema=true`).
> - Top-level index of all portals: https://dev.wix.com/docs/llms.txt
> - Full concatenated docs: https://dev.wix.com/docs/llms-full.txt

## Resource: NumberInput Component

## Article: NumberInput Component

## Article Link: https://dev.wix.com/docs/wix-design-system/components/form/number-input-component.md

## Article Content:

# NumberInput

_Components/Form_

Interactive docs page: <https://wix-pages.com/design-system-documentation/#/component/numberinput>

## Overview

```jsx
() => {
  const [value, setValue] = React.useState(20);
  return (
    <Box align="center">
      <Box direction="vertical" width="30%">
        <FormField label="Price">
          <NumberInput
            prefix={<Input.Affix>$</Input.Affix>}
            value={value}
            onChange={setValue}
          />
        </FormField>
      </Box>
    </Box>
  );
};
```

Number inputs allow users to enter and edit numeric values in a single line input field. The value can be inserted using the keyboard or incremented using the arrow controls.

### Do

- Use it to enter custom numeric values, e.g., amount, price, quantity.
- Use it to adjust values by a specific amount, e.g., the number of items in a shopping cart.

### Don't

- Don't use it to enter numerals that don't indicate quantity or measurements, e.g., phone numbers or postal codes. Use regular `<Input/>` instead.
- Don't use it to enter dates and times. Use `<DatePicker/>` or `<TimeInput/>` instead.

### Feature examples

#### Size

Adjust the size using the `size` prop. There are 3 supported sizes:

- When the input needs to be emphasized, like in onboarding flows, use `large.`
- In most cases, use the default `medium.`
- For dense and narrow layouts where space is tight, use `small.`

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NumberInput size="large" placeholder="Large" />
  <NumberInput size="medium" placeholder="Medium" />
  <NumberInput size="small" placeholder="Small" />
</StorybookComponents.Stack>;
```

#### Border

Style the field using the `border` prop. It supports 4 styles:

- For most common cases, like forms, use `standard`.
- To build inputs that can be used to filter data, use `round`.
- Use `bottomLine` to create an editable, underlined title field.
- When a component provides its own hover and focus styles, such as a table or spreadsheet cells, use `none`.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NumberInput border="standard" placeholder="Standard" />
  <NumberInput border="round" placeholder="Round" />
  <NumberInput border="bottomLine" placeholder="Bottom line" />
  <NumberInput border="none" placeholder="None" />
</StorybookComponents.Stack>;
```

#### Status

Control the status of the input using the `status` prop. It supports 3 states:

- `error` demonstrates that a required input is missing something or the entry was invalid.
- `warning` highlights an input value that might have a significant impact to a user.
- `loading` shows when an input value is being uploaded to the server.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NumberInput status="error" placeholder="Error" />
  <NumberInput status="warning" placeholder="Warning" />
  <NumberInput status="loading" placeholder="Loading" />
</StorybookComponents.Stack>;
```

#### Status message

Add text that explains the status or what action the user should take with the `statusMessage` prop.

Showing the status message inline, directly below the input is preferred in all default cases.

- To add an accessible inline message, wrap the component in a `<FormField/>` and add the `statusMessage`.
- To add a status message in a tooltip that requires users to hover on the icon, use the `statusMessage` prop. Control tooltip placement with `tooltipPlacement` prop.

View more inline status message examples in `<FormField/>`.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <StorybookComponents.Stack flexDirection="column" gap="12px">
    <Text secondary>For all default cases:</Text>
    <FormField status="error" statusMessage="This is an error message.">
      <NumberInput placeholder="See message below" tooltipPlacement="top-end" />
    </FormField>
  </StorybookComponents.Stack>
  <StorybookComponents.Stack flexDirection="column" gap="12px">
    <Text secondary>For narrow layouts only:</Text>
    <NumberInput
      placeholder="Hover on status icon"
      status="error"
      statusMessage="This is an error message."
      tooltipPlacement="top-end"
    />
  </StorybookComponents.Stack>
</StorybookComponents.Stack>;
```

#### Prefix and suffix

Add text, icons or a button at the beginning or end of the input field using `prefix` and `suffix`.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NumberInput prefix={<Input.Affix>$</Input.Affix>} value="20.00" />
  <NumberInput suffix={<Input.Affix>%</Input.Affix>} value="10" />
  <NumberInput
    prefix={
      <Input.IconAffix>
        <Icons.Users />
      </Input.IconAffix>
    }
    value="2"
    suffix={<Input.Affix>guests</Input.Affix>}
  />
</StorybookComponents.Stack>;
```

#### Read-only and disabled

Inputs can also be made read-only or disabled entirely.

- `readOnly` disables the field, so users can't enter new values. The current value can still be copied.
- `disabled` removes all interactions and creates a disabled input state. Use it to highlight functions that are unavailable.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NumberInput placeholder="Read-only" readOnly />
  <NumberInput placeholder="Disabled" disabled />
</StorybookComponents.Stack>;
```

#### Clear button

Enable a button that lets users easily clear the input value by using the `clearButton` prop. Use it when the input value is optional or has to be cleared often.

```jsx
() => {
  const [inputText, setInputText] = React.useState('20');

  return (
    <NumberInput
      value={inputText}
      clearButton
      onChange={(value, stringValue) => setInputText(stringValue)}
      onClear={() => setInputText('')}
    />
  );
};
```

#### Increment by steps

Use the `step` prop to specify what the increments are when clicking up or down on the arrows.

The arrows controls can be hidden with `hideStepper`. When the arrows are hidden, the field value can still be incremented by the set `step` when the field is changed using the arrow keys on the keyboard.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NumberInput
    step={20}
    placeholder="Click on the arrows to change the value by 20 units at a time."
  />
  <NumberInput
    step={20}
    hideStepper
    placeholder="Click the up and down arrow keys to change the value by 20 when the arrows are hidden."
  />
</StorybookComponents.Stack>;
```

#### Min and max values

If the user inputs something outside of the minimum or maximum, explain that it's invalid using the `invalidMessage` prop.

Get informed about invalid message events by using the `onInvalid` callback function.

```jsx
<NumberInput
  min={-5}
  max={5}
  invalidMessage="Enter a number between -5 and 5."
  placeholder="Try typing a number less than -5 or more than 5"
/>;
```

### Developer examples

#### Controlled

Use NumberInput in controlled mode by passing `value` and `onChange` props.

```jsx
() => {
  const [value, setValue] = React.useState('0');

  return (
    <NumberInput
      value={value}
      onChange={(numberValue, stringValue) => setValue(stringValue)}
    />
  );
};
```

#### Range validation

The `min` and `max` properties enable built-in range validation, so no need to add `onChange` and `value.`

Users will still be able to enter invalid numbers, but will be notified that what they entered is invalid. Set the error message using `invalidMessage.`

Don't allow users to submit a form with an invalid input value. Use `onInvalid` to get an invalid event.

```jsx
() => {
  const ref = React.useRef(null);
  const [invalid, setInvalid] = React.useState(false);
  const [errorMessage, setErrorMessage] = React.useState('');

  const onInvalid = (value) => {
    if (Number(value) < 2) {
      setErrorMessage('You must order at least 2 tickets.');
    }

    if (Number(value) > 20) {
      setErrorMessage('You can only order up to 20 tickets at a time.');
    }
  };

  const onSubmit = () => {
    if (errorMessage) {
      ref.current.focus();
    }
  };

  return (
    <Layout>
      <Cell>
        <FormField
          label="Number of tickets"
          infoContent="You can buy between 2 and 20 tickets at a time."
        >
          <NumberInput
            inputRef={ref}
            min={5}
            max={20}
            invalidMessage={errorMessage}
            onInvalid={onInvalid}
            placeholder="How many tickets would you like?"
          />
        </FormField>
      </Cell>
      <Cell>
        <Button onClick={onSubmit}>Purchase</Button>
      </Cell>
    </Layout>
  );
};
```

#### Integrating with react-hook-form

react-hook-form reduces the amount of code you need to write while removing unnecessary re-renders. The preview here demonstrates form validation in action while using the number input.

```jsx
() => {
  const [state, setState] = React.useState({});
  const {
    handleSubmit,
    formState: { errors },
    control,
  } = useForm();

  const { field } = useController({
    name: 'tickets',
    control,
    rules: { min: 2, max: 20 },
    defaultValue: 2,
  });

  const status = errors.tickets && 'error';
  const statusMessage =
    errors.tickets && errors.tickets.type === 'min'
      ? 'You must order at least 2 tickets.'
      : 'You can only order up to 20 tickets at a time.';

  const onSubmit = (data) => setState(data);

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <Layout>
        <Cell>
          <FormField
            label="Number of tickets"
            infoContent="You can buy between 2 and 20 tickets at a time."
          >
            <NumberInput
              {...field}
              inputRef={field.ref}
              status={status}
              statusMessage={statusMessage}
              placeholder="How many tickets would you like?"
            />
          </FormField>
        </Cell>
        <Cell>
          <Layout alignItems="center">
            <Cell span={2}>
              <Button type="submit">Purchase</Button>
            </Cell>
            <Cell span={10}>
              <SectionHelper appearance="preview">
                {JSON.stringify(state)}
              </SectionHelper>
            </Cell>
          </Layout>
        </Cell>
      </Layout>
    </form>
  );
};
```

### Common use case examples

#### Settings panel

Use number input with other components like `<Slider/>` in a `<FieldSet/>` wrapper to group them together and let users define the exact numerical value.

```jsx
() => {
  const [value, setValue] = React.useState(50);
  const [opacity, setOpacity] = React.useState(100);
  return (
    <SidePanel
      skin="floating"
      width="420px"
      onCloseButtonClick={() => {}}
      onHelpButtonClick={() => {}}
    >
      <SidePanel.Header title="Events" />
      <Box height="480px">
        <VerticalTabs size="small" activeTabId={1} onChange={() => {}}>
          <VerticalTabs.TabItem id={0}>Main</VerticalTabs.TabItem>
          <VerticalTabs.TabItem id={1}>Design</VerticalTabs.TabItem>
          <VerticalTabs.TabItem id={2}>Text</VerticalTabs.TabItem>
        </VerticalTabs>
        <Divider direction="vertical" />
        <SidePanel.Content noPadding>
          <SidePanel.Field>
            <Button
              priority="secondary"
              size="tiny"
              prefixIcon={<Icons.ChevronLeft />}
            >
              Back
            </Button>
          </SidePanel.Field>
          <SidePanel.Section title="Background">
            <SidePanel.Field>
              <FieldSet
                legend="Background color"
                legendSize="small"
                legendPlacement="top"
                alignment="center"
                columns="30px auto 72px"
              >
                <FillPreview fill="#000000" aspectRatio={1} />
                <Slider
                  gradientColor="#000000"
                  min={0}
                  max={100}
                  displayMarks={false}
                  onChange={(value) => setOpacity(Number(value))}
                  value={opacity}
                />
                <NumberInput
                  value={opacity}
                  min={0}
                  max={100}
                  onChange={(value) => setOpacity(value)}
                  suffix={<Input.Affix>%</Input.Affix>}
                  size="small"
                  hideStepper
                />
              </FieldSet>
            </SidePanel.Field>
            <SidePanel.Field>
              <FieldSet gap="small" legend="Border width" columns="auto 60px">
                <Slider
                  onChange={(value) => setValue(Number(value))}
                  min={0}
                  max={100}
                  value={value}
                  displayMarks={false}
                />
                <Input
                  value={value}
                  size="small"
                  onChange={(e) => setValue(Number(e.target.value))}
                />
              </FieldSet>
            </SidePanel.Field>
          </SidePanel.Section>
        </SidePanel.Content>
      </Box>
    </SidePanel>
  );
};
```

#### Compound input

Stack items next to each other with `<Box/> `when fields represent the same data, or when a change in one input affects one or more other fields.

```jsx
() => {
  const signs = {
    amount: '$',
    percentage: '%',
  };
  const [value, setValue] = React.useState(20);
  const [signValue, setSignValue] = React.useState('amount');

  const onClick = (_, value) => {
    setSignValue(value);
  };

  return (
    <FormField
      label="Discount"
      infoContent="This is how much will be taken off the final price. Discount can be offered in percentage off the starting price or a specific amount."
    >
      <Box gap="12px" width="100%">
        <Box direction="vertical" width="100%">
          <NumberInput
            prefix={
              signValue === 'amount' ? (
                <Input.Affix>{signs[signValue]}</Input.Affix>
              ) : null
            }
            suffix={
              signValue === 'percentage' ? (
                <Input.Affix>{signs[signValue]}</Input.Affix>
              ) : null
            }
            onChange={setValue}
            value={value}
          />
        </Box>
        <Box direction="vertical">
          <SegmentedToggle
            defaultSelected="amount"
            onClick={onClick}
            selected={signValue}
          >
            <SegmentedToggle.Button value="amount">
              {signs.amount}
            </SegmentedToggle.Button>
            <SegmentedToggle.Button value="percentage">
              {signs.percentage}
            </SegmentedToggle.Button>
          </SegmentedToggle>
        </Box>
      </Box>
    </FormField>
  );
};
```

#### Disabled stepper

Disable the arrows once the minimum or maximum value has been reached.

```jsx
() => {
  const [value, setValue] = React.useState(20);

  return (
    <FormField
      label="Number of tickets"
      statusMessage="Between 2 and 20 tickets"
    >
      <NumberInput
        min={2}
        max={20}
        value={value}
        onChange={setValue}
        placeholder="How many tickets would you like?"
        strict={true}
      />
    </FormField>
  );
};
```

### Accessibility examples

#### Helper text

To help users enter the correct value, use helper text below the input which describes the constraints.

This will help prevent user errors.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <FormField label="Label" statusMessage="Helper text">
    <NumberInput size="medium" />
  </FormField>
  <FormField
    label="Number of visitors"
    statusMessage="Enter numbers only, from 1 to 100"
  >
    <NumberInput size="medium" />
  </FormField>
</StorybookComponents.Stack>;
```

## Code

```jsx
import { NumberInput } from '@wix/design-system';
```

### Props

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `ariaControls` | `string` | — | Associate a control with the regions that it controls. |
| `ariaDescribedby` | `string` | — | Associate a region with its descriptions. Similar to aria-controls but instead associating descriptions to the region and description identifiers are separated with a space. |
| `ariaLabel` | `string` | — | Define a string that labels the current element in case where a text label isn't visible on the screen. |
| `autocomplete` | `string` | — | Sets the value of the native `autocomplete` attribute, for example `off` or `email`. |
| `autoFocus` | `boolean` | — | Focus the element on mount (standard React input autoFocus) |
| `autoSelect` | `boolean` | — | Automatically selects the entire input text. |
| `backgroundColor` | `string` | — | Sets the background color of the input. Accepts any CSS color value. |
| `border` | `"none" \| "standard" \| "round" \| "bottomLine"` | — | Control the border style of input. |
| `clearButton` | `boolean` | — | Displays clear button (X) on a non-empty input. |
| `clearButtonAriaLabel` | `string` | — | Aria label for the clear button. |
| `clearButtonTooltipContent` | `ReactNode` | — | When provided, hovering displays a tooltip with this content. |
| `clearButtonTooltipProps` | `TooltipCommonProps` | — | Clear button tooltip props. |
| `customInput` | `ReactNode \| Function` | — | Render a custom input instead of the default html input tag. |
| `dataHook` | `string` | — | Applies a data-hook HTML attribute that can be used in the tests. |
| `defaultValue` | `string \| number` | — | Defines the initial value of an input. |
| `disabled` | `boolean` | — | Specifies whether input should be disabled or not. |
| `disableEditing` | `boolean` | — | Restricts input editing. |
| `enterKeyHint` | `"search" \| "enter" \| "done" \| "go" \| "next" \| "previous" \| "send"` | — | Sets the label of the virtual keyboard's enter key on touch devices. |
| `focusOnClearClick` | `boolean` | — | Specifies whether to focus the field when clear button is clicked. |
| `hideStatusSuffix` | `boolean` | — | Specifies whether status suffix should be hidden. |
| `hideStepper` | `boolean` | — | Specifies whether stepper should be hidden. |
| `id` | `string` | — | Assigns a unique identifier for the root element. |
| `inputmode` | `string` | `'numeric'` | Sets the native `inputmode` attribute, which picks the virtual keyboard on touch devices. |
| `inputRef` | `(input: HTMLInputElement) => void \| MutableRefObject<HTMLInputElement \| null>` | — | Ref to the underlying `<input>` DOM element. Accepts callback and object refs. Use for input masking libraries such as `use-mask-input`. Memoize callback refs to avoid reattaching on every render. |
| `invalidMessage` | `string` | — | Enables internal validation and defines a message to display when user types invalid value. |
| `max` | `number` | — | Sets a maximum value of an input. Similar to html5 max attribute. |
| `maxLength` | `number` | — | Sets the maximum number of characters that can be inserted to a field. |
| `menuArrow` | `boolean` | — | Specifies whether input should have a dropdown menu arrow on the right side. |
| `min` | `number` | — | Sets a minimum value of an input. Similar to HTML5 min attribute. |
| `name` | `string` | — | Reference element data when a form is submitted. |
| `noLeftBorderRadius` | `boolean` | — | Specifies whether input shouldn't have rounded corners on its left. |
| `noRightBorderRadius` | `boolean` | — | Specifies whether input shouldn't have rounded corners on its right. |
| `onBlur` | `FocusEventHandler` | — | Defines a standard input onBlur callback. |
| `onChange` | `(value: number \| null, stringValue: string) => void` | — | Defines a standard input onChange callback. |
| `onClear` | `(event: KeyboardEvent<HTMLButtonElement> \| MouseEvent<HTMLButtonElement, MouseEvent>) => void` | — | Displays clear button (X) on a non-empty input and calls a callback function. |
| `onCompositionChange` | `(isComposing: boolean) => void` | — | Defines a callback function called on compositionstart/compositionend events. |
| `onEnterPressed` | `KeyboardEventHandler<HTMLInputElement>` | — | Defines a callback handler that is called when the user presses -enter-. |
| `onEscapePressed` | `KeyboardEventHandler<HTMLInputElement>` | — | Defines a callback handler that is called when the user presses -escape-. |
| `onFocus` | `(e?: FocusEvent<HTMLInputElement, Element> \| undefined) => void` | — | Defines a standard input onFocus callback. |
| `onInputClicked` | `MouseEventHandler` | — | Defines a standard input onClick callback. |
| `onInvalid` | `(stringValue: string, { validationType, value, }: { validationType?: "outOfBoundsError" \| "formatError" \| undefined; value: string; }) => void` | — | Defines a callback function which is called on cases when invalid value is typed. - return { stringValue: string, { validationType: 'formatError' \| 'outOfBoundsError', value: string }} - `validationType` - type 'formatError' is set when value is in the wrong format - type 'outOfBoundsError' is set when min or max props are used and value doesn't match the bounds - `value` - is set to current input value |
| `onKeyDown` | `KeyboardEventHandler<HTMLInputElement>` | — | Defines a standard input onKeyDown callback. |
| `onKeyUp` | `KeyboardEventHandler<HTMLInputElement>` | — | Defines a standard input onKeyUp callback. |
| `onPaste` | `ClipboardEventHandler<HTMLInputElement>` | — | Defines a callback handler that is called when user pastes text from a clipboard (using a mouse or keyboard shortcut) |
| `pattern` | `string` | — | Sets a pattern that typed value must match to be valid (regex) |
| `placeholder` | `string` | — | Sets a placeholder message to display. |
| `prefix` | `ReactNode` | — | Pass a component you want to show as the prefix of the input, e.g., text, icon. |
| `readOnly` | `boolean` | — | Specifies whether input is read only. |
| `required` | `boolean` | — | Specifies whether input is mandatory. |
| `rtl` | `boolean` | — | Specifies text direction. If true, the text is displayed from right to left. |
| `size` | `"small" \| "tiny" \| "medium" \| "large"` | — | Controls the size of the input. |
| `status` | `"error" \| "warning" \| "loading"` | — | Specify the status of a field. |
| `statusMessage` | `ReactNode` | — | Defines the message to display on status icon hover. If not given or empty, no tooltip is displayed. |
| `statusMessageTooltipProps` | `TooltipCommonProps` | — | Status message tooltip props. |
| `step` | `number \| number[]` | — | Specifies the interval between number values. |
| `strict` | `boolean` | — | Has no effect. |
| `suffix` | `ReactNode` | — | Pass a component you want to show as the suffix of the input, e.g., text, icon. |
| `tabIndex` | `number` | — | Indicates that element can be focused and where it participates in sequential keyboard navigation. |
| `textOverflow` | `"ellipsis" \| "clip"` | — | Handles text overflow behavior. It can either `clip` (default) or display `ellipsis`. |
| `tooltipPlacement` | `"right" \| "left" \| "top" \| "bottom" \| "auto" \| "auto-start" \| "auto-end" \| "top-start" \| "top-end" \| "right-start" \| "right-end" \| "bottom-end" \| "bottom-start" \| "left-end" \| "left-start"` | — | Controls placement of a status tooltip. |
| `type` | `string` | — | Specifies the type of `<input/>` element to display. Default is text. |
| `value` | `string \| number` | — | Specifies the current value of the element. |
| `withSelection` | `boolean` | — |  |

## Testkit

Import the driver matching your test environment:

```jsx
// UniDriver
import { NumberInputUniDriver } from '@wix/design-system/dist/testkit/unidriver';

// Vanilla
import { NumberInputTestkit } from '@wix/design-system/dist/testkit';

// Puppeteer
import { NumberInputTestkit } from '@wix/design-system/dist/testkit/puppeteer';

// Testing Library
import { NumberInputTestkit } from '@wix/design-system/dist/testkit/testing-library';
```

### Driver methods

| Method | Description |
| --- | --- |
| `clickOnIncrement` | Click on ticker up |
| `clickOnDecrement` | Click on ticker down |
| `isDownDisabled` | Check if ticker down is disabled |
| `isUpDisabled` | Check if ticker up is disabled |
| `click` | — |
| `getInputAttribute` | — |
| `getInputElementClasses` | — |
| `suffixComponentExists` | — |
| `getRootElementClasses` | — |
| `getAriaDescribedby` | — |
| `getAriaLabel` | — |
| `getName` | — |
| `getMaxLength` | — |
| `getType` | — |
| `getAriaControls` | — |
| `clickIconAffix` | — |
| `clickCustomAffix` | — |
| `getCustomAffixText` | — |
| `hasSuffix` | — |
| `getClearButtonTooltipContent` | — |
| `prefixComponentExists` | — |
| `hasPrefix` | — |
| `hasClearButton` | — |
| `clickClear` | — |
| `getValue` | — |
| `getText` | — |
| `getPattern` | — |
| `getPlaceholder` | — |
| `isOfSize` | — |
| `getSize` | — |
| `isDisabled` | — |
| `isHoveredStyle` | — |
| `isFocusedStyle` | — |
| `getRequired` | — |
| `enterText` | — |
| `getAutocomplete` | — |
| `getDefaultValue` | — |
| `getTabIndex` | — |
| `isCustomInput` | — |
| `getReadOnly` | — |
| `getDisabled` | — |
| `getTextOverflow` | — |
| `focus` | — |
| `blur` | — |
| `keyUp` | — |
| `keyDown` | — |
| `pressKey` | — |
| `paste` | — |
| `copy` | — |
| `wheel` | — |
| `trigger` | — |
| `isFocus` | — |
| `clickMenuArrow` | — |
| `hasMenuArrow` | — |
| `isRTL` | — |
| `getCursorLocation` | — |
| `clearText` | — |
| `clickOutside` | — |
| `isMasked` | — |
| `isSelected` | — |
| `hasStatus` | Return true if there's a status |
| `getStatusMessage` | If there's a status message, returns its text value |
| `exists` | Checks whether the component found with the given data hook. |
| `element` | Gets the component root element. |
| `base` | Returns UniDriver for the base element. |

## Changelog

- **1.340.0** (2026-10-21) — maintenance release, no component-specific changes
- **1.339.0** (2026-10-19) — maintenance release, no component-specific changes
- **1.338.0** (2026-10-15) — maintenance release, no component-specific changes
- **1.336.0** (2026-10-13) — maintenance release, no component-specific changes
- **1.331.0** (2026-10-01) — maintenance release, no component-specific changes
- **1.330.3** (2026-09-29) — maintenance release, no component-specific changes
- **1.330.1** (2026-09-28) — maintenance release, no component-specific changes
- **1.330.0** (2026-09-28) — maintenance release, no component-specific changes
- **1.325.0** (2026-09-17) — maintenance release, no component-specific changes
- **1.312.0** (2026-08-14) — maintenance release, no component-specific changes
- **1.310.0** (2026-08-10) — maintenance release, no component-specific changes
- **1.292.0** (2026-06-22) — maintenance release, no component-specific changes
- **1.289.0** (2026-06-17) — maintenance release, no component-specific changes
- **1.288.0** (2026-06-15) — maintenance release, no component-specific changes
- **1.282.0** (2026-05-27) — feat: add tooltip props, deprecate tooltipPlacement ([#16299](invalid-url))
- **1.277.0** (2026-05-07) — maintenance release, no component-specific changes
- **1.272.0** (2026-04-27) — maintenance release, no component-specific changes
- **1.266.0** (2026-04-07) — maintenance release, no component-specific changes
- **1.260.0** (2026-03-17) — maintenance release, no component-specific changes
- **1.245.0** (2026-01-06) — fix: fix disabled states of ticker and local/controlled states and suffix testkit ([#15658](invalid-url))
- **1.213.0** (2025-08-19) — maintenance release, no component-specific changes
- **1.204.1** (2025-07-10) — maintenance release, no component-specific changes
- **1.184.0** (2025-04-30) — fix: when min is 0 and value is smaller increment broken ([#14801](invalid-url))
- **1.178.0** (2025-04-08) — feat: add inc/dec handlers ([#14675](invalid-url))
- **1.169.0** (2025-03-10) — maintenance release, no component-specific changes
- **1.159.0** (2025-02-06) — fix: type ([#14506](invalid-url))
- **1.155.0** (2025-01-23) — fix: tickers(up/down) disabled visual state ([#14457](invalid-url))
- **1.149.1** (2024-12-20) — maintenance release, no component-specific changes
- **1.138.1** (2024-10-30) — maintenance release, no component-specific changes
- **1.134.0** (2024-10-18) — fix: set to min value when incrementing ([#14220](invalid-url))
- **1.133.0** (2024-10-14) — maintenance release, no component-specific changes
- **1.126.0** (2024-09-09) — fix: decimal values & NaN fix ([#14100](invalid-url))
- **1.123.1** (2024-09-05) — maintenance release, no component-specific changes
- **1.120.1** (2024-08-08) — fix: call onChange when invalid in controlled mode ([#14022](invalid-url))
- **1.117.0** (2024-07-25) — fix: when value and onChange is provided controlled mode is on ([#13978](invalid-url))
- **1.115.0** (2024-07-17) — maintenance release, no component-specific changes
- **1.109.2** (2024-06-17) — maintenance release, no component-specific changes
- **1.98.0** (2024-03-15) — fix: inputRef function not work well ([#13458](invalid-url))
- **1.97.2** (2024-03-04) — fix: fixed propType which was out of sync with types ([#13411](invalid-url))
- **1.97.0** (2024-02-26) — maintenance release, no component-specific changes
- **1.92.1** (2024-02-05) — maintenance release, no component-specific changes