@jetbrains/ring-ui-built 7.0.124 → 8.0.0-beta.10

package/components/tab-trap/tab-trap.d.ts

@@ -2,6 +2,7 @@ import { type HTMLAttributes, type ReactNode } from 'react';
 import * as React from 'react';
 export declare const FOCUSABLE_ELEMENTS = "input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])";
 export interface TabTrapProps extends HTMLAttributes<HTMLElement> {
+    ref?: React.Ref<TabTrapObject>;
     children: ReactNode;
     trapDisabled?: boolean;
     autoFocusFirst?: boolean;
@@ -11,8 +12,7 @@ export interface TabTrapProps extends HTMLAttributes<HTMLElement> {
 /**
  * @name TabTrap
  */
-interface TabTrap {
+export interface TabTrapObject {
     node: HTMLElement | null;
 }
-declare const TabTrap: React.ForwardRefExoticComponent<TabTrapProps & React.RefAttributes<TabTrap>>;
-export default TabTrap;
+export default function TabTrap({ ref, children, trapDisabled, autoFocusFirst, focusBackOnClose, focusBackOnExit, ...restProps }: TabTrapProps): React.JSX.Element;

package/components/tab-trap/tab-trap.js

@@ -1,21 +1,21 @@
-import { c } from 'react-compiler-runtime';
-import { forwardRef, useRef, useImperativeHandle, useEffect } from 'react';
+import { c } from 'react/compiler-runtime';
+import { useRef, useImperativeHandle, useEffect } from 'react';
 import { isNodeInVisiblePartOfPage } from '../global/dom.js';
 import { jsx, jsxs } from 'react/jsx-runtime';
 
 var styles = {"trapButton":"ring-tab-trap-trapButton"};
 
 const FOCUSABLE_ELEMENTS = 'input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])';
-// eslint-disable-next-line no-shadow
-const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
-  const $ = c(38);
-  if ($[0] !== "2100b1464fbf6825dd3f080feb9e20c095c3f9f9256eec8ae18adf474c19d1f2") {
-    for (let $i = 0; $i < 38; $i += 1) {
+function TabTrap(t0) {
+  const $ = c(39);
+  if ($[0] !== "daf3c9f73144edaae4842be22241426b0a063f37615637c8bca095939d2fdeaf") {
+    for (let $i = 0; $i < 39; $i += 1) {
       $[$i] = Symbol.for("react.memo_cache_sentinel");
     }
-    $[0] = "2100b1464fbf6825dd3f080feb9e20c095c3f9f9256eec8ae18adf474c19d1f2";
+    $[0] = "daf3c9f73144edaae4842be22241426b0a063f37615637c8bca095939d2fdeaf";
   }
   let children;
+  let ref;
   let restProps;
   let t1;
   let t2;
@@ -23,6 +23,7 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
   let t4;
   if ($[1] !== t0) {
     ({
+      ref,
       children,
       trapDisabled: t1,
       autoFocusFirst: t2,
@@ -32,18 +33,20 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
     } = t0);
     $[1] = t0;
     $[2] = children;
-    $[3] = restProps;
-    $[4] = t1;
-    $[5] = t2;
-    $[6] = t3;
-    $[7] = t4;
+    $[3] = ref;
+    $[4] = restProps;
+    $[5] = t1;
+    $[6] = t2;
+    $[7] = t3;
+    $[8] = t4;
   } else {
     children = $[2];
-    restProps = $[3];
-    t1 = $[4];
-    t2 = $[5];
-    t3 = $[6];
-    t4 = $[7];
+    ref = $[3];
+    restProps = $[4];
+    t1 = $[5];
+    t2 = $[6];
+    t3 = $[7];
+    t4 = $[8];
   }
   const trapDisabled = t1 === undefined ? false : t1;
   const autoFocusFirst = t2 === undefined ? true : t2;
@@ -59,20 +62,20 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
   }
   let t5;
   let t6;
-  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
     t5 = () => ({
       node: nodeRef.current
     });
     t6 = [];
-    $[8] = t5;
-    $[9] = t6;
+    $[9] = t5;
+    $[10] = t6;
   } else {
-    t5 = $[8];
-    t6 = $[9];
+    t5 = $[9];
+    t6 = $[10];
   }
   useImperativeHandle(ref, t5, t6);
   let t7;
-  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
     t7 = function restoreFocusIfUnmounted(orElse) {
       const previousFocusedNode = previousFocusedNodeRef.current;
       if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode) && mountedRef.current === false) {
@@ -83,13 +86,13 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
         orElse?.();
       }
     };
-    $[10] = t7;
+    $[11] = t7;
   } else {
-    t7 = $[10];
+    t7 = $[11];
   }
   const restoreFocusIfUnmounted = t7;
   let t8;
-  if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
     t8 = function focusElement(t9) {
       const first = t9 === undefined ? true : t9;
       const node = nodeRef.current;
@@ -102,30 +105,30 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
         toBeFocused.focus();
       }
     };
