@jetbrains/ring-ui 8.0.0-beta.1 → 8.0.0-beta.3

package/components/island/adaptive-island-hoc.js

@@ -17,11 +17,11 @@ export default function adaptiveIslandHOC(ComposedComponent) {
             }
         };
         render() {
-            return (<PhaseContext.Provider value={this.state.phase}>
-          <ScrollHandlerContext.Provider value={this.onContentScroll}>
+            return (<PhaseContext value={this.state.phase}>
+          <ScrollHandlerContext value={this.onContentScroll}>
             <ComposedComponent {...this.props}/>
-          </ScrollHandlerContext.Provider>
-        </PhaseContext.Provider>);
+          </ScrollHandlerContext>
+        </PhaseContext>);
         }
     };
 }

package/components/island/content.d.ts

@@ -1,11 +1,13 @@
-import { Component, type HTMLAttributes } from 'react';
+import { Component, type Ref, type HTMLAttributes } from 'react';
 import createResizeDetector from 'element-resize-detector';
 export interface IslandContentProps extends Omit<HTMLAttributes<HTMLElement>, 'onScroll'> {
+    ref?: Ref<Content>;
     fade?: boolean | null | undefined;
     onScrollToBottom?: (() => void) | null | undefined;
     scrollableWrapperClassName?: string | null | undefined;
 }
 export interface IslandContentInnerProps extends IslandContentProps {
+    ref?: Ref<Content>;
     onScroll: (node: HTMLElement) => void;
     bottomBorder: boolean;
 }
@@ -29,5 +31,8 @@ declare class Content extends Component<IslandContentInnerProps> {
     setScrollableNodeAndCalculatePosition: (node: HTMLElement | null) => void;
     render(): import("react").JSX.Element;
 }
-declare const ContentWrapper: import("react").ForwardRefExoticComponent<IslandContentProps & import("react").RefAttributes<Content>>;
+declare const ContentWrapper: {
+    ({ ...props }: IslandContentProps): import("react").JSX.Element;
+    displayName: string;
+};
 export default ContentWrapper;

package/components/island/content.js

@@ -1,4 +1,4 @@
-import { forwardRef, Component } from 'react';
+import { Component } from 'react';
 import classNames from 'classnames';
 import createResizeDetector from 'element-resize-detector';
 import scheduleRAF from '../global/schedule-raf';
