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

## Article: TableActionCell Component

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

## Article Content:

# TableActionCell

_Components/Lists/Table_

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

## Overview

```jsx
<TableListItem
  onClick={() => {}}
  options={[
    {
      value: (
        <TableActionCell
          primaryAction={{
            text: 'Edit',
            skin: 'standard',
            onClick: () => {},
          }}
          secondaryActions={[
            {
              text: 'Mark as favourite',
              icon: <Icons.FavoriteSmall />,
              onClick: () => {},
            },
            {
              text: 'Download as PDF',
              icon: <Icons.DownloadImportSmall />,
              onClick: () => {},
            },
            {
              text: 'Duplicate',
              icon: <Icons.DuplicateSmall />,
              onClick: () => {},
            },
            {
              text: 'Print',
              icon: <Icons.PrintSmall />,
              onClick: () => {},
            },
          ]}
          numOfVisibleSecondaryActions={0}
          moreActionsTooltipText="More Actions"
        />
      ),
    },
  ]}
/>;
```

Table action cell is a built-in solution that displays actions inside of table cells. The primary action is displayed as a button, while secondary actions are displayed either as multiple icon buttons or listed in a popover menu. Component should be rendered in the last column of a data row.

### Do

- Use it to display actions that a user can take on a specific table row.
- Render it in the last column of a table row.
- Group similar items together using dividers in popover menu for easy readability.

### Don't

- Don't use it to display single or multiple actions directly on a page or a widget. Use standard `<Button/>` instead.

### Feature examples

#### Size

Control the size of primary and secondary actions displayed in a table cell with the `size` prop. Component supports 2 sizes:

- `medium` - use in all common cases
- `small` - use for dense tables

```jsx
<StorybookComponents.Stack flexDirection="column">
  <TableListItem
    onClick={() => {}}
    options={[
      {
        value: (
          <TableActionCell
            size="medium"
            primaryAction={{
              text: 'Medium',
              onClick: () => {},
            }}
          />
        ),
      },
    ]}
  />
  <TableListItem
    onClick={() => {}}
    options={[
      {
        value: (
          <TableActionCell
            size="small"
            primaryAction={{
              text: 'Small',
              onClick: () => {},
            }}
          />
        ),
      },
    ]}
  />
</StorybookComponents.Stack>;
```

#### Primary action

Define a main action of a cell with the `primaryAction` prop. Action will be revealed on table row hover only.

```jsx
<TableListItem
  onClick={() => {}}
  options={[
    {
      value: (
        <TableActionCell
          primaryAction={{
            text: 'Primary Action',
            onClick: () => {},
          }}
        />
      ),
    },
  ]}
/>;
```

#### Primary action visibility

Control the appearance of a primary action with the `visibility` prop. It supports 2 options:

- `onHover` (default) - button is only visible when the mouse hovers over item.
- `always` - button is always visible and appears as a secondary button.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <TableListItem
    onClick={() => {}}
    options={[
      {
        value: (
          <TableActionCell
            primaryAction={{
              text: 'On Hover',
              visibility: 'onHover',
              onClick: () => {},
            }}
          />
        ),
      },
    ]}
  />
  <TableListItem
    onClick={() => {}}
    options={[
      {
        value: (
          <TableActionCell
            primaryAction={{
              text: 'Always',
              visibility: 'always',
              onClick: () => {},
            }}
          />
        ),
      },
    ]}
  />
</StorybookComponents.Stack>;
```

#### Primary action icon affix

Give more context to the primary action by adding an icon affix. It can be added to 2 locations:

- `prefixIcon` - use to add a descriptive icon in front of a label
- `suffixIcon` - use to add a directional icon at the end of a label

```jsx
<StorybookComponents.Stack flexDirection="column">
  <TableListItem
    onClick={() => {}}
    options={[
      {
        value: (
          <TableActionCell
            primaryAction={{
              text: 'Add Members',
              prefixIcon: <Icons.UserAdd />,
              onClick: () => {},
            }}
          />
        ),
      },
    ]}
  />
  <TableListItem
    onClick={() => {}}
    options={[
      {
        value: (
          <TableActionCell
            primaryAction={{
              text: 'View',
              suffixIcon: <Icons.ChevronRight />,
              onClick: () => {},
            }}
          />
        ),
      },
    ]}
  />
