> 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: TableListItem Component

## Article: TableListItem Component

## Article Link: https://dev.wix.com/docs/wix-design-system/components/lists/table/table-list-item-component.md

## Article Content:

# TableListItem

_Components/Lists/Table_

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

## Overview

```jsx
() => {
  const [checked, setChecked] = React.useState(false);

  return (
    <TableListItem
      onClick={() => {}}
      onCheckboxChange={() => setChecked(!checked)}
      checkbox
      checked={checked}
      options={[
        {
          value: <Image height="42px" width="60px" src="TravelExample1.jpg" />,
          width: 'auto',
        },
        {
          value: (
            <Box direction="vertical">
              <Text weight="normal">Travel and sport</Text>
              <Text size="small" secondary>
                30 members • 125 posts
              </Text>
            </Box>
          ),
        },
        { value: <Badge skin="neutralSuccess">Trending</Badge>, width: 'auto' },
        {
          value: (
            <TableActionCell
              onClick={() => {}}
              size="small"
              primaryAction={{
                text: 'Edit',
                onClick: () => {},
              }}
              secondaryActions={[
                {
                  text: 'Download',
                  icon: <Icons.DownloadImportSmall />,
                  onClick: () => {},
                },
                {
                  text: 'Duplicate',
                  icon: <Icons.DuplicateSmall />,
                  onClick: () => {},
                },
                {
                  text: 'Delete',
                  icon: <Icons.DeleteSmall />,
                  onClick: () => {},
                },
              ]}
            />
          ),
          width: 'auto',
        },
      ]}
    />
  );
};
```

A table list item is a single row of a table or a list, that allows users to scan and compare sets of data. These sets can be a list of similar items, like products, posts or contacts.

### Do

- Use this component for a simple list when a `<Table/>` is too complex.
- Group similar items together for improved readability.
- Organize important information for users.

### Don't

- Don't create tables with multiple actions like filtering, bulk operations and column sorting. Build a `<Table/>` instead.
- Don't build drag and drop lists, a `<NestableList/>` is a better option for this.

### Feature examples

#### Structure

Table list item organizes different sets of information into columns. It can have any number of columns, which can be added through `options`.

Add any content to the column with the `value` prop.

Note that column width and alignment can be controlled separately.

```jsx
<TableListItem
  options={[
    {
      value: (
        <StorybookComponents.Placeholder>
          Column 1
        </StorybookComponents.Placeholder>
      ),
    },
    {
      value: (
        <StorybookComponents.Placeholder>
          Column 2
        </StorybookComponents.Placeholder>
      ),
    },
    {
      value: (
        <StorybookComponents.Placeholder>
          Column 3
        </StorybookComponents.Placeholder>
      ),
    },
    {
      value: (
        <StorybookComponents.Placeholder>
          Column 4
        </StorybookComponents.Placeholder>
      ),
    },
  ]}
/>;
```

#### Padding

Adjust vertical spacing by using `verticalPadding` and `horizontalPadding` props. It supports 6 options:

- `xxTiny`
- `xTiny`
- `tiny`
- `small` (default)
- `medium`
- `large`

Use tiny size set for compact lists that display more items in smaller space.

Small (default) is a standard list size for most common cases.

While medium and large are used to emphasize a few items.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <TableListItem
    horizontalPadding="xxTiny"
    verticalPadding="xxTiny"
    options={[{ value: <Text>xxTiny</Text> }]}
  />
  <TableListItem
    horizontalPadding="xTiny"
    verticalPadding="xTiny"
    options={[{ value: <Text>xTiny</Text> }]}
  />
  <TableListItem
    horizontalPadding="tiny"
    verticalPadding="tiny"
    options={[{ value: <Text>Tiny</Text> }]}
  />
  <TableListItem
    horizontalPadding="small"
    verticalPadding="small"
    options={[{ value: <Text>Small (default)</Text> }]}
  />
  <TableListItem
    horizontalPadding="medium"
    verticalPadding="medium"
    options={[{ value: <Text>Medium</Text> }]}
  />
  <TableListItem
    horizontalPadding="large"
    verticalPadding="large"
    options={[{ value: <Text>Large</Text> }]}
  />