-    $[11] = t8;
+    $[12] = t8;
   } else {
-    t8 = $[11];
+    t8 = $[12];
   }
   const focusElement = t8;
   let t9;
-  if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
     t9 = () => focusElement(true);
-    $[12] = t9;
+    $[13] = t9;
   } else {
-    t9 = $[12];
+    t9 = $[13];
   }
   const focusFirst = t9;
   let t10;
-  if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
     t10 = () => focusElement(false);
-    $[13] = t10;
+    $[14] = t10;
   } else {
-    t10 = $[13];
+    t10 = $[14];
   }
   const focusLast = t10;
   let t11;
   let t12;
-  if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
     t11 = () => {
       mountedRef.current = true;
       return () => {
@@ -133,16 +136,16 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
       };
     };
     t12 = [];
-    $[14] = t11;
-    $[15] = t12;
+    $[15] = t11;
+    $[16] = t12;
   } else {
-    t11 = $[14];
-    t12 = $[15];
+    t11 = $[15];
+    t12 = $[16];
   }
   useEffect(t11, t12);
   let t13;
   let t14;
-  if ($[16] !== autoFocusFirst || $[17] !== focusBackOnClose || $[18] !== trapDisabled) {
+  if ($[17] !== autoFocusFirst || $[18] !== focusBackOnClose || $[19] !== trapDisabled) {
     t13 = () => {
       if (autoFocusFirst) {
         focusFirst();
@@ -163,18 +166,18 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
       };
     };
     t14 = [autoFocusFirst, trapDisabled, focusBackOnClose, focusFirst];
-    $[16] = autoFocusFirst;
-    $[17] = focusBackOnClose;
-    $[18] = trapDisabled;
-    $[19] = t13;
-    $[20] = t14;
+    $[17] = autoFocusFirst;
+    $[18] = focusBackOnClose;
+    $[19] = trapDisabled;
+    $[20] = t13;
+    $[21] = t14;
   } else {
-    t13 = $[19];
-    t14 = $[20];
+    t13 = $[20];
+    t14 = $[21];
   }
   useEffect(t13, t14);
   let t15;
-  if ($[21] !== focusBackOnExit) {
+  if ($[22] !== focusBackOnExit) {
     t15 = function focusLastIfEnabled(event) {
       if (trapWithoutFocusRef.current) {
         return;
@@ -188,14 +191,14 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
         focusLast();
       }
     };
-    $[21] = focusBackOnExit;
-    $[22] = t15;
+    $[22] = focusBackOnExit;
+    $[23] = t15;
   } else {
-    t15 = $[22];
+    t15 = $[23];
   }
   const focusLastIfEnabled = t15;
   let t16;
-  if ($[23] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[24] === Symbol.for("react.memo_cache_sentinel")) {
     t16 = function handleBlurIfWithoutFocus(event_0) {
       if (!trapWithoutFocusRef.current) {
         return;
@@ -210,13 +213,13 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
       }
       focusLast();
     };
-    $[23] = t16;
+    $[24] = t16;
   } else {
-    t16 = $[23];
+    t16 = $[24];
   }
   const handleBlurIfWithoutFocus = t16;
   let t17;
-  if ($[24] !== focusBackOnExit) {
+  if ($[25] !== focusBackOnExit) {
     t17 = function restoreFocusOrFocusFirst() {
       if (focusBackOnExit) {
         restoreFocusIfUnmounted(focusFirst);
@@ -224,30 +227,30 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
         focusFirst();
       }
     };
-    $[24] = focusBackOnExit;
-    $[25] = t17;
+    $[25] = focusBackOnExit;
+    $[26] = t17;
   } else {
-    t17 = $[25];
+    t17 = $[26];
   }
   const restoreFocusOrFocusFirst = t17;
   if (trapDisabled) {
     let t18;
-    if ($[26] !== children || $[27] !== restProps) {
+    if ($[27] !== children || $[28] !== restProps) {
       t18 = /*#__PURE__*/jsx("div", {
         ref: nodeRef,
         ...restProps,
         children: children
       });
-      $[26] = children;
-      $[27] = restProps;
-      $[28] = t18;
+      $[27] = children;
+      $[28] = restProps;
+      $[29] = t18;
     } else {
-      t18 = $[28];
+      t18 = $[29];
     }
     return t18;
   }
   let t18;
-  if ($[29] !== focusLastIfEnabled) {
+  if ($[30] !== focusLastIfEnabled) {
     t18 = /*#__PURE__*/jsx("div", {
       tabIndex: 0,
       ref: trapButtonNodeRef,
@@ -256,40 +259,40 @@ const TabTrap = /*#__PURE__*/forwardRef(function TabTrap(t0, ref) {
       onBlur: handleBlurIfWithoutFocus,
       "data-trap-button": true
     });
-    $[29] = focusLastIfEnabled;
-    $[30] = t18;
+    $[30] = focusLastIfEnabled;
+    $[31] = t18;
   } else {
-    t18 = $[30];
+    t18 = $[31];
   }
   let t19;
-  if ($[31] !== restoreFocusOrFocusFirst) {
+  if ($[32] !== restoreFocusOrFocusFirst) {
     t19 = /*#__PURE__*/jsx("div", {
       tabIndex: 0,
       onFocus: restoreFocusOrFocusFirst,
       "data-trap-button": true
     });
-    $[31] = restoreFocusOrFocusFirst;
-    $[32] = t19;
+    $[32] = restoreFocusOrFocusFirst;
+    $[33] = t19;
   } else {
-    t19 = $[32];
+    t19 = $[33];
   }
   let t20;
-  if ($[33] !== children || $[34] !== restProps || $[35] !== t18 || $[36] !== t19) {
+  if ($[34] !== children || $[35] !== restProps || $[36] !== t18 || $[37] !== t19) {
     t20 = /*#__PURE__*/jsxs("div", {
       ref: nodeRef,
       ...restProps,
       children: [t18, children, t19]
     });
-    $[33] = children;
-    $[34] = restProps;
-    $[35] = t18;
-    $[36] = t19;
-    $[37] = t20;
+    $[34] = children;
+    $[35] = restProps;
+    $[36] = t18;
+    $[37] = t19;
+    $[38] = t20;
   } else {
-    t20 = $[37];
+    t20 = $[38];
   }
   return t20;
-});
+}
 function _temp(item) {
   return item.tabIndex >= 0;
 }

package/components/table/default-item-renderer.d.ts

@@ -0,0 +1,55 @@
+import { type ComponentPropsWithRef } from 'react';
+export interface DefaultItemRendererProps {
+    /**
+     * The index of the `data` item to render.
+     */
+    index: number;
+    /**
+     * If `true`, the row will be focusable with up/down arrow keys.
+     * Focus is implemented using the
+     * ["roving tabindex"](https://developer.mozilla.org/en-US/docs/Web/Accessibility/Guides/Keyboard-navigable_JavaScript_widgets#technique_1_roving_tabindex)
+     * technique, that is, only the focused row has `tabIndex={0}`.
+     */
+    keyboardFocusable?: boolean;
+    /**
+     * Changes the background on hover and applies the pointer cursor.
+     * Note that `false` does not mean the row cannot handle `onClick`.
+     */
+    clickable?: boolean;
+    /**
+     * If `true`, the row is highlighted as selected with a different background color.
+     */
+    selected?: boolean;
+    /**
+     * The nesting level of an item. Applies an indent for columns with
+     * `Column.indent` set to `true`. `0`, negative values, and an unset value
+     * mean no indent.
+     */
+    level?: number;
+    /**
+     * When set to `true`, does not control item virtualization.
+     * Useful when you include `DefaultItemRenderer` as a part of a custom row renderer,
+     * and track the visibility yourself.
+     */
+    noItemVirtualization?: boolean;
+    /**
+     * When set to `true`, does not report the item's boundaries to the reorder system.
+     * Useful when you include `DefaultItemRenderer` as a part of a custom row renderer
+     * that registers boundaries itself.
+     */
+    noReorderLayout?: boolean;
+}
+/**
+ * Standard component for rendering a table row.
+ *
+ * Renders an item using the table's column definitions and lets you
+ * configure item-scoped behavior such as selection, keyboard navigation,
+ * event handlers, `className`, and `ref`.
+ *
+ * Note that row-level click and keyboard handlers are not discoverable
+ * by assistive technologies. Make sure that any functionality relying on
+ * them (such as selection or expand/collapse) is also available through
+ * accessible controls, such as checkboxes or buttons with accessible
+ * labels.
+ */
+export declare function DefaultItemRenderer<T>({ index, keyboardFocusable, clickable, selected, level, noItemVirtualization, noReorderLayout, ref: userRef, className, ...restProps }: DefaultItemRendererProps & ComponentPropsWithRef<'tr'>): import("react").JSX.Element | null;

package/components/table/default-item-renderer.js

@@ -0,0 +1,240 @@
+import { c } from 'react/compiler-runtime';
+import { useRef, use } from 'react';
+import classNames from 'classnames';
+import { TablePropsContext } from './table-const.js';
+import { useComposedRef } from '../global/compose-refs.js';
+import { useItemVirtualization } from './item-virtualization.js';
+import { TableRow, TableCell } from './table-primitives.js';
+import { ReorderAnimationContext } from '../internal/reorder-animation-context.js';
+import { useReorderItemLayout } from './reorder-item-layout.js';
+import { s as styles } from '../_helpers/table.js';
+import { jsx } from 'react/jsx-runtime';
+import 'memoize-one';
+import '../internal/virtualization.js';
+import '../global/intersection-observer-context.js';
+import '../global/schedule-with-cleanup.js';
+import '../internal/reorder-handle.js';
+import '@jetbrains/icons/drag-12px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon.constants.js';
+import '../_helpers/icon-svg.js';
+import '../global/memoize.js';
+import '../global/parse-css-duration.js';
+import '../internal/reorder-layout-context.js';
+
+function DefaultItemRenderer(t0) {
+  const $ = c(47);
+  if ($[0] !== "bc245d0d0a3699b5ab0d750beda2a663dcc05f6d122b039db369f77f976f7ee8") {
+    for (let $i = 0; $i < 47; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "bc245d0d0a3699b5ab0d750beda2a663dcc05f6d122b039db369f77f976f7ee8";
+  }
+  let className;
+  let clickable;
+  let index;
+  let keyboardFocusable;
+  let level;
+  let noItemVirtualization;
+  let noReorderLayout;
+  let restProps;
+  let selected;
+  let userRef;
+  if ($[1] !== t0) {
+    ({
+      index,
+      keyboardFocusable,
+      clickable,
+      selected,
+      level,
+      noItemVirtualization,
+      noReorderLayout,
+      ref: userRef,
+      className,
+      ...restProps
+    } = t0);
+    $[1] = t0;
+    $[2] = className;
+    $[3] = clickable;
+    $[4] = index;
+    $[5] = keyboardFocusable;
+    $[6] = level;
+    $[7] = noItemVirtualization;
+    $[8] = noReorderLayout;
+    $[9] = restProps;
+    $[10] = selected;
+    $[11] = userRef;
+  } else {
+    className = $[2];
+    clickable = $[3];
+    index = $[4];
+    keyboardFocusable = $[5];
+    level = $[6];
+    noItemVirtualization = $[7];
+    noReorderLayout = $[8];
+    restProps = $[9];
+    selected = $[10];
+    userRef = $[11];
+  }
+  const localRef = useRef(null);
+  const composedRef = useComposedRef(userRef, localRef);
+  let t1;
+  if ($[12] !== noItemVirtualization) {
+    t1 = (t2, _i, t3) => {
+      const [isIntersecting] = t2;
+      const [element] = t3;
+      return isIntersecting === false && !noItemVirtualization && element?.isConnected && !element.contains(document.activeElement) && !element.previousElementSibling?.contains(document.activeElement) && !element.nextElementSibling?.contains(document.activeElement) ? element.getBoundingClientRect().height : undefined;
+    };
+    $[12] = noItemVirtualization;
+    $[13] = t1;
+  } else {
+    t1 = $[13];
+  }
+  const t2 = t1;
+  let t3;
+  if ($[14] !== index || $[15] !== t2) {
+    t3 = {
+      index,
+      refs: localRef,
+      onIntersectionChange: t2
+    };
+    $[14] = index;
+    $[15] = t2;
+    $[16] = t3;
+  } else {
+    t3 = $[16];
+  }
+  useItemVirtualization(t3);
+  let t4;
+  if ($[17] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = () => {
+      var _r$top, _r$bottom;
+      const r = localRef.current?.getBoundingClientRect();
+      return {
+        start: (_r$top = r?.top) !== null && _r$top !== void 0 ? _r$top : 0,
+        end: (_r$bottom = r?.bottom) !== null && _r$bottom !== void 0 ? _r$bottom : 0
+      };
+    };
+    $[17] = t4;
+  } else {
+    t4 = $[17];
+  }
+  let t5;
+  if ($[18] !== index || $[19] !== noReorderLayout) {
+    t5 = {
+      disabled: noReorderLayout,
+      index,
+      getBounds: t4
+    };
+    $[18] = index;
+    $[19] = noReorderLayout;
+    $[20] = t5;
+  } else {
+    t5 = $[20];
+  }
+  useReorderItemLayout(t5);
+  const tableProps = use(TablePropsContext);
+  if (!tableProps) {
+    return null;
+  }
+  const {
+    reorderAnimation
+  } = use(ReorderAnimationContext);
+  const isAnimatedItem = reorderAnimation?.direction === "items" && reorderAnimation.index === index;
+  const animatedColumnIndex = reorderAnimation?.direction === "columns" ? reorderAnimation.index : undefined;
+  const animateClassName = reorderAnimation?.className;
+  const {
+    data,
+    columns
+  } = tableProps;
+  const item = data[index];
+  const t6 = clickable && styles.clickableRow;
+  const t7 = selected && styles.selectedRow;
+  const t8 = isAnimatedItem && animateClassName;
+  let t9;
+  if ($[21] !== className || $[22] !== t6 || $[23] !== t7 || $[24] !== t8) {
+    t9 = classNames(className, t6, t7, t8);
+    $[21] = className;
+    $[22] = t6;
+    $[23] = t7;
+    $[24] = t8;
+    $[25] = t9;
+  } else {
+    t9 = $[25];
+  }
+  let t10;
+  if ($[26] !== animateClassName || $[27] !== animatedColumnIndex || $[28] !== columns || $[29] !== data || $[30] !== index || $[31] !== item || $[32] !== level) {
+    let t11;
+    if ($[34] !== animateClassName || $[35] !== animatedColumnIndex || $[36] !== data || $[37] !== index || $[38] !== item || $[39] !== level) {
+      t11 = (column, columnIndex) => {
+        var _column$renderCell;
+        const {
+          key,
+          tdClassName,
+          indent
+        } = column;
+        return /*#__PURE__*/jsx(TableCell, {
+          className: classNames(columnIndex === animatedColumnIndex && animateClassName, typeof tdClassName === "function" ? tdClassName(item, index, data) : tdClassName),
+          style: indent && level != null && level > 0 ? {
+            paddingInlineStart: `${level * 24}px`
+          } : undefined,
+          children: (_column$renderCell = column.renderCell?.(item, index, data)) !== null && _column$renderCell !== void 0 ? _column$renderCell : getDefaultCellValue(item, columnIndex, key)
+        }, key);
+      };
+      $[34] = animateClassName;
+      $[35] = animatedColumnIndex;
+      $[36] = data;
+      $[37] = index;
+      $[38] = item;
+      $[39] = level;
+      $[40] = t11;
+    } else {
+      t11 = $[40];
+    }
+    t10 = columns.map(t11);
+    $[26] = animateClassName;
+    $[27] = animatedColumnIndex;
+    $[28] = columns;
+    $[29] = data;
+    $[30] = index;
+    $[31] = item;
+    $[32] = level;
+    $[33] = t10;
+  } else {
+    t10 = $[33];
+  }
+  let t11;
+  if ($[41] !== composedRef || $[42] !== keyboardFocusable || $[43] !== restProps || $[44] !== t10 || $[45] !== t9) {
+    t11 = /*#__PURE__*/jsx(TableRow, {
+      ref: composedRef,
+      keyboardFocusable: keyboardFocusable,
+      className: t9,
+      ...restProps,
+      children: t10
+    });
+    $[41] = composedRef;
+    $[42] = keyboardFocusable;
+    $[43] = restProps;
+    $[44] = t10;
+    $[45] = t9;
+    $[46] = t11;
+  } else {
+    t11 = $[46];
+  }
+  return t11;
+}
+function getDefaultCellValue(item, columnIndex, columnKey) {
+  if (Array.isArray(item)) {
+    return String(item[columnIndex]);
+  }
+  if (item !== null && typeof item === 'object') {
+    return String(item[String(columnKey)]);
+  }
+  if (columnIndex === 0) {
+    return String(item);
+  }
+  return '';
+}
+
+export { DefaultItemRenderer };

package/components/table/internal/reorder-animation-context.d.ts

@@ -0,0 +1,21 @@
+import { type RefObject } from 'react';
+import type { Column } from '../table-props';
+import type { ReorderAnimation } from '../reorder-animation';
+export interface ReorderSpec {
+    direction: 'columns' | 'items';
+    fromIndex: number;
+    insertionIndex: number;
+}
+interface ReorderAnimationContextValue {
+    reorderAnimation: ReorderAnimation | null;
+    expectReorder: (reorderSpec: ReorderSpec) => void;
+}
+export declare const ReorderAnimationContext: import("react").Context<ReorderAnimationContextValue>;
+export declare function useReorderAnimationContextValue<T>({ noColumnReorderAnimation, noItemReorderAnimation, tableRef, data, columns, }: {
+    noColumnReorderAnimation: boolean | undefined;
+    noItemReorderAnimation: boolean | undefined;
+    tableRef: RefObject<HTMLTableElement | null>;
+    data: readonly T[];
+    columns: readonly Column<T>[];
+}): ReorderAnimationContextValue;
+export {};

package/components/table/internal/reorder-handle.d.ts

@@ -0,0 +1,9 @@
+import { type ComponentPropsWithRef } from 'react';
+import type { DragState } from '../table-primitives';
+export declare function ReorderHandle<T>({ direction, index, noDragFrame, noHandleTranslate, onUserDrag, ref: userRef, className, onKeyDown, onPointerDown, onPointerMove, onPointerUp, onPointerCancel, onLostPointerCapture, ...restProps }: {
+    direction: 'columns' | 'items';
+    index: number;
+    noDragFrame?: boolean;
+    noHandleTranslate?: boolean;
+    onUserDrag?: (state: DragState) => void;
+} & ComponentPropsWithRef<'button'>): import("react").JSX.Element;