@jetbrains/ring-ui-built 6.0.1

package/components/link/link.js

@@ -0,0 +1,86 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, g as _objectSpread2, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import joinDataTestAttributes from '../global/data-tests.js';
+import ClickableLink from './clickableLink.js';
+import { m as modules_607b0772 } from '../_helpers/link.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.concat.js';
+
+var _excluded = ["active", "inherit", "pseudo", "hover", "className", "data-test", "href", "children", "onPlainLeftClick", "onClick"];
+function linkHOC(ComposedComponent) {
+  var _class;
+  var isCustom = typeof ComposedComponent !== 'string' && ComposedComponent !== ClickableLink;
+  return _class = /*#__PURE__*/function (_PureComponent) {
+    _inherits(Link, _PureComponent);
+    var _super = _createSuper(Link);
+    function Link() {
+      _classCallCheck(this, Link);
+      return _super.apply(this, arguments);
+    }
+    _createClass(Link, [{
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+          active = _this$props.active,
+          inherit = _this$props.inherit,
+          pseudo = _this$props.pseudo,
+          hover = _this$props.hover,
+          className = _this$props.className,
+          dataTest = _this$props['data-test'],
+          href = _this$props.href,
+          children = _this$props.children,
+          onPlainLeftClick = _this$props.onPlainLeftClick,
+          onClick = _this$props.onClick,
+          restProps = _objectWithoutProperties(_this$props, _excluded);
+        var useButton = pseudo || !isCustom && href == null;
+        var classes = classNames(modules_607b0772.link, className, {
+          [modules_607b0772.active]: active,
+          [modules_607b0772.inherit]: inherit,
+          [modules_607b0772.hover]: hover,
+          [modules_607b0772.pseudo]: useButton
+        });
+        var props = restProps;
+        if (isCustom && !props.activeClassName) {
+          props = _objectSpread2(_objectSpread2({}, props), {}, {
+            activeClassName: modules_607b0772.active
+          });
+        }
+        if (useButton) {
+          return /*#__PURE__*/React.createElement("button", _extends({
+            type: "button"
+          }, props, {
+            className: classes,
+            onClick: onClick || onPlainLeftClick,
+            "data-test": joinDataTestAttributes('ring-link', dataTest)
+          }), children);
+        }
+        return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, props, {
+          href: href,
+          className: classes,
+          onClick: onClick,
+          onPlainLeftClick: onPlainLeftClick,
+          "data-test": joinDataTestAttributes('ring-link', dataTest)
+        }), children);
+      }
+    }]);
+    return Link;
+  }(PureComponent), _defineProperty(_class, "propTypes", {
+    className: 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
+  }), _class;
+}
+var Link = linkHOC(ClickableLink);
+
+export { Link as default, linkHOC };

package/components/list/consts.d.ts

@@ -0,0 +1,77 @@
+import React, { ComponentType, ReactNode, ReactElement, SyntheticEvent } from 'react';
+import { LinkProps } from '../link/link';
+import { IconType, Size } from '../icon/icon';
+import { ClickableLinkProps } from '../link/clickableLink';
+/**
+ * @enum {number}
+ */
+export declare enum Type {
+    SEPARATOR = 0,
+    LINK = 1,
+    ITEM = 2,
+    HINT = 3,
+    CUSTOM = 4,
+    TITLE = 5,
+    MARGIN = 6
+}
+export declare const Dimension: {
+    ITEM_PADDING: number;
+    ITEM_HEIGHT: number;
+    COMPACT_ITEM_HEIGHT: number;
+    SEPARATOR_HEIGHT: number;
+    SEPARATOR_FIRST_HEIGHT: number;
+    SEPARATOR_TEXT_HEIGHT: number;
+    TITLE_HEIGHT: number;
+    INNER_PADDING: number;
+    MARGIN: number;
+};
+export declare const DEFAULT_ITEM_TYPE = Type.ITEM;
+export 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<ClickableLinkProps> | string | null | undefined;
+    template?: ReactNode | ((props: ListDataItemProps<T>) => ReactNode);
+    labelWrapper?: (children: ReactNode) => ReactElement;
+    custom?: boolean | null | undefined;
+    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 type ListDataItemProps<T = unknown> = Omit<ListDataItem<T>, keyof ListDataItemAddProps> & ListDataItemAddProps;

package/components/list/consts.js