</StorybookComponents.Stack>;
```

#### Drag handle size

Control a drag handle size with `dragHandleSize` prop. It supports two sizes:

- `small` is used for more compact lists
- `large` (default) is used for tables and more spacious UI layouts

```jsx
<StorybookComponents.Stack flexDirection="column">
  <TableListItem
    draggable
    dragHandleSize="large"
    showDivider
    verticalPadding="tiny"
    options={[
      {
        value: <Text size="medium">Large drag handle (default)</Text>,
      },
    ]}
  />
  <TableListItem
    draggable
    dragHandleSize="small"
    showDivider
    horizontalPadding="tiny"
    verticalPadding="xTiny"
    options={[
      { width: 'auto', value: null },
      {
        value: <Text size="small">Small drag handle</Text>,
      },
    ]}
  />
</StorybookComponents.Stack>;
```

#### Draggable item indication

Control a drag grip icon with props:

- `draggable` marks that the component can be dragged.
- `dragging` indicates that the component is being dragged.
- `showDragHandleOnHover` shows handle only on hover
- `dragDisabled` show that the component can't be dragged.

Note, drag and drop logic is not part of this component. For this solution, go to `<NestableList/>`.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <TableListItem draggable options={[{ value: <Text>Draggable</Text> }]} />
  <TableListItem
    draggable
    dragging
    options={[{ value: <Text>Draggable active</Text> }]}
  />
  <TableListItem
    draggable
    showDragHandleOnHover
    options={[{ value: <Text>Draggable on hover</Text> }]}
  />
  <TableListItem
    draggable
    dragDisabled
    options={[{ value: <Text>Draggable disabled</Text> }]}
  />
</StorybookComponents.Stack>;
```

#### Border

Control the appearance of the component using the `border` prop.

Use this property to emphasize the separation between items in a list.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <TableListItem
    showDivider
    verticalPadding="tiny"
    options={[
      {
        value: <Text size="small">No border (default)</Text>,
      },
    ]}
  />

  <TableListItem
    border={true}
    showDivider
    verticalPadding="tiny"
    options={[
      {
        value: <Text size="small">Border</Text>,
      },
    ]}
  />
</StorybookComponents.Stack>;
```

#### Expandable

Give an ability to make an item expandable with `expanded` prop.

```jsx
() => {
  const [isExpanded, setIsExpanded] = React.useState(false);

  return (
    <>
      <TableListItem
        expanded={isExpanded}
        expandable
        draggable
        dragHandleSize="small"
        showDivider
        horizontalPadding="tiny"
        verticalPadding="xTiny"
        onClickExpand={() => setIsExpanded(!isExpanded)}
        options={[
          {
            value: <Text size="small">Expandable</Text>,
          },
        ]}
      />
      {isExpanded && (
        <StorybookComponents.Placeholder>
          <Box verticalAlign="middle" align="center">
            <Text size="small">Content</Text>
          </Box>
        </StorybookComponents.Placeholder>
      )}
    </>
  );
};
```

#### Selectable

Make an item selectable with the following props:

- Use `checkbox` to enable the checkbox and show that the item can be selected.
- `checked `changes the checkbox's default state to selected.
- `showSelectionBorder` allows to turn off the blue strip indication when the item is selected
- `checkboxDisabled` disables the checkbox.
- `selectable` enables the selected state on the item

```jsx
() => {
  const [checked, setChecked] = React.useState(false);

  return (
    <StorybookComponents.Stack flexDirection="column">
      <TableListItem checkbox options={[{ value: <Text>Checkbox</Text> }]} />

      <TableListItem
        checkbox
        checked
        options={[{ value: <Text>Selected checkbox</Text> }]}
      />

      <TableListItem
        checkbox
        showSelectionBorder={false}
        checked
        options={[{ value: <Text>Selected checkbox without border</Text> }]}
      />

      <TableListItem
        checkbox
        checkboxDisabled
        options={[{ value: <Text>Disabled checkbox</Text> }]}
      />
      <TableListItem
        selectable
        onClick={() => setChecked((prev) => !prev)}
        checked={checked}
        options={[
          {
            value: <Text>Selectable</Text>,
          },
        ]}
      />
    </StorybookComponents.Stack>
  );
};
```

#### Divider

Enable the bottom divider with `showDivider`, which visually separates the items.

Note that the last item on the list shouldn't have a bottom divider.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <StorybookComponents.Stack flexDirection="column" gap={0}>
    <TableListItem options={[{ value: <Text>Divider off</Text> }]} />
    <TableListItem options={[{ value: <Text>Divider off</Text> }]} />
    <TableListItem options={[{ value: <Text>Divider off</Text> }]} />
  </StorybookComponents.Stack>
  <StorybookComponents.Stack flexDirection="column" gap={0}>
    <TableListItem showDivider options={[{ value: <Text>Divider on</Text> }]} />
    <TableListItem showDivider options={[{ value: <Text>Divider on</Text> }]} />
    <TableListItem options={[{ value: <Text>Divider off</Text> }]} />
  </StorybookComponents.Stack>
</StorybookComponents.Stack>;
```

