@hipay/hipay-material-ui 2.0.0-beta.50 → 2.0.0-beta.51

package/es/HiSelectNew/HiNestedSelectContent.js

@@ -0,0 +1,406 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+// @inheritedComponent HiSelectContent
+import React from 'react';
+import PropTypes from 'prop-types';
+import HiSelectContent from './HiSelectContent';
+import HiIcon from '../HiIcon';
+import withStyles from '../styles/withStyles';
+import { foldAccents } from '../utils/helpers';
+/**
+ * Return array of final item id in nested list (via props chlidren)
+ * @param itemList
+ * @param finalItemIdList
+ * @returns {*[]}
+ */
+
+export function getRecursiveFinalItemIdList(itemList, finalItemIdList = []) {
+  return [...finalItemIdList, ...itemList.reduce((memo, item) => {
+    if (item.children) {
+      return getRecursiveFinalItemIdList(item.children, memo);
+    }
+
+    return [...memo, item.id];
+  }, [])];
+}
+/**
+ * Find item by id in nested list (via props children)
+ * @param itemList
+ * @param searchId
+ * @returns {boolean}
+ */
+
+export function findFinalItemRecursively(itemList, searchId) {
+  let foundItem = false;
+  itemList.some(item => {
+    if (item.id === searchId) {
+      foundItem = item;
+    } else if (item.children && !foundItem) {
+      foundItem = findFinalItemRecursively(item.children, searchId);
+    }
+
+    return foundItem !== false;
+  });
+  return foundItem;
+}
+/**
+ * Build item list by settings item props relative to the nested parent/child situation
+ * Reduce the item list to build specified items (displayed, pinned, disabled, selected, indeterminate)
+ * Parent item is selected if each children item is include in selectedItemIdList (s stay to true)
+ * Parent item is indeterminate if it is not selected & not unselected (s goes false & u goes false)
+ *
+ * @param itemList - initial list of item
+ * @param selectedItemIdList - global list of selected id
+ * @param searchValue - search value on which filter item
+ * @param visibleParent - visibility of the list parent item (default false)
+ * @param pinnedParent - parent will be displayed as pinned items
+ * @param disabledParent - parent will not be selectable
+ * @param nbChildrenAsInfo - Show children number as info
+ * @param translations - Translations
+ * @returns {*}
+ */
+
+function buildFilteredItemList(itemList, selectedItemIdList = [], searchValue = '', visibleParent = false, pinnedParent = false, disabledParent = false, nbChildrenAsInfo = false, translations) {
+  return itemList.reduce(({
+    l: memoItemList,
+    s: memoSelected,
+    u: memoUnselected,
+    v: memoVisible
+  }, item) => {
+    const itemVisible = searchValue === '' || foldAccents(item.label.toString().toLowerCase()).search(foldAccents(searchValue.toLowerCase())) !== -1; // Parent item
+
+    if (item.children) {
+      const {
+        l: customizedChildren,
+        s: selected,
+        u: unselected,
+        v: visible
+      } = buildFilteredItemList(item.children, selectedItemIdList, searchValue, itemVisible, pinnedParent, disabledParent);
+
+      if (nbChildrenAsInfo) {
+        item.info = translations.n_children.replace('%s', item.children.length);
+      }
+
+      return {
+        l: [...memoItemList, _objectSpread({}, item, disabledParent && {
+          disabled: true,
+          hideCheckbox: true // don't display checkbox on disabled parent
+
+        }, {
+          pinned: pinnedParent,
+          children: customizedChildren,
+          selected,
+          indeterminate: !selected && !unselected,
+          displayed: itemVisible || visible
+        })],
+        s: memoSelected && selected,
+        u: memoUnselected && unselected,
+        v: memoVisible || itemVisible || visible
+      };
+    }
+
+    const itemSelected = selectedItemIdList.includes(item.id);
+    return {
+      l: [...memoItemList, _objectSpread({
+        displayed: itemVisible || visibleParent
+      }, item)],
+      s: itemSelected && memoSelected,
+      u: !itemSelected && memoUnselected,
+      v: itemVisible || visibleParent || memoVisible
+    };
+  }, {
+    l: [],
+    s: true,
+    u: true,
+    v: visibleParent
+  });
+}
+
+export const styles = theme => ({
+  root: {
+    backgroundColor: theme.palette.background2,
+    maxWidth: 500,
+    width: '100%',
+    position: 'relative'
+  },
+  popper: {
+    // width: '100%',
+    zIndex: 1200
+  },
+  paper: {
+    borderRadius: '0px 2px',
+    maxHeight: 480,
+    transition: 'none !important'
+  },
+  labelImg: {
+    height: 18,
+    width: 'auto',
+    margin: '0 4px',
+    verticalAlign: 'middle'
+  },
+  selectIconLabel: _objectSpread({
+    whiteSpace: 'nowrap',
+    overflow: 'hidden',
+    textOverflow: 'ellipsis',
+    paddingRight: 16
+  }, theme.typography.b1, {
+    display: 'inline-flex',
+    width: '100%'
+  }),
+  selectImgLabel: _objectSpread({
+    whiteSpace: 'nowrap',
+    overflow: 'hidden',
+    textOverflow: 'ellipsis',
+    paddingRight: 16
+  }, theme.typography.b1, {
+    display: 'inline-flex',
+    width: '100%'
+  })
+});
+/**
+ * HiNestedSelectContent hérite du composant HiSelectContent
+ *
+ * Sa fonction buildSelectProps construit la liste des options selon le comportement d'un object nested
+ * (association parent/child via la prop children). Le composant accepte des props spécifique à cet utilisation,
+ * comme disableParent ou pinnedParent. Uniquement les ids des enfants finaux (n'ayant pas d'enfants) sont considérés.
+ * Comportement:
+ * - si un parent est sélectionné, on ajoute tous ses enfants dans la liste des éléments sélectionné (mais pas le parent)
+ * - si tous les enfants sont sélectionnés, le parent est affiché "selected".
+ * - si une partie des enfants sont sélectionné, le parent est affiché "indeterminate".
+ * - si aucun enfant n'est sélectionné, le parent est affiché "unselected".
+ */
+
+class HiNestedSelectContent extends React.PureComponent {
+  constructor(props) {
+    super(props);
+
+    this.handleSelect = (event, item) => {
+      const {
+        hasAll,
+        multiple,
+        onChange,
+        options,
+        value
+      } = this.props;
+
+      if (!multiple) {
+        // single value
+        onChange(event, item.id, item);
+      } else if (hasAll && item.id === '_all') {
+        // ALL
+        const selectableItemIdList = getRecursiveFinalItemIdList(options);
+
+        if (value.length === selectableItemIdList.length) {
+          // unselect _all options
+          onChange(event, [], item);
+        } else {
+          // select _all options
+          onChange(event, selectableItemIdList, item);
+        }
+      } else if (item.children) {
+        // PARENT
+        const parentSelectableItemIdList = getRecursiveFinalItemIdList(item.children); // deselect parent if every selectable child id is includes in value.
+
+        if (parentSelectableItemIdList.every(pid => value.includes(pid))) {
+          onChange(event, value.filter(vid => !parentSelectableItemIdList.includes(vid)), item);
+        } else {
+          // select parent > add each selectable child without duplicates.
+          onChange(event, [...value.filter(vid => !parentSelectableItemIdList.includes(vid)), ...parentSelectableItemIdList], item);
+        }
+      } else if (value.includes(item.id)) {
+        // unselect item
+        onChange(event, value.filter(id => id !== item.id), item);
+      } else {
+        onChange(event, [...value, item.id], item);
+      }
+    };
+
+    this.buildSelectProps = (options, value = [], search = '', loading = false) => {
+      const {
+        classes,
+        disabledParent,
+        hasAll,
+        iconAll,
+        multiple,
+        nbChildrenAsInfo,
+        pinnedParent,
+        translations
+      } = this.props; // build item list
+
+      const {
+        l: filteredItemList,
+        s: allSelected,
+        u: allUnselected,
+        v: visible
+      } = buildFilteredItemList(options, value, search, false, pinnedParent, disabledParent || !multiple, nbChildrenAsInfo, translations);
+      const itemList = !visible ? [...(loading ? [{
+        id: '_loading',
+        type: 'loader',
+        disabled: true,
+        centered: true,
+        hideCheckbox: true,
+        label: 'loading'
+      }] : [{
+        id: '_no_result',
+        type: 'text',
+        disabled: true,
+        centered: true,
+        hideCheckbox: true,
+        label: translations.no_result_match
+      }])] : [...(loading ? [{
+        id: '_loading',
+        type: 'loader',
+        disabled: true,
+        centered: true,
+        hideCheckbox: true,
+        label: 'loading'
+      }] : []), ...(hasAll ? [{
+        id: '_all',
+        iconAll,
+        label: translations.all,
+        selected: allSelected,
+        indeterminate: !allSelected && !allUnselected,
+        displayed: search === ''
+      }] : []), ...filteredItemList];
+      return {
+        itemList
+      };
+    };
+
+    this.handleSelect = this.handleSelect.bind(this);
+  }
+  /**
+   * Call onChange with the updated value
+   *
+   * - handle single value
+   * - handle multiple value
+   * - handle '_all' id
+   *
+   * @param event
+   * @param item
+   */
+
+
+  render() {
+    const _this$props = this.props,
+          {
+      hasAll,
+      hiSelectableListProps,
+      multiple,
+      options,
+      searchable,
+      translations,
+      value
+    } = _this$props,
+          other = _objectWithoutProperties(_this$props, ["hasAll", "hiSelectableListProps", "multiple", "options", "searchable", "translations", "value"]);
+
+    if (multiple) {
+      if (!Array.isArray(value)) {
+        throw new Error('HiPay Material-UI: the `value` property must be an array ' + 'when using the `HiSelect` component with `multiple`.');
+      }
+    }
+
+    return React.createElement(HiSelectContent, _extends({
+      buildSelectProps: this.buildSelectProps,
+      hasAll: hasAll,
+      hiSelectableListProps: _objectSpread({
+        onSelect: this.handleSelect
+      }, hiSelectableListProps),
+      multiple: multiple,
+      options: options,
+      searchable: searchable,
+      translations: translations,
+      value: value
+    }, other));
+  }
+
+}
+
+HiNestedSelectContent.defaultProps = {
+  disabledParent: false,
+  hasAll: false,
+  multiple: false,
+  pinnedParent: false,
+  searchable: false,
+  translations: {
+    all: 'All',
+    no_result_match: 'No result match',
+    search: 'Search',
+    n_children: '%s',
+    one_child: '%s item'
+  }
+};
+HiNestedSelectContent.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * Useful to extend the style applied to components.
+   */
+  classes: PropTypes.object,
+
+  /**
+   * Parent items are not selectable
+   */
+  disabledParent: PropTypes.bool,
+
+  /**
+   * Affiche l'élément 'All'
+   */
+  hasAll: PropTypes.bool,
+
+  /**
+   * id du select
+   */
+  id: PropTypes.string,
+
+  /**
+   * Ajoute un loader
+   */
+  loading: PropTypes.bool,
+
+  /**
+   * Autorise la sélection de plusieurs valeurs
+   */
+  multiple: PropTypes.bool,
+
+  /**
+   * Définit si l'on doit afficher le nombre d'enfants du parent dans son champ info
+   */
+  nbChildrenAsInfo: PropTypes.bool,
+
+  /**
+   * Fonction de callback qui renvoit la/les valeurs sélectionnées
+   *
+   * @param {object} event
+   * @param {string || array} value
+   */
+  onChange: PropTypes.func.isRequired,
+
+  /**
+   * Listes des options du select
+   */
+  options: PropTypes.array.isRequired,
+
+  /**
+   * Parent items are pinned, with sticky behavior (hide checkboxes but still selectable)
+   */
+  pinnedParent: PropTypes.bool,
+
+  /**
+   * Affiche un input de recherche permettant de filtrer les options
+   */
+  searchable: PropTypes.bool,
+
+  /**
+   * Traductions (par défaut en anglais)
+   */
+  translations: PropTypes.object,
+
+  /**
+   * Value(s) du select
+   */
+  value: PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.array])
+} : {};
+export default withStyles(styles, {
+  hiComponent: true,
+  name: 'HmuiHiNestedSelectContent'
+})(HiNestedSelectContent);