@jetbrains/ring-ui 4.1.12 → 5.0.0-beta.11

package/dist/checkbox/checkbox.js

@@ -24,6 +24,8 @@ class Checkbox extends PureComponent {
   constructor() {
     super(...arguments);
 
+    _defineProperty(this, "input", void 0);
+
     _defineProperty(this, "inputRef", el => {
       if (el != null) {
         el.indeterminate = this.props.indeterminate;
@@ -105,4 +107,8 @@ _defineProperty(Checkbox, "propTypes", {
   children: PropTypes.node
 });
 
+_defineProperty(Checkbox, "defaultProps", {
+  indeterminate: false
+});
+
 export { Checkbox as default };

package/dist/code/code.d.ts

@@ -0,0 +1,43 @@
+import React, { PureComponent, Ref } from 'react';
+import PropTypes from 'prop-types';
+import highlight from 'highlight.js/lib/core';
+declare function noop(): void;
+export interface CodeProps {
+    code: string;
+    inline: boolean;
+    softWrap: boolean;
+    replacer: ((element: HTMLElement | null) => void);
+    className?: string | null | undefined;
+    language?: string | null | undefined;
+    codeRef?: Ref<HTMLElement> | null | undefined;
+}
+/**
+ * @name Code
+ */
+export default class Code extends PureComponent<CodeProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        code: PropTypes.Validator<string>;
+        inline: PropTypes.Requireable<boolean>;
+        softWrap: PropTypes.Requireable<boolean>;
+        language: PropTypes.Requireable<string>;
+        replacer: PropTypes.Requireable<(...args: any[]) => any>;
+        codeRef: PropTypes.Requireable<((...args: any[]) => any) | PropTypes.InferProps<{
+            current: PropTypes.Requireable<Element>;
+        }>>;
+    };
+    static defaultProps: {
+        inline: boolean;
+        softWrap: boolean;
+        replacer: typeof noop;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    code?: HTMLElement | null;
+    highlight(): Promise<void>;
+    get codeRef(): HTMLElement | null | undefined;
+    get initCodeRef(): React.RefObject<HTMLElement> | ((ref: HTMLElement | null) => void);
+    render(): JSX.Element;
+}
+declare const code: (strings: TemplateStringsArray, ...interpolations: unknown[]) => void;
+export { code, highlight };

package/dist/code/code.js

@@ -8,7 +8,7 @@ import normalizeIndent from '../global/normalize-indent.js';
 import trivialTemplateTag from '../global/trivial-template-tag.js';
 import memoize from '../global/memoize.js';
 
-var modules_66c414ea = {"unit":"8px","code":"code_rui_e63a","inline":"inline_rui_e63a","softWrap":"softWrap_rui_e63a"};
+var modules_66c414ea = {"unit":"8px","code":"code_rui_b9a5","inline":"inline_rui_b9a5","softWrap":"softWrap_rui_b9a5"};
 
 var modules_39cf09e8 = {"highlightContainer":"highlightContainer_rui_b939"};
 
@@ -25,6 +25,12 @@ const registerLanguage = memoize(async language => {
  */
 
 class Code extends PureComponent {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "code", void 0);
+  }
+
   componentDidMount() {
     this.highlight();
   }
@@ -49,7 +55,8 @@ class Code extends PureComponent {
     if (!inline) {
       if (language != null && highlight.getLanguage(language) == null) {
         await registerLanguage(language);
-      }
+      } // @ts-expect-error https://github.com/highlightjs/highlight.js/issues/2945
+
 
       highlight.highlightElement(codeRef);
     }
@@ -61,26 +68,23 @@ class Code extends PureComponent {
     const {
       codeRef
     } = this.props;
-    return !codeRef || this.isFunctionCodeRef ? this.code : codeRef.current;
-  }
-
-  get isFunctionCodeRef() {
-    return typeof this.props.codeRef === 'function';
+    return !codeRef || typeof codeRef === 'function' ? this.code : codeRef.current;
   }
 
   get initCodeRef() {
     const {
       codeRef
     } = this.props;
+    const isFunctionCodeRef = typeof codeRef === 'function';
 
-    if (codeRef && !this.isFunctionCodeRef) {
+    if (codeRef && !isFunctionCodeRef) {
       return codeRef;
     }
 
     return ref => {
       this.code = ref;
 
-      if (this.isFunctionCodeRef) {
+      if (isFunctionCodeRef) {
         codeRef(this.code);
       }
     };

package/dist/confirm/confirm.d.ts

@@ -0,0 +1,48 @@
+import React, { PureComponent, ReactNode } from 'react';
+import PropTypes from 'prop-types';
+export interface ConfirmProps {
+    text: string;
+    description: ReactNode;
+    show: boolean;
+    rejectOnEsc: boolean;
+    inProgress: boolean;
+    cancelIsDefault: boolean;
+    confirmLabel: string;
+    rejectLabel: string;
+    onConfirm: ((event: React.MouseEvent<HTMLButtonElement>) => void);
+    onReject: ((event?: React.MouseEvent<HTMLButtonElement>) => void);
+    className?: string | undefined;
+}
+/**
+ * @name Confirm
+ */
+export default class Confirm extends PureComponent<ConfirmProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        text: PropTypes.Requireable<string>;
+        description: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        show: PropTypes.Requireable<boolean>;
+        rejectOnEsc: PropTypes.Requireable<boolean>;
+        inProgress: PropTypes.Requireable<boolean>;
+        cancelIsDefault: PropTypes.Requireable<boolean>;
+        confirmLabel: PropTypes.Requireable<string>;
+        rejectLabel: PropTypes.Requireable<string>;
+        onConfirm: PropTypes.Requireable<(...args: any[]) => any>;
+        onReject: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        text: null;
+        description: null;
+        show: boolean;
+        rejectOnEsc: boolean;
+        inProgress: boolean;
+        cancelIsDefault: boolean;
+        confirmLabel: string;
+        rejectLabel: string;
+        onConfirm: () => void;
+        onReject: () => void;
+    };
+    onEscPress: () => void;
+    render(): JSX.Element;
+}
+export declare type ConfirmAttributes = JSX.LibraryManagedAttributes<typeof Confirm, ConfirmProps>;

package/dist/confirm/confirm.js

@@ -2,7 +2,7 @@ import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import Dialog from '../dialog/dialog.js';
-import Button from '../button/button.js';
+import { Button } from '../button/button.js';
 import '../island/island.js';
 import Panel from '../panel/panel.js';
 import HeaderWrapper from '../island/header.js';
@@ -35,12 +35,12 @@ import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
 import '../global/memoize.js';
-import '../global/theme.js';
 import '../link/clickableLink.js';
+import '../global/controls-height.js';
 import '../_helpers/button__classes.js';
 import '../_helpers/panel.js';
 
-var modules_4c9c3a3a = {"unit":"8px","description":"description_rui_c96b"};
+var modules_4c9c3a3a = {"unit":"8px","description":"description_rui_54ee"};
 
 /**
  * @name Confirm
@@ -71,7 +71,7 @@ class Confirm extends PureComponent {
       onReject
     } = this.props;
     return /*#__PURE__*/React.createElement(Dialog, {
-      label: text || description,
+      label: text || (typeof description === 'string' ? description : undefined),
       className: className,
       onEscPress: this.onEscPress,
       show: show,

package/dist/confirm-ng/confirm-ng.js

@@ -35,8 +35,8 @@ import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
 import '../global/memoize.js';
-import '../global/theme.js';
 import '../link/clickableLink.js';
+import '../global/controls-height.js';
 import '../_helpers/button__classes.js';
 import '../popup/popup.target.js';
 import '../_helpers/dialog__body-scroll-preventer.js';

package/dist/confirm-service/confirm-service.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+/**
+ * @name Confirm Service
+ */
+export declare const containerElement: HTMLDivElement;
+export interface ConfirmServiceParams {
+    text?: string | undefined;
+    description?: ReactNode;
+    cancelIsDefault?: boolean | undefined;
+    confirmLabel?: string | undefined;
+    rejectLabel?: string | undefined;
+    onBeforeConfirm?: (() => void) | undefined;
+}
+export default function confirm({ text, description, confirmLabel, rejectLabel, cancelIsDefault, onBeforeConfirm }: ConfirmServiceParams): Promise<void>;
+export declare function hideConfirm(): void;

package/dist/confirm-service/confirm-service.js

@@ -32,8 +32,8 @@ import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
 import '../global/memoize.js';
-import '../global/theme.js';
 import '../link/clickableLink.js';
+import '../global/controls-height.js';
 import '../_helpers/button__classes.js';
 import '../popup/popup.target.js';
 import '../_helpers/dialog__body-scroll-preventer.js';

package/dist/content-layout/content-layout.d.ts

@@ -0,0 +1,26 @@
+import { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface ContentLayoutProps extends HTMLAttributes<HTMLElement> {
+    responsive: boolean;
+    contentClassName?: string | null | undefined;
+}
+/**
+ * @name Content Layout
+ */
+export default class ContentLayout extends Component<ContentLayoutProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        contentClassName: PropTypes.Requireable<string>;
+        responsive: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        responsive: boolean;
+    };
+    state: {
+        contentNode: null;
+    };
+    saveContentNode: (contentNode: HTMLElement | null) => void;
+    render(): JSX.Element;
+}
+export { default as Sidebar } from './sidebar';

package/dist/content-layout/content-layout.js

@@ -14,7 +14,9 @@ class ContentLayout extends Component {
   constructor() {
     super(...arguments);
 
-    _defineProperty(this, "state", {});
+    _defineProperty(this, "state", {
+      contentNode: null
+    });
 
     _defineProperty(this, "saveContentNode", contentNode => {
       this.setState({
@@ -36,7 +38,7 @@ class ContentLayout extends Component {
     });
     const contentClasses = classNames(modules_b8a9dd4f.contentLayoutContent, contentClassName);
     const childrenArray = React.Children.toArray(children);
-    const sidebarChild = childrenArray.filter(child => child && child.type === Sidebar)[0];
+    const sidebarChild = childrenArray.filter(child => child != null && typeof child === 'object' && 'type' in child && child.type === Sidebar)[0];
     const sidebar = sidebarChild && /*#__PURE__*/cloneElement(sidebarChild, {
       contentNode: this.state.contentNode
     });

package/dist/content-layout/sidebar.d.ts

@@ -0,0 +1,31 @@
+import { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+import { Waypoint } from 'react-waypoint';
+export interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    right?: boolean | null | undefined;
+    containerClassName?: string | null | undefined;
+    fixedClassName?: string | null | undefined;
+    contentNode?: HTMLElement | null | undefined;
+}
+export default class Sidebar extends Component<SidebarProps> {
+    static propTypes: {
+        right: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        containerClassName: PropTypes.Requireable<string>;
+        fixedClassName: PropTypes.Requireable<string>;
+        contentNode: PropTypes.Requireable<object>;
+    };
+    state: {
+        topIsOutside: boolean;
+        bottomIsOutside: boolean;
+        sidebarVisibleHeight: undefined;
+    };
+    sidebarNode?: HTMLElement | null;
+    handleTopWaypoint: ({ currentPosition }: Waypoint.CallbackArgs) => void;
+    handleBottomWaypoint: ({ currentPosition, waypointTop }: Waypoint.CallbackArgs) => void;
+    shouldUseFixation(): boolean;
+    shouldFixateBottom(): boolean;
+    sidebarRef: (node: HTMLElement | null) => void;
+    render(): JSX.Element;
+}

package/dist/contenteditable/contenteditable.d.ts

@@ -0,0 +1,47 @@
+import { Component, HTMLAttributes, Ref } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * @name ContentEditable
+ */
+declare function noop(): void;
+export interface ContentEditableBaseProps extends HTMLAttributes<HTMLElement> {
+    disabled: boolean;
+    onComponentUpdate: ((prevProps: ContentEditableBaseProps) => void);
+    inputRef?: Ref<HTMLDivElement> | null | undefined;
+    __html: string;
+}
+declare class ContentEditableBase extends Component<ContentEditableBaseProps> {
+    static propTypes: {
+        __html: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        disabled: boolean;
+        tabIndex: number;
+        onInput: typeof noop;
+        onComponentUpdate: typeof noop;
+    };
+    shouldComponentUpdate(nextProps: ContentEditableBaseProps): boolean;
+    componentDidUpdate(prevProps: ContentEditableBaseProps): void;
+    render(): JSX.Element;
+}
+declare type ContentEditableBaseAttrs = JSX.LibraryManagedAttributes<typeof ContentEditableBase, ContentEditableBaseProps>;
+export declare type ContentEditableProps = Omit<ContentEditableBaseAttrs, '__html'>;
+declare const ContentEditable: {
+    ({ children, ...props }: ContentEditableProps): JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+};
+export default ContentEditable;

package/dist/contenteditable/contenteditable.js

@@ -23,8 +23,8 @@ class ContentEditableBase extends Component {
     return nextProps.disabled !== this.props.disabled || nextProps.__html !== this.props.__html;
   }
 
-  componentDidUpdate(prevProps, prevState) {
-    this.props.onComponentUpdate(prevProps, prevState);
+  componentDidUpdate(prevProps) {
+    this.props.onComponentUpdate(prevProps);
   }
 
   render() {
@@ -37,10 +37,12 @@ class ContentEditableBase extends Component {
       ...props
     } = this.props;
     return /*#__PURE__*/React.createElement("div", _extends({}, props, {
-      ref: inputRef,
+      ref: inputRef // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      ,
       disabled: disabled,
       role: "textbox",
-      tabIndex: disabled ? null : tabIndex,
+      tabIndex: disabled ? undefined : tabIndex,
       contentEditable: !this.props.disabled,
       dangerouslySetInnerHTML: {
         __html

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

@@ -0,0 +1,89 @@
+/**
+  * @name Data List
+  */
+import React, { Component } from 'react';
+import { FocusSensorOuterProps } from '../global/focus-sensor-hoc';
+import { SelectionShortcutsAddProps, SelectionShortcutsOuterProps } from '../table/selection-shortcuts-hoc';
+import { DisableHoverAddProps } from '../table/disable-hover-hoc';
+import { SelectionItem } from '../table/selection';
+import { FormattedItem, moreLessButtonStates } from './item';
+export interface DataListBaseProps<T extends SelectionItem> {
+    data: readonly T[];
+    itemFormatter: (item: T) => FormattedItem<T>;
+    loading?: boolean | undefined;
+    onItemMoreLess?: ((item: T, more: boolean) => void) | undefined;
+    itemMoreLessState?: ((item: FormattedItem<T>) => moreLessButtonStates) | undefined;
+    remoteSelection?: boolean | undefined;
+    className?: string | null | undefined;
+    disabledHover?: boolean | null | undefined;
+}
+declare type FocusableProps<T extends SelectionItem> = DataListBaseProps<T> & DisableHoverAddProps & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsAddProps<T>;
+export declare type DataListContainerProps<T extends SelectionItem> = DataListBaseProps<T> & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsOuterProps<T>;
+export default class DataListContainer<T extends SelectionItem> extends Component<DataListContainerProps<T>> {
+    static propTypes: React.WeakValidationMap<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<SelectionItem, FocusableProps<SelectionItem>>> | undefined;
+    DataList: {
+        new (props: import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | Readonly<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(): JSX.Element;
+            context: any;
+            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>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: 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: 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(): JSX.Element;
+            context: any;
+            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>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: 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: 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;
+        };
+        propTypes: React.WeakValidationMap<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
+        defaultProps: Partial<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
+        contextType?: React.Context<any> | undefined;
+    };
+    render(): JSX.Element;
+}
+export {};

package/dist/data-list/data-list.js

@@ -1,5 +1,5 @@
 import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
-import React, { PureComponent } from 'react';
+import React, { PureComponent, Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import focusSensorHOC from '../global/focus-sensor-hoc.js';
@@ -8,8 +8,10 @@ import disableHoverHOC from '../table/disable-hover-hoc.js';
 import getUID from '../global/get-uid.js';
 import Shortcuts from '../shortcuts/shortcuts.js';
 import Loader from '../loader/loader.js';
+import { refObject } from '../global/prop-types.js';
 import Item, { moreLessButtonStates } from './item.js';
 import { m as modules_09d014b4 } from '../_helpers/title.js';
+import Selection from './selection.js';
 import '../global/composeRefs.js';
 import '../table/selection.js';
 import '../shortcuts/core.js';
@@ -28,13 +30,7 @@ import '../link/clickableLink.js';
 import '../_helpers/link.js';
 import '../text/text.js';
 import '../loader-inline/loader-inline.js';
-import '../global/theme.js';
-import '../_helpers/inject-styles.js';
-import '../global/conic-gradient.js';
-import 'conic-gradient';
-import '../global/supports-css.js';
-import '../global/inject-styles.js';
-import '../global/radial-gradient-mask.js';
+import '../_helpers/loader-inline.js';
 import '../button/button.js';
 import '@jetbrains/icons/chevron-10px';
 import '../icon/icon.js';
@@ -42,6 +38,7 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
+import '../global/controls-height.js';
 import '../_helpers/button__classes.js';
 import '../checkbox/checkbox.js';
 import '@jetbrains/icons/checkmark';
@@ -80,12 +77,22 @@ class DataList extends PureComponent {
         selection,
         itemFormatter
       } = this.props;
-      const item = itemFormatter(selection.getFocused());
+      const focused = selection.getFocused();
+
+      if (focused == null) {
+        throw new Error('No focused item');
+      }
+
+      const item = itemFormatter(focused);
 
       if (item.collapsed) {
-        item.onExpand();
+        var _item$onExpand;
+
+        (_item$onExpand = item.onExpand) === null || _item$onExpand === void 0 ? void 0 : _item$onExpand.call(item);
       } else {
-        item.onCollapse();
+        var _item$onCollapse;
+
+        (_item$onCollapse = item.onCollapse) === null || _item$onCollapse === void 0 ? void 0 : _item$onCollapse.call(item);
       }
     });
 
@@ -142,6 +149,8 @@ class DataList extends PureComponent {
     }), /*#__PURE__*/React.createElement("ul", {
       className: classes
     }, data.map(model => {
+      var _this$props$itemMoreL, _this$props;
+
       const item = itemFormatter(model);
       const {
         id,
@@ -149,7 +158,7 @@ class DataList extends PureComponent {
         title,
         items
       } = item;
-      const showMoreLessButton = this.props.itemMoreLessState(item);
+      const showMoreLessButton = (_this$props$itemMoreL = (_this$props = this.props).itemMoreLessState) === null || _this$props$itemMoreL === void 0 ? void 0 : _this$props$itemMoreL.call(_this$props, item);
       return /*#__PURE__*/React.createElement(Item, {
         key: key || id,
         item: model,
@@ -160,7 +169,6 @@ class DataList extends PureComponent {
         collapsed: item.collapsed,
         onCollapse: item.onCollapse,
         onExpand: item.onExpand,
-        focused: selection.isFocused(model),
         showFocus: selection.isFocused(model),
         onFocus: this.onItemFocus,
         selection: selection,
@@ -171,36 +179,52 @@ class DataList extends PureComponent {
         onItemMoreLess: this.props.onItemMoreLess
       });
     })), loading && /*#__PURE__*/React.createElement("div", {
-      className: data.length > 0 ? modules_09d014b4.loadingOverlay : null
+      className: data.length > 0 ? modules_09d014b4.loadingOverlay : undefined
     }, /*#__PURE__*/React.createElement(Loader, null)));
   }
 
 }
 
-_defineProperty(DataList, "propTypes", {
+_defineProperty(DataList, "defaultProps", {
+  loading: false,
+  onItemMoreLess: () => {},
+  itemMoreLessState: () => moreLessButtonStates.UNUSED,
+  remoteSelection: false
+});
+
+DataList.propTypes = {
   className: PropTypes.string,
   data: PropTypes.array.isRequired,
   loading: PropTypes.bool,
-  focused: PropTypes.bool,
+  focused: PropTypes.bool.isRequired,
   disabledHover: PropTypes.bool,
-  selection: PropTypes.object,
-  selectable: PropTypes.bool,
-  shortcutsMap: PropTypes.object,
-  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  selection: PropTypes.instanceOf(Selection).isRequired,
+  selectable: PropTypes.bool.isRequired,
+  shortcutsMap: PropTypes.shape({}).isRequired,
+  innerRef: PropTypes.oneOfType([refObject(PropTypes.instanceOf(HTMLDivElement)), PropTypes.func]),
   itemFormatter: PropTypes.func.isRequired,
   onItemMoreLess: PropTypes.func,
   itemMoreLessState: PropTypes.func,
-  onSelect: PropTypes.func,
+  onSelect: PropTypes.func.isRequired,
   remoteSelection: PropTypes.bool
-});
+};
 
-_defineProperty(DataList, "defaultProps", {
-  loading: false,
-  onItemMoreLess: () => {},
-  itemMoreLessState: () => moreLessButtonStates.UNUSED,
-  remoteSelection: false
-});
+const getContainer = () => disableHoverHOC(selectionShortcutsHOC(focusSensorHOC(DataList))); // eslint-disable-next-line react/no-multi-comp
+
+
+class DataListContainer extends Component {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "DataList", getContainer());
+  }
+
+  render() {
+    return /*#__PURE__*/React.createElement(this.DataList, this.props);
+  }
+
+}
 
-var DataList$1 = disableHoverHOC(selectionShortcutsHOC(focusSensorHOC(DataList)));
+_defineProperty(DataListContainer, "propTypes", getContainer().propTypes);
 
-export { DataList$1 as default };
+export { DataListContainer as default };