@jetbrains/ring-ui 7.0.39 → 7.0.41

package/components/alert/container.d.ts

@@ -1,10 +1,13 @@
-import { PureComponent, HTMLAttributes } from 'react';
+import { PureComponent, HTMLAttributes, ReactElement } from 'react';
+import type { AlertProps } from './alert';
 /**
  * @name Alert Container
  * @description Displays a stack of alerts on top of the page.
  * @extends {PureComponent}
  */
-export type AlertContainerProps = HTMLAttributes<HTMLDivElement>;
+export type AlertContainerProps = HTMLAttributes<HTMLDivElement> & {
+    children: ReactElement<AlertProps> | ReactElement<AlertProps>[];
+};
 export default class Alerts extends PureComponent<AlertContainerProps> {
     render(): import("react").ReactPortal | null;
 }

package/components/button/button.d.ts

@@ -53,7 +53,7 @@ export declare class Button extends PureComponent<ButtonProps> {
     static IconSize: typeof Size;
     static contextType: React.Context<ControlsHeight>;
     context: React.ContextType<typeof ControlsHeightContext>;
-    buttonRef: React.RefObject<HTMLButtonElement>;
+    buttonRef: React.RefObject<HTMLButtonElement | null>;
     render(): import("react/jsx-runtime").JSX.Element;
 }
 export { Size as IconSize };

package/components/button/button.js

@@ -10,6 +10,10 @@ import { ControlsHeightContext } from '../global/controls-height';
 import styles from './button.css';
 import { getButtonClasses } from './button__classes';
 const warnText = deprecate(() => { }, 'Button: "text" prop is deprecated and will be removed in 8.0. Use inline instead.');
+function removeLinkProps(props) {
+    const { download, href, hrefLang, media, ping, target, type, referrerPolicy, onConditionalClick, onPlainLeftClick, activeClassName, ...restProps } = props;
+    return restProps;
+}
 /**
  * @name Button
  */
