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

## Article: NestableList Component

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

## Article Content:

# NestableList

_Components/Lists_

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

## Overview

```jsx
() => {
  const TableListItemContent = ({ imageSrc, title, description }) => (
    <Box align="space-between" verticalAlign="middle">
      <Box verticalAlign="middle">
        <Image width="72px" height="48px" src={imageSrc} />
        <Box marginLeft="SP3" direction="vertical">
          <Text weight="normal">{title}</Text>
          <Text size="small" secondary>
            {description}
          </Text>
        </Box>
      </Box>
      <PopoverMenu
        placement="left"
        triggerElement={
          <IconButton skin="light">
            <Icons.More />
          </IconButton>
        }
      >
        <PopoverMenu.MenuItem
          text="Edit Category"
          prefixIcon={<Icons.Edit />}
        />
        <PopoverMenu.MenuItem
          text="Move Category"
          prefixIcon={<Icons.FolderMove />}
        />
        <PopoverMenu.MenuItem
          text="Delete Category"
          prefixIcon={<Icons.Delete />}
        />
      </PopoverMenu>
    </Box>
  );

  return (
    <NestableList
      items={[
        {
          id: '1',
          verticalPadding: 'tiny',
          options: [
            {
              value: (
                <TableListItemContent
                  imageSrc="TennisExample1.jpg"
                  title="Sports"
                  description="1 post · 60 views"
                />
              ),
            },
          ],
          children: [
            {
              id: '2',
              verticalPadding: 'tiny',
              options: [
                {
                  value: (
                    <TableListItemContent
                      imageSrc="TennisExample2.jpg"
                      title="Equipment"
                      description="5 posts · 100 views"
                    />
                  ),
                },
              ],
            },
            {
              id: '3',
              verticalPadding: 'tiny',
              options: [
                {
                  value: (
                    <TableListItemContent
                      imageSrc="TennisExample3.jpg"
                      title="Courts"
                      description="3 posts · 120 views"
                    />
                  ),
                },
              ],
            },
          ],
        },
        {
          id: '4',
          verticalPadding: 'tiny',
          options: [
            {
              value: (
                <TableListItemContent
                  imageSrc="TennisExample4.jpg"
                  title="Tournaments"
                  description="15 posts · 160 views"
                />
              ),
            },
          ],
        },
      ]}
      onChange={() => {}}
    />
  );
};
```

Nestable lists let users sort their list items into sub-levels using drag and drop.

### Do

- Organize items into sub-levels and categories.
- Create lists that users can add to.

### Don't

- Don't show static lists. Use `<Accordion/>` or `<Table/>` instead.
- Don't use them for lists that span across multiple pages.

### Feature examples

#### Add items

Let users add new parent items or child items with the `addItemLabel` prop.

```jsx
<NestableList
  addItemLabel="Add item to level 1"
  items={[
    {
      id: 1,
      options: [{ value: <Text size="small">Item 1</Text> }],
      addItemLabel: 'Add item to level 2',
      children: [
        { id: 2, options: [{ value: <Text size="small">Item 2</Text> }] },
      ],
    },
  ]}
  onChange={() => {}}
/>;
```

#### Maximum depth

Define a maximum number of sub-levels that can be added to the list with the `maxDepth` prop.

By default, the maximum `maxDepth` value is set to `10`.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <Text size="small">Maximum depth of 3 levels</Text>
  <NestableList
    maxDepth={3}
    items={[
      {
        id: '1',
        options: [
          {
            value: <Text size="small">Item 1</Text>,
          },
        ],
        children: [
          {
            id: '2',
            options: [
              {
                value: <Text size="small">Item 2</Text>,
              },
            ],
            children: [
              {
                id: '3',
                options: [
                  {
                    value: <Text size="small">Item 3</Text>,
                  },
                ],
              },
            ],
          },
        ],
      },
    ]}
    onChange={() => {}}
  />
  <Text size="small">Maximum depth of 2 levels</Text>
  <NestableList
    maxDepth={2}
    items={[
      {
        id: '4',
        options: [
          {
            value: <Text size="small">Item 1</Text>,
          },
        ],
        children: [
          {
            id: '5',
            options: [
              {
                value: <Text size="small">Item 2</Text>,
              },
            ],
          },
          {
            id: '6',
            options: [
              {
                value: (
                  <Text size="small">This item can't be moved to level 3</Text>
                ),
              },
            ],
          },
        ],
      },
    ]}
    onChange={() => {}}
  />
