@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

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';
@@ -80,12 +82,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 +154,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 +163,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 +174,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 +184,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 };

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

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { SelectionItem } from '../table/selection';
+export interface Item extends SelectionItem {
+    title: ReactNode;
+    collapsible?: boolean;
+    selectable?: boolean;
+    items?: Item[];
+}
+declare const items: Item[];
+export declare const moreItems: {
+    id: number;
+    selectable: boolean;
+    collapsible: boolean;
+    title: JSX.Element;
+}[];
+export default items;

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

@@ -11,7 +11,7 @@ import '../link/clickableLink.js';
 import '../_helpers/link.js';
 import '../_helpers/badge.js';
 
-var dataList_mock = [{
+const items = [{
   id: 1,
   title: /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement("strong", null, "Assigner"), " in 60 projects"),
   collapsible: true,
@@ -187,4 +187,4 @@ const moreItems = [{
   }, "duplicate"))
 }];
 
-export { dataList_mock as default, moreItems };
+export { items as default, moreItems };

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

@@ -0,0 +1,50 @@
+import { PureComponent, ReactNode } from 'react';
+import Selection, { SelectionItem } from '../table/selection';
+export declare enum moreLessButtonStates {
+    UNUSED = 0,
+    MORE = 1,
+    MORE_LOADING = 2,
+    LESS = 3
+}
+export interface BaseFormattedItem<T> {
+    items?: readonly T[];
+    title?: ReactNode;
+    collapsible?: boolean | null | undefined;
+    collapsed?: boolean | null | undefined;
+    onCollapse?: () => void;
+    onExpand?: () => void;
+    selectable?: boolean | undefined;
+}
+export interface FormattedItem<T> extends BaseFormattedItem<T> {
+    key?: string | null | undefined;
+    id?: string | number | null | undefined;
+}
+export interface ItemProps<T extends SelectionItem> extends BaseFormattedItem<T> {
+    item: T;
+    onFocus: (item: T) => void;
+    onSelect: (item: T, selected: boolean) => void;
+    itemFormatter: (item: T) => FormattedItem<T>;
+    level: number;
+    parentShift: number;
+    showMoreLessButton: moreLessButtonStates;
+    onItemMoreLess: (item: T, more: boolean) => void;
+    className?: string | null | undefined;
+    showFocus?: boolean | undefined;
+    selection: Selection<T>;
+    selected?: boolean | undefined;
+}
+export default class Item<T extends SelectionItem> extends PureComponent<ItemProps<T>> {
+    static defaultProps: {
+        items: never[];
+        level: number;
+        parentShift: number;
+        showMoreLessButton: moreLessButtonStates;
+        onItemMoreLess: () => void;
+    };
+    onShowMore: () => void;
+    onShowLess: () => void;
+    onFocus: () => void;
+    onSelect: (selected: boolean) => void;
+    renderItem: (model: T, parentShift: number) => JSX.Element;
+    render(): JSX.Element;
+}

package/dist/data-list/item.js

@@ -5,8 +5,9 @@ import chevronRightIcon from '@jetbrains/icons/chevron-right';
 import chevronDownIcon from '@jetbrains/icons/chevron-down';
 import Link from '../link/link.js';
 import Text from '../text/text.js';
-import LoaderInline from '../loader-inline/loader-inline.js';
-import Button from '../button/button.js';
+import ThemedLoaderInline from '../loader-inline/loader-inline.js';
+import ThemedButton from '../button/button.js';
+import Selection from '../table/selection.js';
 import { m as modules_09d014b4, T as Title } from '../_helpers/title.js';
 import 'focus-visible';
 import 'classnames';
@@ -30,18 +31,22 @@ import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
 import '../_helpers/button__classes.js';
 import '../global/focus-sensor-hoc.js';
+import '../global/prop-types.js';
 import '../global/composeRefs.js';
 import '../checkbox/checkbox.js';
 import '@jetbrains/icons/checkmark';
 import '@jetbrains/icons/remove-10px';
 import '../_helpers/checkbox.js';
 
