@jetbrains/ring-ui-built 6.0.1

package/components/query-assist/query-assist__suggestions.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { ListDataItem } from '../list/consts';
+export interface QueryAssistSuggestion {
+    description: string;
+    group: string;
+    icon?: string | undefined;
+    option: string;
+    prefix?: string | undefined;
+    suffix?: string | undefined;
+    className?: string | undefined;
+    matchingStart?: number;
+    matchingEnd?: number;
+    caret?: number;
+    completionStart?: number;
+    completionEnd?: number;
+}
+export interface SuggestionItem {
+    data?: QueryAssistSuggestion;
+}
+export default class QueryAssistSuggestions {
+    static createKey(suggestion: QueryAssistSuggestion): string;
+    static renderLabel(suggestion: QueryAssistSuggestion): React.JSX.Element;
+    static renderGroupSeparator(suggestion: QueryAssistSuggestion, prevSuggestion: string): {
+        key: string;
+        description: string;
+        rgItemType: import("../list/consts").Type;
+    } | null;
+    static renderList(suggestions: readonly QueryAssistSuggestion[], suggestionRenderer: (suggestion: QueryAssistSuggestion) => ListDataItem<SuggestionItem>): ListDataItem<SuggestionItem>[];
+}

package/components/query-assist/query-assist__suggestions.js

@@ -0,0 +1,75 @@
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.symbol.js';
+import 'core-js/modules/es.symbol.description.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'react';
+import '../list/list.js';
+export { Q as default } from '../_helpers/query-assist__suggestions.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.find-index.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.find.js';
+import 'prop-types';
+import 'classnames';
+import 'react-virtualized/dist/es/List';
+import 'react-virtualized/dist/es/AutoSizer';
+import 'react-virtualized/dist/es/WindowScroller';
+import 'react-virtualized/dist/es/CellMeasurer';
+import 'util-deprecate';
+import 'memoize-one';
+import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
+import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../global/schedule-raf.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import '../global/dom.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.set.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.string.match.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../global/create-stateful-context.js';
+import '../list/list__link.js';
+import '../link/link.js';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../_helpers/list.js';
+import '../list/list__item.js';
+import 'core-js/modules/es.array.index-of.js';
+import '../avatar/avatar.js';
+import '../global/url.js';
+import 'core-js/modules/es.string.replace.js';
+import '../avatar/fallback-avatar.js';
+import 'core-js/modules/es.array.from.js';
+import '../checkbox/checkbox.js';
+import '@jetbrains/icons/checkmark-14px';
+import '@jetbrains/icons/remove-14px';
+import '../icon/icon.js';
+import '../icon/icon__constants.js';
+import '../_helpers/icon__svg.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/prop-types.js';
+import '../global/composeRefs.js';
+import '../list/list__custom.js';
+import '../global/get-event-key.js';
+import '../list/list__title.js';
+import '../list/list__separator.js';
+import '../list/list__hint.js';
+import '../list/consts.js';

package/components/radio/radio.d.ts

@@ -0,0 +1,18 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { RadioProps } from './radio__item';
+/**
+ * @name Radio
+ */
+export default class Radio extends Component<RadioProps> {
+    static propTypes: {
+        name: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        value: PropTypes.Requireable<NonNullable<string | number | boolean | null | undefined>>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+    };
+    static Item: React.ForwardRefExoticComponent<import("./radio__item").RadioItemProps & React.RefAttributes<import("./radio__item").Radio>>;
+    uid: string;
+    render(): React.JSX.Element;
+}

package/components/radio/radio.js