</StorybookComponents.Stack>;
```

#### Indent size

Control arrow indent size with `indentSize` prop:

- `small` is best for very narrow layouts, such as settings panels.
- `medium` is for smaller layouts.
- `large` (default) is used for admin tables.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NestableList
    indentSize="small"
    readOnly={true}
    items={[
      {
        id: 1,
        options: [{ value: <Text size="small">Item 1</Text> }],
        children: [
          { id: 2, options: [{ value: <Text size="small">Item 2</Text> }] },
          { id: 3, options: [{ value: <Text size="small">Item 3</Text> }] },
        ],
      },
    ]}
    onChange={() => {}}
  />
  <NestableList
    indentSize="medium"
    readOnly={true}
    items={[
      {
        id: 1,
        options: [{ value: <Text size="small">Item 1</Text> }],
        children: [
          { id: 2, options: [{ value: <Text size="small">Item 2</Text> }] },
          { id: 3, options: [{ value: <Text size="small">Item 3</Text> }] },
        ],
      },
    ]}
    onChange={() => {}}
  />
  <NestableList
    indentSize="large"
    readOnly={true}
    items={[
      {
        id: 1,
        options: [{ value: <Text size="small">Item 1</Text> }],
        children: [
          { id: 2, options: [{ value: <Text size="small">Item 2</Text> }] },
          { id: 3, options: [{ value: <Text size="small">Item 3</Text> }] },
        ],
      },
    ]}
    onChange={() => {}}
  />
</StorybookComponents.Stack>;
```

#### Dividers

Turn off dividers with `dividers` prop to give the component more minimal look, by setting the property to `false`. Dividers are on by default.

```jsx
<NestableList
  indentSize="medium"
  dividers={false}
  readOnly={true}
  items={[
    {
      id: 1,
      options: [{ value: <Text size="small">Item 1</Text> }],
      children: [
        { id: 2, options: [{ value: <Text size="small">Item 2</Text> }] },
        { id: 3, options: [{ value: <Text size="small">Item 3</Text> }] },
      ],
    },
  ]}
  onChange={() => {}}
/>;
```

#### Prevent changing depth

Lock the existing depth for all items in the list with the `preventChangeDepth` prop. This property allows users to change the order of items, but only at the same level of hierarchy.

By default the value of the `preventChangeDepth` property is `false`. This means users can drag and drop any item to any level.

```jsx
<NestableList
  preventChangeDepth={true}
  items={[
    {
      id: 1,
      options: [
        { value: <Text size="small">This item can only move in level 1</Text> },
      ],
      children: [
        {
          id: 2,
          options: [
            {
              value: (
                <Text size="small">This item can only move in level 2</Text>
              ),
            },
          ],
        },
        {
          id: 3,
          options: [
            {
              value: (
                <Text size="small">This item can only move in level 2</Text>
              ),
            },
          ],
        },
      ],
    },
    {
      id: 4,
      options: [
        { value: <Text size="small">This item can only move in level 1</Text> },
      ],
      children: [
        {
          id: 5,
          options: [
            {
              value: (
                <Text size="small">This item can only move in level 2</Text>
              ),
            },
          ],
        },
      ],
    },
  ]}
  onChange={() => {}}
/>;
```

#### Lock dragging

To lock an individual item's position, use the `items` prop and set `draggable` to `false`.

Items that aren't locked can still freely change their position in the list.

```jsx
<NestableList
  items={[
    {
      id: 1,
      options: [
        { value: <Text size="small">This item can't be dragged</Text> },
      ],
      draggable: false,
      children: [
        {
          id: 2,
          options: [
            { value: <Text size="small">This item can't be dragged</Text> },
          ],
          draggable: false,
        },
        {
          id: 3,
          options: [
            { value: <Text size="small">This item can be moved freely</Text> },
          ],
        },
      ],
    },
    {
      id: 4,
      options: [
        { value: <Text size="small">This item can be moved freely</Text> },
      ],
      children: [
        {
          id: 5,
          options: [
            { value: <Text size="small">This item can be moved freely</Text> },
          ],
        },
      ],
    },
  ]}
  onChange={() => {}}
/>;
```

#### Read only mode

Prevent any reordering in the list with the `readOnly` prop. The list won't display any interactive icons.