-const moreLessButtonStates = {
-  UNUSED: 0,
-  MORE: 1,
-  MORE_LOADING: 2,
-  LESS: 3
-};
+var moreLessButtonStates;
+
+(function (moreLessButtonStates) {
+  moreLessButtonStates[moreLessButtonStates["UNUSED"] = 0] = "UNUSED";
+  moreLessButtonStates[moreLessButtonStates["MORE"] = 1] = "MORE";
+  moreLessButtonStates[moreLessButtonStates["MORE_LOADING"] = 2] = "MORE_LOADING";
+  moreLessButtonStates[moreLessButtonStates["LESS"] = 3] = "LESS";
+})(moreLessButtonStates || (moreLessButtonStates = {}));
+
 const ITEM_LEFT_OFFSET = 32;
 const LIST_LEFT_OFFSET = 24;
 class Item extends PureComponent {
@@ -101,7 +106,6 @@ class Item extends PureComponent {
         collapsed: item.collapsed,
         onCollapse: item.onCollapse,
         onExpand: item.onExpand,
-        focused: selection.isFocused(model),
         showFocus: selection.isFocused(model),
         onFocus: onFocus,
         selection: selection,
@@ -136,7 +140,7 @@ class Item extends PureComponent {
         inherit: true,
         pseudo: true,
         onClick: this.onShowMore
-      }, 'Show more'), showMoreLessButton === moreLessButtonStates.MORE_LOADING && /*#__PURE__*/React.createElement(LoaderInline, {
+      }, 'Show more'), showMoreLessButton === moreLessButtonStates.MORE_LOADING && /*#__PURE__*/React.createElement(ThemedLoaderInline, {
         className: modules_09d014b4.showMoreLoader
       }));
     } else if (showMoreLessButton === moreLessButtonStates.LESS) {
@@ -153,7 +157,7 @@ class Item extends PureComponent {
 
     if (collapsible) {
       if (collapsed) {
-        collapserExpander = /*#__PURE__*/React.createElement(Button, {
+        collapserExpander = /*#__PURE__*/React.createElement(ThemedButton, {
           title: "Expand",
           onClick: onExpand,
           icon: chevronRightIcon,
@@ -162,7 +166,7 @@ class Item extends PureComponent {
           "data-test": "ring-data-list-expand"
         });
       } else {
-        collapserExpander = /*#__PURE__*/React.createElement(Button, {
+        collapserExpander = /*#__PURE__*/React.createElement(ThemedButton, {
           title: "Collapse",
           onClick: onCollapse,
           icon: chevronDownIcon,
@@ -173,7 +177,7 @@ class Item extends PureComponent {
       }
     }
 
-    const itemIsEmpty = !items.length || collapsible && collapsed;
+    const itemIsEmpty = !(items !== null && items !== void 0 && items.length) || collapsible && collapsed;
     const offset = level * LIST_LEFT_OFFSET + ITEM_LEFT_OFFSET + parentShift;
     return /*#__PURE__*/React.createElement("li", null, /*#__PURE__*/React.createElement(Title, {
       title: title,
@@ -194,34 +198,36 @@ class Item extends PureComponent {
 
 }
 
-_defineProperty(Item, "propTypes", {
-  item: PropTypes.object,
+_defineProperty(Item, "defaultProps", {
+  items: [],
+  level: 0,
+  parentShift: 0,
+  showMoreLessButton: moreLessButtonStates.UNUSED,
+  onItemMoreLess: () => {}
+});
+
+Item.propTypes = {
+  item: PropTypes.shape({
+    id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired
+  }).isRequired,
   title: PropTypes.node,
   items: PropTypes.array,
   className: PropTypes.string,
   level: PropTypes.number,
   parentShift: PropTypes.number,
-  itemFormatter: PropTypes.func,
+  itemFormatter: PropTypes.func.isRequired,
   collapsible: PropTypes.bool,
   collapsed: PropTypes.bool,
   onCollapse: PropTypes.func,
   onExpand: PropTypes.func,
   showFocus: PropTypes.bool,
-  onFocus: PropTypes.func,
-  selection: PropTypes.object,
+  onFocus: PropTypes.func.isRequired,
+  selection: PropTypes.instanceOf(Selection).isRequired,
   selectable: PropTypes.bool,
   selected: PropTypes.bool,
-  onSelect: PropTypes.func,
+  onSelect: PropTypes.func.isRequired,
   showMoreLessButton: PropTypes.number,
   onItemMoreLess: PropTypes.func
-});
-
-_defineProperty(Item, "defaultProps", {
-  items: [],
-  level: 0,
-  parentShift: 0,
-  showMoreLessButton: moreLessButtonStates.UNUSED,
-  onItemMoreLess: () => {}
-});
+};
 
 export { Item as default, moreLessButtonStates };

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

@@ -0,0 +1,16 @@
+import TableSelection, { CloneWithConfig, SelectionItem } from '../table/selection';
+export default class Selection<T extends SelectionItem> extends TableSelection<T> {
+    protected _buildData(data: T[]): Set<T>;
+    protected _buildSelected(data: Set<T>, selected: Set<T>): Set<T>;
+    private _getDescendants;
+    private _getAncestors;
+    private _selectDescendants;
+    private _deselectDescendants;
+    private _selectAncestors;
+    private _deselectAncestors;
+    select(value?: T | null): Selection<T>;
+    focus(value: T | null | undefined): Selection<T>;
+    resetSelection(): Selection<T>;
+    cloneWith(config: CloneWithConfig<T>): Selection<T>;
+    deselect(value?: T | null): Selection<T>;
+}

package/dist/data-list/selection.js

@@ -1,4 +1,5 @@
 import Selection$1 from '../table/selection.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
 
 class Selection extends Selection$1 {
   _buildData(data) {
@@ -77,6 +78,18 @@ class Selection extends Selection$1 {
     });
   }
 
+  focus(value) {
+    return super.focus(value);
+  }
+
+  resetSelection() {
+    return super.resetSelection();
+  }
+
+  cloneWith(config) {
+    return super.cloneWith(config);
+  }
+
   deselect() {
     let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._focused;
 

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

@@ -0,0 +1,26 @@
+import React, { PureComponent, ReactNode } from 'react';
+import { FocusSensorAddProps } from '../global/focus-sensor-hoc';
+export interface TitleProps extends FocusSensorAddProps<HTMLDivElement> {
+    onSelect: (selected: boolean) => void;
+    selectable?: boolean | undefined;
+    selected?: boolean | undefined;
+    showFocus?: boolean | undefined;
+    offset?: number | undefined;
+    className?: string | null | undefined;
+    title?: ReactNode;
+    collapserExpander?: ReactNode;
+}
+declare class Title extends PureComponent<TitleProps> {
+    static defaultProps: {
+        selectable: boolean;
+        selected: boolean;
+        showFocus: boolean;
+    };
+    id: string;
+    onCheckboxFocus: () => void;
+    onCheckboxChange: () => void;
+    toggleSelection(): void;
+    render(): JSX.Element;
+}
+declare const _default: React.ComponentType<import("../global/focus-sensor-hoc").FocusSensorProps<TitleProps, HTMLDivElement, typeof Title>>;
+export default _default;

package/dist/data-list/title.js

@@ -5,6 +5,7 @@ import 'classnames';
 import '../global/focus-sensor-hoc.js';
 import '../checkbox/checkbox.js';
 import '../global/get-uid.js';
+import '../global/prop-types.js';
 export { T as default } from '../_helpers/title.js';
 import '../global/composeRefs.js';
 import '@jetbrains/icons/checkmark';

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

@@ -1,5 +1,5 @@
 import angularComponentFactory from '../global/angular-component-factory.js';
-import DataList from '../data-list/data-list.js';
+import DataListContainer from '../data-list/data-list.js';
 import '../_helpers/_rollupPluginBabelHelpers.js';
 import 'angular';
 import 'react';
@@ -9,6 +9,7 @@ import '../global/react-dom-renderer.js';
 import 'prop-types';
 import 'classnames';
 import '../global/focus-sensor-hoc.js';
+import '../global/prop-types.js';
 import '../global/composeRefs.js';
 import '../table/selection-shortcuts-hoc.js';
 import '../table/selection.js';
@@ -53,7 +54,8 @@ import '../checkbox/checkbox.js';
 import '@jetbrains/icons/checkmark';
 import '@jetbrains/icons/remove-10px';
 import '../_helpers/checkbox.js';
+import '../data-list/selection.js';
 
-var dataListNg = angularComponentFactory(DataList, 'DataList').name;
+var dataListNg = angularComponentFactory(DataListContainer, 'DataList').name;
 
 export { dataListNg as default };

package/dist/date-picker/consts.d.ts

@@ -0,0 +1,99 @@
+import { ReactNode } from 'react';
+import PropTypes from 'prop-types';
+import type { Locale } from 'date-fns';
+declare const units: {
+    unit: number;
+    cellSize: number;
+    calHeight: number;
+    yearHeight: number;
+};
+export default units;
+export declare const YEAR = 12;
+export declare const WEEK = 7;
+export declare const weekdays: {
+    MO: number;
+    TU: number;
+    WE: number;
+    TH: number;
+    FR: number;
+    SA: number;
+    SU: number;
+};
+export declare const MIDDLE_DAY = 15;
+export declare const yearDuration: number;
+export declare const yearScrollSpeed: number;
+export declare const DOUBLE = 2;
+export declare const HALF = 0.5;
+export declare const dateType: PropTypes.Requireable<string | number | Date>;
+export declare function parseTime(time: string): string | null;
+export interface DateInputTranslations {
+    addFirstDate: string;
+    addSecondDate: string;
+    addTime: string;
+    selectName: string;
+}
+export interface DateSpecificPopupProps {
+    withTime?: false | undefined;
+    range?: false | undefined;
+    onChange: (date: Date | null | undefined) => void;
+}
+export interface DatePickerChange {
+    from?: Date | null | undefined;
+    to?: Date | null | undefined;
+    date?: Date | null | undefined;
+    time?: string | null | undefined;
+}
+export interface TimeSpecificPopupProps {
+    withTime: true;
+    range?: false | undefined;
+    onChange: (change: DatePickerChange) => void;
+}
+export interface RangeSpecificPopupProps {
+    withTime?: false | undefined;
+    range: true;
+    onChange: (change: DatePickerChange) => void;
+}
+export interface DatePopupState {
+    active: Field;
+    text: string | null;
+    hoverDate: Date | null;
+    scrollDate: number | null;
+}
+export interface DatePopupBaseProps {
+    date?: Date | number | string | null | undefined;
+    time?: string | null | undefined;
+    from?: Date | number | string | null | undefined;
+    to?: Date | number | string | null | undefined;
+    minDate?: string | null | undefined;
+    maxDate?: string | null | undefined;
+    translations: DateInputTranslations;
+    fromPlaceholder?: string | null | undefined;
+    toPlaceholder?: string | null | undefined;
+    timePlaceholder?: string | null | undefined;
+    hidden: boolean;
+    locale?: Locale | undefined;
+    parseDateInput: (text: Date | number | string | null | undefined) => Date | null;
+    displayFormat: (date: Date, locale: Locale | undefined) => string;
+    onComplete: () => void;
+    onClear?: ((e: React.MouseEvent<HTMLButtonElement>) => void) | null | undefined;
+    renderAfterCalendar?: ((state: DatePopupState) => ReactNode) | undefined;
+}
+export interface Dates {
+    from?: Date | null | undefined;
+    to?: Date | null | undefined;
+    date?: Date | null | undefined;
+    time?: never;
+}
+export interface CalendarProps extends Omit<DatePopupBaseProps, 'date' | 'from' | 'to' | 'time'>, Dates {
+    activeDate: Date | null;
+    scrollDate: number | Date;
+    currentRange: [Date, Date] | null;
+    activeRange: [Date, Date] | null;
+    onScroll: (to: number) => void;
+    onScrollChange: (date: number) => void;
+}
+export interface MonthsProps extends CalendarProps {
+    onSelect: (date: Date) => void;
+    onHover: (date: Date) => void;
+}
+export declare type Field = 'date' | 'time' | 'from' | 'to';