@@ -57,7 +57,7 @@ class Content extends Component {
         this.calculateScrollPosition();
     };
     render() {
-        const { children, className, bottomBorder, scrollableWrapperClassName, onScroll, onScrollToBottom, fade, tabIndex, ...restProps } = this.props;
+        const { ref, children, className, bottomBorder, scrollableWrapperClassName, onScroll, onScrollToBottom, fade, tabIndex, ...restProps } = this.props;
         const { scrolledToTop, scrolledToBottom } = this.state;
         const classes = classNames(styles.content, className, {
             [styles.contentWithTopFade]: fade && !scrolledToTop,
@@ -75,11 +75,11 @@ class Content extends Component {
       </div>);
     }
 }
-const ContentWrapper = forwardRef((props, ref) => (<ScrollHandlerContext.Consumer>
+const ContentWrapper = ({ ...props }) => (<ScrollHandlerContext.Consumer>
     {onScroll => {
         const addProps = onScroll ? { onScroll, bottomBorder: true } : {};
-        return <Content {...props} {...addProps} ref={ref}/>;
+        return <Content {...props} {...addProps}/>;
     }}
-  </ScrollHandlerContext.Consumer>));
+  </ScrollHandlerContext.Consumer>);
 ContentWrapper.displayName = 'ContentWrapper';
 export default ContentWrapper;

package/components/legacy-table/cell.js

@@ -1,7 +1,7 @@
 import { PureComponent } from 'react';
 import classNames from 'classnames';
 import dataTests from '../global/data-tests';
-import style from './table.css';
+import style from './legacy-table.css';
 export default class Cell extends PureComponent {
     render() {
         const classes = classNames(style.cell, this.props.className);

package/components/legacy-table/header-cell.js

@@ -4,7 +4,7 @@ import sortableIcon from '@jetbrains/icons/unsorted-12px';
 import sortedIcon from '@jetbrains/icons/chevron-12px-down';
 import Icon from '../icon/icon';
 import dataTests from '../global/data-tests';
-import style from './table.css';
+import style from './legacy-table.css';
 export default class HeaderCell extends PureComponent {
     static defaultProps = {
         onSort: () => { },

package/components/legacy-table/header.js

@@ -3,7 +3,7 @@ import classNames from 'classnames';
 import Checkbox from '../checkbox/checkbox';
 import getUID from '../global/get-uid';
 import HeaderCell from './header-cell';
-import style from './table.css';
+import style from './legacy-table.css';
 export default class Header extends PureComponent {
     static defaultProps = {
         selectable: true,

package/components/legacy-table/multitable.d.ts

@@ -1,6 +1,6 @@
 import { PureComponent, type ReactElement } from 'react';
 import { type TableAttrs } from './table';
-import { type SelectionItem } from './selection';
+import { type SelectionItem } from '../global/table-selection';
 type TableComponent = ReactElement<TableAttrs<SelectionItem>>;
 export interface MultiTableProps {
     children: TableComponent[];

package/components/legacy-table/row.js

@@ -11,7 +11,7 @@ import dataTests from '../global/data-tests';
 import getUID from '../global/get-uid';
 import { createComposedRef } from '../global/compose-refs';
 import Cell from './cell';
-import style from './table.css';
+import style from './legacy-table.css';
 const DragHandle = ({ alwaysShowDragHandle, dragHandleTitle = 'Drag to reorder' }) => {
     const classes = classNames(style.dragHandle, {
         [style.visibleDragHandle]: alwaysShowDragHandle,

package/components/legacy-table/selection-adapter.d.ts

@@ -1,6 +1,6 @@
-import type Selection from './selection';
-import type { SelectionItem } from './selection';
-export default function selectionAdapter(getSelection: () => Selection<SelectionItem>): {
+import type TableSelection from '../global/table-selection';
+import type { SelectionItem } from '../global/table-selection';
+export default function selectionAdapter(getSelection: () => TableSelection<SelectionItem>): {
     readonly size: number;
     readonly items: SelectionItem[];
 };

package/components/legacy-table/selection-shortcuts-hoc.d.ts

@@ -1,16 +1,16 @@
 import { type ComponentClass } from 'react';
 import { type ShortcutsMap } from '../shortcuts/core';
-import type Selection from './selection';
+import type TableSelection from '../global/table-selection';
 export interface SelectionShortcutsOuterProps<T extends object> {
-    selection: Selection<T>;
+    selection: TableSelection<T>;
     selectable?: boolean | undefined;
-    onSelect?: ((selection: Selection<T>) => void) | undefined;
+    onSelect?: ((selection: TableSelection<T>) => void) | undefined;
     shortcuts?: ShortcutsMap | undefined;
 }
 export interface SelectionShortcutsAddProps<T extends object> {
-    selection: Selection<T>;
+    selection: TableSelection<T>;
     selectable: boolean;
-    onSelect: (selection: Selection<T>) => void;
+    onSelect: (selection: TableSelection<T>) => void;
     shortcutsMap: ShortcutsMap;
 }
 export type SelectionShortcutsProps<T extends object, P> = Omit<P, keyof SelectionShortcutsAddProps<T>> & SelectionShortcutsOuterProps<T>;

package/components/legacy-table/simple-table.d.ts

@@ -1,6 +1,6 @@
 import { PureComponent } from 'react';
 import { type TableAttrs } from './table';
-import Selection, { type SelectionItem } from './selection';
+import TableSelection, { type SelectionItem } from '../global/table-selection';
 export interface SimpleTableProps<T extends SelectionItem> extends Omit<TableAttrs<T>, 'selection' | 'onSelect' | 'selectable'> {
 }
 declare class SimpleTable<T extends SelectionItem> extends PureComponent<SimpleTableProps<T>> {
@@ -9,7 +9,7 @@ declare class SimpleTable<T extends SelectionItem> extends PureComponent<SimpleT
         wideFirstColumn: boolean;
     };
     state: {
-        selection: Selection<T>;
+        selection: TableSelection<T>;
     };
     classes: string;
     render(): import("react").JSX.Element;

package/components/legacy-table/simple-table.js

@@ -1,15 +1,15 @@
 import { PureComponent } from 'react';
 import classNames from 'classnames';
 import Table from './table';
-import Selection from './selection';
-import style from './table.css';
+import TableSelection from '../global/table-selection';
+import style from './legacy-table.css';
 class SimpleTable extends PureComponent {
     static defaultProps = {
         selectable: false,
         wideFirstColumn: false,
     };
     state = {
-        selection: new Selection({
+        selection: new TableSelection({
             data: this.props.data,
         }),
     };

package/components/legacy-table/smart-table.d.ts

@@ -1,19 +1,19 @@
 import { PureComponent } from 'react';
 import { type TableAttrs } from './table';
-import Selection, { type SelectionItem } from './selection';
+import TableSelection, { type SelectionItem } from '../global/table-selection';
 export interface SmartTableProps<T extends SelectionItem> extends Omit<TableAttrs<T>, 'selection' | 'onSelect'> {
-    onSelectionChange: (selection: Selection<T>) => void;
-    selection?: Selection<T>;
+    onSelectionChange: (selection: TableSelection<T>) => void;
+    selection?: TableSelection<T>;
 }
 declare class SmartTable<T extends SelectionItem> extends PureComponent<SmartTableProps<T>> {
     static defaultProps: {
         onSelectionChange: () => void;
     };
     state: {
-        selection: Selection<T>;
+        selection: TableSelection<T>;
     };
     UNSAFE_componentWillReceiveProps(nextProps: SmartTableProps<T>): void;
-    onSelect: (selection: Selection<T>) => void;
+    onSelect: (selection: TableSelection<T>) => void;
     render(): import("react").JSX.Element;
 }
 export default SmartTable;

package/components/legacy-table/smart-table.js

@@ -1,12 +1,12 @@
 import { PureComponent } from 'react';
 import Table from './table';
-import Selection from './selection';
+import TableSelection from '../global/table-selection';
 class SmartTable extends PureComponent {
     static defaultProps = {
         onSelectionChange: () => { },
     };
     state = {
-        selection: new Selection({
+        selection: new TableSelection({
             data: this.props.data,
             isItemSelectable: this.props.isItemSelectable,
         }),
@@ -18,7 +18,7 @@ class SmartTable extends PureComponent {
         }
         else if (this.props.data !== data || this.props.isItemSelectable !== isItemSelectable) {
             this.setState({
-                selection: new Selection({ data, isItemSelectable }),
+                selection: new TableSelection({ data, isItemSelectable }),
             });
         }
     }

package/components/legacy-table/table.js

@@ -13,7 +13,7 @@ import Header from './header';
 import selectionShortcutsHOC from './selection-shortcuts-hoc';
 import disableHoverHOC from './disable-hover-hoc';
 import Row from './row-with-focus-sensor';
-import style from './table.css';
+import style from './legacy-table.css';
 /**
  * Interactive table with selection and keyboard navigation support.
  */

package/components/login-dialog/service.js

@@ -7,9 +7,9 @@ const reactRoot = createRoot(containerElement);
  * Renders LoginDialog into virtual node to skip maintaining container
  */
 function renderLoginDialog(props) {
-    reactRoot.render(<ControlsHeightContext.Provider value={getGlobalControlsHeight()}>
+    reactRoot.render(<ControlsHeightContext value={getGlobalControlsHeight()}>
       <LoginDialog {...props}/>
-    </ControlsHeightContext.Provider>);
+    </ControlsHeightContext>);
 }
 function noop() { }
 export default function showAuthDialog(props = { onCancel: noop }) {

package/components/popup/popup.target.d.ts

@@ -1,13 +1,14 @@
-import { type HTMLAttributes, type ReactNode } from 'react';
+import { type HTMLAttributes, type Ref, type ReactNode } from 'react';
 interface ComplexConfig {
     target: string | Element | undefined;
     cssPositioning?: boolean;
 }
 export declare const PopupTargetContext: import("react").Context<string | Element | ComplexConfig | undefined>;
 export interface PopupTargetProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    ref?: Ref<HTMLDivElement>;
     id: string;
     children: ReactNode | ((target: ReactNode) => ReactNode);
 }
 export declare function normalizePopupTarget(value: string | Element | undefined | ComplexConfig): string | Element | undefined;
-export declare const PopupTarget: import("react").ForwardRefExoticComponent<PopupTargetProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare function PopupTarget({ ref, id, children, ...restProps }: PopupTargetProps): import("react").JSX.Element;
 export {};

package/components/popup/popup.target.js

@@ -1,13 +1,11 @@
-import { createContext, forwardRef } from 'react';
+import { createContext } from 'react';
 export const PopupTargetContext = createContext(undefined);
 export function normalizePopupTarget(value) {
     return typeof value === 'string' || value instanceof Element ? value : value?.target;
 }
-export const PopupTarget = forwardRef(function PopupTarget({ id, children, ...restProps }, ref) {
+export function PopupTarget({ ref, id, children, ...restProps }) {
     const target = (<div {...restProps} data-portaltarget={id} ref={ref}>
       {typeof children !== 'function' && children}
     </div>);
-    return (<PopupTargetContext.Provider value={id}>
-      {typeof children === 'function' ? children(target) : target}
-    </PopupTargetContext.Provider>);
-});
+    return (<PopupTargetContext value={id}>{typeof children === 'function' ? children(target) : target}</PopupTargetContext>);
+}

package/components/query-assist/query-assist.d.ts

@@ -285,5 +285,7 @@ export default class QueryAssist extends Component<QueryAssistProps> {
     render(): React.JSX.Element;
 }
 export type QueryAssistAttrs = React.JSX.LibraryManagedAttributes<typeof QueryAssist, QueryAssistProps>;
-export declare const RerenderableQueryAssist: React.ForwardRefExoticComponent<QueryAssistProps & React.RefAttributes<QueryAssist>>;
+export declare const RerenderableQueryAssist: ({ ref, ...props }: QueryAssistProps & {
+    ref?: React.Ref<QueryAssist> | undefined;
+}) => React.JSX.Element;
 export {};

package/components/query-assist/query-assist.js

@@ -733,7 +733,7 @@ export default class QueryAssist extends Component {
             [styles.hugePlaceholder]: huge,
             [styles.withoutGlass]: !glass || (!renderLoader && huge),
         });
-        return (<ControlsHeightContext.Provider value={ControlsHeight.M}>
+        return (<ControlsHeightContext value={ControlsHeight.M}>
         <I18nContext.Consumer>
           {({ translate }) => (<div data-test={dataTests('ring-query-assist', dataTest)} className={containerClasses} role='presentation' ref={this.nodeRef}>
               {this.state.shortcuts && <Shortcuts map={this.shortcutsMap} scope={this.shortcutsScope}/>}
@@ -768,7 +768,7 @@ export default class QueryAssist extends Component {
                 </div>)}
             </div>)}
         </I18nContext.Consumer>
-      </ControlsHeightContext.Provider>);
+      </ControlsHeightContext>);
     }
 }
 export const RerenderableQueryAssist = rerenderHOC(QueryAssist);

package/components/radio/radio-item.d.ts

@@ -1,4 +1,4 @@
-import { Component, type InputHTMLAttributes, type ReactNode } from 'react';
+import { Component, type Ref, type InputHTMLAttributes, type ReactNode } from 'react';
 export interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
     value?: string | undefined;
     onChange?: ((value: string) => void) | null | undefined;
@@ -17,7 +17,7 @@ export declare class RadioItemInner extends Component<RadioItemInnerProps> {
     render(): import("react").JSX.Element;
 }
 export interface RadioItemProps extends RadioItemInnerProps {
+    ref?: Ref<RadioItemInner>;
     value: string;
 }
-declare const RadioItem: import("react").ForwardRefExoticComponent<RadioItemProps & import("react").RefAttributes<RadioItemInner>>;
-export default RadioItem;
+export default function RadioItem({ ref, ...props }: RadioItemProps): import("react").JSX.Element;

package/components/radio/radio-item.js

@@ -1,4 +1,4 @@
-import { Component, createContext, forwardRef } from 'react';
+import { Component, createContext } from 'react';
 import classNames from 'classnames';
 import getUID from '../global/get-uid';
 import ControlHelp from '../control-help/control-help';
@@ -28,9 +28,8 @@ export class RadioItemInner extends Component {
       </label>);
     }
 }
-const RadioItem = forwardRef(function RadioItem(props, ref) {
+export default function RadioItem({ ref, ...props }) {
     return (<RadioContext.Consumer>
       {({ value, onChange, ...restContext }) => (<RadioItemInner ref={ref} {...restContext} checked={value !== undefined ? value === props.value : undefined} onChange={onChange ? () => onChange(props.value) : undefined} {...props}/>)}
     </RadioContext.Consumer>);
-});
-export default RadioItem;
+}

package/components/radio/radio.d.ts

@@ -1,10 +1,10 @@
 import { Component } from 'react';
-import { type RadioProps } from './radio-item';
+import RadioItem, { type RadioProps } from './radio-item';
 /**
  * @name Radio
  */
 export default class Radio extends Component<RadioProps> {
-    static Item: import("react").ForwardRefExoticComponent<import("./radio-item").RadioItemProps & import("react").RefAttributes<import("./radio-item").RadioItemInner>>;
+    static Item: typeof RadioItem;
     uid: string;
     render(): import("react").JSX.Element;
 }

package/components/radio/radio.js

@@ -8,6 +8,6 @@ export default class Radio extends Component {
     static Item = RadioItem;
     uid = getUID('ring-radio-');
     render() {
-        return <RadioContext.Provider value={{ name: this.uid, ...this.props }}>{this.props.children}</RadioContext.Provider>;
+        return <RadioContext value={{ name: this.uid, ...this.props }}>{this.props.children}</RadioContext>;
     }
 }

package/components/select/select.d.ts

@@ -282,5 +282,7 @@ export default class Select<T = unknown> extends Component<SelectProps<T>, Selec
 export type SingleSelectAttrs<T = unknown> = React.JSX.LibraryManagedAttributes<typeof Select, SingleSelectProps<T>>;
 export type MultipleSelectAttrs<T = unknown> = React.JSX.LibraryManagedAttributes<typeof Select, MultipleSelectProps<T>>;
 export type SelectAttrs<T = unknown> = React.JSX.LibraryManagedAttributes<typeof Select, SelectProps<T>>;
-export declare const RerenderableSelect: React.ForwardRefExoticComponent<Omit<any, "ref"> & React.RefAttributes<any>>;
+export declare const RerenderableSelect: ({ ref, ...props }: Omit<any, "ref"> & {
+    ref?: Ref<any> | undefined;
+}) => React.JSX.Element;
 export {};

package/components/slider/slider.js

@@ -1,11 +1,10 @@
-import { Fragment, useEffect, useRef, useState } from 'react';
+import { Fragment, useEffect, useEffectEvent, useRef, useState } from 'react';
 import * as React from 'react';
 import classNames from 'classnames';
 import { isArray } from '../global/typescript-utils';
 import Shortcuts from '../shortcuts/shortcuts';
 import getUID from '../global/get-uid';
 import { adjustValues, calculateMarks, calculateValue, HUNDRED, toPercent, toRange, validateValue } from './slider.utils';
-import useEventCallback from '../global/use-event-callback';
 import styles from './slider.css';
 export const Slider = ({ defaultValue, value, min = 0, max = HUNDRED, step = 1, disabled, marks, showTicks, showTag, className, renderTag, onChange, }) => {
     const ref = useRef(null);
@@ -86,7 +85,7 @@ export const Slider = ({ defaultValue, value, min = 0, max = HUNDRED, step = 1,
         setIsDragging(true);
         previouslyDragged.current = false;
     };
-    const handleMouseUp = useEventCallback(({ pageX }) => {
+    const handleMouseUp = useEffectEvent(({ pageX }) => {
         const nextValues = adjustValues(validValues, ref, draggedIndex, pageX, max, min, validStep);
         if (nextValues[0] > nextValues[1]) {
             nextValues.reverse();
@@ -96,7 +95,7 @@ export const Slider = ({ defaultValue, value, min = 0, max = HUNDRED, step = 1,
         setIsDragging(false);
         previouslyDragged.current = true;
     });
-    const handleMouseMove = useEventCallback(({ pageX }) => {
+    const handleMouseMove = useEffectEvent(({ pageX }) => {
         const nextValues = adjustValues(validValues, ref, draggedIndex, pageX, max, min, validStep);
         if (nextValues[0] > nextValues[1]) {
             nextValues.reverse();
@@ -120,7 +119,7 @@ export const Slider = ({ defaultValue, value, min = 0, max = HUNDRED, step = 1,
             window.removeEventListener('mousemove', handleMouseMove);
             window.removeEventListener('mouseup', handleMouseUp);
         };
-    }, [isDragging, disabled, handleMouseMove, handleMouseUp]);
+    }, [isDragging, disabled]);
     return (<div ref={ref} role='presentation' // contains interactive elements
      className={classNames(styles.slider, className, {
             [styles.disabled]: disabled,

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,10 +1,9 @@
-import { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, } from 'react';
+import { useCallback, useEffect, useImperativeHandle, useRef } from 'react';
 import * as React from 'react';
 import { isNodeInVisiblePartOfPage } from '../global/dom';
 import styles from './tab-trap.css';
 export 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 = forwardRef(function TabTrap({ children, trapDisabled = false, autoFocusFirst = true, focusBackOnClose = true, focusBackOnExit = false, ...restProps }, ref) {
+export default function TabTrap({ ref, children, trapDisabled = false, autoFocusFirst = true, focusBackOnClose = true, focusBackOnExit = false, ...restProps }) {
     const nodeRef = useRef(null);
     const trapButtonNodeRef = useRef(null);
     const previousFocusedNodeRef = useRef(null);
@@ -121,5 +120,4 @@ const TabTrap = forwardRef(function TabTrap({ children, trapDisabled = false, au
     // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
     tabIndex={0} onFocus={restoreFocusOrFocusFirst} data-trap-button/>
     </div>);
-});
-export default TabTrap;
+}

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

@@ -1,25 +1,36 @@
-import { type ComponentPropsWithoutRef } from 'react';
+import { type ComponentPropsWithRef } from 'react';
 export interface DefaultItemRendererProps {
     /**
-     * Installed on the `<tr>` element
+     * The index of the `data` item to render.
      */
-    ref?: React.RefObject<HTMLTableRowElement | null>;
+    index: number;
     /**
-     * The index of the `data` item to render
+     * 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}`.
+     *
+     * To focus the row on click or other user interaction, add e.g. `onClick()`
+     * and invoke `focusRow(e.currentTarget)` imported from `table-row-focus.ts`.
      */
-    index: number;
+    keyboardFocusable?: boolean;
     /**
-     * Changes the highlight on hover and applies the pointer cursor.
-     * Note that `false` doesn't mean it cannot handle `onClick`.
+     * 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, that is, with the
+     * a different background color.
+     */
+    selected?: boolean;
     /**
      * A level of a nested item. Results in an indent for columns with `indent: true`.
-     * 0, negative and not set mean no indent.
+     * 0, negative values, and an unset value mean no indent.
      */
     level?: number;
 }
 /**
  * @see TableProps.renderItem
  */
-export declare function DefaultItemRenderer<T>({ ref: userRef, index, clickable, level, className, onKeyDown, onBlur, ...restProps }: DefaultItemRendererProps & ComponentPropsWithoutRef<'tr'>): import("react").JSX.Element;
+export declare function DefaultItemRenderer<T>({ index, keyboardFocusable, clickable, selected, level, ref: userRef, className, ...restProps }: DefaultItemRendererProps & ComponentPropsWithRef<'tr'>): import("react").JSX.Element | null;

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

@@ -1,50 +1,29 @@
-import { useContext, useEffect, useRef } from 'react';
+import { use, useRef } from 'react';
 import classNames from 'classnames';
+import { mergeRefs } from 'react-merge-refs';
 import { CollapseItemIntoSpacerContext, TablePropsContext } from './table-const';
 import { useIsIntersectingListener } from '../global/intersection-observer-context';
-import { TableCell, TableRow } from './table-base';
+import { TableCell, TableRow } from './table-primitives';
 import styles from './table.css';
 const INDENT_SIZE = 24;
 /**
  * @see TableProps.renderItem
  */
-export function DefaultItemRenderer({ ref: userRef, index, clickable, level, className, onKeyDown, onBlur, ...restProps }) {
-    const selfRef = useRef(null);
-    const ref = userRef ?? selfRef;
-    const collapseItemIntoSpacer = useContext(CollapseItemIntoSpacerContext);
-    useIsIntersectingListener(ref, isIntersecting => {
-        if (ref.current && !isIntersecting) {
-            collapseItemIntoSpacer(ref.current.getBoundingClientRect().height);
+export function DefaultItemRenderer({ index, keyboardFocusable, clickable, selected, level, ref: userRef, className, ...restProps }) {
+    const localRef = useRef(null);
+    const collapseItemIntoSpacer = use(CollapseItemIntoSpacerContext);
+    useIsIntersectingListener(localRef, isIntersecting => {
+        if (localRef.current && !isIntersecting) {
+            collapseItemIntoSpacer(localRef.current.getBoundingClientRect().height);
         }
     });
-    const { data, columns, selection, isItemKeyboardFocusable, onItemFocus } = useContext(TablePropsContext);
-    const item = data[index];
-    const selected = selection?.isSelected(item);
-    function handleKeyDown(e) {
-        onKeyDown?.(e);
-        if (!e.defaultPrevented && (e.key === 'ArrowUp' || e.key === 'ArrowDown')) {
-            const step = e.key === 'ArrowUp' ? -1 : 1;
-            // eslint-disable-next-line yoda
-            for (let i = index + step; 0 <= i && i < data.length; i += step) {
-                if (isItemKeyboardFocusable?.(data[i], i, data)) {
-                    onItemFocus?.(data[i], i, data);
-                    break;
-                }
-            }
-        }
+    const tableProps = use(TablePropsContext);
+    if (!tableProps) {
+        return null;
     }
-    const focused = selection?.isFocused(item);
-    useEffect(() => {
-        if (focused)
-            ref.current?.focus();
-    }, [focused, ref]);
-    function handleBlur(e) {
-        onBlur?.(e);
-        if (!e.defaultPrevented && focused) {
-            onItemFocus?.(null, -1, data);
-        }
-    }
-    return (<TableRow ref={ref} className={classNames(className, clickable && styles.clickableRow, selected && styles.selectedRow)} onKeyDown={handleKeyDown} tabIndex={focused ? 0 : undefined} onBlur={focused ? handleBlur : undefined} {...restProps}>
+    const { data, columns } = tableProps;
+    const item = data[index];
+    return (<TableRow ref={mergeRefs([userRef, localRef])} keyboardFocusable={keyboardFocusable} className={classNames(className, clickable && styles.clickableRow, selected && styles.selectedRow)} {...restProps}>
       {columns.map((column, columnIndex) => (<TableCell key={column.key} className={column.tdClassName?.(item, index, data)} style={column.indent && level != null && level > 0 ? { paddingInlineStart: `${level * INDENT_SIZE}px` } : undefined}>
           {column.renderCell?.(item, index, data) ?? getDefaultCellValue(item, columnIndex)}
         </TableCell>))}