```jsx
<NestableList
  readOnly={true}
  items={[
    {
      id: 1,
      options: [{ value: <Text size="small">Item 1</Text> }],
      children: [
        { id: 2, options: [{ value: <Text size="small">Item 2</Text> }] },
        { id: 3, options: [{ value: <Text size="small">Item 3</Text> }] },
      ],
    },
  ]}
  onChange={() => {}}
/>;
```

#### Collapse items

To hide children and only show the parent item, use the `items` prop and set `isCollapsed` to `true`.

By default, parent items hide their children when they're being selected and dragged.

```jsx
() => {
  const CollapseIcon = ({ id, allItems }) => {
    const onCollapse = () => {
      setItems(
        allItems.map((item) =>
          item.id === id ? { ...item, isCollapsed: !item.isCollapsed } : item,
        ),
      );
    };
    const { isCollapsed } = allItems.filter((item) => item.id === id)[0];

    return (
      <Box align="right">
        <IconButton skin="light" onClick={onCollapse}>
          {isCollapsed ? <Icons.ChevronDown /> : <Icons.ChevronUp />}
        </IconButton>
      </Box>
    );
  };

  const [items, setItems] = React.useState([
    {
      id: 'item-1',
      options: [{ value: <Text size="small">Item 1</Text> }],
    },
    {
      id: 'item-2',
      isCollapsed: true,
      options: [{ value: <Text size="small">Show and hide children</Text> }],
      children: [
        {
          id: 'item-2-child-1',
          options: [{ value: <Text size="small">Child 1</Text> }],
        },
        {
          id: 'item-2-child-2',
          options: [{ value: <Text size="small">Child 2</Text> }],
        },
        {
          id: 'item-2-child-3',
          options: [{ value: <Text size="small">Child 3</Text> }],
        },
      ],
    },
    {
      id: 'item-3',
      options: [{ value: <Text size="small">Item 3</Text> }],
    },
  ]);

  const itemsWithUpdatedControls = items.map((item) => {
    return {
      ...item,
      options: item.children
        ? [
            item.options[0],
            {
              value: <CollapseIcon id={item.id} allItems={items} />,
            },
          ]
        : [item.options[0]],
    };
  });

  return (
    <NestableList
      items={itemsWithUpdatedControls}
      onChange={(onChangeData) => setItems(onChangeData.items)}
    />
  );
};
```

#### Bottom border

Add a bottom border to the last item in the list with the `withBottomBorder` prop. The default value is set to `false`.

Use the border when the list is outside the card or modal, for example, in the sidebar and on white backgrounds.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <NestableList
    items={[
      {
        id: 1,
        options: [{ value: <Text size="small">Item 1</Text> }],
      },
      {
        id: 2,
        options: [{ value: <Text size="small">Item 2</Text> }],
      },
      {
        id: 3,
        options: [
          { value: <Text size="small">No bottom border (default)</Text> },
        ],
      },
    ]}
    onChange={() => {}}
  />

  <NestableList
    withBottomBorder
    items={[
      {
        id: 4,
        options: [{ value: <Text size="small">Item 1</Text> }],
      },
      {
        id: 5,
        options: [{ value: <Text size="small">Item 2</Text> }],
      },
      {
        id: 6,
        options: [{ value: <Text size="small">With bottom border</Text> }],
      },
    ]}
    onChange={() => {}}
  />
