@jetbrains/ring-ui-built 7.0.39 → 7.0.40

package/components/_helpers/select__filter.js

@@ -21,9 +21,6 @@ class SelectFilter extends Component {
       this.props.inputRef(el);
     });
   }
-  componentWillUnmount() {
-    this.blur();
-  }
   focus() {
     const {
       input

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

@@ -16,8 +16,26 @@ import 'core-js/modules/es.regexp.exec.js';
 import 'core-js/modules/es.string.replace.js';
 import '../global/memoize.js';
 
-const _excluded = ["active", "danger", "delayed", "loader", "primary", "success", "error", "secondary", "ghost", "short", "text", "dropdown", "height", "icon", "iconRight", "iconSize", "iconClassName", "iconRightClassName", "iconSuppressSizeWarning", "className", "children", "inline", "disabled", "href"];
+const _excluded = ["download", "href", "hrefLang", "media", "ping", "target", "type", "referrerPolicy", "onConditionalClick", "onPlainLeftClick", "activeClassName"],
+  _excluded2 = ["active", "danger", "delayed", "loader", "primary", "success", "error", "secondary", "ghost", "short", "text", "dropdown", "height", "icon", "iconRight", "iconSize", "iconClassName", "iconRightClassName", "iconSuppressSizeWarning", "className", "children", "inline", "disabled"];
 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
+    } = props,
+    restProps = _objectWithoutProperties(props, _excluded);
+  return restProps;
+}
 /**
  * @name Button
  */
@@ -57,10 +75,9 @@ class Button extends PureComponent {
         className,
         children,
         inline,
-        disabled,
-        href
+        disabled
       } = _this$props,
-      props = _objectWithoutProperties(_this$props, _excluded);
+      props = _objectWithoutProperties(_this$props, _excluded2);
     const isInline = (_ref = inline !== null && inline !== void 0 ? inline : text) !== null && _ref !== void 0 ? _ref : icon != null;
     if (text != null) {
       warnText();
@@ -84,8 +101,7 @@ class Button extends PureComponent {
       })]
     });
     const isDisabled = disabled || loader || undefined;
-    const commonProps = _objectSpread2(_objectSpread2({}, props), {}, {
-      href: isDisabled ? undefined : href,
+    const commonProps = _objectSpread2(_objectSpread2({}, props.href != null && isDisabled ? removeLinkProps(props) : props), {}, {
       className: classes,
       children: jsxs(Fragment, {
         children: [loader && !isInline && jsx("div", {

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

@@ -18,6 +18,7 @@ const CollapseControl = _ref => {
     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

@@ -34,36 +34,6 @@ export default class DataListContainer<T extends SelectionItem> extends Componen
             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;
@@ -77,6 +47,7 @@ export default class DataListContainer<T extends SelectionItem> extends Componen
         };
         defaultProps: Partial<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
         contextType?: import("react").Context<any> | undefined;
+        propTypes?: any;
     };
     render(): import("react/jsx-runtime").JSX.Element;
 }

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

@@ -2,7 +2,7 @@ import 'core-js/modules/web.dom-collections.iterator.js';
 import { useRef, useLayoutEffect, useCallback } from 'react';
 
 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(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
 }
 export type ProfileAttrs = React.JSX.LibraryManagedAttributes<typeof Profile, ProfileProps>;

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

@@ -13,35 +13,6 @@ export default function adaptiveIslandHOC<P>(ComposedComponent: ComponentType<P>
         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;
@@ -56,5 +27,6 @@ export default function adaptiveIslandHOC<P>(ComposedComponent: ComponentType<P>
         UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
     };
     contextType?: import("react").Context<any> | undefined;
+    propTypes?: any;
 };
 export {};

package/components/island/island.d.ts

@@ -21,35 +21,6 @@ export declare const AdaptiveIsland: {
         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;
@@ -64,6 +35,7 @@ export declare const AdaptiveIsland: {
         UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
     contextType?: import("react").Context<any> | undefined;
+    propTypes?: any;
 };
 export { default as Header } from './header';
 export { default as Content } from './content';

package/components/link/link.d.ts

@@ -20,32 +20,6 @@ export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent:
         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;
@@ -60,6 +34,7 @@ export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent:
         UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     contextType?: import("react").Context<any> | undefined;
+    propTypes?: any;
 };
 declare const _default: {
     new (props: LinkProps<ClickableLinkProps>): {
@@ -69,32 +44,6 @@ declare const _default: {
         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;
@@ -109,5 +58,6 @@ declare const _default: {
         UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     contextType?: import("react").Context<any> | undefined;
+    propTypes?: 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

@@ -1115,6 +1115,7 @@ class Select extends Component {
     });
   }
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 _defineProperty(Select, "defaultProps", {
   data: [],
   filter: false,

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/shortcuts/shortcuts-hoc.d.ts

@@ -16,33 +16,6 @@ export default function shortcutsHOC<P extends {}>(ComposedComponent: ComponentT
         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;
@@ -57,4 +30,5 @@ export default function shortcutsHOC<P extends {}>(ComposedComponent: ComponentT
         UNSAFE_componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
     contextType?: import("react").Context<any> | undefined;
+    propTypes?: any;
 };

package/components/shortcuts/shortcuts.d.ts

@@ -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(): string | number | bigint | true | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | null;
 }

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;
 }[];