@@ -0,0 +1,27 @@
+/**
+ * @enum {number}
+ */
+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 = {}));
+var 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
+};
+var DEFAULT_ITEM_TYPE = Type.ITEM;
+
+export { DEFAULT_ITEM_TYPE, Dimension, Type };

package/components/list/list.d.ts

@@ -0,0 +1,205 @@
+/**
+ * @name List
+ */
+import React, { 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';
+import { WindowScrollerChildProps } from 'react-virtualized/dist/es/WindowScroller';
+import { ShortcutsMap } from '../shortcuts/core';
+import ListHint from './list__hint';
+import { ListDataItem, ListDataItemProps, Type } from './consts';
+export type { ListDataItem };
+declare function noop(): void;
+/**
+ * @param {Type} listItemType
+ * @param {Object} item list item
+ */
+declare function isItemType<T>(listItemType: Type, item: ListDataItem<T>): boolean;
+export interface SelectHandlerParams {
+    tryKeepOpen?: boolean;
+}
+export interface ListProps<T = unknown> {
+    data: readonly ListDataItem<T>[];
+    restoreActiveIndex: boolean;
+    activateSingleItem: boolean;
+    activateFirstItem: boolean;
+    onMouseOut: (e: SyntheticEvent<HTMLElement>) => void;
+    onSelect: (item: ListDataItem<T>, event: Event | SyntheticEvent, params?: SelectHandlerParams) => void;
+    onScrollToBottom: () => void;
+    onResize: (info: Size) => void;
+    shortcuts: boolean;
+    shortcutsMap?: ShortcutsMap;
+    renderOptimization: boolean;
+    disableMoveDownOverflow: boolean;
+    ariaLabel: string;
+    id?: string | undefined;
+    className?: string | null | undefined;
+    hint?: ReactNode;
+    hintOnSelection?: string | null | undefined;
+    maxHeight?: number | null | undefined;
+    activeIndex?: number | null | undefined;
+    useMouseUp?: boolean | null | undefined;
+    visible?: boolean | null | undefined;
+    disableMoveOverflow?: boolean | null | undefined;
+    compact?: boolean | null | undefined;
+    disableScrollToActive?: boolean | null | undefined;
+    hidden?: boolean | null | undefined;
+}
+export declare const ActiveItemContext: {
+    ValueContext: React.Context<string | undefined>;
+    UpdateContext: React.Context<(value: string | undefined) => void>;
+    Provider: {
+        ({ children }: import("../global/create-stateful-context").ProviderProps): React.JSX.Element;
+        propTypes: {
+            children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        };
+        displayName: string;
+    };
+    useUpdate: (value: string | undefined, skipUpdate?: boolean | undefined) => void;
+    Updater: React.MemoExoticComponent<{
+        ({ value, skipUpdate }: import("../global/create-stateful-context").UpdaterProps<string | undefined>): null;
+        displayName: string;
+    }>;
+};
+export interface ListState<T = unknown> {
+    activeIndex: number | null;
+    prevActiveIndex: number | null;
+    prevData: ListDataItem<T>[];
+    activeItem: ListDataItem<T> | null;
+    needScrollToActive: boolean;
+    scrolling: boolean;
+    hasOverflow: boolean;
+    disabledHover: boolean;
+    scrolledToBottom: boolean;
+}
+interface RenderVirtualizedInnerParams extends Partial<WindowScrollerChildProps> {
+    height: number;
+    maxHeight?: number;
+    autoHeight?: boolean;
+    rowCount: number;
+}
+/**
+ * @name List
+ * @constructor
+ * @extends {ReactComponent}
+ */
+/**
+ * Displays a list of items.
+ */
+export default class List<T = unknown> extends Component<ListProps<T>, ListState<T>> {
+    static propTypes: {
+        id: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        hint: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        hintOnSelection: PropTypes.Requireable<string>;
+        data: PropTypes.Requireable<any[]>;
+        maxHeight: PropTypes.Requireable<number>;
+        activeIndex: PropTypes.Requireable<number>;
+        restoreActiveIndex: PropTypes.Requireable<boolean>;
+        activateSingleItem: PropTypes.Requireable<boolean>;
+        activateFirstItem: PropTypes.Requireable<boolean>;
+        shortcuts: PropTypes.Requireable<boolean>;
+        shortcutsMap: PropTypes.Requireable<object>;
+        onMouseOut: PropTypes.Requireable<(...args: any[]) => any>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        onScrollToBottom: PropTypes.Requireable<(...args: any[]) => any>;
+        onResize: PropTypes.Requireable<(...args: any[]) => any>;
+        useMouseUp: PropTypes.Requireable<boolean>;
+        visible: PropTypes.Requireable<boolean>;
+        renderOptimization: PropTypes.Requireable<boolean>;
+        disableMoveOverflow: PropTypes.Requireable<boolean>;
+        disableMoveDownOverflow: PropTypes.Requireable<boolean>;
+        compact: PropTypes.Requireable<boolean>;
+        disableScrollToActive: PropTypes.Requireable<boolean>;
+        hidden: PropTypes.Requireable<boolean>;
+        ariaLabel: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        data: never[];
+        restoreActiveIndex: boolean;
+        activateSingleItem: boolean;
+        activateFirstItem: boolean;
+        onMouseOut: typeof noop;
+        onSelect: typeof noop;
+        onScrollToBottom: typeof noop;
+        onResize: typeof noop;
+        shortcuts: boolean;
+        renderOptimization: boolean;
+        disableMoveDownOverflow: boolean;
+        ariaLabel: string;
+    };
+    state: ListState<T>;
+    static getDerivedStateFromProps(nextProps: ListProps, prevState: ListState): {
+        prevActiveIndex: number | null | undefined;
+        prevData: readonly ListDataItem<unknown>[];
+    };
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: ListProps<T>, nextState: ListState<T>): boolean;
+    componentDidUpdate(prevProps: ListProps<T>): void;
+    componentWillUnmount(): void;
+    scheduleScrollListener: (cb: () => void) => void;
+    scheduleHoverListener: (cb: () => void) => void;
+    static isItemType: typeof isItemType;
+    static ListHint: typeof ListHint;
+    static ListProps: {
+        Type: typeof Type;
+        Dimension: {
+            ITEM_PADDING: number;
+            ITEM_HEIGHT: number;
+            COMPACT_ITEM_HEIGHT: number;
+            SEPARATOR_HEIGHT: number;
+            SEPARATOR_FIRST_HEIGHT: number;
+            SEPARATOR_TEXT_HEIGHT: number;
+            TITLE_HEIGHT: number;
+            INNER_PADDING: number;
+            MARGIN: number;
+        };
+    };
+    virtualizedList?: VirtualizedList | null;
+    unmounted?: boolean;
+    container?: HTMLElement | null;
+    hoverHandler: (arg: number) => () => void;
+    private _bufferSize;
+    sizeCacheKey: (index: number) => string | Type.ITEM | Type.MARGIN;
+    private _cache;
+    private _hasActivatableItems;
+    hasActivatableItems(): any;
+    activateFirst: () => void;
+    selectHandler: (arg: number) => (event: Event | SyntheticEvent, tryKeepOpen?: boolean) => void;
+    checkboxHandler: (arg: number) => (event: SyntheticEvent) => void;
+    upHandler: (e: KeyboardEvent) => void;
+    downHandler: (e: KeyboardEvent) => void;
+    homeHandler: (e: KeyboardEvent) => void;
+    endHandler: (e: KeyboardEvent) => void;
+    onDocumentMouseMove: () => void;
+    onDocumentKeyDown: (e: KeyboardEvent) => void;
+    moveHandler(index: number, retryCallback: (e: KeyboardEvent) => void, e: KeyboardEvent): void;
+    mouseHandler: () => void;
+    scrollHandler: () => void;
+    enterHandler: (event: KeyboardEvent, shortcut?: string) => boolean;
+    getFirst(): ListDataItem<T> | undefined;
+    getSelected(): ListDataItem<T> | null;
+    clearSelected: () => void;
+    defaultItemHeight(): number;
+    scrollEndHandler: () => void;
+    checkOverflow: () => void;
+    getVisibleListHeight(maxHeight: number): number;
+    private _deprecatedGenerateKeyFromContent;
+    getId(item: ListDataItem<T> | null): string | undefined;
+    renderItem: ({ index, style, isScrolling, parent, key }: Partial<ListRowProps>) => 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;
+    id: string;
+    shortcutsScope: string;
+    shortcutsMap: ShortcutsMap;
+    /** @override */
+    render(): React.JSX.Element;
+}
+export type ListAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof List, ListProps<T>>;