</StorybookComponents.Stack>;
```

### Common use case examples

#### Sort items into sub-categories

Use nestable lists to let the users organize their items (posts, articles, products, etc.) into categories and subcategories.

Use any necessary `<TableListItem/>` props to format the style and content inside the list of items.

```jsx
() => {
  const CollapseIcon = ({ id, allItems }) => {
    const onCollapse = () => {
      setItems(
        allItems.map((item) =>
          item.id === id ? { ...item, isCollapsed: !item.isCollapsed } : item,
        ),
      );
    };
    const { isCollapsed } = allItems.filter((item) => item.id === id)[0];

    return (
      <Box align="right">
        <IconButton skin="light" onClick={onCollapse}>
          {isCollapsed ? <Icons.ChevronDown /> : <Icons.ChevronUp />}
        </IconButton>
      </Box>
    );
  };

  const ItemText = ({ title, description = null }) => (
    <Box direction="vertical">
      <Text weight="normal">{title}</Text>
      {description && (
        <Text size="small" secondary>
          {description}
        </Text>
      )}
    </Box>
  );

  const [items, setItems] = React.useState([
    {
      id: 'item-1',
      addItemLabel: 'Add Step',
      options: [
        {
          value: <ItemText title="Step 1" description="Research" />,
        },
      ],
      children: [
        {
          id: 'item-1-child-1',
          options: [{ value: <ItemText title="Collect data" /> }],
        },
        {
          id: 'item-1-child-2',
          options: [{ value: <ItemText title="Analyze data" /> }],
        },
      ],
    },
    {
      id: 'item-2',
      isCollapsed: true,
      addItemLabel: 'Add Step',
      options: [
        {
          value: <ItemText title="Step 2" description="Plan" />,
        },
      ],
      children: [
        {
          id: 'item-2-child-1',
          options: [{ value: <ItemText title="Consult experts" /> }],
        },
        {
          id: 'item-2-child-2',
          options: [{ value: <ItemText title="Create plan" /> }],
        },
      ],
    },
    {
      id: 'item-3',
      isCollapsed: true,
      addItemLabel: 'Add Step',
      options: [
        {
          value: <ItemText title="Step 3" description="Launch" />,
        },
      ],
      children: [
        {
          id: 'item-3-child-1',
          options: [{ value: <ItemText title="Start with a soft launch" /> }],
        },
      ],
    },
  ]);

  const itemsWithUpdatedControls = items.map((item) => {
    return {
      ...item,
      options: item.children
        ? [
            item.options[0],
            {
              value: <CollapseIcon id={item.id} allItems={items} />,
            },
          ]
        : [item.options[0]],
    };
  });

  return (
    <Card>
      <Card.Header
        title="Starting a business"
        suffix={
          <PopoverMenu
            triggerElement={
              <Button
                priority="secondary"
                prefixIcon={<Icons.Add />}
                size="small"
              >
                Add
              </Button>
            }
          >
            <PopoverMenu.MenuItem text="Add Step" />
            <PopoverMenu.MenuItem text="Add Section" />
          </PopoverMenu>
        }
      />
      <Card.Divider />
      <Box minHeight="1px" />
      <NestableList
        items={itemsWithUpdatedControls}
        onChange={(onChangeData) => setItems(onChangeData.items)}
        addItemLabel="Add Section"
      />
    </Card>
  );
};
```

#### Rearrange the order of items

Use nestable lists to allow quick rearrangement of list items.

In `<SidePanel/>` or on other white backgrounds, use the `withBottomBorder` prop to add a border divider at the end of the list.

```jsx
<SidePanel>
  <SidePanel.Header title="Site pages" />
  <Box gap="SP1" direction="vertical" height="502px">
    <Box margin="SP4 SP4 0 SP4">
      <SectionHelper
        title="Manage menus"
        onClose={() => {}}
        appearance="standard"
      >
        Go to any menu to customize which pages and links are displayed.
        <TextButton skin="dark" size="small" underline="always">
          More on menus
        </TextButton>
      </SectionHelper>
    </Box>
    <NestableList
      withBottomBorder
      items={[
        {
          id: 1,
          options: [{ value: <Text size="small">Home</Text> }],
        },
        {
          id: 2,
          options: [{ value: <Text size="small">About</Text> }],
        },
        {
          id: 3,
          options: [{ value: <Text size="small">Shop</Text> }],
        },
        {
          id: 4,
          options: [{ value: <Text size="small">Contact</Text> }],
        },
      ]}
      onChange={() => {}}
    />
  </Box>
  <SidePanel.Footer>
    <Box align="right">
      <Button prefixIcon={<Icons.Add />}>Add Page</Button>
    </Box>
  </SidePanel.Footer>