@@ -0,0 +1,48 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, g as _objectSpread2 } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import getUID from '../global/get-uid.js';
+import RadioItem, { RadioContext } from './radio__item.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'classnames';
+
+/**
+ * @name Radio
+ */
+var Radio = /*#__PURE__*/function (_Component) {
+  _inherits(Radio, _Component);
+  var _super = _createSuper(Radio);
+  function Radio() {
+    var _this;
+    _classCallCheck(this, Radio);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "uid", getUID('ring-radio-'));
+    return _this;
+  }
+  _createClass(Radio, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(RadioContext.Provider, {
+        value: _objectSpread2({
+          name: this.uid
+        }, this.props)
+      }, this.props.children);
+    }
+  }]);
+  return Radio;
+}(Component);
+_defineProperty(Radio, "propTypes", {
+  name: PropTypes.string,
+  disabled: PropTypes.bool,
+  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool]),
+  onChange: PropTypes.func,
+  children: PropTypes.node.isRequired
+});
+_defineProperty(Radio, "Item", RadioItem);
+
+export { Radio as default };

package/components/radio/radio__item.d.ts

@@ -0,0 +1,28 @@
+import React, { Component, InputHTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    value?: string | undefined;
+    onChange?: ((value: string) => void) | null | undefined;
+}
+export declare const RadioContext: React.Context<RadioProps>;
+export declare class Radio extends Component<InputHTMLAttributes<HTMLInputElement>> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        value: PropTypes.Requireable<string>;
+        name: PropTypes.Requireable<string>;
+        checked: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    uid: string;
+    input?: HTMLElement | null;
+    inputRef: (el: HTMLElement | null) => void;
+    label?: HTMLElement | null;
+    labelRef: (el: HTMLElement | null) => void;
+    render(): React.JSX.Element;
+}
+export interface RadioItemProps extends InputHTMLAttributes<HTMLInputElement> {
+    value: string;
+}
+declare const RadioItem: React.ForwardRefExoticComponent<RadioItemProps & React.RefAttributes<Radio>>;
+export default RadioItem;

package/components/radio/radio__item.js

@@ -0,0 +1,88 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { createContext, Component, forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import getUID from '../global/get-uid.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+
+var modules_df92307a = {"light":"light_rui_2ac4","radio":"radio_rui_370b","circle":"circle_rui_370b","input":"input_rui_370b","focus":"focus_rui_370b","label":"label_rui_370b"};
+
+var _excluded = ["className", "children"],
+  _excluded2 = ["value", "onChange"];
+var RadioContext = /*#__PURE__*/createContext({});
+var Radio = /*#__PURE__*/function (_Component) {
+  _inherits(Radio, _Component);
+  var _super = _createSuper(Radio);
+  function Radio() {
+    var _this;
+    _classCallCheck(this, Radio);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "uid", getUID('ring-radio-item-'));
+    _defineProperty(_assertThisInitialized(_this), "input", void 0);
+    _defineProperty(_assertThisInitialized(_this), "inputRef", function (el) {
+      _this.input = el;
+    });
+    _defineProperty(_assertThisInitialized(_this), "label", void 0);
+    _defineProperty(_assertThisInitialized(_this), "labelRef", function (el) {
+      _this.label = el;
+    });
+    return _this;
+  }
+  _createClass(Radio, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_df92307a.radio, className);
+      return /*#__PURE__*/React.createElement("label", {
+        ref: this.labelRef,
+        className: classes,
+        htmlFor: this.uid
+      }, /*#__PURE__*/React.createElement("input", _extends({
+        id: this.uid
+      }, restProps, {
+        ref: this.inputRef,
+        className: modules_df92307a.input,
+        type: "radio"
+      })), /*#__PURE__*/React.createElement("span", {
+        className: modules_df92307a.circle
+      }), /*#__PURE__*/React.createElement("span", {
+        className: modules_df92307a.label
+      }, children));
+    }
+  }]);
+  return Radio;
+}(Component);
+_defineProperty(Radio, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node,
+  value: PropTypes.string,
+  name: PropTypes.string,
+  checked: PropTypes.bool,
+  onChange: PropTypes.func
+});
+var RadioItem = /*#__PURE__*/forwardRef(function RadioItem(props, ref) {
+  return /*#__PURE__*/React.createElement(RadioContext.Consumer, null, function (_ref) {
+    var value = _ref.value,
+      onChange = _ref.onChange,
+      restContext = _objectWithoutProperties(_ref, _excluded2);
+    return /*#__PURE__*/React.createElement(Radio, _extends({
+      ref: ref
+    }, restContext, {
+      checked: value != null ? value === props.value : undefined,
+      onChange: onChange != null ? function () {
+        return onChange(props.value);
+      } : undefined
+    }, props));
+  });
+});
+RadioItem.propTypes = Radio.propTypes;
+
+export { Radio, RadioContext, RadioItem as default };