@@ -28,7 +32,7 @@ export class Button extends PureComponent {
         // Modifiers
         active, danger, delayed, loader, primary, success, error, secondary, ghost, short, text, dropdown, height, 
         // Props
-        icon, iconRight, iconSize, iconClassName, iconRightClassName, iconSuppressSizeWarning, className, children, inline, disabled, href, ...props } = this.props;
+        icon, iconRight, iconSize, iconClassName, iconRightClassName, iconSuppressSizeWarning, className, children, inline, disabled, ...props } = this.props;
         const isInline = inline ?? text ?? icon != null;
         if (text != null) {
             warnText();
@@ -41,8 +45,7 @@ export class Button extends PureComponent {
         const content = (_jsxs(_Fragment, { children: [icon && (_jsx(Icon, { className: classNames(styles.icon, iconClassName), glyph: icon, size: iconSize, suppressSizeWarning: iconSuppressSizeWarning })), children, iconRight && _jsx(Icon, { className: classNames(styles.iconRight, iconRightClassName), glyph: iconRight }), dropdown && _jsx(Icon, { glyph: isInline ? chevron12pxDown : chevronDown, className: styles.dropdownIcon })] }));
         const isDisabled = disabled || loader || undefined;
         const commonProps = {
-            ...props,
-            href: isDisabled ? undefined : href,
+            ...(props.href != null && isDisabled ? removeLinkProps(props) : props),
             className: classes,
             children: (_jsxs(_Fragment, { children: [loader && !isInline && _jsx("div", { className: styles.loaderBackground }), content] })),
         };

package/components/button-group/button-group.js

@@ -13,7 +13,10 @@ export default class ButtonGroup extends PureComponent {
     render() {
         const { className, split, 'data-test': dataTest, label, help, ...restProps } = this.props;
         const classes = classNames(split ? styles.split : styles.buttonGroup, className, {
-            [styles.disabled]: Children.toArray(this.props.children).every(child => child != null && typeof child === 'object' && 'props' in child && child.props.disabled),
+            [styles.disabled]: Children.toArray(this.props.children).every(child => child != null &&
+                typeof child === 'object' &&
+                'props' in child &&
+                child.props.disabled),
         });
         return (_jsxs(_Fragment, { children: [label && _jsx(ControlLabel, { children: label }), _jsx("div", { ...restProps, "data-test": dataTests('ring-button-group', dataTest), className: classes }), help && _jsx(ControlHelp, { className: styles.help, children: help })] }));
     }

package/components/code/code.d.ts

@@ -24,7 +24,7 @@ export default class Code extends PureComponent<CodeProps> {
     code?: HTMLElement | null;
     highlight(): Promise<void>;
     get codeRef(): HTMLElement | null | undefined;
-    get initCodeRef(): import("react").RefObject<HTMLElement> | ((ref: HTMLElement | null) => void);
+    get initCodeRef(): import("react").RefObject<HTMLElement | null> | ((ref: HTMLElement | null) => void);
     render(): import("react/jsx-runtime").JSX.Element;
 }
 declare const code: (strings: TemplateStringsArray, ...interpolations: unknown[]) => void;

package/components/collapse/collapse-control.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
-type ChildrenFunction = (collapsed: boolean) => React.ReactElement;
+type ChildrenFunction = (collapsed: boolean) => React.ReactElement<any>;
 type Props = {
-    children: ChildrenFunction | React.ReactElement;
+    children: ChildrenFunction | React.ReactElement<any>;
     'data-test'?: string | null | undefined;
 };
 /**

package/components/collapse/collapse-control.js

@@ -8,6 +8,7 @@ import { COLLAPSE_CONTROL_TEST_ID } from './consts';
  */
 export const CollapseControl = ({ children, 'data-test': dataTest }) => {
     const { setCollapsed, collapsed, id } = useContext(CollapseContext);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const child = useMemo(() => {
         if (typeof children === 'function') {
             return children(collapsed);

package/components/data-list/data-list.d.ts

@@ -20,64 +20,7 @@ export interface DataListBaseProps<T extends SelectionItem> {
 type FocusableProps<T extends SelectionItem> = DataListBaseProps<T> & DisableHoverAddProps & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsAddProps<T>;
 export type DataListContainerProps<T extends SelectionItem> = DataListBaseProps<T> & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsOuterProps<T>;
 export default class DataListContainer<T extends SelectionItem> extends Component<DataListContainerProps<T>> {
-    DataList: {
-        new (props: import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>): {
-            state: {
-                disabledHover: boolean;
-            };
-            componentDidMount(): void;
-            componentWillUnmount(): void;
-            onMouseMove: () => void;
-            onKeyDown: (e: KeyboardEvent) => void;
-            render(): import("react/jsx-runtime").JSX.Element;
-            context: unknown;
-            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-            forceUpdate(callback?: (() => void) | undefined): void;
-            readonly props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>;
-            refs: {
-                [key: string]: import("react").ReactInstance;
-            };
-            shouldComponentUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
-            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-            getSnapshotBeforeUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>): any;
-            componentDidUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>, snapshot?: any): void;
-            componentWillMount?(): void;
-            UNSAFE_componentWillMount?(): void;
-            componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
-            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
-            componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
-            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
-        };
-        new (props: import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>, context: any): {
-            state: {
-                disabledHover: boolean;
-            };
-            componentDidMount(): void;
-            componentWillUnmount(): void;
-            onMouseMove: () => void;
-            onKeyDown: (e: KeyboardEvent) => void;
-            render(): import("react/jsx-runtime").JSX.Element;
-            context: unknown;
-            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-            forceUpdate(callback?: (() => void) | undefined): void;
-            readonly props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>;
-            refs: {
-                [key: string]: import("react").ReactInstance;
-            };
-            shouldComponentUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
-            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-            getSnapshotBeforeUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>): any;
-            componentDidUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>, snapshot?: any): void;
-            componentWillMount?(): void;
-            UNSAFE_componentWillMount?(): void;
-            componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
-            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
-            componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
-            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
-        };
-        defaultProps: Partial<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
-        contextType?: import("react").Context<any> | undefined;
-    };
+    DataList: import("react").ComponentClass<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>, any>;
     render(): import("react/jsx-runtime").JSX.Element;
 }
 export {};

package/components/data-list/title.d.ts

@@ -22,5 +22,5 @@ declare class Title extends PureComponent<TitleProps> {
     toggleSelection(): void;
     render(): import("react/jsx-runtime").JSX.Element;
 }
-declare const _default: import("react").ComponentType<import("../global/focus-sensor-hoc").FocusSensorProps<TitleProps, HTMLDivElement, typeof Title>>;
+declare const _default: import("react").ComponentClass<import("../global/focus-sensor-hoc").FocusSensorProps<TitleProps, HTMLDivElement, typeof Title>, any>;
 export default _default;

package/components/date-picker/date-popup.d.ts

@@ -14,7 +14,7 @@ export default class DatePopup extends Component<DatePopupProps, DatePopupState>
     private _scrollDate?;
     private _scrollTS?;
     isInTimeMode: () => boolean;
-    componentRef: React.RefObject<HTMLDivElement>;
+    componentRef: React.RefObject<HTMLDivElement | null>;
     handleWheel: (e: WheelEvent) => void;
     parse(text: string | null | undefined, type: 'time'): string;
     parse(text: Date | number | string | null | undefined, type?: 'date' | 'from' | 'to'): Date;

package/components/date-picker/years.d.ts

@@ -12,7 +12,7 @@ export default class Years extends PureComponent<CalendarProps> {
     componentWillUnmount(): void;
     stoppedScrolling?: boolean;
     setYear(date: number): void;
-    componentRef: import("react").RefObject<HTMLDivElement>;
+    componentRef: import("react").RefObject<HTMLDivElement | null>;
     handleWheel: (e: WheelEvent) => void;
     render(): import("react/jsx-runtime").JSX.Element;
 }

package/components/dialog/dialog.d.ts

@@ -44,7 +44,7 @@ export default class Dialog extends PureComponent<DialogProps> {
     };
     dialog?: HTMLElement | null;
     dialogRef: (tabTrap: TabTrap | null) => void;
-    nativeDialog: React.RefObject<HTMLDialogElement>;
+    nativeDialog: React.RefObject<HTMLDialogElement | null>;
     render(): false | import("react/jsx-runtime").JSX.Element;
 }
 export type DialogAttrs = React.JSX.LibraryManagedAttributes<typeof Dialog, DialogProps>;

package/components/dropdown/dropdown.d.ts

@@ -20,7 +20,7 @@ export interface DropdownProps extends Omit<HTMLAttributes<HTMLElement>, 'childr
      * Can be string, React element, or a function accepting an object with {active, pinned} properties and returning a React element
      * React element should render some interactive HTML element like `button` or `a`
      */
-    anchor: ReactElement | readonly ReactElement[] | string | ((props: AnchorProps) => ReactNode);
+    anchor: ReactElement<any> | readonly ReactElement<any>[] | string | ((props: AnchorProps) => ReactNode);
     children: DropdownChildren;
     initShown: boolean;
     disabled?: boolean | null | undefined;

package/components/footer/footer.d.ts

@@ -1,7 +1,7 @@
 /**
  * @name Footer
  */
-import { HTMLAttributeAnchorTarget, ReactChild } from 'react';
+import { HTMLAttributeAnchorTarget, ReactElement } from 'react';
 /**
  * Return copyright string
  * @param year {int}
@@ -15,7 +15,7 @@ export interface FooterLinkItem {
     target?: HTMLAttributeAnchorTarget | undefined;
     title?: string | undefined;
 }
-type FooterItem = FooterLinkItem | ReactChild;
+type FooterItem = FooterLinkItem | ReactElement<any> | string | number;
 type FooterItems = readonly (FooterItem | readonly FooterItem[])[];
 export interface FooterProps {
     className?: string | null | undefined;

package/components/global/focus-sensor-hoc.d.ts

@@ -1,4 +1,4 @@
-import { ComponentType, Ref } from 'react';
+import { ComponentClass, Ref } from 'react';
 export interface FocusSensorOuterProps<T extends HTMLElement> {
     focused?: boolean | undefined;
     autofocus?: boolean | undefined;
@@ -14,6 +14,6 @@ export interface FocusSensorAddProps<T extends HTMLElement> {
     onFocusRestore: () => void;
 }
 type RestProps<P, T extends HTMLElement> = Omit<P, keyof FocusSensorAddProps<T>>;
-export type FocusSensorProps<P extends FocusSensorAddProps<T>, T extends HTMLElement, C extends ComponentType<P>> = RestProps<React.JSX.LibraryManagedAttributes<C, P>, T> & FocusSensorOuterProps<T>;
-export default function focusSensorHOC<T extends HTMLElement, P extends FocusSensorAddProps<T>, C extends ComponentType<P>>(ComposedComponent: C): ComponentType<FocusSensorProps<P, T, typeof ComposedComponent>>;
+export type FocusSensorProps<P extends FocusSensorAddProps<T>, T extends HTMLElement, C extends ComponentClass<P>> = RestProps<React.JSX.LibraryManagedAttributes<C, P>, T> & FocusSensorOuterProps<T>;
+export default function focusSensorHOC<T extends HTMLElement, P extends FocusSensorAddProps<T>, C extends ComponentClass<P>>(ComposedComponent: C): ComponentClass<FocusSensorProps<P, T, typeof ComposedComponent>>;
 export {};

package/components/global/theme.d.ts

@@ -14,7 +14,7 @@ export interface WithThemeClassesProps {
     theme: Theme;
     children: (classes: string) => ReactElement;
 }
-export declare function WithThemeClasses({ theme, children }: WithThemeClassesProps): ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+export declare function WithThemeClasses({ theme, children }: WithThemeClassesProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 export declare function applyTheme(theme: Theme.DARK | Theme.LIGHT, container: HTMLElement): void;
 type WrapperType = FunctionComponent<HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
 export interface ThemeProviderProps extends HTMLAttributes<HTMLDivElement> {

package/components/global/use-event-callback.js

@@ -1,6 +1,6 @@
 import { useCallback, useLayoutEffect, useRef } from 'react';
 export default function useEventCallback(fn) {
-    const ref = useRef();
+    const ref = useRef(null);
     useLayoutEffect(() => {
         ref.current = fn;
     });

package/components/header/profile.d.ts

@@ -44,6 +44,6 @@ export default class Profile extends PureComponent<ProfileProps> {
     static contextType: React.Context<import("../i18n/i18n-context").I18nContextProps>;
     context: React.ContextType<typeof Profile.contextType>;
     static Size: typeof Size;
-    render(): string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | null | undefined;
+    render(): ReactNode;
 }
 export type ProfileAttrs = React.JSX.LibraryManagedAttributes<typeof Profile, ProfileProps>;

package/components/island/adaptive-island-hoc.d.ts

@@ -1,60 +1,6 @@
-import { ComponentType } from 'react';
+import { ComponentClass, ComponentType } from 'react';
 export declare const PhaseContext: import("react").Context<number | null>;
 type ScrollHandler = (element: Element) => void;
 export declare const ScrollHandlerContext: import("react").Context<ScrollHandler | null>;
-export default function adaptiveIslandHOC<P>(ComposedComponent: ComponentType<P>): {
-    new (props: P): {
-        state: {
-            phase: null;
-        };
-        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<P>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: P, context: any): {
-        state: {
-            phase: null;
-        };
-        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<P>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: import("react").Context<any> | undefined;
-};
+export default function adaptiveIslandHOC<P>(ComposedComponent: ComponentType<P>): ComponentClass<P>;
 export {};

package/components/island/island.d.ts

@@ -10,60 +10,6 @@ export interface IslandProps extends HTMLAttributes<HTMLElement> {
 export default class Island extends Component<IslandProps> {
     render(): import("react/jsx-runtime").JSX.Element;
 }
-export declare const AdaptiveIsland: {
-    new (props: IslandProps): {
-        state: {
-            phase: null;
-        };
-        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<IslandProps>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: IslandProps, context: any): {
-        state: {
-            phase: null;
-        };
-        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<IslandProps>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: import("react").Context<any> | undefined;
-};
+export declare const AdaptiveIsland: import("react").ComponentClass<IslandProps, any>;
 export { default as Header } from './header';
 export { default as Content } from './content';

package/components/link/link.d.ts

@@ -1,4 +1,4 @@
-import { ReactNode, ComponentType } from 'react';
+import { ReactNode, ComponentType, ComponentClass } from 'react';
 import { ClickableLinkProps } from './clickableLink';
 /**
  * @name Link
@@ -12,102 +12,6 @@ export interface LinkBaseProps {
     children: ReactNode;
 }
 export type LinkProps<P extends ClickableLinkProps = ClickableLinkProps> = Omit<P, keyof LinkBaseProps> & LinkBaseProps;
-export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent: ComponentType<P> | string): {
-    new (props: LinkProps<P>): {
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<LinkProps<P>>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: LinkProps<P>, context: any): {
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<LinkProps<P>>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: import("react").Context<any> | undefined;
-};
-declare const _default: {
-    new (props: LinkProps<ClickableLinkProps>): {
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<LinkProps<ClickableLinkProps>>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: LinkProps<ClickableLinkProps>, context: any): {
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<LinkProps<ClickableLinkProps>>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: import("react").Context<any> | undefined;
-};
+export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent: ComponentType<P> | string): ComponentClass<LinkProps<P>>;
+declare const _default: ComponentClass<LinkProps<ClickableLinkProps>, any>;
 export default _default;

package/components/list/consts.d.ts

@@ -55,7 +55,7 @@ export type ListDataItem<T = unknown> = T & Partial<Omit<LinkProps, 'onClick' |
     label?: ReactNode;
     rightNodes?: ReactNode;
     leftNodes?: ReactNode;
-    tagName?: keyof JSX.IntrinsicElements | null | undefined;
+    tagName?: keyof React.JSX.IntrinsicElements | null | undefined;
     selectedLabel?: string | null | undefined;
     originalModel?: never;
     LinkComponent?: ComponentType<ClickableLinkProps> | string | null | undefined;

package/components/select/select.d.ts

@@ -280,5 +280,5 @@ 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<SelectProps<unknown> & React.RefAttributes<Select<unknown>>>;
+export declare const RerenderableSelect: React.ForwardRefExoticComponent<Omit<any, "ref"> & React.RefAttributes<any>>;
 export {};

package/components/select/select.js

@@ -845,4 +845,5 @@ export default class Select extends Component {
         return (_jsx(ActiveItemContext.Provider, { children: _jsx(ActiveItemContext.ValueContext.Consumer, { children: activeItemId => this.renderSelect(activeItemId) }) }));
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const RerenderableSelect = rerenderHOC(Select);

package/components/select/select__filter.d.ts

@@ -9,7 +9,6 @@ export default class SelectFilter extends Component<SelectFilterProps> {
     static defaultProps: {
         inputRef: typeof noop;
     };
-    componentWillUnmount(): void;
     focus(): void;
     blur(): void;
     input?: HTMLInputElement | HTMLTextAreaElement | null;

package/components/select/select__filter.js

@@ -11,9 +11,6 @@ export default class SelectFilter extends Component {
     static defaultProps = {
         inputRef: noop,
     };
-    componentWillUnmount() {
-        this.blur();
-    }
     focus() {
         const { input } = this;
         if (input && input !== document.activeElement) {

package/components/shortcuts/shortcuts-hoc.d.ts

@@ -1,4 +1,4 @@
-import { ComponentType } from 'react';
+import { ComponentClass, ComponentType } from 'react';
 import { ShortcutsMap, ShortcutsScopeOptions } from './core';
 export interface ShortcutsHOCOptions extends ShortcutsScopeOptions {
     disabled?: boolean | null | undefined;
@@ -7,54 +7,4 @@ export interface ShortcutsHOCProps {
     rgShortcutsOptions: ShortcutsHOCOptions;
     rgShortcutsMap: ShortcutsMap;
 }
-export default function shortcutsHOC<P extends {}>(ComposedComponent: ComponentType<P> | string): {
-    new (props: P & ShortcutsHOCProps): {
-        _shortcutsScopeUid: string;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P & ShortcutsHOCProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<P & ShortcutsHOCProps>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: P & ShortcutsHOCProps, context: any): {
-        _shortcutsScopeUid: string;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P & ShortcutsHOCProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<P & ShortcutsHOCProps>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: import("react").Context<any> | undefined;
-};
+export default function shortcutsHOC<P extends {}>(ComposedComponent: ComponentType<P> | string): ComponentClass<P & ShortcutsHOCProps>;

package/components/shortcuts/shortcuts.d.ts

@@ -1,10 +1,10 @@
-import { PureComponent } from 'react';
+import { PureComponent, type ReactNode } from 'react';
 import { ShortcutsMap, ShortcutsScopeOptions } from './core';
 export interface ShortcutsProps {
     map: ShortcutsMap;
     scope: string;
     options: ShortcutsScopeOptions;
-    children?: React.ReactNode;
+    children?: ReactNode;
     disabled?: boolean | null | undefined;
 }
 export default class Shortcuts extends PureComponent<ShortcutsProps> {
@@ -16,5 +16,5 @@ export default class Shortcuts extends PureComponent<ShortcutsProps> {
     componentWillUnmount(): void;
     turnShorcutsOn(): void;
     turnShorcutsOff(): void;
-    render(): string | number | true | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null;
+    render(): ReactNode;
 }

package/components/slider/slider.utils.d.ts

@@ -1,10 +1,10 @@
 import { RefObject } from 'react';
 export declare const HUNDRED = 100;
 export declare function toPercent(value: number, min: number, max: number): number;
-export declare function calculateValue(ref: RefObject<HTMLDivElement>, x: number, min: number, max: number, step: number): number | null;
+export declare function calculateValue(ref: RefObject<HTMLDivElement | null>, x: number, min: number, max: number, step: number): number | null;
 export declare function validateValue(value: number, min: number, max: number): number;
 export declare function toRange(value: number | number[], min: number, max: number): number[];
-export declare function adjustValues(values: number[], ref: RefObject<HTMLDivElement>, index: number, x: number, max: number, min: number, step: number): number[];
+export declare function adjustValues(values: number[], ref: RefObject<HTMLDivElement | null>, index: number, x: number, max: number, min: number, step: number): number[];
 export declare function calculateMarks(min: number, max: number, step: number): {
     value: number;
 }[];

package/components/table/disable-hover-hoc.d.ts

@@ -1,63 +1,6 @@
-import { ComponentType } from 'react';
+import { ComponentClass } from 'react';
 export interface DisableHoverAddProps {
     disabledHover: boolean;
 }
 export type DisableHoverProps<P extends DisableHoverAddProps> = Omit<P, keyof DisableHoverAddProps>;
-export default function disableHoverHOC<P extends DisableHoverAddProps>(ComposedComponent: ComponentType<P>): {
-    new (props: DisableHoverProps<P>): {
-        state: {
-            disabledHover: boolean;
-        };
-        componentDidMount(): void;
-        componentWillUnmount(): void;
-        onMouseMove: () => void;
-        onKeyDown: (e: KeyboardEvent) => void;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<DisableHoverProps<P>>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: DisableHoverProps<P>, context: any): {
-        state: {
-            disabledHover: boolean;
-        };
-        componentDidMount(): void;
-        componentWillUnmount(): void;
-        onMouseMove: () => void;
-        onKeyDown: (e: KeyboardEvent) => void;
-        render(): import("react/jsx-runtime").JSX.Element;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<DisableHoverProps<P>>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    defaultProps: Partial<P> | undefined;
-    contextType?: import("react").Context<any> | undefined;
-};
+export default function disableHoverHOC<P extends DisableHoverAddProps>(ComposedComponent: ComponentClass<P>): ComponentClass<DisableHoverProps<P>>;

package/components/table/multitable.d.ts

@@ -1,8 +1,9 @@
 import { PureComponent, ReactElement } from 'react';
 import { TableAttrs } from './table';
 import { SelectionItem } from './selection';
+type TableComponent = ReactElement<TableAttrs<SelectionItem>>;
 export interface MultiTableProps {
-    children: ReactElement<TableAttrs<SelectionItem>>[];
+    children: TableComponent[];
 }
 export default class MultiTable extends PureComponent<MultiTableProps> {
     componentDidUpdate(prevProps: MultiTableProps): void;
@@ -19,3 +20,4 @@ export default class MultiTable extends PureComponent<MultiTableProps> {
     };
     render(): import("react/jsx-runtime").JSX.Element;
 }
+export {};

package/components/table/multitable.js

@@ -52,13 +52,13 @@ export default class MultiTable extends PureComponent {
     onEscPress = () => {
         const { children } = this.props;
         Children.forEach(children, ({ props: { selection, onSelect } }) => {
-            onSelect(selection.reset());
+            onSelect?.(selection.reset());
         });
     };
     onCmdAPress = () => {
         const { children } = this.props;
         Children.forEach(children, ({ props: { selection, onSelect } }) => {
-            onSelect(selection.selectAll());
+            onSelect?.(selection.selectAll());
         });
         return false;
     };

package/components/table/row-with-focus-sensor.d.ts

@@ -9,7 +9,7 @@ export interface RowWithFocusSensorCallbacksProps<T extends SelectionItem> exten
     onExpand?: (item: T) => void;
 }
 export default class RowWithFocusSensorCallbacks<T extends SelectionItem> extends PureComponent<RowWithFocusSensorCallbacksProps<T>> {
-    RowWithFocusSensor: import("react").ComponentType<FocusSensorProps<RowProps<T>, HTMLDivElement, typeof Row>>;
+    RowWithFocusSensor: import("react").ComponentClass<FocusSensorProps<RowProps<T>, HTMLDivElement, typeof Row>, any>;
     onFocus: () => void;
     onSelect: (item: T, selected: boolean) => void;
     onCollapse: () => void;

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

@@ -1,4 +1,4 @@
-import { ComponentType } from 'react';
+import { ComponentClass } from 'react';
 import { ShortcutsMap } from '../shortcuts/core';
 import Selection, { SelectionItem } from './selection';
 export interface SelectionShortcutsOuterProps<T extends SelectionItem> {
@@ -14,4 +14,4 @@ export interface SelectionShortcutsAddProps<T extends SelectionItem> {
     shortcutsMap: ShortcutsMap;
 }
 export type SelectionShortcutsProps<T extends SelectionItem, P> = Omit<P, keyof SelectionShortcutsAddProps<T>> & SelectionShortcutsOuterProps<T>;
-export default function selectionShortcutsHOC<T extends SelectionItem, P extends SelectionShortcutsAddProps<T>>(ComposedComponent: ComponentType<P>): ComponentType<SelectionShortcutsProps<T, P>>;
+export default function selectionShortcutsHOC<T extends SelectionItem, P extends SelectionShortcutsAddProps<T>>(ComposedComponent: ComponentClass<P>): ComponentClass<SelectionShortcutsProps<T, P>>;

package/components/table/table.d.ts

@@ -102,63 +102,6 @@ export declare class Table<T extends SelectionItem> extends PureComponent<TableP
 }
 export type TableAttrs<T extends SelectionItem> = DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>;
 export default class TableContainer<T extends SelectionItem> extends Component<TableAttrs<T>> {
-    Table: {
-        new (props: DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>): {
-            state: {
-                disabledHover: boolean;
-            };
-            componentDidMount(): void;
-            componentWillUnmount(): void;
-            onMouseMove: () => void;
-            onKeyDown: (e: KeyboardEvent) => void;
-            render(): import("react/jsx-runtime").JSX.Element;
-            context: unknown;
-            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-            forceUpdate(callback?: (() => void) | undefined): void;
-            readonly props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>;
-            refs: {
-                [key: string]: React.ReactInstance;
-            };
-            shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
-            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-            getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>): any;
-            componentDidUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>, snapshot?: any): void;
-            componentWillMount?(): void;
-            UNSAFE_componentWillMount?(): void;
-            componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
-            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
-            componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
-            UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
-        };
-        new (props: DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>, context: any): {
-            state: {
-                disabledHover: boolean;
-            };
-            componentDidMount(): void;
-            componentWillUnmount(): void;
-            onMouseMove: () => void;
-            onKeyDown: (e: KeyboardEvent) => void;
-            render(): import("react/jsx-runtime").JSX.Element;
-            context: unknown;
-            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-            forceUpdate(callback?: (() => void) | undefined): void;
-            readonly props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>;
-            refs: {
-                [key: string]: React.ReactInstance;
-            };
-            shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
-            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-            getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>): any;
-            componentDidUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>, snapshot?: any): void;
-            componentWillMount?(): void;
-            UNSAFE_componentWillMount?(): void;
-            componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
-            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
-            componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
-            UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
-        };
-        defaultProps: Partial<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>> | undefined;
-        contextType?: React.Context<any> | undefined;
-    };
+    Table: React.ComponentClass<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>, any>;
     render(): import("react/jsx-runtime").JSX.Element;
 }

package/components/user-card/tooltip.d.ts

@@ -1,13 +1,9 @@
-import { Component, ReactElement, ReactNode } from 'react';
-import { DropdownAttrs } from '../dropdown/dropdown';
+import { Component, ReactNode } from 'react';
+import { DropdownAttrs, DropdownProps } from '../dropdown/dropdown';
 import { UserCardAttrs, UserCardUser } from './card';
-interface ChildrenProps {
-    active: boolean;
-    pinned: boolean;
-}
 export interface UserCardTooltipProps extends Omit<UserCardAttrs, 'children' | 'user'> {
     user?: UserCardUser | null | undefined;
-    children: ReactElement | readonly ReactElement[] | string | ((props: ChildrenProps) => ReactNode);
+    children: DropdownProps['anchor'];
     dropdownProps: Partial<DropdownAttrs>;
     renderUserCard: (props: UserCardAttrs) => ReactNode;
     renderNoUser: () => ReactNode;
@@ -24,4 +20,3 @@ export default class UserCardTooltip extends Component<UserCardTooltipProps> {
     render(): import("react/jsx-runtime").JSX.Element;
 }
 export type UserCardTooltipAttrs = React.JSX.LibraryManagedAttributes<typeof UserCardTooltip, UserCardTooltipProps>;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetbrains/ring-ui",
-  "version": "7.0.39",
+  "version": "7.0.41",
   "description": "JetBrains UI library",
   "author": {
     "name": "JetBrains"
@@ -93,7 +93,7 @@
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.20.0",
     "@figma/code-connect": "^1.3.2",
-    "@jetbrains/eslint-config": "^6.0.4",
+    "@jetbrains/eslint-config": "^6.0.5",
     "@jetbrains/logos": "3.0.0-canary.734b213.0",
     "@jetbrains/rollup-css-plugin": "./packages/rollup-css-plugin",
     "@jetbrains/stylelint-config": "^4.0.2",
@@ -122,8 +122,8 @@
     "@types/chai-dom": "1.11.3",
     "@types/eslint__js": "^8.42.3",
     "@types/markdown-it": "^14.1.2",
-    "@types/react": "^18.3.12",
-    "@types/react-dom": "^18.3.1",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.1",
     "@types/sinon": "^17.0.4",
     "@types/sinon-chai": "^4.0.0",
     "@types/webpack-env": "^1.18.8",
@@ -161,18 +161,17 @@
     "jest": "~29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "jest-teamcity": "^1.12.0",
-    "lint-staged": "^15.5.0",
+    "lint-staged": "^15.5.1",
     "markdown-it": "^14.1.0",
     "merge-options": "^3.0.4",
     "pinst": "^3.0.0",
     "prettier": "^3.5.3",
     "raw-loader": "^4.0.2",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-test-renderer": "^19.1.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
     "regenerator-runtime": "^0.14.1",
     "rimraf": "^6.0.1",
-    "rollup": "^4.39.0",
+    "rollup": "^4.40.0",
     "rollup-plugin-clear": "^2.0.7",
     "sinon": "^20.0.0",
     "sinon-chai": "^4.0.0",
@@ -192,8 +191,8 @@
     "xmlappend": "^1.0.4"
   },
   "peerDependencies": {
-    "@types/react": ">=16.8.0",
-    "@types/react-dom": ">=16.8.0",
+    "@types/react": ">=18.0.0",
+    "@types/react-dom": ">=18.0.0",
     "core-js": ">=3.0.0",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0",