</SidePanel>;
```

#### In panels

Use it to help manage complex lists

```jsx
() => {
  const commonItemProps = {
    verticalPadding: 'tiny',
    dragHandleSize: 'small',
    horizontalPadding: 'small',
  };

  const Value = ({ children }) => {
    return (
      <Box gap="6px">
        <Icons.FolderSmall />
        <Text size="small">{children}</Text>
      </Box>
    );
  };

  const [items, setItems] = React.useState([
    {
      ...commonItemProps,
      id: 'item-1',
      options: [{ value: <Value>Item 1</Value> }],
    },
    {
      ...commonItemProps,
      id: 'item-2',
      isCollapsed: true,
      options: [{ value: <Value>Show and hide children</Value> }],
      children: [
        {
          ...commonItemProps,
          id: 'item-2-child-1',
          options: [{ value: <Value>Child 1</Value> }],
        },
        {
          ...commonItemProps,
          id: 'item-2-child-2',
          options: [{ value: <Value>Child 2</Value> }],
          children: [
            {
              ...commonItemProps,
              id: 'item-2-child-2-child-1',
              options: [{ value: <Value>Child 3</Value> }],
            },
          ],
        },
      ],
    },
    {
      ...commonItemProps,
      id: 'item-3',
      options: [{ value: <Value>Item 3</Value> }],
    },
  ]);

  const updateItemsWithControls = (items) => {
    return items.map((item) => {
      const newItem = {
        ...item,
        expandable: !!item.children,
        onClickExpand: () => onCollapse(item.id),
      };
      if (item.children) {
        newItem.children = updateItemsWithControls(item.children);
      }
      return newItem;
    });
  };

  const onCollapse = (id) => {
    setItems((allItems) =>
      allItems.map((item) =>
        item.id === id
          ? {
              ...item,
              isCollapsed: !item.isCollapsed,
              isExpanded: !item.isExpanded,
            }
          : {
              ...item,
              children: item.children
                ? toggleChildrenCollapse(item.children, id)
                : item.children,
            },
      ),
    );
  };

  const toggleChildrenCollapse = (children, id) => {
    return children.map((child) =>
      child.id === id
        ? {
            ...child,
            isCollapsed: !child.isCollapsed,
            isExpanded: !child.isExpanded,
          }
        : {
            ...child,
            children: child.children
              ? toggleChildrenCollapse(child.children, id)
              : child.children,
          },
    );
  };

  const itemsWithUpdatedControls = updateItemsWithControls(items);

  return (
    <SidePanel
      onCloseButtonClick={() => {}}
      skin="floating"
      width="288px"
      height="576px"
    >
      <SidePanel.Header title="Manage list" />
      <SidePanel.Content noPadding>
        <NestableList
          indentSize="medium"
          dividers={false}
          items={itemsWithUpdatedControls}
          onChange={(onChangeData) => setItems(onChangeData.items)}
        />
      </SidePanel.Content>
      <SidePanel.Footer>
        <Box direction="vertical" align="center">
          <Button size="small">Add Item</Button>
        </Box>
      </SidePanel.Footer>
    </SidePanel>
  );
};
```

## Code

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

### Props

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `actions` | `Action[]` | — | Adds a row of text button actions below the list. Each action shows its `label` and `prefixIcon`, and calls its `onClick` when clicked. When set, it replaces the `addItemLabel` button. With a single action, a click anywhere on the row calls it. |
| `addItemLabel` | `string` | — | Adds a button to create a new item (to the Root or a child to the existing item). |
| `canDrop` | `(dragItem: NestableListItem, hoverItem: NestableListItem) => boolean` | — | Returns `false` to reject a drop while the cursor hovers over `hoverItem`. Runs after the built-in constraint flags. When it returns `false`, no placeholder is shown and the drop is rejected at hover time — useful for arbitrary per-position rules that the built-in flags can't express. |
| `dataHook` | `string` | — | Can be applied in the tests as a data-hook HTML attribute. |
| `dividers` | `boolean` | — | Sets the divider visibility. |
| `dragHandleSize` | `"small" \| "large"` | `'large'` | Size of the drag handle. |
| `enforcePinnedOrder` | `boolean` | `false` | Allows dragging and dropping an item only on its pin section. |
| `fullWidthItems` | `boolean` | `false` | Stretches items to the full width of the list container, indenting each item's inner controls instead of the item itself. Suppresses `hierarchyIndicator`. |
| `hierarchyIndicator` | `boolean` | `true` | Displays hierarchyIndicator from the parent to children. |
| `indentSize` | `"small" \| "medium" \| "large"` | — | Sets the indent size. |
| `itemHeight` | `number` | — | Fixed row height in px. Required when `virtualized` is true. |
| `items` *(required)* | `NestableListItem[]` | — | Defines each Nestable List item individually, using the following props: * __id__ - specifies an item's ID. * __addItemLabel__ - creates the "Add new ..." button with a given label at the bottom of the item. * __isCollapsed__ - bool prop, defines whether to render the item's children. * __children__ - defines an item's children. * __draggable__ - bool prop, turns on / off dragging ability for an item. * __hideDragHandle__ - bool prop, turns on / off drag handle for an item. * All `<TableListItem/>` props can be used to format an item's style and content. |
| `maxDepth` | `number` | `10` | Defines a maximum depth (number of levels) for the list. |
| `offscreenRowCount` | `number` | `5` | Extra rows to render above and below the visible window. |
| `onAddItem` | `(item: NestableListItem) => void` | — | Triggers function when the "Add new ..." button is clicked. |
| `onChange` | `(data: { items: NestableListItem[]; item: NestableListItem; }) => void` | — | Triggers function when the item's order or nesting position is changed. |
| `onDragEnd` | `() => void` | — | Triggers function when the drag of item ends. |
| `onDragStart` | `() => void` | — | Triggers function when the drag of item starts. |
| `preventChangeDepth` | `boolean` | `false` | Allows dragging and dropping an item only on its own depth (inside the same level). |
| `preventChangeParent` | `boolean` | `false` | Allows dragging and dropping an item only on its own parent. |
| `readOnly` | `boolean` | — | Prevents the list from being reordered by removing the dragging grip icons. |
| `showDragHandleOnHover` | `boolean` | `false` | Shows the drag handle only on hover. |
| `viewportHeight` | `number` | — | Scroll viewport height in px. Required when `virtualized` is true. |
| `virtualized` | `boolean` | `false` | Opt into windowed rendering for large lists. Requires `itemHeight` and `viewportHeight`. |
| `withBottomBorder` | `boolean` | — | Adds a bottom border (divider) to the last item. |
| `zIndex` | `number` | — | Defines the zIndex of the draggable layer. |

## Testkit

No testkit for this component — it doesn't expose a unidriver testkit.

## 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.330.0** (2026-09-28) — 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.310.0** (2026-08-10) — maintenance release, no component-specific changes
- **1.308.0** (2026-08-04) — feat: new `fullWidthItems` prop stretches items to the full width of the list container, indenting each item's inner controls instead of the item itself. ([#16721](invalid-url)) — has visual changes
- **1.295.0** (2026-07-03) — maintenance release, no component-specific changes
- **1.294.0** (2026-07-02) — fix: reveal drag handle on mobile ([#16457](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.280.0** (2026-05-19) — feat: show not-allowed cursor when canDrop rejects a drop ([#16263](invalid-url))
- **1.279.0** (2026-05-13) — feat: add canDrop callback for per-position drop validation ([#16260](invalid-url))
- **1.278.0** (2026-05-08) — feat: add virtualized rendering ([#16227](invalid-url))
- **1.266.0** (2026-04-07) — maintenance release, no component-specific changes
- **1.262.0** (2026-03-25) — fix: prevent item state reset during drag when parent re-renders ([#16055](invalid-url))
- **1.260.0** (2026-03-17) — maintenance release, no component-specific changes
- **1.250.0** (2026-01-27) — maintenance release, no component-specific changes
- **1.242.0** (2025-12-19) — maintenance release, no component-specific changes
- **1.241.0** (2025-12-17) — fix: add auto scroll + delay before drag on touch ([#15629](invalid-url))
- **1.239.0** (2025-12-12) — maintenance release, no component-specific changes
- **1.230.0** (2025-11-19) — feat: expose `onDragStart` & `onDragEnd` props ([#15535](invalid-url))
- **1.217.0** (2025-09-08) — maintenance release, no component-specific changes
- **1.212.0** (2025-08-11) — maintenance release, no component-specific changes
- **1.198.0** (2025-06-07) — feat: static items & draggable items without visible dragHandle ([#14845](invalid-url))
- **1.190.0** (2025-05-21) — fix: add missing `hierarchyIndicator` type ([#14875](invalid-url))
- **1.189.0** (2025-05-15) — feat: add hierarchyIndicator prop ([#14850](invalid-url))
- **1.187.0** (2025-05-07) — breaking: expandable and non-expandable siblings are now aligned ([#14819](invalid-url))
- **1.176.0** (2025-04-02) — feat: add dragHandle props ([#14673](invalid-url))
- **1.174.0** (2025-03-28) — maintenance release, no component-specific changes
- **1.170.0** (2025-03-12) — maintenance release, no component-specific changes
- **1.138.1** (2024-10-30) — maintenance release, no component-specific changes
- **1.123.0** (2024-08-26) — fix: fix random item duplication and removal when dragging ([#14055](invalid-url))
- **1.116.0** (2024-07-22) — maintenance release, no component-specific changes
- **1.115.0** (2024-07-17) — feat: add dividers and indentSize props ([#13938](invalid-url))
- **1.102.0** (2024-04-16) — 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