#### Column width

Control the width of columns with the `width` prop. It supports all CSS [grid-column-template](https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns) values.

```jsx
<TableListItem
  options={[
    {
      value: (
        <StorybookComponents.Placeholder>
          Width depends on content
        </StorybookComponents.Placeholder>
      ),
      width: 'max-content',
    },
    {
      value: (
        <StorybookComponents.Placeholder>
          Fills available space
        </StorybookComponents.Placeholder>
      ),
      width: '1fr',
    },
  ]}
/>;
```

#### Column alignment

Align content inside of column cells using the `align` prop. It supports 3 values:

- `left`
- `center`
- `right`

```jsx
<StorybookComponents.Stack flexDirection="column" gap={0}>
  <TableListItem
    showDivider
    options={[
      {
        value: <Text>Left</Text>,
        align: 'left',
      },
      {
        value: <Text>Center</Text>,
        align: 'center',
      },
      {
        value: <Text>Right</Text>,
        align: 'right',
      },
    ]}
  />
  <TableListItem
    options={[
      {
        value: <Text>Left with longer text</Text>,
        align: 'left',
      },
      {
        value: <Text>Center with longer text</Text>,
        align: 'center',
      },
      {
        value: <Text>Right with longer text</Text>,
        align: 'right',
      },
    ]}
  />
</StorybookComponents.Stack>;
```

#### Actionable

Make an item actionable with the `onClick` prop. Once enabled, the item becomes interactive.

The `<TableActionCell/>` displays main and secondary actions.

```jsx
<TableListItem
  onClick={() => {}}
  options={[
    { value: <Text>Actionable item</Text> },
    {
      value: (
        <TableActionCell
          primaryAction={{
            text: 'Click me',
            onClick: () => {},
          }}
        />
      ),
      align: 'right',
    },
  ]}
/>;
```

### Common use case examples

#### Grouped list

The `TableListItem` can be used to build lists that splits items into stages or categories.

Use `<TableListHeader/>` component to display titles for different sections.