</StorybookComponents.Stack>;
```

#### Secondary actions

Define an array of additional actions for each row with the `secondaryActions` prop. Icon and text label are required to be specified. Actions will be listed in a popover menu.

Add the label for an icon button that opens up a popover menu using `moreActionsTooltipText`. Recommended label text: 'More actions'. It will be shown in a tooltip on hover or focus.

```jsx
<TableListItem
  onClick={() => {}}
  options={[
    {
      value: (
        <TableActionCell
          secondaryActions={[
            {
              text: 'Star',
              icon: <Icons.FavoriteSmall />,
              onClick: () => {},
            },
            {
              text: 'Download',
              icon: <Icons.DownloadImportSmall />,
              onClick: () => {},
            },
            {
              text: 'Duplicate',
              icon: <Icons.DuplicateSmall />,
              onClick: () => {},
            },
            {
              text: 'Print',
              icon: <Icons.PrintSmall />,
              onClick: () => {},
            },
          ]}
          moreActionsTooltipText="More actions"
        />
      ),
    },
  ]}
/>;
```

#### Number of visible secondary actions

Display a selected number of secondary actions as icon buttons with the `numOfVisibleSecondaryActions` prop. By default actions will be revealed on hover only.

To display the icons all the time use the `alwaysShowSecondaryActions` prop.

```jsx
() => {
  const secondaryActions = [
    {
      text: 'Star',
      icon: <Icons.Favorite />,
      onClick: () => {},
    },
    {
      text: 'Download',
      icon: <Icons.DownloadImport />,
      onClick: () => {},
    },
    {
      text: 'Duplicate',
      icon: <Icons.DuplicateSmall />,
      onClick: () => {},
    },
    {
      text: 'Print',
      icon: <Icons.PrintSmall />,
      onClick: () => {},
    },
  ];

  return (
    <StorybookComponents.Stack flexDirection="column">
      <TableListItem
        onClick={() => {}}
        options={[
          {
            value: (
              <TableActionCell
                secondaryActions={secondaryActions}
                numOfVisibleSecondaryActions={2}
              />
            ),
          },
        ]}
      />
      <TableListItem
        onClick={() => {}}
        options={[
          {
            value: (
              <TableActionCell
                secondaryActions={secondaryActions}
                numOfVisibleSecondaryActions={2}
                alwaysShowSecondaryActions
              />
            ),
          },
        ]}
      />
    </StorybookComponents.Stack>
  );
};
```

#### Divider

Add a separating line to group related actions or distinguish destructive actions from the rest. Do it in a popover menu by rendering `divider` as a separate action in the `secondaryActions` array.

```jsx
() => {
  const secondaryActions = [
    {
      text: 'Star',
      icon: <Icons.FavoriteSmall />,
      onClick: () => {},
    },
    {
      text: 'Download',
      icon: <Icons.DownloadImportSmall />,
      onClick: () => {},
    },
    {
      text: 'Duplicate',
      icon: <Icons.DuplicateSmall />,
      onClick: () => {},
    },
    {
      divider: true,
    },
    {
      text: 'Delete',
      icon: <Icons.DeleteSmall />,
      onClick: () => {},
    },
  ];

  return (
    <TableListItem
      onClick={() => {}}
      options={[
        {
          value: <TableActionCell secondaryActions={secondaryActions} />,
        },
      ]}
    />
  );
};
```

#### Disabled

Disable all interactions for primary or secondary actions with the `disabled` prop. Use it to highlight unavailable functions.

Always provide an explanation for the user why actions cannot be accessed. Use `disabledDescription` prop to show a descriptive message in a tooltip.

_Note_: at the moment description can be added to visible secondary actions only.

```jsx
() => {
  const primaryAction = {
    text: 'Edit',
    onClick: () => {},
    disabled: true,
  };

  const secondaryActions = [
    {
      text: 'Star',
      icon: <Icons.Star />,
      onClick: () => {},
      disabled: true,
      disabledDescription:
        'Message that explains why user cannot access this action',
    },
    {
      text: 'Download',
      icon: <Icons.Download />,
      onClick: () => {},
      disabled: true,
      disabledDescription:
        'Message that explains why user cannot access this action',
    },
    {
      text: 'Duplicate',
      icon: <Icons.DuplicateSmall />,
      onClick: () => {},
      disabled: true,
    },
    {
      text: 'Print',
      icon: <Icons.PrintSmall />,
      onClick: () => {},
      disabled: true,
    },
  ];

  return (
    <TableListItem
      onClick={() => {}}
      options={[
        {
          value: (
            <TableActionCell
              primaryAction={primaryAction}
              secondaryActions={secondaryActions}
              numOfVisibleSecondaryActions={2}
            />
          ),
        },
      ]}
    />
  );
};
```

#### Popover menu

Customize the appearance of secondary actions popover menu with `popoverMenuProps`.

Check `<PopoverMenu/>` API for a full list of available properties.

```jsx
() => {
  const secondaryActions = [
    {
      text: 'Mark as favorite',
      icon: <Icons.FavoriteSmall />,
      onClick: () => {},
    },
    {
      text: 'Download',
      icon: <Icons.DownloadImportSmall />,
      onClick: () => {},
    },
    {
      text: 'Duplicate',
      icon: <Icons.DuplicateSmall />,
      onClick: () => {},
    },
    {
      divider: true,
    },
    {
      text: 'Delete',
      icon: <Icons.DeleteSmall />,
      onClick: () => {},
    },
  ];

  return (
    <TableListItem
      onClick={() => {}}
      options={[
        {
          value: (
            <TableActionCell
              popoverMenuProps={{
                placement: 'bottom',
                showArrow: false,
                textSize: 'small',
                maxWidth: '90px',
                ellipsis: true,
              }}
              secondaryActions={secondaryActions}
            />
          ),
        },
      ]}
    />
  );
};
```

### Common use case examples

#### Row actions

Use table action cell to display row actions in the last column of a data table.

```jsx
() => {
  const records = [
    {
      name: `Light grey hoodie`,
      SKU: '00224239',
      price: '$59.00',
      inventory: 'In stock',
    },
    {
      name: `Black watch`,
      SKU: '00352464',
      price: '$229.00',
      inventory: 'In stock',
    },
    {
      name: 'Reading glasses',
      SKU: '00486430',
      price: '$69.00',
      inventory: 'In stock',
    },
    {
      name: 'Leather shoes',
      SKU: '00515642',
      price: '$129.00',
      inventory: 'Out of stock',
    },
  ];

  const columns = [
    { title: 'Name', render: (row) => row.name },
    { title: 'SKU', render: (row) => row.SKU },
    { title: 'Inventory', render: (row) => row.inventory },
    { title: 'Price', render: (row) => row.price },
    {
      title: '',
      render: () => (
        <TableActionCell
          onClick={() => {}}
          primaryAction={{
            text: 'Edit',
            onClick: () => {},
          }}
          secondaryActions={[
            {
              text: 'Duplicate',
              icon: <Icons.DuplicateSmall />,
              onClick: () => {},
            },
            {
              text: 'Delete',
              icon: <Icons.DeleteSmall />,
              onClick: () => {},
            },
          ]}
        />
      ),
    },
  ];

  return (
    <Card>
      <Table data={records} columns={columns} onRowClick={() => {}}>
        <TableToolbar>
          <TableToolbar.Title>Products</TableToolbar.Title>
        </TableToolbar>
        <Table.Content />
      </Table>
    </Card>
  );
};
```

#### Groups

Use dividers to group large lists of actions in a secondary actions menu.

```jsx
() => {
  const data = [
    {
      imageSrc: 'TravelExample1.jpg',
      title: 'Weekend by the Lake Como',
      subtitle: 'Jun 1, 2020 • Matthew W.',
      translations: 'English, Lithuanian',
    },
    {
      imageSrc: 'TravelExample2.jpg',
      title: 'Top 10 Restaurants in London Chinatown',
      subtitle: 'Jun 1, 2020 • Matthew W.',
      translations: 'English',
    },
    {
      imageSrc: 'TravelExample7.jpg',
      title: 'Bucket List: Indonesia',
      subtitle: 'Jun 1, 2020 • Matthew W.',
      translations: 'English',
    },
  ];

  const [activeSearch, setActiveSearch] = React.useState('');
  const [filteredData, setFilteredData] = React.useState(data);

  const renderDescription = (title, subtitle) => (
    <Box direction="vertical" verticalAlign="middle">
      <Text size="medium" weight="normal">
        {title}
      </Text>
      <Text size="tiny" secondary>
        {subtitle}
      </Text>
    </Box>
  );

  const records = filteredData.map(
    ({ imageSrc, title, subtitle, translations }) => ({
      image: <Image width="90px" height="60px" src={imageSrc} />,
      name: (
        <Box direction="vertical" verticalAlign="middle">
          <Text size="medium" weight="normal">
            {title}
          </Text>
          <Text size="tiny" secondary>
            {subtitle}
          </Text>
        </Box>
      ),
      translations,
    }),
  );

  const findFilteredData = (activeSearch) => {
    setFilteredData(
      data.filter(({ title, subtitle, translations }) => {
        const searchData = [title, subtitle, translations]
          .join(' ')
          .toLowerCase();

        const searchQuery = activeSearch.trim().toLowerCase();

        if (searchQuery && searchData.indexOf(searchQuery) === -1) {
          return false;
        }

        return true;
      }),
    );

    setActiveSearch(activeSearch);
  };

  const columns = [
    { title: '', width: '90px', render: (row) => row.image },
    { title: 'Name', width: '40%', render: (row) => row.name },
    { title: 'Translations', render: (row) => row.translations },
    {
      title: '',
      render: () => (
        <TableActionCell
          onClick={() => {}}
          popoverMenuProps={{
            maxWidth: 'max-content',
          }}
          secondaryActions={[
            {
              text: 'View post',
              icon: <Icons.VisibleSmall />,
              onClick: () => {},
            },
            {
              text: 'Share post',
              icon: <Icons.ShareSmall />,
              onClick: () => {},
            },
            {
              text: 'View post report',
              icon: <Icons.StatisticsSmall />,
              onClick: () => {},
            },
            {
              divider: true,
            },
            {
              text: 'Add to a subscription plan',
              icon: <Icons.PaymentSmall />,
              onClick: () => {},
            },
            {
              text: 'Translate post',
              icon: <Icons.LanguagesSmall />,
              onClick: () => {},
            },
            {
              text: 'Change language',
              icon: <Icons.ReplaceSmall />,
              onClick: () => {},
            },
            {
              divider: true,
            },
            {
              text: 'Duplicate post',
              icon: <Icons.DuplicateSmall />,
              onClick: () => {},
            },
            {
              text: 'Revert to draft',
              icon: <Icons.RefreshSmall />,
              onClick: () => {},
            },
            {
              text: 'Move to trash',
              icon: <Icons.DeleteSmall />,
              onClick: () => {},
            },
          ]}
        />
      ),
    },
  ];

  return (
    <Card>
      <Table data={records} columns={columns}>
        <TableToolbar>
          <TableToolbar.ItemGroup>
            <TableToolbar.Item>
              <Text size="small" secondary>
                3 posts
              </Text>
            </TableToolbar.Item>
          </TableToolbar.ItemGroup>
          <TableToolbar.ItemGroup>
            <TableToolbar.Item>
              <Search
                size="small"
                value={activeSearch}
                onChange={(event) => findFilteredData(event.target.value)}
              />
            </TableToolbar.Item>
          </TableToolbar.ItemGroup>
        </TableToolbar>
        <Table.Content />
      </Table>
    </Card>
  );
};
```

## Code

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

### Props

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `alwaysShowPrimaryActions` | `boolean` | — | Specifies whether primary actions should be visible all the time. By default primary actions are visible on row hover only. |
| `alwaysShowSecondaryActions` | `boolean` | — | Specifies whether secondary actions should be visible all the time. By default secondary actions are visible on row hover only. |
| `dataHook` | `string` | — | Applies a data-hook HTML attribute to be used in the tests. |
| `moreActionsProps` | `TableActionCellMoreActionsProps` | — | Controls the appearance of the more actions icon button. |
| `moreActionsTooltipText` | `string` | — | Sets the tooltip text of more actions icon button. |
| `numOfVisibleSecondaryActions` | `number` | — | Specifies the number of secondary actions to display outside of the popover menu. |
| `onClick` | `() => void` | — | Called when clicking on the table action cell. |
| `popoverMenuProps` | `TableActionCellPopoverMenuProps` | — | Controls the appearance of secondary actions menu with all common popover menu props. |
| `primaryAction` | `ButtonHTMLAttributes<HTMLButtonElement> & { visibility?: TableActionCellPrimaryActionVisibility \| undefined; } & { ...; } & BaseActionProps \| AnchorHTMLAttributes<HTMLAnchorElement> & { visibility?: TableActionCellPrimaryActionVisibility \| undefined; } & { ...; } & BaseActionProps \| { visibility?: TableActionCellPrimaryActionVisibility \| undefined; } & { [additionalProps: string]: any; as: "object" \| "abbr" \| "address" \| ... 106 more ... \| "wbr"; onClick?: MouseEventHandler<...> \| undefined; } & BaseActionProps \| { visibility?: TableActionCellPrimaryActionVisibility \| undefined; } & { [additionalProps: string]: any; as: ComponentType<any>; onClick?: MouseEventHandler<...> \| undefined; } & BaseActionProps \| TableActionCellMainAction[]` | — | Controls the behaviour and appearance of a primary action. Can be a single action object or an array of action objects. |
| `primaryActionPlaceholderProps` | `TableActionCellPrimaryActionPlaceholderProps` | — | Controls the appearance of the primary action placeholder icon button. |
| `secondaryActions` | `(TableActionCellSecondaryAction \| TableActionCellSecondaryDivider)[]` | — | Controls the behaviour and appearance of secondary actions. |
| `secondaryActionsProps` | `TableActionCellSecondaryActionsProps` | — | Controls the appearance of the visible inline secondary action icon buttons. |
| `size` | `"small" \| "tiny" \| "medium"` | `medium` | Controls the size of action buttons. |

## Testkit

Import the driver matching your test environment:

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

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

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

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

### Driver methods

| Method | Description |
| --- | --- |
| `getPrimaryActionButtonDriver` | Get the driver of the primary action <Button/> from the action column |
| `getPrimaryActionButtonDriverByDataHook` | Get the driver of a specific primary action <Button/> by dataHook (for array format) |
| `getPrimaryActionsCount` | Get the number of primary actions (for array format) |
| `getPrimaryActionButtonVisibility` | Gets primary action visibility value |
| `clickPrimaryActionButton` | Clicks the primary action button of the action column |
| `clickPrimaryAction` | Clicks a specific primary action button by index (for array format) |
| `clickPrimaryActionByDataHook` | Clicks a specific primary action button by dataHook (for array format) |
| `getIsPrimaryActionButtonDisabled` | Checks whether the primary action button is disabled |
| `primaryActionButtonPrefixIconExists` | Checks whether the primary action button has an prefix icon |
| `primaryActionButtonSuffixIconExists` | Checks whether the primary action button has an suffix icon |
| `getVisibleActionsCount` | Get the number of the visible secondary actions |
| `getHiddenActionsCount` | Get the number of hidden secondary actions (in the <PopoverMenu/>, requires it to be open) |
| `getVisibleActionTooltipDriver` | Gets a specific visible secondary action <Tooltip/> driver |
| `getVisibleActionByDataHookTooltipDriver` | Get the driver of a specific visible secondary action <Tooltip/> by its specified dataHook |
| `getVisibleActionButtonDriver` | Get the driver of a specific visible secondary action <Button/> |
| `getVisibleActionByDataHookButtonDriver` | Gets a specific visible secondary action <Button/> driver by its specified dataHook |
| `getHiddenActionsPopoverMenuDriver` | Gets the hidden secondary action <PopoverMenu/> driver |
| `clickVisibleAction` | Clicks on a visible secondary action |
| `clickVisibleActionByDataHook` | Clicks on a visible secondary action by its specified dataHook |
| `clickPopoverMenu` | Clicks on the hidden secondary actions <PopoverMenu/> |
| `clickHiddenAction` | Clicks on a hidden secondary action (requires the <PopoverMenu/> to be open) |
| `clickHiddenActionByDataHook` | Clicks hidden action by data hook |
| `getMoreActionsTooltipText` | Gets tooltip text of more actions toggle button |
| `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.342.0** (2026-10-26) — maintenance release, no component-specific changes
- **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.331.0** (2026-10-01) — maintenance release, no component-specific changes
- **1.330.3** (2026-09-29) — fix: row actions are now always visible when `WixDesignSystemProvider` has `mobile` enabled, including inside `Table`, where touch users previously couldn't reveal them. Desktop behavior is unchanged. ([#17265](invalid-url)) — has visual 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.321.0** (2026-09-08) — feat: added `primaryActionPlaceholderProps` prop, letting you control the priority of the primary action's placeholder icon button. ([#17020](invalid-url)) — has visual changes
- **1.313.1** (2026-08-18) — fix: in Harmony (odeditor) and Studio 2.0 (odeditor-dark), row content that reaches the actions now fades into a backdrop that matches the row's background (including its hover fill) just before the first visible action instead of running under the buttons, and items in the "more actions" popover menu hover grey like other PopoverMenu items. ([#16780](invalid-url)) — has visual changes
- **1.310.0** (2026-08-10) — maintenance release, no component-specific changes
- **1.306.0** (2026-07-31) — maintenance release, no component-specific changes
- **1.299.0** (2026-07-17) — breaking: reduce gap between action buttons (Harmony & Harmony Dark themes) ([#16564](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.284.0** (2026-06-04) — feat: add secondaryActionsProps to override visible action priority ([#16334](invalid-url)) — has visual changes
- **1.280.0** (2026-05-19) — feat: forward click event to secondary action onClick ([#16279](invalid-url))
- **1.280.0** (2026-05-19) — fix: respect size prop in cell height ([#16268](invalid-url)) — has visual changes
- **1.278.0** (2026-05-08) — maintenance release, no component-specific changes
- **1.277.0** (2026-05-07) — 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.247.2** (2026-01-21) — maintenance release, no component-specific changes
- **1.242.0** (2025-12-19) — maintenance release, no component-specific changes
- **1.222.0** (2025-10-23) — feat: add `moreActionsProps` to allow skin and priority control of IconButton ([#15428](invalid-url))
- **1.220.0** (2025-09-29) — feat: primaryAction can be array with different priorities ([#15338](invalid-url))
- **1.204.0** (2025-07-03) — feat: add premium skin to primary and secondary actions ([#15035](invalid-url))
- **1.204.0** (2025-07-03) — fix: disabled tooltip not showing ([#15044](invalid-url))
- **1.180.0** (2025-04-14) — maintenance release, no component-specific changes
- **1.172.0** (2025-03-20) — fix: return missing dataHook ([#14630](invalid-url))
- **1.172.0** (2025-03-20) — fix: fix broken import of data hooks ([#14624](invalid-url))
- **1.171.0** (2025-03-14) — feat: add disabled primary action tooltip for table list item action cell ([#14609](invalid-url))
- **1.154.0** (2025-01-17) — maintenance release, no component-specific changes
- **1.122.0** (2024-08-21) — fix: missing focus ring when keyboard navigating ([#14042](invalid-url))
- **1.115.0** (2024-07-17) — maintenance release, no component-specific changes
- **1.104.0** (2024-05-06) — fix: revert "feat(TableActionCell): add background gradient (#13654)" ([#13700](invalid-url))
- **1.103.4** (2024-05-02) — fix: sticky cell will be always visible ([#13662](invalid-url))
- **1.103.3** (2024-04-30) — feat: add background gradient ([#13654](invalid-url))
- **1.102.0** (2024-04-16) — maintenance release, no component-specific changes
- **1.98.0** (2024-03-15) — maintenance release, no component-specific changes
- **1.92.1** (2024-02-05) — maintenance release, no component-specific changes