@jetbrains/ring-ui 8.0.0-beta.2 → 8.0.0-beta.4

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-popup.d.ts

@@ -127,7 +127,7 @@ export default class SelectPopup<T = unknown> extends PureComponent<SelectPopupP
     list?: List<T> | null;
     listRef: (el: List<T> | null) => void;
     filterRef: (el: HTMLInputElement | null) => void;
-    composedFilterRef: import("memoize-one").MemoizedFn<(...refs: (Ref<HTMLInputElement> | undefined)[]) => (value: T_1 | null) => void>;
+    composedFilterRef: import("memoize-one").MemoizedFn<(...refs: (Ref<HTMLInputElement> | undefined)[]) => (value: T_1 | null) => () => void>;
     shortcutsScope: string;
     shortcutsMap: {
         tab: (event: Event) => void;

package/components/select/select.d.ts

@@ -264,7 +264,7 @@ export default class Select<T = unknown> extends Component<SelectProps<T>, Selec
     private _getAvatar;
     filter?: HTMLInputElement | null;
     filterRef: (el: HTMLInputElement | null) => void;
-    composedFilterRef: import("memoize-one").MemoizedFn<(...refs: (Ref<HTMLInputElement> | undefined)[]) => (value: T_1 | null) => void>;
+    composedFilterRef: import("memoize-one").MemoizedFn<(...refs: (Ref<HTMLInputElement> | undefined)[]) => (value: T_1 | null) => () => void>;
     getShortcutsMap(): {
         enter: () => true | undefined;
         esc: (event: KeyboardEvent) => boolean | undefined;
@@ -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,49 @@
-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}`.
      */
-    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;
     /**
-     * A level of a nested item. Results in an indent for columns with `indent: true`.
-     * 0, negative and not set mean no indent.
+     * 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;
 }
 /**
- * @see TableProps.renderItem
+ * 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>({ 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, noItemVirtualization, ref: userRef, className, ...restProps }: DefaultItemRendererProps & ComponentPropsWithRef<'tr'>): import("react").JSX.Element | null;

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

@@ -1,61 +1,61 @@
-import { useContext, useEffect, useRef } from 'react';
+import { use, useCallback, useRef } from 'react';
 import classNames from 'classnames';
-import { CollapseItemIntoSpacerContext, TablePropsContext } from './table-const';
-import { useIsIntersectingListener } from '../global/intersection-observer-context';
-import { TableCell, TableRow } from './table-base';
+import { ColumnAnimationContext, TablePropsContext } from './table-const';
+import { useComposedRef } from '../global/compose-refs';
+import { useItemVirtualization } from './item-virtualization';
+import { TableCell, TableRow } from './table-primitives';
 import styles from './table.css';
-const INDENT_SIZE = 24;
 /**
- * @see TableProps.renderItem
+ * 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 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, noItemVirtualization, ref: userRef, className, ...restProps }) {
+    const localRef = useRef(null);
+    const composedRef = useComposedRef(userRef, localRef);
+    useItemVirtualization({
+        index,
+        refs: localRef,
+        onIntersectionChange: useCallback(([isIntersecting], _i, [element]) => isIntersecting === false &&
+            !noItemVirtualization &&
+            element?.isConnected &&
+            !element.contains(document.activeElement) &&
+            !element.previousElementSibling?.contains(document.activeElement) &&
+            !element.nextElementSibling?.contains(document.activeElement)
+            ? element.getBoundingClientRect().height
+            : undefined, [noItemVirtualization]),
     });
-    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 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);
-        }
+    const tableProps = use(TablePropsContext);
+    if (!tableProps) {
+        return null;
     }
-    return (<TableRow ref={ref} className={classNames(className, clickable && styles.clickableRow, selected && styles.selectedRow)} onKeyDown={handleKeyDown} tabIndex={focused ? 0 : undefined} onBlur={focused ? handleBlur : undefined} {...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>))}
+    const animatedColumn = use(ColumnAnimationContext);
+    const { data, columns } = tableProps;
+    const item = data[index];
+    const indentSize = 24;
+    return (<TableRow ref={composedRef} keyboardFocusable={keyboardFocusable} className={classNames(className, clickable && styles.clickableRow, selected && styles.selectedRow)} {...restProps}>
+      {columns.map((column, columnIndex) => {
+            const { key, tdClassName, indent } = column;
+            return (<TableCell key={key} className={classNames(columnIndex === animatedColumn?.columnIndex && animatedColumn.cellClassName, typeof tdClassName === 'function' ? tdClassName(item, index, data) : tdClassName)} style={indent && level != null && level > 0 ? { paddingInlineStart: `${level * indentSize}px` } : undefined}>
+            {column.renderCell?.(item, index, data) ?? getDefaultCellValue(item, columnIndex, key)}
+          </TableCell>);
+        })}
     </TableRow>);
 }
-function getDefaultCellValue(item, columnIndex) {
+function getDefaultCellValue(item, columnIndex, columnKey) {
     if (Array.isArray(item)) {
-        return String(item[columnIndex] ?? '');
+        return String(item[columnIndex]);
     }
     if (item !== null && typeof item === 'object') {
-        return String(Object.values(item)[columnIndex] ?? '');
+        return String(item[String(columnKey)]);
     }
     if (columnIndex === 0) {
         return String(item);

package/components/table/internal/column-animation.d.ts

@@ -0,0 +1,16 @@
+import { type RefObject } from 'react';
+import type { Column } from '../table-props';
+import type { ColumnAnimation } from '../table-const';
+export interface ReorderSpec {
+    fromIndex: number;
+    insertionIndex: number;
+}
+export type ExpectColumnReorder = (reorderSpec: ReorderSpec) => void;
+export declare function useColumnAnimation<T>({ disabled, tableRef, columns, }: {
+    disabled: boolean | undefined;
+    tableRef: RefObject<HTMLTableElement | null>;
+    columns: readonly Column<T>[];
+}): {
+    columnAnimation: ColumnAnimation | null;
+    expectColumnReorder: ExpectColumnReorder;
+};

package/components/table/internal/column-animation.js

@@ -0,0 +1,45 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { parseCssDuration } from '../../global/parse-css-duration';
+import { requestAnimationFrameWithCleanup, setTimeoutWithCleanup } from '../../global/schedule-with-cleanup';
+import styles from '../table.css';
+const reorderExpectationTimeout = 1000;
+export function useColumnAnimation({ disabled, tableRef, columns, }) {
+    const [columnAnimation, setColumnAnimation] = useState(null);
+    const pendingColumnReorder = useRef(null);
+    const expectColumnReorder = useCallback((reorderSpec) => {
+        if (disabled)
+            return;
+        const timerId = window.setTimeout(() => {
+            pendingColumnReorder.current = null;
+        }, reorderExpectationTimeout);
+        pendingColumnReorder.current = { ...reorderSpec, timerId, columns };
+    }, [disabled, columns]);
+    useEffect(() => {
+        return () => {
+            if (pendingColumnReorder.current) {
+                window.clearTimeout(pendingColumnReorder.current.timerId);
+                pendingColumnReorder.current = null;
+            }
+        };
+    }, []);
+    useEffect(() => {
+        const table = tableRef.current;
+        if (!table || !pendingColumnReorder.current || columns === pendingColumnReorder.current.columns)
+            return;
+        const { fromIndex, insertionIndex } = pendingColumnReorder.current;
+        pendingColumnReorder.current = null;
+        const columnIndex = fromIndex < insertionIndex ? insertionIndex - 1 : insertionIndex;
+        return requestAnimationFrameWithCleanup(() => setColumnAnimation(prev => prev == null ? { columnIndex, phase: 'initial', cellClassName: styles.animatedColumnInitial } : prev));
+    }, [columns, tableRef]);
+    useEffect(() => {
+        if (columnAnimation?.phase === 'initial') {
+            return requestAnimationFrameWithCleanup(() => setColumnAnimation(prev => prev === columnAnimation ? { ...prev, phase: 'fade-out', cellClassName: styles.animatedColumnFadeOut } : prev));
+        }
+        if (columnAnimation?.phase === 'fade-out') {
+            const fadeOutMs = parseCssDuration(window.getComputedStyle(tableRef.current).getPropertyValue('--animated-column-fade-out-duration'));
+            return setTimeoutWithCleanup(() => setColumnAnimation(prev => (prev === columnAnimation ? null : prev)), fadeOutMs);
+        }
+        return undefined;
+    }, [columnAnimation, tableRef]);
+    return { columnAnimation, expectColumnReorder };
+}

package/components/table/internal/table-header.d.ts

@@ -0,0 +1,4 @@
+import { type ExpectColumnReorder } from './column-animation';
+export declare function TableHeader<T>({ expectColumnReorder }: {
+    expectColumnReorder: ExpectColumnReorder;
+}): import("react").JSX.Element | null;