```jsx
<Box direction="vertical">
  <TableListHeader options={[{ value: 'In review' }]} />
  <TableListItem
    showDivider
    verticalPadding="tiny"
    onClick={() => {}}
    options={[
      {
        value: <Image width="90px" height="60px" src="TravelExample1.jpg" />,
        width: 'auto',
      },
      {
        value: (
          <Box direction="vertical">
            <Text weight="normal">Weekend by the Lake Como</Text>
            <Text size="small" secondary>
              Sep 23, 2022
            </Text>
          </Box>
        ),
      },
      {
        value: <Badge skin="warningLight">In review</Badge>,
        width: 'auto',
      },
      {
        value: (
          <TableActionCell
            size="small"
            primaryAction={{
              text: 'View',
              skin: 'standard',
              onClick: () => {},
            }}
            secondaryActions={[
              {
                text: 'Download',
                icon: <Icons.DownloadImportSmall />,
                onClick: () => {},
              },
              {
                text: 'Duplicate',
                icon: <Icons.DuplicateSmall />,
                onClick: () => {},
              },
              {
                text: 'Delete',
                icon: <Icons.DeleteSmall />,
                onClick: () => {},
              },
            ]}
            numOfVisibleSecondaryActions={0}
          />
        ),
        width: 'auto',
      },
    ]}
  />
  <TableListItem
    verticalPadding="tiny"
    onClick={() => {}}
    options={[
      {
        value: <Image width="90px" height="60px" src="TravelExample2.jpg" />,
        width: 'auto',
      },
      {
        value: (
          <Box direction="vertical">
            <Text weight="normal">Top 10 Restaurants in London Chinatown</Text>
            <Text size="small" secondary>
              Jun 1, 2022
            </Text>
          </Box>
        ),
      },
      {
        value: <Badge skin="warningLight">In review</Badge>,
        width: 'auto',
      },
      {
        value: (
          <TableActionCell
            size="small"
            primaryAction={{
              text: 'View',
              skin: 'standard',
              onClick: () => {},
            }}
            secondaryActions={[
              {
                text: 'Download',
                icon: <Icons.DownloadImportSmall />,
                onClick: () => {},
              },
              {
                text: 'Duplicate',
                icon: <Icons.DuplicateSmall />,
                onClick: () => {},
              },
              {
                text: 'Delete',
                icon: <Icons.DeleteSmall />,
                onClick: () => {},
              },
            ]}
            numOfVisibleSecondaryActions={0}
          />
        ),
        width: 'auto',
      },
    ]}
  />
  <TableListHeader options={[{ value: 'Approved' }]} />
  <TableListItem
    showDivider
    verticalPadding="tiny"
    onClick={() => {}}
    options={[
      {
        value: <Image width="90px" height="60px" src="TravelExample7.jpg" />,
        width: 'auto',
      },
      {
        value: (
          <Box direction="vertical">
            <Text weight="normal">Bucket List: Indonesia</Text>
            <Text size="small" secondary>
              Apr 13, 2022
            </Text>
          </Box>
        ),
      },
      {
        value: <Badge skin="neutralSuccess">Approved</Badge>,
        width: 'auto',
      },
      {
        value: (
          <TableActionCell
            size="small"
            primaryAction={{
              text: 'View',
              skin: 'standard',
              onClick: () => {},
            }}
            secondaryActions={[
              {
                text: 'Download',
                icon: <Icons.DownloadImportSmall />,
                onClick: () => {},
              },
              {
                text: 'Duplicate',
                icon: <Icons.DuplicateSmall />,
                onClick: () => {},
              },
              {
                text: 'Delete',
                icon: <Icons.DeleteSmall />,
                onClick: () => {},
              },
            ]}
            numOfVisibleSecondaryActions={0}
          />
        ),
        width: 'auto',
      },
    ]}
  />
  <TableListItem
    showDivider
    verticalPadding="tiny"
    onClick={() => {}}
    options={[
      {
        value: <Image width="90px" height="60px" src="TravelExample4.jpg" />,
        width: 'auto',
      },
      {
        value: (
          <Box direction="vertical">
            <Text weight="normal">A weekend in a desert</Text>
            <Text size="small" secondary>
              May 19, 2022
            </Text>
          </Box>
        ),
      },
      {
        value: <Badge skin="neutralSuccess">Approved</Badge>,
        width: 'auto',
      },
      {
        value: (
          <TableActionCell
            size="small"
            primaryAction={{
              text: 'View',
              skin: 'standard',
              onClick: () => {},
            }}
            secondaryActions={[
              {
                text: 'Download',
                icon: <Icons.DownloadImportSmall />,
                onClick: () => {},
              },
              {
                text: 'Duplicate',
                icon: <Icons.DuplicateSmall />,
                onClick: () => {},
              },
              {
                text: 'Delete',
                icon: <Icons.DeleteSmall />,
                onClick: () => {},
              },
            ]}
            numOfVisibleSecondaryActions={0}
          />
        ),
        width: 'auto',
      },
    ]}
  />
  <TableListItem
    showDivider
    verticalPadding="tiny"
    onClick={() => {}}
    options={[
      {
        value: <Image width="90px" height="60px" src="TravelExample5.jpg" />,
        width: 'auto',
      },
      {
        value: (
          <Box direction="vertical">
            <Text weight="normal">Top places to visit in Portugal</Text>
            <Text size="small" secondary>
              Mar 30, 2022
            </Text>
          </Box>
        ),
      },
      {
        value: <Badge skin="neutralSuccess">Approved</Badge>,
        width: 'auto',
      },
      {
        value: (
          <TableActionCell
            size="small"
            primaryAction={{
              text: 'View',
              skin: 'standard',
              onClick: () => {},
            }}
            secondaryActions={[
              {
                text: 'Download',
                icon: <Icons.DownloadImportSmall />,
                onClick: () => {},
              },
              {
                text: 'Duplicate',
                icon: <Icons.DuplicateSmall />,
                onClick: () => {},
              },
              {
                text: 'Delete',
                icon: <Icons.DeleteSmall />,
                onClick: () => {},
              },
            ]}
            numOfVisibleSecondaryActions={0}
          />
        ),
        width: 'auto',
      },
    ]}
  />
</Box>;
```