package/components/select/select.d.ts

@@ -0,0 +1,276 @@
+import React, { ButtonHTMLAttributes, Component, ComponentType, CSSProperties, HTMLAttributes, ReactNode, Ref, RefCallback, SyntheticEvent } from 'react';
+import { SelectHandlerParams } from '../list/list';
+import { Size } from '../input/input';
+import { LabelType } from '../control-label/control-label';
+import { ListDataItem } from '../list/consts';
+import { Directions } from '../popup/popup.consts';
+import { ControlsHeight } from '../global/controls-height';
+import SelectPopup, { Filter, FilterFn, Multiple, Tags } from './select__popup';
+/**
+ * @name Select
+ */
+declare function noop(): void;
+/**
+ * @enum {number}
+ */
+export declare enum Type {
+    BUTTON = "BUTTON",
+    INPUT = "INPUT",
+    CUSTOM = "CUSTOM",
+    INLINE = "INLINE",
+    INPUT_WITHOUT_CONTROLS = "INPUT_WITHOUT_CONTROLS"
+}
+type SelectItemData<T> = T & {
+    key: string | number;
+    isResetItem?: boolean | null | undefined;
+    separator?: boolean | null | undefined;
+};
+export type SelectItem<T = unknown> = ListDataItem<SelectItemData<T>>;
+declare function getLowerCaseLabel<T>(item: SelectItem<T>): string | null;
+declare function doesLabelMatch<T>(itemToCheck: SelectItem<T>, fn: (label: string) => boolean): boolean;
+export interface Add {
+    alwaysVisible?: boolean | null | undefined;
+    regexp?: RegExp | null | undefined;
+    minlength?: number | null | undefined;
+    label?: ((filterString: string) => string) | string | null | undefined;
+    prefix?: string | null | undefined;
+    delayed?: boolean | null | undefined;
+}
+export interface DataTestProps {
+    'data-test'?: string | null | undefined;
+}
+export interface CustomAnchorProps {
+    wrapperProps: HTMLAttributes<HTMLElement> & DataTestProps & {
+        ref: RefCallback<HTMLElement>;
+    };
+    buttonProps: Pick<ButtonHTMLAttributes<HTMLButtonElement>, 'id' | 'disabled' | 'children'> & {
+        onClick: () => void;
+    } & DataTestProps;
+    popup: ReactNode;
+}
+export type CustomAnchor = ((props: CustomAnchorProps) => ReactNode);
+export interface BaseSelectProps<T = unknown> {
+    data: readonly SelectItem<T>[];
+    filter: boolean | Filter<T>;
+    filterIcon?: string | ComponentType | null | undefined;
+    filterRef?: Ref<HTMLInputElement>;
+    clear: boolean;
+    loading: boolean;
+    disabled: boolean;
+    loadingMessage?: string;
+    notFoundMessage?: string;
+    type: Type;
+    size: Size;
+    hideSelected: boolean;
+    allowAny: boolean;
+    maxHeight: number;
+    hideArrow: boolean;
+    showPopup: boolean;
+    directions: readonly Directions[];
+    label: string | null;
+    selectedLabel: ReactNode;
+    labelType?: LabelType;
+    inputPlaceholder: string;
+    shortcutsEnabled: boolean;
+    tryKeepOpen?: boolean;
+    onBeforeOpen: () => void;
+    onLoadMore: () => void;
+    onOpen: () => void;
+    onFilter: (value: string) => void;
+    onFocus: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onBlur: () => void;
+    onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    onSelect: (selected: SelectItem<T> | null, event?: Event | SyntheticEvent) => void;
+    onDeselect: (selected: SelectItem<T> | null) => void;
+    onOutsideClick: (e: PointerEvent) => void;
+    onAdd: (value: string) => void;
+    onDone: () => void;
+    onReset: () => void;
+    dir: 'ltr' | 'rtl';
+    renderBottomToolbar?: () => ReactNode;
+    renderTopToolbar?: () => ReactNode;
+    height?: ControlsHeight | undefined;
+    targetElement?: HTMLElement | null | undefined;
+    className?: string | null | undefined;
+    buttonClassName?: string | null | undefined;
+    id?: string | undefined;
+    getInitial?: (() => string) | null | undefined;
+    minWidth?: number | undefined;
+    popupClassName?: string | null | undefined;
+    popupStyle?: CSSProperties | undefined;
+    top?: number | undefined;
+    left?: number | undefined;
+    renderOptimization?: boolean | undefined;
+    ringPopupTarget?: string | null | undefined;
+    error?: ReactNode | null | undefined;
+    hint?: ReactNode;
+    add?: Add | null | undefined;
+    compact?: boolean | null | undefined;
+    customAnchor?: CustomAnchor | null | undefined;
+    disableMoveOverflow?: boolean | null | undefined;
+    disableScrollToActive?: boolean | null | undefined;
+    'data-test'?: string | null | undefined;
+}
+export interface SingleSelectProps<T = unknown> extends BaseSelectProps<T> {
+    multiple: false;
+    onClose: (selected: SelectItem<T> | null) => void;
+    onChange: (selected: SelectItem<T> | null, event?: Event | SyntheticEvent) => void;
+    selected?: SelectItem<T> | null | undefined;
+    tags?: null | undefined;
+}
+export interface MultipleSelectProps<T = unknown> extends BaseSelectProps<T> {
+    multiple: true | Multiple;
+    selected: readonly SelectItem<T>[];
+    onClose: (selected: SelectItem<T>[]) => void;
+    onChange: (selected: SelectItem<T>[], event?: Event | SyntheticEvent) => void;
+    tags?: Tags | boolean | null | undefined;
+}
+export type SelectProps<T = unknown> = SingleSelectProps<T> | MultipleSelectProps<T>;
+interface AddButton {
+    prefix: string | null | undefined;
+    label: string;
+    delayed: boolean;
+}
+export interface SelectState<T = unknown> {
+    data: SelectItem<T>[];
+    shownData: SelectItem<T>[];
+    selected: SelectItem<T> | SelectItem<T>[] | null | undefined;
+    selectedIndex: number | null;
+    filterValue: string;
+    shortcutsEnabled: boolean;
+    popupShortcuts: boolean;
+    showPopup: boolean;
+    prevData: readonly SelectItem<T>[];
+    prevSelected: SelectItem<T> | readonly SelectItem<T>[] | null | undefined;
+    prevMultiple: Multiple | boolean | null | undefined;
+    multipleMap: Record<string, boolean>;
+    addButton: AddButton | null;
+    focused?: boolean;
+}
+/**
+ * @name Select
+ * @constructor
+ * @extends {Component}
+ */
+/**
+ * Displays a select.
+ */
+export default class Select<T = unknown> extends Component<SelectProps<T>, SelectState<T>> {
+    static defaultProps: {
+        data: never[];
+        filter: boolean;
+        filterIcon: null;
+        filterRef: typeof noop;
+        multiple: boolean;
+        clear: boolean;
+        loading: boolean;
+        disabled: boolean;
+        type: Type;
+        size: Size;
+        targetElement: null;
+        hideSelected: boolean;
+        allowAny: boolean;
+        hideArrow: boolean;
+        showPopup: boolean;
+        maxHeight: number;
+        directions: Directions[];
+        selected: null;
+        label: null;
+        selectedLabel: null;
+        inputPlaceholder: string;
+        hint: null;
+        shortcutsEnabled: boolean;
+        onBeforeOpen: typeof noop;
+        onLoadMore: typeof noop;
+        onOpen: typeof noop;
+        onClose: typeof noop;
+        onFilter: typeof noop;
+        onFocus: typeof noop;
+        onBlur: typeof noop;
+        onKeyDown: typeof noop;
+        onSelect: typeof noop;
+        onDeselect: typeof noop;
+        onOutsideClick: typeof noop;
+        onChange: typeof noop;
+        onAdd: typeof noop;
+        onDone: typeof noop;
+        onReset: typeof noop;
+        tags: null;
+        ringPopupTarget: null;
+        dir: string;
+    };
+    static getDerivedStateFromProps<T = unknown>(nextProps: SelectProps<T>, prevState: SelectState<T>): Partial<SelectState<T>>;
+    state: SelectState<T>;
+    componentDidUpdate(prevProps: SelectProps<T>, prevState: SelectState<T>): void;
+    static contextType: React.Context<ControlsHeight>;
+    static Type: typeof Type;
+    static Size: typeof Size;
+    id: string;
+    shortcutsScope: string;
+    listId: string;
+    private _focusHandler;
+    private _blurHandler;
+    node?: HTMLElement | null;
+    nodeRef: (el: HTMLElement | null) => void;
+    _popup: SelectPopup<SelectItemData<T>> | null;
+    onEmptyPopupEnter: () => void;
+    focus: () => void;
+    private _onEnter;
+    private _onEsc;
+    _inputShortcutHandler: () => void;
+    getValueForFilter(selected: SelectItem<T> | readonly SelectItem<T>[] | null | undefined): string;
+    _getSelectedIndex(selected: SelectItem<T> | readonly SelectItem<T>[] | null | undefined, data: readonly SelectItem<T>[]): number | null;
+    popupRef: (el: SelectPopup<SelectItemData<T>> | null) => void;
+    _getResetOption(): SelectItem<T> | null;
+    _prependResetOption(shownData: SelectItem<T>[]): SelectItem<T>[];
+    private _renderPopup;
+    _showPopup(): void;
+    _hidePopup(tryFocusAnchor?: boolean): void;
+    addHandler: () => void;
+    getToolbar(): React.JSX.Element | null;
+    getTopbar(): React.ReactNode;
+    getLowerCaseLabel: typeof getLowerCaseLabel;
+    doesLabelMatch: typeof doesLabelMatch;
+    getFilterFn(): FilterFn<T>;
+    getListItems(rawFilterString: string, data?: SelectItem<T>[]): SelectItem<T>[];
+    filterValue(): string;
+    filterValue(setValue: string): void;
+    isInputMode(): boolean;
+    _clickHandler: () => void;
+    _openPopupIfClosed: () => void;
+    _filterChangeHandler: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    private _setFilter;
+    private _rebuildMultipleMap;
+    _redrawPopup: () => void;
+    _listSelectHandler: (selected: SelectItem<T>, event?: Event, opts?: SelectHandlerParams) => void;
+    _listSelectAllHandler: (isSelectAll?: boolean) => void;
+    private _onCloseAttempt;
+    clearFilter: (e?: SyntheticEvent) => void;
+    clear: (event?: Event | SyntheticEvent) => boolean;
+    _selectionIsEmpty(): boolean;
+    private _getLabel;
+    private _getPlaceholder;
+    _getSelectedString(): string | null;
+    private _getIcons;
+    private _getAvatar;
+    filter?: HTMLInputElement | null;
+    filterRef: (el: HTMLInputElement | null) => void;
+    getShortcutsMap(): {
+        enter: () => true | undefined;
+        esc: (event: KeyboardEvent) => boolean | undefined;
+        up: () => void;
+        down: () => void;
+        right: typeof noop;
+        left: typeof noop;
+        'shift+up': typeof noop;
+        'shift+down': typeof noop;
+        space: typeof noop;
+    };
+    renderSelect(activeItemId: string | undefined): React.JSX.Element;
+    render(): React.JSX.Element;
+}
+export type SingleSelectAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof Select, SingleSelectProps<T>>;
+export type MultipleSelectAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof Select, MultipleSelectProps<T>>;
+export type SelectAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof Select, SelectProps<T>>;
+export declare const RerenderableSelect: React.ForwardRefExoticComponent<SelectProps<unknown> & React.RefAttributes<Select<unknown>>>;
+export {};