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

package/es/HiColoredLabel/HiColoredLabel.js

@@ -112,9 +112,10 @@ function HiColoredLabel(props) {
     color,
     active,
     fontWeight,
+    style,
     theme
   } = props,
-        other = _objectWithoutProperties(props, ["classes", "className", "label", "color", "active", "fontWeight", "theme"]);
+        other = _objectWithoutProperties(props, ["classes", "className", "label", "color", "active", "fontWeight", "style", "theme"]);
 
   const isHiColor = ['primary', 'secondary', 'positive', 'negative', 'middle', 'neutral'].includes(color);
   const isHexColor = !isHiColor && /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(color);
@@ -125,7 +126,7 @@ function HiColoredLabel(props) {
       [classes[`activeColor${capitalize(color)}`]]: active && isHiColor,
       [classes[`color${capitalize(color)}`]]: !active && isHiColor
     }, className),
-    style: _objectSpread({}, isHexColor && {
+    style: _objectSpread({}, style, isHexColor && {
       backgroundColor: active ? color : fade(color, 0.08),
       color: active ? theme.palette.getContrastText(color) : color
     }, fontWeight && {

package/es/HiForm/HiInput.js

@@ -160,12 +160,8 @@ class HiInput extends React.PureComponent {
   }
 
   handleChange(event) {
-    const authorizedChar = '1234567890TOto<>';
-
     if (this.props.onChange) {
-      if (authorizedChar.indexOf(event.target.value.charAt(event.target.value.length - 1)) >= 0 && this.props.onlyNumbers === true || this.props.onlyNumbers !== true) {
-        this.props.onChange(event);
-      }
+      this.props.onChange(event);
     }
   }
 

package/es/HiSelectNew/HiNestedSelectContent.js

@@ -0,0 +1,347 @@
+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 { foldAccents } from '../utils/helpers';
+/**
+ * Return array of final item id in nested list (via props children)
+ * @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
+  });
+}
+/**
+ * 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(...args) {
+    super(...args);
+
+    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
+      };
+    };
+  }
+
+  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 HiNestedSelectContent;