## Code

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

### Props

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `ariaLabel` | `string` | — | Provides context for screen readers when has a root element of list component in selectable state. |
| `border` | `boolean` | `false` | Adds a border around the component. |
| `borderRadius` | `"none"` | — | Controls the border radius of the component. Set to `'none'` to render square (0px) corners, useful in themes that apply rounded corners by default. |
| `checkbox` | `boolean` | `false` | Defines whether the component is selectable by a checkbox. |
| `checkboxDisabled` | `boolean` | — | Disables the visible checkbox. |
| `checkboxTooltipContent` | `ReactNode` | — | Defines a message to be displayed in a tooltip. Tooltip is displayed on a checkbox hover. |
| `checkboxTooltipProps` | `TooltipCommonProps` | — | Tooltip props (when hovering over the checkbox) |
| `checked` | `boolean` | — | Defines if component is selected. |
| `contentStyle` | `CSSProperties` | — | Styles applied to the row's leading content — the controls container when the item renders controls, the options container otherwise. |
| `dataHook` | `string` | — | Applies a data-hook HTML attribute to be used in the tests. |
| `dragDisabled` | `boolean` | — | Disables the visible drag handle. |
| `draggable` | `boolean` | `false` | Makes drag handle visible. |
| `dragging` | `boolean` | — | Visually indicates that component is being dragged. |
| `dragHandleProps` | `Partial<DragHandleProps>` | — | Extra props to pass to the `<DragHandle />` element. |
| `dragHandleSize` | `"small" \| "large"` | `large` | Changes the size of the DragHandle. |
| `expandable` | `boolean` | `false` | Adds functionality to expand the list item. |
| `expandDisabled` | `boolean` | — | Disables the visible expand handle. |
| `expanded` | `boolean` | `false` | Defines whether the list component is expanded/collapsed. |
| `focused` | `boolean` | — | Forces focus on drag handle. |
| `hideDragHandle` | `boolean` | — | Hides drag handle visually. |
| `horizontalPadding` | `"small" \| "tiny" \| "medium" \| "large" \| "xxTiny" \| "xTiny"` | `large` | Adjusts the left and right padding size. |
| `onBlur` | `(e: FocusEvent<Element, Element>) => void` | — | Defines a callback when item loses its focus. |
| `onCheckboxChange` | `ChangeEventHandler` | — | Defines a callback when checkbox is clicked. |
| `onClick` | `ReactEventHandler<HTMLElement>` | — | Defines a callback when the item is clicked. |
| `onClickExpand` | `MouseEventHandler` | — | Defines a callback when caret handle is clicked. |
| `onContextMenu` | `MouseEventHandler` | — | Defines a callback function which is called on `contextmenu` event on the list item. |
| `onFocus` | `(e: FocusEvent<Element, Element>) => void` | — | Defines a callback when item gains focus. |
| `onKeyUp` | `(e: KeyboardEvent<Element>) => void` | — | Defines a callback when the item is focused, and a key is pressed and released. Used for NestableList solutions controlled with a keyboard. |
| `onMouseEnter` | `MouseEventHandler` | — | Defines a callback function which is called on `onMouseEnter` event on the list item. |
| `onMouseLeave` | `MouseEventHandler` | — | Defines a callback function which is called on `onMouseLeave` event on the list item. |
| `options` *(required)* | `TableListItemColumn[]` | — | Defines each TableListItem column  individually, using the following props: - `value` - defines column's content. - `width` - sets the width of a column. It supports every CSS `grid-template-columns` track value, for example `2fr` or `120px`. - `align` - aligns the content in the horizontal axis. |
| `ref` | `null \| string \| (instance: unknown) => void \| RefObject<unknown>` | — | Allows getting a ref to the component instance. Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref). |
| `reserveDragHandleSpace` | `boolean` | — | Hides the drag handle without changing the layout. Used for aligning items when there's a mix of draggable and non-draggable items at the same level. |
| `reserveExpandHandleSpace` | `boolean` | — | Hides the expand handle without changing the layout. Used for aligning items when there's a mix of expandable and non-expandable items at the same level. |
| `selectable` | `boolean` | `false` | Defines whether the root element of list component is selectable. |
| `showDivider` | `boolean` | `false` | Enables a divider at the bottom of the list item. |
| `showDragHandleOnHover` | `boolean` | `false` | Enables showing drag handle only on hover. |
| `showSelectionBorder` | `boolean` | `true` | When item is with checkbox and is selected, adds a border on the left side of the component. |
| `verticalPadding` | `"small" \| "tiny" \| "medium" \| "large" \| "xxTiny" \| "xTiny"` | `small` | Adjusts the top and bottom padding size. |

