@jetbrains/ring-ui 6.0.35 → 6.0.36

package/components/icon/icon__svg.d.ts

@@ -1,9 +1,9 @@
-import React, { SVGAttributes } from 'react';
+import { SVGAttributes } from 'react';
 import PropTypes from 'prop-types';
 export interface IconSVGProps extends SVGAttributes<SVGSVGElement> {
     src: string;
 }
-declare function IconSVG({ src, className, ...rest }: IconSVGProps): React.JSX.Element;
+declare function IconSVG({ src, className, ...rest }: IconSVGProps): import("react").JSX.Element;
 declare namespace IconSVG {
     var propTypes: {
         className: PropTypes.Requireable<string>;
@@ -11,5 +11,5 @@ declare namespace IconSVG {
         style: PropTypes.Requireable<object>;
     };
 }
-declare const _default: React.MemoExoticComponent<typeof IconSVG>;
+declare const _default: import("react").MemoExoticComponent<typeof IconSVG>;
 export default _default;

package/components/icon/icon__svg.js

@@ -1,5 +1,5 @@
 // Inspired by https://github.com/sairion/svg-inline-react
-import React, { memo } from 'react';
+import { memo } from 'react';
 import classNames from 'classnames';
 import PropTypes from 'prop-types';
 import memoize from '../global/memoize';

package/components/input/input.css

@@ -121,7 +121,7 @@
 
 .clear {
   position: absolute;
-  top: calc(var(--ring-input-padding-block) + 2px);
+  top: calc(var(--ring-input-padding-block) + 1px);
   right: var(--ring-input-padding-inline);
 
   height: auto;
@@ -165,6 +165,10 @@ textarea.input {
   line-height: var(--ring-line-height-lowest);
 }
 
+.helpText {
+  margin-top: calc(var(--ring-unit) / 2);
+}
+
 .sizeS {
   width: calc(var(--ring-unit) * 12);
 }

package/components/input/input.d.ts

@@ -1,4 +1,5 @@
-import React, { PureComponent, Ref, ComponentType, InputHTMLAttributes, TextareaHTMLAttributes, ReactNode } from 'react';
+import { PureComponent, Ref, ComponentType, InputHTMLAttributes, TextareaHTMLAttributes, ReactNode } from 'react';
+import * as React from 'react';
 import { ControlsHeight } from '../global/controls-height';
 import { LabelType } from '../control-label/control-label';
 declare function noop(): void;
@@ -22,8 +23,8 @@ export interface InputBaseProps {
     inputClassName?: string | null | undefined;
     label?: ReactNode;
     labelType?: LabelType;
-    active?: boolean | null | undefined;
     error?: ReactNode | null | undefined;
+    help?: ReactNode | null | undefined;
     borderless?: boolean | null | undefined;
     onClear?: ((e: React.MouseEvent<HTMLButtonElement>) => void) | null | undefined;
     icon?: string | ComponentType | null | undefined;

package/components/input/input.js

@@ -1,4 +1,5 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
+import * as React from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import closeIcon from '@jetbrains/icons/close-12px';
@@ -10,6 +11,7 @@ import { I18nContext } from '../i18n/i18n-context';
 import composeRefs from '../global/composeRefs';
 import { ControlsHeightContext } from '../global/controls-height';
 import { ControlLabel } from '../control-label/control-label';
+import ControlHelp from '../control-help/control-help';
 import styles from './input.css';
 function noop() { }
 /**
@@ -91,14 +93,13 @@ export class Input extends PureComponent {
     render() {
         const { 
         // Modifiers
-        size, active, multiline, borderless, 
+        size, multiline, borderless, 
         // Props
-        label, labelType, error, className, inputClassName, children, value, onClear, disabled, inputRef, onChange, enableShortcuts, id, placeholder, icon, translations, height = this.context, afterInput, ...restProps } = this.props;
+        label, labelType, error, help, className, inputClassName, children, value, onClear, disabled, inputRef, onChange, enableShortcuts, id, placeholder, icon, translations, height = this.context, afterInput, ...restProps } = this.props;
         const { empty } = this.state;
         const clearable = !!onClear;
         const classes = classNames(className, styles.outerContainer, [styles[`size${size}`]], [styles[`height${height}`]], {
             'ring-js-shortcuts': enableShortcuts === true,
-            [styles.active]: active,
             [styles.error]: error != null,
             [styles.empty]: empty,
             [styles.withIcon]: icon != null,
@@ -128,7 +129,9 @@ export class Input extends PureComponent {
               {clearable && !disabled && (<Button title={translations?.clear ?? translate('clear')} data-test="ring-input-clear" className={styles.clear} icon={closeIcon} onClick={this.clear}/>)}
               {afterInput}
             </div>
-            {error && <div className={styles.errorText}>{error}</div>}
+            {error
+                    ? <div className={styles.errorText}>{error}</div>
+                    : (help && <ControlHelp className={styles.helpText}>{help}</ControlHelp>)}
           </div>)}
       </I18nContext.Consumer>);
     }
@@ -139,7 +142,6 @@ Input.propTypes = {
     inputClassName: PropTypes.string,
     size: PropTypes.oneOf(Object.values(Size)).isRequired,
     label: PropTypes.node,
-    active: PropTypes.bool,
     error: PropTypes.string,
     multiline: PropTypes.bool,
     onChange: PropTypes.func,

package/components/input-size/input-size.stories.js

@@ -2,7 +2,6 @@ import '../input/input-legacy.css';
 import '../form/form.css';
 import './input-size.css';
 import '../error-bubble/error-bubble-legacy.css';
-import React from 'react';
 
 export default {
   title: 'Style-only/Input Sizes'

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

@@ -1,25 +1,25 @@
-import React, { ComponentType } from 'react';
-export declare const PhaseContext: React.Context<number | null>;
+import { ComponentType } from 'react';
+export declare const PhaseContext: import("react").Context<number | null>;
 type ScrollHandler = (element: Element) => void;
-export declare const ScrollHandlerContext: React.Context<ScrollHandler | null>;
+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(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -34,18 +34,18 @@ export default function adaptiveIslandHOC<P>(ComposedComponent: ComponentType<P>
             phase: null;
         };
         onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -55,7 +55,7 @@ export default function adaptiveIslandHOC<P>(ComposedComponent: ComponentType<P>
         componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    propTypes: React.WeakValidationMap<P> | undefined;
-    contextType?: React.Context<any> | undefined;
+    propTypes: import("react").WeakValidationMap<P> | undefined;
+    contextType?: import("react").Context<any> | undefined;
 };
 export {};

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

@@ -1,4 +1,4 @@
-import React, { Component, createContext } from 'react';
+import { Component, createContext } from 'react';
 import { interpolateLinear } from '../global/linear-function';
 const TITLE_RESIZE_END = 20;
 const TITLE_RESIZE_THRESHOLD = 36;

package/components/island/content.d.ts

@@ -1,4 +1,4 @@
-import React, { Component, HTMLAttributes } from 'react';
+import { Component, HTMLAttributes } from 'react';
 import PropTypes from 'prop-types';
 import createResizeDetector from 'element-resize-detector';
 export interface IslandContentProps extends Omit<HTMLAttributes<HTMLElement>, 'onScroll'> {
@@ -37,7 +37,7 @@ declare class Content extends Component<IslandContentInnerProps> {
     calculateScrollPosition: () => void;
     scrollableNode?: HTMLElement | null;
     setScrollableNodeAndCalculatePosition: (node: HTMLElement | null) => void;
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }
-declare const ContentWrapper: React.ForwardRefExoticComponent<IslandContentProps & React.RefAttributes<Content>>;
+declare const ContentWrapper: import("react").ForwardRefExoticComponent<IslandContentProps & import("react").RefAttributes<Content>>;
 export default ContentWrapper;

package/components/island/content.js

@@ -1,4 +1,4 @@
-import React, { forwardRef, Component } from 'react';
+import { forwardRef, Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import createResizeDetector from 'element-resize-detector';

package/components/island/header.d.ts

@@ -1,8 +1,8 @@
-import React, { HTMLAttributes } from 'react';
+import { HTMLAttributes } from 'react';
 export interface IslandHeaderProps extends HTMLAttributes<HTMLElement> {
     wrapWithTitle?: boolean | undefined;
     border?: boolean | null | undefined;
     phase?: number | undefined;
 }
-declare const HeaderWrapper: (props: IslandHeaderProps) => React.JSX.Element;
+declare const HeaderWrapper: (props: IslandHeaderProps) => import("react").JSX.Element;
 export default HeaderWrapper;

package/components/island/header.js

@@ -1,4 +1,4 @@
-import React, { Component } from 'react';
+import { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import { interpolateLinear } from '../global/linear-function';

package/components/island/island.css

@@ -80,7 +80,7 @@
 }
 
 .narrowIsland .scrollableWrapper {
-  padding: calc(var(--ring-unit) * 2) calc(var(--ring-unit) * 2);
+  padding: calc(var(--ring-unit) * 2);
 }
 
 .withoutPaddings .scrollableWrapper {

package/components/island/island.d.ts

@@ -1,4 +1,4 @@
-import React, { Component, HTMLAttributes } from 'react';
+import { Component, HTMLAttributes } from 'react';
 import PropTypes from 'prop-types';
 export interface IslandProps extends HTMLAttributes<HTMLElement> {
     narrow?: boolean | null | undefined;
@@ -16,7 +16,7 @@ export default class Island extends Component<IslandProps> {
         withoutPaddings: PropTypes.Requireable<boolean>;
         'data-test': PropTypes.Requireable<string>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }
 export declare const AdaptiveIsland: {
     new (props: IslandProps): {
@@ -24,18 +24,18 @@ export declare const AdaptiveIsland: {
             phase: null;
         };
         onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -50,18 +50,18 @@ export declare const AdaptiveIsland: {
             phase: null;
         };
         onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -71,8 +71,8 @@ export declare const AdaptiveIsland: {
         componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    propTypes: React.WeakValidationMap<IslandProps> | undefined;
-    contextType?: React.Context<any> | undefined;
+    propTypes: import("react").WeakValidationMap<IslandProps> | undefined;
+    contextType?: import("react").Context<any> | undefined;
 };
 export { default as Header } from './header';
 export { default as Content } from './content';

package/components/island/island.js

@@ -1,4 +1,4 @@
-import React, { Component } from 'react';
+import { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import dataTests from '../global/data-tests';

package/components/island-legacy/content-legacy.d.ts

@@ -1,4 +1,4 @@
-import React, { HTMLAttributes, PureComponent } from 'react';
+import { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import './island-legacy.css';
 export default class Content extends PureComponent<HTMLAttributes<HTMLElement>> {
@@ -6,5 +6,5 @@ export default class Content extends PureComponent<HTMLAttributes<HTMLElement>>
         className: PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }

package/components/island-legacy/content-legacy.js

@@ -1,4 +1,4 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import './island-legacy.css';

package/components/island-legacy/header-legacy.d.ts

@@ -1,4 +1,4 @@
-import React, { HTMLAttributes, PureComponent } from 'react';
+import { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import './island-legacy.css';
 export default class Header extends PureComponent<HTMLAttributes<HTMLElement>> {
@@ -6,5 +6,5 @@ export default class Header extends PureComponent<HTMLAttributes<HTMLElement>> {
         className: PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }

package/components/island-legacy/header-legacy.js

@@ -1,4 +1,4 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import './island-legacy.css';

package/components/island-legacy/island-legacy.d.ts

@@ -1,4 +1,4 @@
-import React, { HTMLAttributes, PureComponent } from 'react';
+import { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import './island-legacy.css';
 export default class Island extends PureComponent<HTMLAttributes<HTMLElement>> {
@@ -6,7 +6,7 @@ export default class Island extends PureComponent<HTMLAttributes<HTMLElement>> {
         className: PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }
 export { default as Header } from './header-legacy';
 export { default as Content } from './content-legacy';

package/components/island-legacy/island-legacy.js

@@ -1,4 +1,4 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import './island-legacy.css';

package/components/link/clickableLink.d.ts

@@ -1,4 +1,5 @@
-import React, { PureComponent, AnchorHTMLAttributes } from 'react';
+import { PureComponent, AnchorHTMLAttributes } from 'react';
+import * as React from 'react';
 import PropTypes from 'prop-types';
 export interface ClickableLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     onConditionalClick?: ((isPlainLeft: boolean, e: React.MouseEvent<HTMLAnchorElement>) => void) | null | undefined;

package/components/link/clickableLink.js

@@ -1,4 +1,5 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
+import * as React from 'react';
 import PropTypes from 'prop-types';
 const LEFT_BUTTON = 0;
 // Cmd/Ctrl/Shift/Alt + Click should trigger default browser behaviour. Same applies to non-left clicks

package/components/link/link.d.ts

@@ -1,4 +1,4 @@
-import React, { ReactNode, ComponentType } from 'react';
+import { ReactNode, ComponentType } from 'react';
 import PropTypes from 'prop-types';
 import { ClickableLinkProps } from './clickableLink';
 /**
@@ -15,19 +15,19 @@ export interface LinkBaseProps {
 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(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -38,19 +38,19 @@ export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent:
         UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     new (props: LinkProps<P>, context: any): {
-        render(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -72,23 +72,23 @@ export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent:
         onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
         onClick: PropTypes.Requireable<(...args: any[]) => any>;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: import("react").Context<any> | undefined;
 };
 declare const _default: {
     new (props: LinkProps<ClickableLinkProps>): {
-        render(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -99,19 +99,19 @@ declare const _default: {
         UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     new (props: LinkProps<ClickableLinkProps>, context: any): {
-        render(): React.JSX.Element;
+        render(): import("react").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]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): 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;
@@ -133,6 +133,6 @@ declare const _default: {
         onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
         onClick: PropTypes.Requireable<(...args: any[]) => any>;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: import("react").Context<any> | undefined;
 };
 export default _default;

package/components/link/link.js

@@ -1,4 +1,4 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import dataTests from '../global/data-tests';

package/components/list/consts.d.ts

@@ -1,4 +1,5 @@
-import React, { ComponentType, ReactNode, ReactElement, SyntheticEvent } from 'react';
+import { ComponentType, ReactNode, ReactElement, SyntheticEvent } from 'react';
+import * as React from 'react';
 import { LinkProps } from '../link/link';
 import { IconType, Size } from '../icon/icon';
 import { ClickableLinkProps } from '../link/clickableLink';

package/components/list/list.d.ts

@@ -1,7 +1,7 @@
 /**
  * @name List
  */
-import React, { Component, ReactNode, SyntheticEvent } from 'react';
+import { Component, ReactNode, SyntheticEvent } from 'react';
 import PropTypes from 'prop-types';
 import VirtualizedList, { ListRowProps } from 'react-virtualized/dist/es/List';
 import { Size } from 'react-virtualized/dist/es/AutoSizer';
@@ -48,17 +48,17 @@ export interface ListProps<T = unknown> {
     preventListOverscroll?: boolean | undefined;
 }
 export declare const ActiveItemContext: {
-    ValueContext: React.Context<string | undefined>;
-    UpdateContext: React.Context<(value: string | undefined) => void>;
+    ValueContext: import("react").Context<string | undefined>;
+    UpdateContext: import("react").Context<(value: string | undefined) => void>;
     Provider: {
-        ({ children }: import("../global/create-stateful-context").ProviderProps): React.JSX.Element;
+        ({ children }: import("../global/create-stateful-context").ProviderProps): import("react").JSX.Element;
         propTypes: {
             children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
         };
         displayName: string;
     };
     useUpdate: (value: string | undefined, skipUpdate?: boolean | undefined) => void;
-    Updater: React.MemoExoticComponent<{
+    Updater: import("react").MemoExoticComponent<{
         ({ value, skipUpdate }: import("../global/create-stateful-context").UpdaterProps<string | undefined>): null;
         displayName: string;
     }>;
@@ -189,19 +189,19 @@ export default class List<T = unknown> extends Component<ListProps<T>, ListState
     getVisibleListHeight(maxHeight: number): number;
     private _deprecatedGenerateKeyFromContent;
     getId(item: ListDataItem<T> | null): string | undefined;
-    renderItem: ({ index, style, isScrolling, parent, key }: Partial<ListRowProps>) => React.JSX.Element;
+    renderItem: ({ index, style, isScrolling, parent, key }: Partial<ListRowProps>) => import("react").JSX.Element;
     addItemDataTestToProp: (props: ListDataItemProps<T>) => ListDataItemProps<T>;
     virtualizedListRef: (el: VirtualizedList | null) => void;
     containerRef: (el: HTMLElement | null) => void;
     private _inner?;
     get inner(): HTMLElement | null | undefined;
-    renderVirtualizedInner({ height, maxHeight, autoHeight, rowCount, isScrolling, onChildScroll, scrollTop, registerChild }: RenderVirtualizedInnerParams): React.JSX.Element;
-    renderVirtualized(maxHeight: number | null | undefined, rowCount: number): React.JSX.Element;
-    renderSimple(maxHeight: number | null | undefined, rowCount: number): React.JSX.Element;
+    renderVirtualizedInner({ height, maxHeight, autoHeight, rowCount, isScrolling, onChildScroll, scrollTop, registerChild }: RenderVirtualizedInnerParams): import("react").JSX.Element;
+    renderVirtualized(maxHeight: number | null | undefined, rowCount: number): import("react").JSX.Element;
+    renderSimple(maxHeight: number | null | undefined, rowCount: number): import("react").JSX.Element;
     id: string;
     shortcutsScope: string;
     shortcutsMap: ShortcutsMap;
     /** @override */
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }
 export type ListAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof List, ListProps<T>>;

package/components/list/list.js

@@ -1,7 +1,7 @@
 /**
  * @name List
  */
-import React, { Component } from 'react';
+import { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import VirtualizedList from 'react-virtualized/dist/es/List';

package/components/list/list__custom.d.ts

@@ -1,4 +1,5 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
+import * as React from 'react';
 import { ListDataItemProps } from './consts';
 export default class ListCustom<T> extends PureComponent<ListDataItemProps<T>> {
     handleKeyPress: (event: React.KeyboardEvent) => void;

package/components/list/list__custom.js

@@ -1,4 +1,5 @@
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
+import * as React from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import dataTests from '../global/data-tests';

package/components/list/list__hint.d.ts

@@ -1,4 +1,4 @@
-import React, { PureComponent, ReactNode } from 'react';
+import { PureComponent, ReactNode } from 'react';
 import PropTypes from 'prop-types';
 export interface ListHintProps {
     label: ReactNode;
@@ -11,5 +11,5 @@ export default class ListHint extends PureComponent<ListHintProps> {
     static propTypes: {
         label: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }