@jetbrains/ring-ui 4.1.6 → 5.0.0-beta.3

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

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

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

@@ -1,29 +1,19 @@
-import React, {PureComponent} from 'react';
+import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-
 import './island-legacy.css';
-
 export default class Island extends PureComponent {
-  static propTypes = {
-    className: PropTypes.string,
-    children: PropTypes.node
-  };
-
-  render() {
-    const {children, className, ...restProps} = this.props;
-    const classes = classNames('ring-island', className);
-
-    return (
-      <div
-        {...restProps}
-        className={classes}
-      >
+    static propTypes = {
+        className: PropTypes.string,
+        children: PropTypes.node
+    };
+    render() {
+        const { children, className, ...restProps } = this.props;
+        const classes = classNames('ring-island', className);
+        return (<div {...restProps} className={classes}>
         {children}
-      </div>
-    );
-  }
+      </div>);
+    }
 }
-
-export {default as Header} from './header-legacy';
-export {default as Content} from './content-legacy';
+export { default as Header } from './header-legacy';
+export { default as Content } from './content-legacy';

package/components/island-ng/island-ng.examples.js

@@ -2,7 +2,7 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import IslandNg from '@jetbrains/ring-ui/components/island-ng/island-ng';
+import IslandNg from './island-ng';
 
 export default {
   title: 'Legacy Angular/Island Ng',

package/components/link/clickableLink.d.ts

@@ -0,0 +1,20 @@
+import React, { PureComponent, AnchorHTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface ClickableLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    onConditionalClick?: ((isPlainLeft: boolean, e: React.MouseEvent<HTMLAnchorElement>) => void) | null | undefined;
+    onPlainLeftClick?: ((e: React.MouseEvent<HTMLAnchorElement>) => void) | null | undefined;
+    activeClassName?: string | null | undefined;
+    disabled?: boolean | undefined;
+}
+export default class ClickableLink extends PureComponent<ClickableLinkProps> {
+    static propTypes: {
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onConditionalClick: PropTypes.Requireable<(...args: any[]) => any>;
+        activeClassName: PropTypes.Requireable<string>;
+        href: PropTypes.Validator<string>;
+        children: PropTypes.Validator<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+    };
+    onClick: (e: React.MouseEvent<HTMLAnchorElement>) => void;
+    render(): JSX.Element;
+}

package/components/link/clickableLink.js

@@ -1,48 +1,33 @@
-import React, {PureComponent} from 'react';
+import React, { PureComponent } 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
-const isPlainLeftClick = e =>
-  e.button === LEFT_BUTTON && !e.altKey && !e.ctrlKey && !e.metaKey && !e.shiftKey;
-
+const isPlainLeftClick = (e) => e.button === LEFT_BUTTON && !e.altKey && !e.ctrlKey && !e.metaKey && !e.shiftKey;
 export default class ClickableLink extends PureComponent {
-  static propTypes = {
-    onClick: PropTypes.func,
-    onPlainLeftClick: PropTypes.func,
-    onConditionalClick: PropTypes.func,
-    activeClassName: PropTypes.string,
-    href: PropTypes.string.isRequired,
-    children: PropTypes.node.isRequired
-  };
-
-  onClick = e => {
-    const {onClick, onConditionalClick, onPlainLeftClick} = this.props;
-
-    const isPlainLeft = isPlainLeftClick(e);
-
-    if (onClick) {
-      onClick(e);
+    static propTypes = {
+        onClick: PropTypes.func,
+        onPlainLeftClick: PropTypes.func,
+        onConditionalClick: PropTypes.func,
+        activeClassName: PropTypes.string,
+        href: PropTypes.string.isRequired,
+        children: PropTypes.node.isRequired
+    };
+    onClick = (e) => {
+        const { onClick, onConditionalClick, onPlainLeftClick } = this.props;
+        const isPlainLeft = isPlainLeftClick(e);
+        if (onClick) {
+            onClick(e);
+        }
+        if (onConditionalClick) {
+            onConditionalClick(isPlainLeft, e);
+        }
+        if (onPlainLeftClick && isPlainLeft) {
+            e.preventDefault();
+            onPlainLeftClick(e);
+        }
+    };
+    render() {
+        const { onConditionalClick, onPlainLeftClick, activeClassName, href, children, ...restProps } = this.props;
+        return <a href={href} {...restProps} onClick={this.onClick}>{children}</a>;
     }
-
-    if (onConditionalClick) {
-      onConditionalClick(isPlainLeft, e);
-    }
-
-    if (onPlainLeftClick && isPlainLeft) {
-      e.preventDefault();
-      onPlainLeftClick(e);
-    }
-  };
-
-  render() {
-    const {
-      onConditionalClick, onPlainLeftClick, activeClassName,
-      href,
-      children,
-      ...restProps
-    } = this.props;
-
-    return <a href={href} {...restProps} onClick={this.onClick}>{children}</a>;
-  }
 }

package/components/link/link.d.ts

@@ -0,0 +1,157 @@
+import 'focus-visible';
+import React, { ReactNode, ComponentType } from 'react';
+import PropTypes from 'prop-types';
+import { ClickableLinkProps } from './clickableLink';
+export declare function setCompatibilityMode(isEnabled: boolean): void;
+export interface WrapTextProps {
+    children: ReactNode;
+    className?: string | null | undefined;
+}
+declare type ChildrenFunction = (WrapText: ComponentType<WrapTextProps>) => ReactNode;
+export interface LinkBaseProps {
+    active?: boolean | null | undefined;
+    inherit?: boolean | null | undefined;
+    pseudo?: boolean | null | undefined;
+    hover?: boolean | null | undefined;
+    innerClassName?: string | null | undefined;
+    'data-test'?: string | null | undefined;
+    children: ReactNode | ChildrenFunction;
+}
+export declare 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> | Readonly<LinkProps<P>>): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        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>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: 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): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        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>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: 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;
+    };
+    propTypes: {
+        className: PropTypes.Requireable<string>;
+        innerClassName: PropTypes.Requireable<string>;
+        active: PropTypes.Requireable<boolean>;
+        inherit: PropTypes.Requireable<boolean>;
+        pseudo: PropTypes.Requireable<boolean>;
+        hover: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        'data-test': PropTypes.Requireable<string>;
+        href: PropTypes.Requireable<string>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+declare const _default: {
+    new (props: LinkProps<ClickableLinkProps> | Readonly<LinkProps<ClickableLinkProps>>): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        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>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: 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): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        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>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: 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;
+    };
+    propTypes: {
+        className: PropTypes.Requireable<string>;
+        innerClassName: PropTypes.Requireable<string>;
+        active: PropTypes.Requireable<boolean>;
+        inherit: PropTypes.Requireable<boolean>;
+        pseudo: PropTypes.Requireable<boolean>;
+        hover: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        'data-test': PropTypes.Requireable<string>;
+        href: PropTypes.Requireable<string>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/components/link/link.js

@@ -1,119 +1,74 @@
 import 'focus-visible';
-import React, {Component, memo} from 'react';
+import React, { Component, memo } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-
 import memoize from '../global/memoize';
 import dataTests from '../global/data-tests';
-
 import ClickableLink from './clickableLink';
 import styles from './link.css';
-
 /**
  * @name Link
  */
-
 let isCompatibilityMode = false;
-
 export function setCompatibilityMode(isEnabled) {
-  isCompatibilityMode = isEnabled;
+    isCompatibilityMode = isEnabled;
 }
-
-const makeWrapText = memoize(innerClassName => {
-  const WrapText = memo(function WrapText({className, children}) {
-    const classes = classNames(styles.inner, className, innerClassName);
-    return <span className={classes}>{children}</span>;
-  });
-
-  WrapText.propTypes = {
-    className: PropTypes.string,
-    children: PropTypes.node
-  };
-
-  return WrapText;
+const makeWrapText = memoize((innerClassName) => {
+    function WrapText({ className, children }) {
+        const classes = classNames(styles.inner, className, innerClassName);
+        return <span className={classes}>{children}</span>;
+    }
+    WrapText.propTypes = {
+        className: PropTypes.string,
+        children: PropTypes.node
+    };
+    return memo(WrapText);
 });
-
 export function linkHOC(ComposedComponent) {
-  const isCustom = typeof ComposedComponent !== 'string' && ComposedComponent !== ClickableLink;
-
-  return class Link extends Component {
-    static propTypes = {
-      className: PropTypes.string,
-      innerClassName: PropTypes.string,
-      active: PropTypes.bool,
-      inherit: PropTypes.bool,
-      pseudo: PropTypes.bool,
-      hover: PropTypes.bool,
-      children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
-      'data-test': PropTypes.string,
-      href: PropTypes.string,
-      onPlainLeftClick: PropTypes.func,
-      onClick: PropTypes.func
-    };
-
-    getChildren() {
-      const {children, innerClassName} = this.props;
-
-      const WrapText = makeWrapText(innerClassName);
-
-      return typeof children === 'function'
-        ? children(WrapText)
-        : <WrapText>{children}</WrapText>;
-    }
-
-    render() {
-      const {
-        active,
-        inherit,
-        pseudo,
-        hover,
-        className,
-        'data-test': dataTest,
-        href,
-        innerClassName, children, onPlainLeftClick, onClick,
-        ...props
-      } = this.props;
-      const useButton = pseudo || !isCustom && href == null;
-
-      const classes = classNames(styles.link, className, {
-        [styles.active]: active,
-        [styles.inherit]: inherit,
-        [styles.hover]: hover,
-        [styles.compatibilityUnderlineMode]: isCompatibilityMode,
-        [styles.pseudo]: useButton,
-        [styles.text]: typeof children !== 'function'
-      });
-
-      if (isCustom && !props.activeClassName) {
-        props.activeClassName = styles.active;
-      }
-
-      if (useButton) {
-        return (
-          <button
-            type="button"
-            {...props}
-            className={classes}
-            onClick={onClick || onPlainLeftClick}
-            data-test={dataTests('ring-link', dataTest)}
-          >{this.getChildren()}</button>
-        );
-      }
-
-      return (
-        <ComposedComponent
-          {...props}
-          href={href}
-          className={classes}
-          onClick={onClick}
-          onPlainLeftClick={onPlainLeftClick}
-          data-test={dataTests('ring-link', dataTest)}
-        >
+    const isCustom = typeof ComposedComponent !== 'string' && ComposedComponent !== ClickableLink;
+    return class Link extends Component {
+        static propTypes = {
+            className: PropTypes.string,
+            innerClassName: PropTypes.string,
+            active: PropTypes.bool,
+            inherit: PropTypes.bool,
+            pseudo: PropTypes.bool,
+            hover: PropTypes.bool,
+            children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+            'data-test': PropTypes.string,
+            href: PropTypes.string,
+            onPlainLeftClick: PropTypes.func,
+            onClick: PropTypes.func
+        };
+        getChildren() {
+            const { children, innerClassName } = this.props;
+            const WrapText = makeWrapText(innerClassName);
+            return typeof children === 'function'
+                ? children(WrapText)
+                : <WrapText>{children}</WrapText>;
+        }
+        render() {
+            const { active, inherit, pseudo, hover, className, 'data-test': dataTest, href, innerClassName, children, onPlainLeftClick, onClick, ...restProps } = this.props;
+            const useButton = pseudo || !isCustom && href == null;
+            const classes = classNames(styles.link, className, {
+                [styles.active]: active,
+                [styles.inherit]: inherit,
+                [styles.hover]: hover,
+                [styles.compatibilityUnderlineMode]: isCompatibilityMode,
+                [styles.pseudo]: useButton,
+                [styles.text]: typeof children !== 'function'
+            });
+            let props = restProps;
+            if (isCustom && !props.activeClassName) {
+                props = { ...props, activeClassName: styles.active };
+            }
+            if (useButton) {
+                return (<button type="button" {...props} className={classes} onClick={(onClick || onPlainLeftClick)} data-test={dataTests('ring-link', dataTest)}>{this.getChildren()}</button>);
+            }
+            return (<ComposedComponent {...props} href={href} className={classes} onClick={onClick} onPlainLeftClick={onPlainLeftClick} data-test={dataTests('ring-link', dataTest)}>
           {this.getChildren()}
-        </ComposedComponent>
-      );
-    }
-  };
+        </ComposedComponent>);
+        }
+    };
 }
-
 export default linkHOC(ClickableLink);

package/components/link-ng/link-ng.examples.js

@@ -2,7 +2,7 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import LinkNG from '@jetbrains/ring-ui/components/link-ng/link-ng';
+import LinkNG from './link-ng';
 
 export default {
   title: 'Legacy Angular/Link Ng',

package/components/list/consts.d.ts

@@ -0,0 +1,74 @@
+import React, { ComponentType, ReactNode, SyntheticEvent } from 'react';
+import { LinkProps } from '../link/link';
+import { IconType, Size } from '../icon/icon';
+/**
+ * @enum {number}
+ */
+export declare enum Type {
+    SEPARATOR = 0,
+    LINK = 1,
+    ITEM = 2,
+    HINT = 3,
+    CUSTOM = 4,
+    TITLE = 5,
+    MARGIN = 6
+}
+export declare enum Dimension {
+    ITEM_PADDING = 16,
+    ITEM_HEIGHT = 32,
+    COMPACT_ITEM_HEIGHT = 24,
+    SEPARATOR_HEIGHT = 25,
+    SEPARATOR_FIRST_HEIGHT = 16,
+    SEPARATOR_TEXT_HEIGHT = 18,
+    TITLE_HEIGHT = 42,
+    INNER_PADDING = 8,
+    MARGIN = 8
+}
+export declare const DEFAULT_ITEM_TYPE = Type.ITEM;
+export declare type ListDataItem<T = unknown> = T & Partial<Omit<LinkProps, 'onClick' | 'onMouseUp'>> & {
+    rgItemType?: Type | null | undefined;
+    key?: string | number | null | undefined;
+    disabled?: boolean | undefined;
+    details?: string | null | undefined;
+    hoverClassName?: string | null | undefined;
+    compact?: boolean | null | undefined;
+    className?: string | null | undefined;
+    url?: string | undefined;
+    showGeneratedAvatar?: boolean | null | undefined;
+    username?: string | null | undefined;
+    avatar?: string | null | undefined;
+    subavatar?: string | null | undefined;
+    glyph?: IconType | string | null | undefined;
+    icon?: string | undefined;
+    iconSize?: Size | null | undefined;
+    rightGlyph?: IconType | string | null | undefined;
+    title?: string | null | undefined;
+    level?: number | null | undefined;
+    checkbox?: boolean | undefined;
+    description?: ReactNode;
+    label?: ReactNode;
+    rightNodes?: ReactNode;
+    leftNodes?: ReactNode;
+    tagName?: keyof JSX.IntrinsicElements | null | undefined;
+    selectedLabel?: string | null | undefined;
+    originalModel?: never;
+    LinkComponent?: ComponentType<LinkProps> | string | null | undefined;
+    template?: ReactNode | ((props: ListDataItemProps<T>) => ReactNode);
+    onClick?: ((item: ListDataItem<T>, event: Event | SyntheticEvent) => void) | null | undefined;
+    onMouseUp?: ((item: ListDataItem<T>, event: Event | SyntheticEvent) => void) | null | undefined;
+};
+export interface ListDataItemAddProps {
+    className?: string;
+    compact?: boolean | null | undefined;
+    hover: boolean;
+    onMouseOver: (e: SyntheticEvent) => void;
+    tabIndex: number;
+    scrolling: boolean;
+    onMouseUp?: (e: React.MouseEvent) => void;
+    onMouseDown?: (e: React.MouseEvent) => void;
+    onClick: (e: SyntheticEvent) => void;
+    onCheckboxChange: (e: React.ChangeEvent) => void;
+    isFirst?: boolean;
+    'data-test'?: string | null | undefined;
+}
+export declare type ListDataItemProps<T = unknown> = Omit<ListDataItem<T>, keyof ListDataItemAddProps> & ListDataItemAddProps;

package/components/list/consts.js

@@ -1,26 +1,26 @@
 /**
  * @enum {number}
  */
-export const Type = {
-  SEPARATOR: 0,
-  LINK: 1,
-  ITEM: 2,
-  HINT: 3,
-  CUSTOM: 4,
-  TITLE: 5,
-  MARGIN: 6
-};
-
-export const Dimension = {
-  ITEM_PADDING: 16,
-  ITEM_HEIGHT: 32,
-  COMPACT_ITEM_HEIGHT: 24,
-  SEPARATOR_HEIGHT: 25,
-  SEPARATOR_FIRST_HEIGHT: 16,
-  SEPARATOR_TEXT_HEIGHT: 18,
-  TITLE_HEIGHT: 42,
-  INNER_PADDING: 8,
-  MARGIN: 8
-};
-
+export var Type;
+(function (Type) {
+    Type[Type["SEPARATOR"] = 0] = "SEPARATOR";
+    Type[Type["LINK"] = 1] = "LINK";
+    Type[Type["ITEM"] = 2] = "ITEM";
+    Type[Type["HINT"] = 3] = "HINT";
+    Type[Type["CUSTOM"] = 4] = "CUSTOM";
+    Type[Type["TITLE"] = 5] = "TITLE";
+    Type[Type["MARGIN"] = 6] = "MARGIN";
+})(Type || (Type = {}));
+export var Dimension;
+(function (Dimension) {
+    Dimension[Dimension["ITEM_PADDING"] = 16] = "ITEM_PADDING";
+    Dimension[Dimension["ITEM_HEIGHT"] = 32] = "ITEM_HEIGHT";
+    Dimension[Dimension["COMPACT_ITEM_HEIGHT"] = 24] = "COMPACT_ITEM_HEIGHT";
+    Dimension[Dimension["SEPARATOR_HEIGHT"] = 25] = "SEPARATOR_HEIGHT";
+    Dimension[Dimension["SEPARATOR_FIRST_HEIGHT"] = 16] = "SEPARATOR_FIRST_HEIGHT";
+    Dimension[Dimension["SEPARATOR_TEXT_HEIGHT"] = 18] = "SEPARATOR_TEXT_HEIGHT";
+    Dimension[Dimension["TITLE_HEIGHT"] = 42] = "TITLE_HEIGHT";
+    Dimension[Dimension["INNER_PADDING"] = 8] = "INNER_PADDING";
+    Dimension[Dimension["MARGIN"] = 8] = "MARGIN";
+})(Dimension || (Dimension = {}));
 export const DEFAULT_ITEM_TYPE = Type.ITEM;