## Testkit

Import the driver matching your test environment:

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

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

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

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

### Driver methods

| Method | Description |
| --- | --- |
| `getColumnTextAt` | Get column alternative text. |
| `rightClick` | Triggers a right-click (contextmenu event) on the root element. |
| `isCheckboxExists` | Defines if checkbox exists. |
| `isCheckboxChecked` | Defines if checkbox is checked. |
| `isCheckboxDisabled` | Defines if checkbox is disabled. |
| `isCheckboxTooltipEnabled` | Defines if checkbox tooltip is enabled. |
| `isDragHandleTooltipEnabled` | Defines if drag handle tooltip is enabled. |
| `expandHandleExists` | Defines if expand handle exists. |
| `toggleCheckbox` | Trigger checkbox toggle. |
| `toggleExpandHandle` | Trigger expand toggle. |
| `hoverDragHandle` | Trigger hover on a drag handle. |
| `getDragHandleDisabled` | Defines if drag handle is disabled. |
| `getCheckboxTooltipContent` | Get the content of checkbox tooltip. |
| `getDragHandleTooltipContent` | Get the content of drag handle tooltip. |
| `exists` | Checks whether the component found with the given data hook. |
| `element` | Gets the component root element. |
| `click` | Clicks on 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.337.0** (2026-10-14) — maintenance release, no component-specific changes
- **1.336.0** (2026-10-13) — maintenance release, no component-specific changes
- **1.330.3** (2026-09-29) — maintenance release, no component-specific changes
- **1.330.0** (2026-09-28) — maintenance release, no component-specific changes
- **1.329.0** (2026-09-24) — maintenance release, no component-specific changes
- **1.328.0** (2026-09-22) — maintenance release, no component-specific changes
- **1.325.0** (2026-09-17) — maintenance release, no component-specific changes
- **1.323.0** (2026-09-10) — maintenance release, no component-specific changes
- **1.313.1** (2026-08-18) — maintenance release, no component-specific changes
- **1.310.0** (2026-08-10) — maintenance release, no component-specific changes
- **1.308.0** (2026-08-04) — maintenance release, no component-specific changes
- **1.307.0** (2026-08-03) — maintenance release, no component-specific changes
- **1.299.0** (2026-07-17) — breaking: bm reimagined controls spacing and border radius tokens ([#16559](invalid-url)) — has visual changes
- **1.294.0** (2026-07-02) — fix: reveal TableActionCell actions on mobile ([#16445](invalid-url)) — has visual changes
- **1.293.0** (2026-06-26) — feat: add borderRadius prop ([#16440](invalid-url)) — has visual changes
- **1.292.0** (2026-06-22) — maintenance release, no component-specific changes
- **1.291.0** (2026-06-19) — maintenance release, no component-specific changes
- **1.290.0** (2026-06-18) — fix: use table-list-item-gap token for column gap ([#16415](invalid-url)) — has visual changes
- **1.289.0** (2026-06-17) — maintenance release, no component-specific changes
- **1.288.0** (2026-06-15) — feat: add onContextMenu callback ([#16366](invalid-url))
- **1.282.0** (2026-05-27) — fix: reduce border-radius from 12px to 8px in odeditor and odeditor-dark ([#16314](invalid-url)) — has visual changes
- **1.282.0** (2026-05-27) — fix: theme the expand chevron color so dark skins render it visibly ([#16309](invalid-url)) — has visual changes
- **1.273.0** (2026-04-30) — 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.254.0** (2026-02-03) — maintenance release, no component-specific changes
- **1.247.2** (2026-01-21) — maintenance release, no component-specific changes
- **1.242.0** (2025-12-19) — maintenance release, no component-specific changes
- **1.241.0** (2025-12-17) — maintenance release, no component-specific changes
- **1.239.0** (2025-12-12) — feat: add onFocus & onBlur callback support ([#15651](invalid-url))
- **1.232.0** (2025-11-28) — maintenance release, no component-specific changes
- **1.224.0** (2025-10-29) — fix: change gap in TableListItem in Studio ([#15443](invalid-url))
- **1.217.0** (2025-09-08) — breaking: update border color & radius ([#15278](invalid-url))
- **1.214.2** (2025-08-25) — feat: add custom selector for mobile hover ([#15214](invalid-url))
- **1.212.0** (2025-08-11) — breaking: add tokens ([#15162](invalid-url))
- **1.200.0** (2025-06-17) — maintenance release, no component-specific changes
- **1.198.0** (2025-06-09) — maintenance release, no component-specific changes
- **1.187.0** (2025-05-07) — maintenance release, no component-specific changes
- **1.176.0** (2025-04-02) — maintenance release, no component-specific changes
- **1.172.1** (2025-03-21) — maintenance release, no component-specific changes
- **1.166.0** (2025-03-04) — breaking: tokenization ([#14564](invalid-url))
- **1.161.0** (2025-02-12) — feat: add ability to hide drag handle and show it only when the item is hovered ([#14520](invalid-url))
- **1.161.0** (2025-02-12) — feat: add ability to enable/disable border indicator on the left ([#14518](invalid-url))
- **1.161.0** (2025-02-12) — breaking: add alternative selected indication state | visual update drag handle color in all states ([#14499](invalid-url))
- **1.154.0** (2025-01-16) — feat: added onMouseEnter/onMouseLeave callbacks ([#14453](invalid-url))
- **1.138.1** (2024-10-30) — maintenance release, no component-specific changes
- **1.136.0** (2024-10-24) — fix: fix table list extend button clicking area ([#14238](invalid-url))
- **1.128.0** (2024-09-19) — maintenance release, no component-specific changes
- **1.127.1** (2024-09-16) — fix: revert making value container fullheight ([#14135](invalid-url))
- **1.127.0** (2024-09-12) — fix: making value container fullheight ([#14120](invalid-url))
- **1.115.0** (2024-07-17) — maintenance release, no component-specific changes
- **1.105.0** (2024-05-21) — maintenance release, no component-specific changes
- **1.104.1** (2024-05-14) — maintenance release, no component-specific changes
- **1.102.0** (2024-04-16) — maintenance release, no component-specific changes
- **1.95.0** (2024-02-15) — maintenance release, no component-specific changes
- **1.93.0** (2024-02-08) — maintenance release, no component-specific changes
- **1.92.1** (2024-02-05) — maintenance release, no component-specific changes