feat:renderItem params add "index"

src/Item.tsx

@@ -1,17 +1,18 @@
 import * as React from 'react';
 import classNames from 'classnames';
 import ResizeObserver from 'rc-resize-observer';
+import type { ItemWithIndex } from './Overflow';
 import type { ComponentType } from './RawItem';
 
 // Use shared variable to save bundle size
 const UNDEFINED = undefined;
 
 export interface ItemProps<ItemType> extends React.HTMLAttributes<any> {
   prefixCls: string;
-  item?: ItemType;
+  item?: ItemWithIndex<ItemType>;
   className?: string;
   style?: React.CSSProperties;
-  renderItem?: (item: ItemType) => React.ReactNode;
+  renderItem?: (item: ItemWithIndex<ItemType>) => React.ReactNode;
   responsive?: boolean;
   // https://github.com/ant-design/ant-design/issues/35475
   /**

src/Overflow.tsx

@@ -1,13 +1,13 @@
-import * as React from 'react';
-import { useState, useMemo, useCallback } from 'react';
 import classNames from 'classnames';
 import ResizeObserver from 'rc-resize-observer';
 import useLayoutEffect from 'rc-util/lib/hooks/useLayoutEffect';
+import * as React from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import Item from './Item';
-import useEffectState, { useBatcher } from './hooks/useEffectState';
 import type { ComponentType } from './RawItem';
 import RawItem from './RawItem';
 import { OverflowContext } from './context';
+import useEffectState, { useBatcher } from './hooks/useEffectState';
 
 const RESPONSIVE = 'responsive' as const;
 const INVALIDATE = 'invalidate' as const;
@@ -16,6 +16,8 @@ export { OverflowContext } from './context';
 
 export type { ComponentType } from './RawItem';
 
+export type ItemWithIndex<ItemType> = ItemType & { index?: number };
+
 export interface OverflowProps<ItemType> extends React.HTMLAttributes<any> {
   prefixCls?: string;
   className?: string;
@@ -24,7 +26,7 @@ export interface OverflowProps<ItemType> extends React.HTMLAttributes<any> {
   itemKey?: React.Key | ((item: ItemType) => React.Key);
   /** Used for `responsive`. It will limit render node to avoid perf issue */
   itemWidth?: number;
-  renderItem?: (item: ItemType) => React.ReactNode;
+  renderItem?: (item: ItemWithIndex<ItemType>) => React.ReactNode;
   /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
   renderRawItem?: (item: ItemType, index: number) => React.ReactElement;
   maxCount?: number | typeof RESPONSIVE | typeof INVALIDATE;
@@ -341,13 +343,13 @@ function Overflow<ItemType = any>(
       }
     : (item: ItemType, index: number) => {
         const key = getKey(item, index);
-
+        const propsItem: ItemWithIndex<ItemType> = { ...item, index };
         return (
           <Item
             {...itemSharedProps}
             order={index}
             key={key}
-            item={item}
+            item={propsItem}
             renderItem={mergedRenderItem}
             itemKey={key}
             registerSize={registerSize}

tests/index.spec.tsx

@@ -51,6 +51,23 @@ describe('Overflow.Basic', () => {
     expect(wrapper.find('Item').text()).toEqual('Bamboo Is Light');
   });
 
+  it('renderItem params have "order"', () => {
+    const testData = getData(3);
+    const wrapper = mount(
+      <Overflow
+        data={testData}
+        renderItem={(item) => {
+          return `${item.label}-${item.index}-test`;
+        }}
+      />,
+    );
+    const renderedItems = wrapper.find('.rc-overflow-item'); 
+    expect(renderedItems).toHaveLength(testData.length);
+    renderedItems.forEach((node, index) => {
+      expect(node.text()).toBe(`${testData[index].label}-${index}-test`);
+    });
+  });
+
   describe('renderRest', () => {
     it('function', () => {
       const wrapper = mount(