@i-novus/n2o-components 1.0.0

package/lib/inputs/InputSelectTree/InputSelectTree.d.ts

@@ -0,0 +1,114 @@
+import { ReactNode } from 'react';
+import { Filter, TOption } from '../InputSelect/types';
+import { TreeNode } from './TreeSelectNode';
+/**
+ * @reactProps {function} onBlur
+ * @reactProps {string} placeholder
+ * @reactProps {function} setTreeExpandedKeys
+ * @reactProps {array} treeExpandedKeys
+ * @reactProps {node} children
+ * @returns {*}
+ * @constructor
+ * @param props
+ */
+declare function InputSelectTree({ t, fetchData, onFocus, value, onBlur, placeholder, notFoundContent, loading, parentFieldId, valueFieldId, labelFieldId, iconFieldId, imageFieldId, badge, hasChildrenFieldId, options, onSearch, onSelect, onChange, hasCheckboxes, filter, multiSelect, children, onClose, onToggle, ajax, className, showCheckedStrategy, maxTagTextLength, disabled, }: Props): JSX.Element;
+declare namespace InputSelectTree {
+    var defaultProps: Props;
+}
+declare type Props = {
+    /**
+     * Флаг динамичексой подгрузки данных. В данных обязательно указывать параметр hasChildrens
+     */
+    ajax?: boolean;
+    /**
+     * Данные для badge
+     */
+    badge: object;
+    children: ReactNode;
+    className?: string;
+    /**
+     * Флаг неактивности
+     */
+    disabled: boolean;
+    /**
+     * Callback на открытие
+     */
+    fetchData?: any;
+    /**
+     * Варианты фильтрации
+     */
+    filter: Filter;
+    /**
+     * Флаг для показа чекбоксов в элементах дерева. Переводит InputSelectTree в мульти режим
+     */
+    hasCheckboxes: boolean;
+    /**
+     * Значение ключа hasChildren в данных
+     */
+    hasChildrenFieldId: string;
+    /**
+     * Значение ключа icon в данных
+     */
+    iconFieldId: string;
+    /**
+     *  Значение ключа image в данных
+     */
+    imageFieldId: string;
+    /**
+     * Значение ключа label в данных
+     */
+    labelFieldId: string;
+    /**
+     * Флаг анимации загрузки
+     */
+    loading: boolean;
+    /**
+     * Количество символов выбранных элементов в chechbox режиме
+     */
+    maxTagTextLength: number;
+    /**
+     * Мульти выбор значений
+     */
+    multiSelect: boolean;
+    notFoundContent?: any;
+    onBlur(arg?: Props['value']): void;
+    /**
+     * Calback изменения
+     */
+    onChange(arg: Props['value']): void;
+    /**
+     * Callback на закрытие
+     */
+    onClose(): void;
+    onFocus(): void;
+    /**
+     * Callback на поиск
+     */
+    onSearch(arg: Props['value']): void;
+    onSelect(arg: Props['value']): void;
+    onToggle(arg: boolean): void;
+    /**
+     * Данные для построения дерева
+     */
+    options: TOption[];
+    /**
+     * Значение ключа parent в данных
+     */
+    parentFieldId: string;
+    /**
+     * Placeholder контрола
+     */
+    placeholder: string;
+    showCheckedStrategy: string;
+    t(arg: string): void;
+    /**
+     * Значение
+     */
+    value?: any;
+    /**
+     * Значение ключа value в данных
+     */
+    valueFieldId: string;
+};
+export { TreeNode, InputSelectTree };
+export declare const InputSelectTreeComponent: any;

package/lib/inputs/InputSelectTree/InputSelectTree.js

@@ -0,0 +1,466 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InputSelectTree = InputSelectTree;
+Object.defineProperty(exports, "TreeNode", {
+  enumerable: true,
+  get: function get() {
+    return _TreeSelectNode.TreeNode;
+  }
+});
+exports.InputSelectTreeComponent = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _rcTreeSelect = _interopRequireDefault(require("rc-tree-select"));
+
+var _difference = _interopRequireDefault(require("lodash/difference"));
+
+var _filter = _interopRequireDefault(require("lodash/filter"));
+
+var _find = _interopRequireDefault(require("lodash/find"));
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _keys = _interopRequireDefault(require("lodash/keys"));
+
+var _map = _interopRequireDefault(require("lodash/map"));
+
+var _some = _interopRequireDefault(require("lodash/some"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _reactI18next = require("react-i18next");
+
+var _reactOnclickoutside = _interopRequireDefault(require("react-onclickoutside"));
+
+var _Icon = require("../../display/Icon/Icon");
+
+var _InlineSpinner = require("../../layouts/Spinner/InlineSpinner");
+
+var _Checkbox = require("../Checkbox/Checkbox");
+
+var _TreeSelectNode = require("./TreeSelectNode");
+
+var _until = require("./until");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var renderSwitcherIcon = function renderSwitcherIcon(_ref) {
+  var isLeaf = _ref.isLeaf;
+  return isLeaf ? null : /*#__PURE__*/_react["default"].createElement(_Icon.Icon, {
+    name: "fa fa-chevron-right"
+  });
+}; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+var getPopupContainer = function getPopupContainer(container) {
+  return container;
+};
+/**
+ * Взять данные по ids.
+ * ['id', 'id'] => [{ id: 'id', ... },{ id: 'id', ... }]
+ * @param options
+ * @param ids
+ * @param valueFieldId
+ */
+
+
+var getDataByIds = function getDataByIds(options, ids, valueFieldId) {
+  return (0, _filter["default"])(options, function (node) {
+    return (0, _some["default"])(ids, function (v) {
+      return v === node[valueFieldId];
+    });
+  });
+};
+
+var getSingleValue = function getSingleValue(options, value, valueFieldId) {
+  return (0, _find["default"])(options, [valueFieldId, value]);
+};
+
+var getMultiValue = function getMultiValue(options, value, valueFieldId) {
+  return getDataByIds(options, value, valueFieldId);
+};
+/**
+ * Функция преобразования value rcTreeSelect в формат n2o
+ * Производит поиск по родителям и потомкам.
+ * rcTreeSelect не дает информации о выделенных потомках при моде 'SHOW_PARENT'
+ * и о выделенных родителях при 'SHOW_CHILD'
+ * ['id', 'id'] => [{ id: 'id', ... },{ id: 'id', ... }]
+ * @param options
+ * @param value
+ * @param multiSelect
+ * @param valueFieldId
+ * @returns {*}
+ */
+
+
+var getItemByValue = function getItemByValue(options, value, multiSelect, valueFieldId) {
+  if (!value) {
+    return null;
+  }
+
+  if (!multiSelect) {
+    return getSingleValue(options, value, valueFieldId);
+  }
+
+  return getMultiValue(options, value, valueFieldId);
+};
+/**
+ * @reactProps {function} onBlur
+ * @reactProps {string} placeholder
+ * @reactProps {function} setTreeExpandedKeys
+ * @reactProps {array} treeExpandedKeys
+ * @reactProps {node} children
+ * @returns {*}
+ * @constructor
+ * @param props
+ */
+// TODO переделать в класс
+
+
+function InputSelectTree(_ref2) {
+  var t = _ref2.t,
+      fetchData = _ref2.fetchData,
+      onFocus = _ref2.onFocus,
+      value = _ref2.value,
+      onBlur = _ref2.onBlur,
+      placeholder = _ref2.placeholder,
+      _ref2$notFoundContent = _ref2.notFoundContent,
+      notFoundContent = _ref2$notFoundContent === void 0 ? t('noData') : _ref2$notFoundContent,
+      loading = _ref2.loading,
+      parentFieldId = _ref2.parentFieldId,
+      valueFieldId = _ref2.valueFieldId,
+      labelFieldId = _ref2.labelFieldId,
+      iconFieldId = _ref2.iconFieldId,
+      imageFieldId = _ref2.imageFieldId,
+      badge = _ref2.badge,
+      hasChildrenFieldId = _ref2.hasChildrenFieldId,
+      options = _ref2.options,
+      onSearch = _ref2.onSearch,
+      onSelect = _ref2.onSelect,
+      onChange = _ref2.onChange,
+      hasCheckboxes = _ref2.hasCheckboxes,
+      filter = _ref2.filter,
+      multiSelect = _ref2.multiSelect,
+      children = _ref2.children,
+      onClose = _ref2.onClose,
+      onToggle = _ref2.onToggle,
+      ajax = _ref2.ajax,
+      className = _ref2.className,
+      showCheckedStrategy = _ref2.showCheckedStrategy,
+      maxTagTextLength = _ref2.maxTagTextLength,
+      disabled = _ref2.disabled;
+  var treeExpandedKeys = (0, _react.useRef)([]);
+
+  var _useState = (0, _react.useState)(''),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      searchValue = _useState2[0],
+      setSearchValue = _useState2[1]; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+  InputSelectTree.handleClickOutside = function () {
+    return setSearchValue('');
+  };
+  /**
+   * Функуия для создания дерева.
+   * Преобразует коллекцию вида [..., { ... }] в [ ..., {..., children: [...]}]
+   * Вложение происходит при совпадении valueFieldId и parentFieldId.
+   * @param items
+   * @returns {*}
+   */
+
+
+  var treeData = (0, _react.useMemo)(function () {
+    var popupProps = {
+      prefixCls: 'n2o-select-tree',
+      iconFieldId: iconFieldId,
+      imageFieldId: imageFieldId,
+      labelFieldId: labelFieldId,
+      badge: badge
+    };
+    var items = options || [];
+    var itemsByID = (0, _toConsumableArray2["default"])(items).reduce(function (acc, item) {
+      return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, item[valueFieldId], _objectSpread(_objectSpread(_objectSpread({}, item), {}, {
+        key: item[valueFieldId],
+        value: item[valueFieldId],
+        title: item.formattedTitle || (0, _until.visiblePartPopup)(item, popupProps)
+      }, ajax && {
+        isLeaf: !item[hasChildrenFieldId]
+      }), {}, {
+        children: []
+      })));
+    }, {} // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+    (0, _keys["default"])(itemsByID).forEach(function (key) {
+      if (itemsByID[key][parentFieldId] && itemsByID[itemsByID[key][parentFieldId]] && itemsByID[itemsByID[key][parentFieldId]].children) {
+        itemsByID[itemsByID[key][parentFieldId]].children.push(_objectSpread({}, itemsByID[key]));
+      }
+    });
+    return (0, _keys["default"])(itemsByID).filter(function (key) {
+      if (!itemsByID[key][parentFieldId]) {
+        return true;
+      }
+
+      return !!(itemsByID[key][parentFieldId] && // eslint-disable-next-line no-prototype-builtins
+      !itemsByID.hasOwnProperty(itemsByID[key][parentFieldId]));
+    }) // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .reduce(function (acc, key) {
+      return [].concat((0, _toConsumableArray2["default"])(acc), [_objectSpread({}, itemsByID[key])]);
+    }, []);
+  }, [ajax, badge, options, hasChildrenFieldId, iconFieldId, imageFieldId, labelFieldId, parentFieldId, valueFieldId]);
+  /**
+   * Функция для поиска.
+   * При поиске вызов функции происходит для каждого элемента дерева.
+   * @param input
+   * @param node
+   * @returns {*}
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  var handlerFilter = (0, _react.useCallback)(function (input, node) {
+    var mode = ['includes', 'startsWith', 'endsWith'];
+
+    if (mode.includes(filter)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return String.prototype[filter].call(node.props[labelFieldId].toLowerCase(), input.toLowerCase());
+    }
+
+    return true;
+  }, [filter, labelFieldId]);
+  /**
+   * Функция для обратного преобразования value n2o в формат rcTreeSelect
+   * ['id', 'id'] => [{ id: 'id', ... },{ id: 'id', ... }]
+   * @param value
+   * @returns {*}
+   */
+
+  var setValue = function setValue(value) {
+    if (!value) {
+      return [];
+    }
+
+    if ((0, _isArray["default"])(value)) {
+      return (0, _map["default"])(value, function (v) {
+        return v[valueFieldId];
+      });
+    }
+
+    return value[valueFieldId];
+  };
+  /**
+   * Функция для переопределения onChange
+   * @param value
+   */
+
+
+  var handleChange = (0, _react.useCallback)(function (value) {
+    onChange(getItemByValue(options, value, multiSelect, valueFieldId));
+    onBlur(getItemByValue(options, value, multiSelect, valueFieldId)); // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [options, multiSelect, onChange, valueFieldId]);
+  /**
+   * Функция для переопределения onSelect
+   * @param value
+   */
+
+  var handleSelect = (0, _react.useCallback)(function (value) {
+    onSelect(getItemByValue(options, value, multiSelect, valueFieldId));
+    onBlur(); // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [options, multiSelect, onSelect, valueFieldId]);
+  /**
+   * Функция для переопределения onSearch
+   * @param value
+   */
+
+  var handleSearch = (0, _react.useCallback)(function (value) {
+    setSearchValue(value);
+    onSearch(value);
+    return true;
+  }, [onSearch]);
+  var clearSearch = (0, _react.useCallback)(function () {
+    setSearchValue('');
+  }, []);
+  /**
+   * Функция для контроля открытия/закрытия popup
+   * @param visible
+   * @returns {boolean}
+   */
+
+  var handleDropdownVisibleChange = (0, _react.useCallback)(function (visible) {
+    if (visible) {
+      onFocus();
+    } // onToggle(visible)
+    // setDropdownExpanded(visible)
+
+
+    if (visible && !options.length) {
+      fetchData();
+    } else {
+      onClose();
+    }
+
+    if (ajax) {
+      treeExpandedKeys.current = [];
+    }
+
+    return false; // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [ajax, onClose, onFocus, fetchData, onToggle]);
+  /**
+   * Функция для контроля открытия/закрытия элемента дерева
+   * @param keys
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  var onTreeExpand = (0, _react.useCallback)( /*#__PURE__*/function () {
+    var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(keys) {
+      var currentKey;
+      return _regenerator["default"].wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              currentKey = (0, _difference["default"])(keys, treeExpandedKeys.current);
+
+              if (!ajax) {
+                _context.next = 4;
+                break;
+              }
+
+              _context.next = 4;
+              return fetchData({
+                'filter.parent_id': currentKey[0]
+              }, true);
+
+            case 4:
+              treeExpandedKeys.current = keys;
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x) {
+      return _ref3.apply(this, arguments);
+    };
+  }(), [ajax, fetchData]);
+
+  var clearIcon = /*#__PURE__*/_react["default"].createElement(_Icon.Icon, {
+    onClick: clearSearch,
+    name: "fa fa-times n2o-input-select-tree__clear-icon"
+  });
+
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: (0, _classnames["default"])('n2o-select-tree-container', className, {
+      empty: (0, _isEmpty["default"])(value),
+      multi: multiSelect,
+      single: !multiSelect
+    })
+  }, /*#__PURE__*/_react["default"].createElement(_rcTreeSelect["default"], {
+    allowClear: !(0, _isEmpty["default"])(value),
+    value: setValue(value),
+    onDropdownVisibleChange: handleDropdownVisibleChange,
+    switcherIcon: renderSwitcherIcon,
+    suffixIcon: /*#__PURE__*/_react["default"].createElement(_Icon.Icon, {
+      name: "fa fa-chevron-down"
+    }),
+    multiple: multiSelect,
+    treeCheckable: hasCheckboxes && /*#__PURE__*/_react["default"].createElement(_Checkbox.Checkbox, {
+      inline: true
+    }),
+    treeData: treeData,
+    filterTreeNode: handlerFilter,
+    treeNodeFilterProp: labelFieldId,
+    treeNodeLabelProp: labelFieldId,
+    maxTagTextLength: maxTagTextLength,
+    clearIcon: clearIcon // иконка очищения всего инпута
+    ,
+    removeIcon: (0, _isEmpty["default"])(value) ? null : clearIcon // иконка очищения итема
+    ,
+    onChange: handleChange,
+    onSelect: handleSelect,
+    onSearch: handleSearch,
+    onTreeExpand: onTreeExpand,
+    showCheckedStrategy: (0, _until.getCheckedStrategy)(showCheckedStrategy),
+    getPopupContainer: getPopupContainer,
+    notFoundContent: loading ? /*#__PURE__*/_react["default"].createElement(_InlineSpinner.InlineSpinner, null) : notFoundContent,
+    placeholder: searchValue ? null : placeholder,
+    disabled: disabled,
+    searchValue: searchValue,
+    showSearch: !multiSelect,
+    listHeight: 400,
+    prefixCls: "n2o-select-tree"
+  }, children));
+}
+
+InputSelectTree.defaultProps = {
+  children: null,
+  hasChildrenFieldId: 'hasChildren',
+  disabled: false,
+  loading: false,
+  parentFieldId: 'parentId',
+  valueFieldId: 'id',
+  labelFieldId: 'name',
+  iconFieldId: 'icon',
+  badge: {
+    fieldId: 'badge',
+    colorFieldId: 'color'
+  },
+  imageFieldId: 'image',
+  sortFieldId: 'name',
+  filter: 'startsWith',
+  hasCheckboxes: false,
+  multiSelect: false,
+  options: [],
+  transitionName: 'slide-up',
+  choiceTransitionName: 'zoom',
+  showCheckedStrategy: 'all',
+  allowClear: true,
+  placeholder: '',
+  showSearch: true,
+  maxTagTextLength: 10,
+  onSearch: function onSearch() {},
+  onSelect: function onSelect() {},
+  onChange: function onChange() {},
+  onClose: function onClose() {},
+  onToggle: function onToggle() {},
+  onFocus: function onFocus() {},
+  onBlur: function onBlur() {},
+  onInput: function onInput() {},
+  t: function t() {}
+};
+var clickOutsideConfig = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handleClickOutside: function handleClickOutside() {
+    return InputSelectTree.handleClickOutside;
+  }
+};
+var InputSelectTreeComponent = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+(0, _reactOnclickoutside["default"])((0, _reactI18next.withTranslation)()(InputSelectTree), clickOutsideConfig);
+exports.InputSelectTreeComponent = InputSelectTreeComponent;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/inputs/InputSelectTree/InputSelectTree.tsx"],"names":["renderSwitcherIcon","isLeaf","getPopupContainer","container","getDataByIds","options","ids","valueFieldId","node","v","getSingleValue","value","getMultiValue","getItemByValue","multiSelect","InputSelectTree","t","fetchData","onFocus","onBlur","placeholder","notFoundContent","loading","parentFieldId","labelFieldId","iconFieldId","imageFieldId","badge","hasChildrenFieldId","onSearch","onSelect","onChange","hasCheckboxes","filter","children","onClose","onToggle","ajax","className","showCheckedStrategy","maxTagTextLength","disabled","treeExpandedKeys","searchValue","setSearchValue","handleClickOutside","treeData","popupProps","prefixCls","items","itemsByID","reduce","acc","item","key","title","formattedTitle","forEach","push","hasOwnProperty","handlerFilter","input","mode","includes","String","prototype","call","props","toLowerCase","setValue","handleChange","handleSelect","handleSearch","clearSearch","handleDropdownVisibleChange","visible","length","current","onTreeExpand","keys","currentKey","clearIcon","empty","multi","single","defaultProps","fieldId","colorFieldId","sortFieldId","transitionName","choiceTransitionName","allowClear","showSearch","onInput","clickOutsideConfig","InputSelectTreeComponent"],"mappings":"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","sourcesContent":["import React, { useCallback, ReactNode, useMemo, useRef, useState } from 'react'\nimport TreeSelect from 'rc-tree-select'\nimport difference from 'lodash/difference'\nimport filterF from 'lodash/filter'\nimport find from 'lodash/find'\nimport isArray from 'lodash/isArray'\nimport isEmpty from 'lodash/isEmpty'\nimport keys from 'lodash/keys'\nimport map from 'lodash/map'\nimport some from 'lodash/some'\nimport classNames from 'classnames'\nimport { withTranslation } from 'react-i18next'\nimport onClickOutsideHOC from 'react-onclickoutside'\n\nimport { Filter, TOption } from '../InputSelect/types'\nimport { Icon } from '../../display/Icon/Icon'\nimport { InlineSpinner } from '../../layouts/Spinner/InlineSpinner'\nimport { Checkbox } from '../Checkbox/Checkbox'\n\nimport { TreeNode } from './TreeSelectNode'\nimport { visiblePartPopup, getCheckedStrategy } from './until'\n\nconst renderSwitcherIcon = ({ isLeaf }: {isLeaf: boolean}) => (isLeaf ? null : <Icon name=\"fa fa-chevron-right\" />)\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst getPopupContainer = (container: any) => container\n/**\n * Взять данные по ids.\n * ['id', 'id'] => [{ id: 'id', ... },{ id: 'id', ... }]\n * @param options\n * @param ids\n * @param valueFieldId\n */\nconst getDataByIds = (options: Props['options'], ids: string[], valueFieldId: Props['valueFieldId']) => filterF(options, node => some(ids, v => v === node[valueFieldId as keyof TOption]))\n\nconst getSingleValue = (options: Props['options'], value: Props['value'], valueFieldId: Props['valueFieldId']) => find(options, [valueFieldId, value])\nconst getMultiValue = (options: Props['options'], value: Props['value'], valueFieldId: Props['valueFieldId']) => getDataByIds(options, value, valueFieldId)\n\n/**\n * Функция преобразования value rcTreeSelect в формат n2o\n * Производит поиск по родителям и потомкам.\n * rcTreeSelect не дает информации о выделенных потомках при моде 'SHOW_PARENT'\n * и о выделенных родителях при 'SHOW_CHILD'\n * ['id', 'id'] => [{ id: 'id', ... },{ id: 'id', ... }]\n * @param options\n * @param value\n * @param multiSelect\n * @param valueFieldId\n * @returns {*}\n */\nconst getItemByValue = (options: Props['options'], value: Props['value'], multiSelect: Props['multiSelect'], valueFieldId: Props['valueFieldId']) => {\n    if (!value) { return null }\n    if (!multiSelect) {\n        return getSingleValue(options, value, valueFieldId)\n    }\n\n    return getMultiValue(options, value, valueFieldId)\n}\n\n/**\n * @reactProps {function} onBlur\n * @reactProps {string} placeholder\n * @reactProps {function} setTreeExpandedKeys\n * @reactProps {array} treeExpandedKeys\n * @reactProps {node} children\n * @returns {*}\n * @constructor\n * @param props\n */\n// TODO переделать в класс\nfunction InputSelectTree({\n    t,\n    fetchData,\n    onFocus,\n    value,\n    onBlur,\n    placeholder,\n    notFoundContent = t('noData'),\n    loading,\n    parentFieldId,\n    valueFieldId,\n    labelFieldId,\n    iconFieldId,\n    imageFieldId,\n    badge,\n    hasChildrenFieldId,\n    options,\n    onSearch,\n    onSelect,\n    onChange,\n    hasCheckboxes,\n    filter,\n    multiSelect,\n    children,\n    onClose,\n    onToggle,\n    ajax,\n    className,\n    showCheckedStrategy,\n    maxTagTextLength,\n    disabled,\n}: Props) {\n    const treeExpandedKeys = useRef([])\n    const [searchValue, setSearchValue] = useState('');\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (InputSelectTree as any).handleClickOutside = () => setSearchValue('')\n\n    /**\n     * Функуия для создания дерева.\n     * Преобразует коллекцию вида [..., { ... }] в [ ..., {..., children: [...]}]\n     * Вложение происходит при совпадении valueFieldId и parentFieldId.\n     * @param items\n     * @returns {*}\n     */\n    const treeData = useMemo(() => {\n        const popupProps = {\n            prefixCls: 'n2o-select-tree',\n            iconFieldId,\n            imageFieldId,\n            labelFieldId,\n            badge,\n        }\n        const items = options || []\n        const itemsByID = [...items].reduce(\n            (acc, item) => ({\n                ...acc,\n                [item[valueFieldId as keyof TOption]]: {\n                    ...item,\n                    key: item[valueFieldId as keyof TOption],\n                    value: item[valueFieldId as keyof TOption],\n                    title: item.formattedTitle || visiblePartPopup(item, popupProps),\n                    ...(ajax && { isLeaf: !item[hasChildrenFieldId as keyof TOption] }),\n                    children: [],\n                },\n            }),\n            {},\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        ) as any\n\n        keys(itemsByID).forEach((key) => {\n            if (\n                itemsByID[key][parentFieldId] &&\n                itemsByID[itemsByID[key][parentFieldId]] &&\n                itemsByID[itemsByID[key][parentFieldId]].children\n            ) {\n                itemsByID[itemsByID[key][parentFieldId]].children.push({\n                    ...itemsByID[key],\n                })\n            }\n        })\n\n        return keys(itemsByID)\n            .filter((key) => {\n                if (!itemsByID[key][parentFieldId]) {\n                    return true\n                }\n\n                return !!(itemsByID[key][parentFieldId] &&\n                    // eslint-disable-next-line no-prototype-builtins\n                    !itemsByID.hasOwnProperty(itemsByID[key][parentFieldId]))\n            })\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            .reduce((acc, key) => [...acc, { ...itemsByID[key] }] as any, [])\n    }, [\n        ajax, badge, options, hasChildrenFieldId,\n        iconFieldId, imageFieldId, labelFieldId,\n        parentFieldId, valueFieldId,\n    ])\n\n    /**\n     * Функция для поиска.\n     * При поиске вызов функции происходит для каждого элемента дерева.\n     * @param input\n     * @param node\n     * @returns {*}\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const handlerFilter = useCallback((input: string, node: any) => {\n        const mode = ['includes', 'startsWith', 'endsWith']\n\n        if (mode.includes(filter)) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            return (String.prototype[filter as any] as any).call(\n                node.props[labelFieldId].toLowerCase(),\n                input.toLowerCase(),\n            )\n        }\n\n        return true\n    }, [filter, labelFieldId])\n\n    /**\n     * Функция для обратного преобразования value n2o в формат rcTreeSelect\n     * ['id', 'id'] => [{ id: 'id', ... },{ id: 'id', ... }]\n     * @param value\n     * @returns {*}\n     */\n    const setValue = (value: Props['value']) => {\n        if (!value) { return [] }\n        if (isArray(value)) {\n            return map(value, v => v[valueFieldId])\n        }\n\n        return value[valueFieldId]\n    }\n\n    /**\n     * Функция для переопределения onChange\n     * @param value\n     */\n    const handleChange = useCallback((value: Props['value']) => {\n        onChange(getItemByValue(options, value, multiSelect, valueFieldId))\n        onBlur(getItemByValue(options, value, multiSelect, valueFieldId))\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [options, multiSelect, onChange, valueFieldId])\n\n    /**\n     * Функция для переопределения onSelect\n     * @param value\n     */\n    const handleSelect = useCallback((value: Props['value']) => {\n        onSelect(getItemByValue(options, value, multiSelect, valueFieldId))\n        onBlur()\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [options, multiSelect, onSelect, valueFieldId])\n\n    /**\n     * Функция для переопределения onSearch\n     * @param value\n     */\n    const handleSearch = useCallback((value: Props['value']) => {\n        setSearchValue(value)\n        onSearch(value)\n\n        return true\n    }, [onSearch])\n\n    const clearSearch = useCallback(() => {\n        setSearchValue('')\n    }, [])\n\n    /**\n     * Функция для контроля открытия/закрытия popup\n     * @param visible\n     * @returns {boolean}\n     */\n    const handleDropdownVisibleChange = useCallback((visible: boolean) => {\n        if (visible) {\n            onFocus()\n        }\n        // onToggle(visible)\n        // setDropdownExpanded(visible)\n\n        if (visible && !options.length) {\n            fetchData()\n        } else {\n            onClose()\n        }\n        if (ajax) { treeExpandedKeys.current = [] }\n\n        return false\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [ajax, onClose, onFocus, fetchData, onToggle])\n\n    /**\n     * Функция для контроля открытия/закрытия элемента дерева\n     * @param keys\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const onTreeExpand = useCallback(async (keys: any) => {\n        const currentKey = difference(keys, treeExpandedKeys.current)\n\n        if (ajax) {\n            await fetchData({ 'filter.parent_id': currentKey[0] }, true)\n        }\n        treeExpandedKeys.current = keys\n    }, [ajax, fetchData])\n\n    const clearIcon = (\n        <Icon\n            onClick={clearSearch}\n            name=\"fa fa-times n2o-input-select-tree__clear-icon\"\n        />\n    )\n\n    return (\n        <div className={classNames(\n            'n2o-select-tree-container',\n            className,\n            {\n                empty: isEmpty(value), multi: multiSelect, single: !multiSelect,\n            },\n        )}\n        >\n            <TreeSelect\n                allowClear={!isEmpty(value)}\n                value={setValue(value)}\n                onDropdownVisibleChange={handleDropdownVisibleChange}\n                switcherIcon={renderSwitcherIcon}\n                suffixIcon={<Icon name=\"fa fa-chevron-down\" />}\n                multiple={multiSelect}\n                treeCheckable={hasCheckboxes && <Checkbox inline />}\n                treeData={treeData}\n                filterTreeNode={handlerFilter}\n                treeNodeFilterProp={labelFieldId}\n                treeNodeLabelProp={labelFieldId}\n                maxTagTextLength={maxTagTextLength}\n                clearIcon={clearIcon} // иконка очищения всего инпута\n                removeIcon={isEmpty(value) ? null : clearIcon} // иконка очищения итема\n                onChange={handleChange}\n                onSelect={handleSelect}\n                onSearch={handleSearch}\n                onTreeExpand={onTreeExpand}\n                showCheckedStrategy={getCheckedStrategy(showCheckedStrategy)}\n                getPopupContainer={getPopupContainer}\n                notFoundContent={loading ? <InlineSpinner /> : notFoundContent}\n                placeholder={searchValue ? null : placeholder}\n                disabled={disabled}\n                searchValue={searchValue}\n                showSearch={!multiSelect}\n                listHeight={400}\n                prefixCls=\"n2o-select-tree\"\n            >\n                {children}\n            </TreeSelect>\n        </div>\n    )\n}\n\nInputSelectTree.defaultProps = {\n    children: null,\n    hasChildrenFieldId: 'hasChildren',\n    disabled: false,\n    loading: false,\n    parentFieldId: 'parentId',\n    valueFieldId: 'id',\n    labelFieldId: 'name',\n    iconFieldId: 'icon',\n    badge: {\n        fieldId: 'badge',\n        colorFieldId: 'color',\n    },\n    imageFieldId: 'image',\n    sortFieldId: 'name',\n    filter: 'startsWith',\n    hasCheckboxes: false,\n    multiSelect: false,\n    options: [],\n    transitionName: 'slide-up',\n    choiceTransitionName: 'zoom',\n    showCheckedStrategy: 'all',\n    allowClear: true,\n    placeholder: '',\n    showSearch: true,\n    maxTagTextLength: 10,\n    onSearch: () => {},\n    onSelect: () => {},\n    onChange: () => {},\n    onClose: () => {},\n    onToggle: () => {},\n    onFocus: () => {},\n    onBlur: () => {},\n    onInput: () => {},\n    t: () => {},\n} as Props\n\ntype Props = {\n    /**\n     * Флаг динамичексой подгрузки данных. В данных обязательно указывать параметр hasChildrens\n     */\n    ajax?: boolean,\n    /**\n     * Данные для badge\n     */\n    badge: object,\n    children: ReactNode,\n    className?: string,\n    /**\n     * Флаг неактивности\n     */\n    disabled: boolean,\n    /**\n     * Callback на открытие\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    fetchData?: any,\n    /**\n     * Варианты фильтрации\n     */\n    filter: Filter,\n    /**\n     * Флаг для показа чекбоксов в элементах дерева. Переводит InputSelectTree в мульти режим\n     */\n    hasCheckboxes: boolean,\n    /**\n     * Значение ключа hasChildren в данных\n     */\n    hasChildrenFieldId: string,\n    /**\n     * Значение ключа icon в данных\n     */\n    iconFieldId: string,\n    /**\n     *  Значение ключа image в данных\n     */\n    imageFieldId: string,\n    /**\n     * Значение ключа label в данных\n     */\n    labelFieldId: string,\n    /**\n     * Флаг анимации загрузки\n     */\n    loading: boolean,\n    /**\n     * Количество символов выбранных элементов в chechbox режиме\n     */\n    maxTagTextLength: number,\n    /**\n     * Мульти выбор значений\n     */\n    multiSelect: boolean,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    notFoundContent?: any,\n    onBlur(arg?: Props['value']): void,\n    /**\n     * Calback изменения\n     */\n    onChange(arg: Props['value']): void,\n    /**\n     * Callback на закрытие\n     */\n    onClose(): void,\n    onFocus(): void,\n    /**\n     * Callback на поиск\n     */\n    onSearch(arg: Props['value']): void,\n    onSelect(arg: Props['value']): void,\n    onToggle(arg: boolean): void,\n    /**\n     * Данные для построения дерева\n     */\n    options: TOption[],\n    /**\n     * Значение ключа parent в данных\n     */\n    parentFieldId: string,\n    /**\n     * Placeholder контрола\n     */\n    placeholder: string,\n    showCheckedStrategy: string,\n    t(arg: string): void,\n    /**\n     * Значение\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    value?: any,\n    /**\n     * Значение ключа value в данных\n     */\n    valueFieldId: string\n}\n\nexport { TreeNode, InputSelectTree }\n\nconst clickOutsideConfig = {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    handleClickOutside: () => (InputSelectTree as any).handleClickOutside,\n}\n\nexport const InputSelectTreeComponent = (\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    onClickOutsideHOC(withTranslation()(InputSelectTree as any), clickOutsideConfig) as any\n)\n"]}