@hipay/hipay-material-ui 1.0.0-beta.9 → 2.0.0-beta.35

package/es/test-utils/getClasses.js

@@ -1,21 +1,17 @@
-import _extends from 'babel-runtime/helpers/extends';
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
 import * as ns from 'react-jss/lib/ns';
 import { SheetsRegistry } from 'jss';
 import createShallow from './createShallow';
 import { sheetsManager } from '../styles/withStyles';
+const shallow = createShallow(); // Helper function to extract the classes from a styleSheet.
 
-const shallow = createShallow();
-
-// Helper function to extract the classes from a styleSheet.
 export default function getClasses(element, options = {}) {
   const sheetsRegistry = new SheetsRegistry();
-
   sheetsManager.clear();
-  shallow(element, _extends({}, options, {
-    context: _extends({
+  shallow(element, _objectSpread({}, options, {
+    context: _objectSpread({
       [ns.sheetsRegistry]: sheetsRegistry
     }, options.context)
   }));
-
   return sheetsRegistry.registry[0].classes;
 }

package/es/test-utils/until.js

@@ -1,30 +1,34 @@
-import _extends from 'babel-runtime/helpers/extends';
-import _objectWithoutProperties from 'babel-runtime/helpers/objectWithoutProperties';
-//  weak
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 
 function shallowRecursively(wrapper, selector, _ref) {
-  let { context } = _ref,
-      other = _objectWithoutProperties(_ref, ['context']);
+  let {
+    context
+  } = _ref,
+      other = _objectWithoutProperties(_ref, ["context"]);
 
   if (wrapper.isEmptyRender() || typeof wrapper.getElement().type === 'string') {
     return wrapper;
   }
 
   let newContext = context;
+  const instance = wrapper.root().instance(); // The instance can be null with a stateless functional component and react >= 16.
 
-  const instance = wrapper.root().instance();
-  // The instance can be null with a stateless functional component and react >= 16.
   if (instance && instance.getChildContext) {
-    newContext = _extends({}, context, instance.getChildContext());
+    newContext = _objectSpread({}, context, instance.getChildContext());
   }
 
-  const nextWrapper = wrapper.shallow(_extends({ context: newContext }, other));
+  const nextWrapper = wrapper.shallow(_objectSpread({
+    context: newContext
+  }, other));
 
   if (selector && wrapper.is(selector)) {
     return nextWrapper;
   }
 
-  return shallowRecursively(nextWrapper, selector, { context: newContext });
+  return shallowRecursively(nextWrapper, selector, {
+    context: newContext
+  });
 }
 
 export default function until(selector, options = {}) {

package/es/test-utils/unwrap.js

@@ -1,5 +1,3 @@
-//  weak
-
 export default function unwrap(component) {
   return component.Naked ? unwrap(component.Naked) : component;
 }

package/es/transitions/utils.js

@@ -1,8 +1,9 @@
 export const reflow = node => node.scrollTop;
-
 export function getTransitionProps(props, options) {
-  const { timeout, style = {} } = props;
-
+  const {
+    timeout,
+    style = {}
+  } = props;
   return {
     duration: style.transitionDuration || typeof timeout === 'number' ? timeout : timeout[options.mode],
     delay: style.transitionDelay

package/es/utils/exactProp.js

@@ -1,21 +1,28 @@
-import _Object$keys from 'babel-runtime/core-js/object/keys';
-import _extends from 'babel-runtime/helpers/extends';
-
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
 // This module is based on https://github.com/airbnb/prop-types-exact repository.
 // However, in order to reduce the number of dependencies and to remove some extra safe checks
 // the module was forked.
-
+// Only exported for test purposes.
 export const specialProperty = 'exact-prop: \u200b';
 
-export default function exactProp(propTypes, componentNameInError) {
-  return _extends({}, propTypes, {
+function exactProp(propTypes) {
+  /* istanbul ignore if */
+  if (process.env.NODE_ENV === 'production') {
+    return propTypes;
+  }
+
+  return _objectSpread({}, propTypes, {
     // eslint-disable-next-line prefer-arrow-callback
     [specialProperty]: props => {
-      const unknownProps = _Object$keys(props).filter(prop => !propTypes.hasOwnProperty(prop));
-      if (unknownProps.length > 0) {
-        return new TypeError(`${componentNameInError}: unknown props found: ${unknownProps.join(', ')}. Please remove the unknown properties.`);
+      const unsupportedProps = Object.keys(props).filter(prop => !propTypes.hasOwnProperty(prop));
+
+      if (unsupportedProps.length > 0) {
+        return new Error(`The following properties are not supported: ${unsupportedProps.map(prop => `\`${prop}\``).join(', ')}. Please remove them.`);
       }
+
       return null;
     }
   });
-}
+}
+
+export default exactProp;

package/es/utils/helpers.js

@@ -1,49 +1,58 @@
-import _Object$keys from 'babel-runtime/core-js/object/keys';
-//  weak
-
 import warning from 'warning';
+export function camelize(string) {
+  string = string.replace(/(_\w)/g, m => m[1].toUpperCase());
+  return string.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, (match, index) => {
+    if (+match === 0) return ''; // or if (/\s+/.test(match)) for white spaces
 
-export function capitalizeFirstLetter(string) {
-    process.env.NODE_ENV !== "production" ? warning(typeof string === 'string', 'Material-UI: capitalizeFirstLetter(string) expects a string argument.') : void 0;
-
-    return string.charAt(0).toUpperCase() + string.slice(1);
+    return index === 0 ? match.toLowerCase() : match.toUpperCase();
+  });
 }
-
 export function capitalize(string) {
-    if (process.env.NODE_ENV !== 'production' && typeof string !== 'string') {
-        throw new Error('Material-UI: capitalize(string) expects a string argument.');
-    }
+  if (process.env.NODE_ENV !== 'production' && typeof string !== 'string') {
+    throw new Error('Material-UI: capitalize(string) expects a string argument.');
+  }
 
-    return string.charAt(0).toUpperCase() + string.slice(1);
+  return string.charAt(0).toUpperCase() + string.slice(1);
 }
-
 export function contains(obj, pred) {
-    return _Object$keys(pred).every(key => {
-        return obj.hasOwnProperty(key) && obj[key] === pred[key];
-    });
+  return Object.keys(pred).every(key => {
+    return obj.hasOwnProperty(key) && obj[key] === pred[key];
+  });
 }
+/**
+ * Echappe les caractères HTML d'une chaîne de catactères
+ * Sauf la balise strong
+ *
+ * @param unsafeStr
+ * @returns {*}
+ */
 
+export function escapeHTML(unsafeStr) {
+  return unsafeStr.replace(/<br\/?>/g, '[br]').replace(/<strong>/g, '[[').replace(/<\/?strong>/g, ']]').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/\[\[/g, '<strong>').replace(/\]\]/g, '</strong>').replace(/\[br\]/g, '<br/>');
+}
 export function findIndex(arr, pred) {
-    const predType = typeof pred;
-    for (let i = 0; i < arr.length; i += 1) {
-        if (predType === 'function' && !!pred(arr[i], i, arr) === true) {
-            return i;
-        }
-        if (predType === 'object' && contains(arr[i], pred)) {
-            return i;
-        }
-        if (['string', 'number', 'boolean'].indexOf(predType) !== -1) {
-            return arr.indexOf(pred);
-        }
+  const predType = typeof pred;
+
+  for (let i = 0; i < arr.length; i += 1) {
+    if (predType === 'function' && !!pred(arr[i], i, arr) === true) {
+      return i;
     }
-    return -1;
-}
 
+    if (predType === 'object' && contains(arr[i], pred)) {
+      return i;
+    }
+
+    if (['string', 'number', 'boolean'].indexOf(predType) !== -1) {
+      return arr.indexOf(pred);
+    }
+  }
+
+  return -1;
+}
 export function find(arr, pred) {
-    const index = findIndex(arr, pred);
-    return index > -1 ? arr[index] : undefined;
+  const index = findIndex(arr, pred);
+  return index > -1 ? arr[index] : undefined;
 }
-
 /**
  * Safe chained function
  *
@@ -53,13 +62,66 @@ export function find(arr, pred) {
  * @param {function} functions to chain
  * @returns {function|null}
  */
+
 export function createChainedFunction(...funcs) {
-    return funcs.filter(func => func != null).reduce((acc, func) => {
-        process.env.NODE_ENV !== "production" ? warning(typeof func === 'function', 'Material-UI: invalid Argument Type, must only provide functions, undefined, or null.') : void 0;
-
-        return function chainedFunction(...args) {
-            acc.apply(this, args);
-            func.apply(this, args);
-        };
-    }, () => {});
+  return funcs.reduce((acc, func) => {
+    if (func == null) {
+      return acc;
+    }
+
+    process.env.NODE_ENV !== "production" ? warning(typeof func === 'function', 'Material-UI: invalid Argument Type, must only provide functions, undefined, or null.') : void 0;
+    return function chainedFunction(...args) {
+      acc.apply(this, args);
+      func.apply(this, args);
+    };
+  }, () => {});
+}
+/**
+ * Remove duplicate items from array useful after concat arrays
+ *
+ * arrayUnique(array1.concat(array2))
+ *
+ * @param array
+ */
+
+export function arrayUnique(array) {
+  const a = [...array];
+
+  for (let i = 0; i < a.length; i + 1) {
+    for (let j = i + 1; j < a.length; j + 1) {
+      if (a[i] === a[j]) a.splice(j - 1, 1);
+    }
+  }
+
+  return a;
+}
+/**
+ * Retourne l'item selectionnable suivant.
+ * @param node
+ * @param direction
+ * @returns {*}
+ */
+
+export function getNextItemSelectable(node, direction) {
+  if (direction === 'down') {
+    if (node.nextSibling === null) {
+      return null;
+    }
+
+    if (node.nextSibling.tabIndex === -1) {
+      return getNextItemSelectable(node.nextSibling, direction);
+    }
+
+    return node.nextSibling;
+  }
+
+  if (node.previousSibling === null) {
+    return null;
+  }
+
+  if (node.previousSibling.tabIndex === -1) {
+    return getNextItemSelectable(node.previousSibling, direction);
+  }
+
+  return node.previousSibling;
 }

package/es/utils/ownerDocument.js

@@ -0,0 +1,5 @@
+function ownerDocument(node) {
+  return node && node.ownerDocument || document;
+}
+
+export default ownerDocument;

package/es/utils/ownerWindow.js

@@ -0,0 +1,8 @@
+import ownerDocument from './ownerDocument';
+
+function ownerWindow(node, fallback = window) {
+  const doc = ownerDocument(node);
+  return doc.defaultView || doc.parentView || fallback;
+}
+
+export default ownerWindow;

package/es/utils/reactHelpers.js

@@ -1,21 +1,19 @@
-
 /* eslint-disable import/prefer-default-export */
-
-import { cloneElement, Children, isValidElement } from 'react';
-
-
+import React from 'react';
+import classNames from 'classnames';
+export function cloneElementWithClassName(child, className) {
+  return React.cloneElement(child, {
+    className: classNames(child.props.className, className)
+  });
+}
 export function cloneChildrenWithClassName(children, className) {
-  return Children.map(children, child => {
-    return isValidElement(child) && cloneElement(child, {
-      className: child.props.hasOwnProperty('className') ? `${child.props.className} ${className}` : className
-    });
+  return React.Children.map(children, child => {
+    return React.isValidElement(child) && cloneElementWithClassName(child, className);
   });
 }
-
 export function isMuiElement(element, muiNames) {
-  return isValidElement(element) && muiNames.indexOf(element.type.muiName) !== -1;
+  return React.isValidElement(element) && muiNames.indexOf(element.type.muiName) !== -1;
 }
-
 export function isMuiComponent(element, muiNames) {
   return muiNames.indexOf(element.muiName) !== -1;
 }

package/es/utils/requirePropFactory.js

@@ -1,6 +1,9 @@
-//  weak
+function requirePropFactory(componentNameInError) {
+  /* istanbul ignore if */
+  if (process.env.NODE_ENV === 'production') {
+    return () => null;
+  }
 
-const requirePropFactory = componentNameInError => {
   const requireProp = requiredProp => (props, propName, componentName, location, propFullName) => {
     const propFullNameSafe = propFullName || propName;
 
@@ -10,7 +13,8 @@ const requirePropFactory = componentNameInError => {
 
     return null;
   };
+
   return requireProp;
-};
+}
 
 export default requirePropFactory;

package/es/utils/unsupportedProp.js

@@ -0,0 +1,16 @@
+function unsupportedProp(props, propName, componentName, location, propFullName) {
+  /* istanbul ignore if */
+  if (process.env.NODE_ENV === 'production') {
+    return null;
+  }
+
+  const propFullNameSafe = propFullName || propName;
+
+  if (typeof props[propName] !== 'undefined') {
+    return new Error(`The property \`${propFullNameSafe}\` is not supported. Please remove it.`);
+  }
+
+  return null;
+}
+
+export default unsupportedProp;

package/es/withMobileDialog/index.js

@@ -0,0 +1 @@
+export { default } from './withMobileDialog';

package/es/{Dialog → withMobileDialog}/withMobileDialog.js

@@ -1,24 +1,27 @@
-import _extends from 'babel-runtime/helpers/extends';
+import _extends from "@babel/runtime/helpers/extends";
 import React from 'react';
 import PropTypes from 'prop-types';
-import withWidth, { isWidthDown } from '../utils/withWidth';
-
+import withWidth, { isWidthDown } from '../withWidth';
 /**
  * Dialog will responsively be full screen *at or below* the given breakpoint
  * (defaults to 'sm' for mobile devices).
  * Notice that this Higher-order Component is incompatible with server side rendering.
  */
+
 const withMobileDialog = (options = {}) => Component => {
-  const { breakpoint = 'sm' } = options;
+  const {
+    breakpoint = 'sm'
+  } = options;
 
   function WithMobileDialog(props) {
-    return React.createElement(Component, _extends({ fullScreen: isWidthDown(breakpoint, props.width) }, props));
+    return React.createElement(Component, _extends({
+      fullScreen: isWidthDown(breakpoint, props.width)
+    }, props));
   }
 
   WithMobileDialog.propTypes = process.env.NODE_ENV !== "production" ? {
     width: PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']).isRequired
   } : {};
-
   return withWidth()(WithMobileDialog);
 };
 

package/es/withWidth/index.js

@@ -0,0 +1,2 @@
+export { default } from './withWidth';
+export * from './withWidth';

package/es/withWidth/withWidth.js

@@ -0,0 +1,176 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+
+/* eslint-disable react/no-did-mount-set-state */
+import React from 'react';
+import PropTypes from 'prop-types';
+import EventListener from 'react-event-listener';
+import debounce from 'debounce'; // < 1kb payload overhead when lodash/debounce is > 3kb.
+
+import wrapDisplayName from 'recompose/wrapDisplayName';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import withTheme from '../styles/withTheme';
+import { keys as breakpointKeys } from '../styles/createBreakpoints';
+import getThemeProps from '../styles/getThemeProps'; // By default, returns true if screen width is the same or greater than the given breakpoint.
+
+export const isWidthUp = (breakpoint, width, inclusive = true) => {
+  if (inclusive) {
+    return breakpointKeys.indexOf(breakpoint) <= breakpointKeys.indexOf(width);
+  }
+
+  return breakpointKeys.indexOf(breakpoint) < breakpointKeys.indexOf(width);
+}; // By default, returns true if screen width is the same or less than the given breakpoint.
+
+export const isWidthDown = (breakpoint, width, inclusive = true) => {
+  if (inclusive) {
+    return breakpointKeys.indexOf(width) <= breakpointKeys.indexOf(breakpoint);
+  }
+
+  return breakpointKeys.indexOf(width) < breakpointKeys.indexOf(breakpoint);
+};
+
+const withWidth = (options = {}) => Component => {
+  const {
+    withTheme: withThemeOption = false,
+    noSSR = false,
+    initialWidth: initialWidthOption,
+    resizeInterval = 166 // Corresponds to 10 frames at 60 Hz.
+
+  } = options;
+
+  class WithWidth extends React.Component {
+    constructor(props) {
+      super(props);
+      this.handleResize = debounce(() => {
+        const width = this.getWidth();
+
+        if (width !== this.state.width) {
+          this.setState({
+            width
+          });
+        }
+      }, resizeInterval);
+      this.state = {
+        width: undefined
+      };
+
+      if (noSSR) {
+        this.state.width = this.getWidth();
+      }
+    }
+
+    componentDidMount() {
+      const width = this.getWidth();
+
+      if (width !== this.state.width) {
+        this.setState({
+          width
+        });
+      }
+    }
+
+    componentWillUnmount() {
+      this.handleResize.clear();
+    }
+
+    getWidth(innerWidth = window.innerWidth) {
+      const breakpoints = this.props.theme.breakpoints;
+      let width = null;
+      /**
+       * Start with the slowest value as low end devices often have a small screen.
+       *
+       * innerWidth |xs      sm      md      lg      xl
+       *            |-------|-------|-------|-------|------>
+       * width      |  xs   |  sm   |  md   |  lg   |  xl
+       */
+
+      let index = 1;
+
+      while (width === null && index < breakpointKeys.length) {
+        const currentWidth = breakpointKeys[index]; // @media are inclusive, so reproduce the behavior here.
+
+        if (innerWidth < breakpoints.values[currentWidth]) {
+          width = breakpointKeys[index - 1];
+          break;
+        }
+
+        index += 1;
+      }
+
+      width = width || 'xl';
+      return width;
+    }
+
+    render() {
+      const _this$props = this.props,
+            {
+        initialWidth,
+        theme,
+        width
+      } = _this$props,
+            other = _objectWithoutProperties(_this$props, ["initialWidth", "theme", "width"]);
+
+      const props = _objectSpread({
+        width: width || this.state.width || initialWidth || initialWidthOption || getThemeProps({
+          theme,
+          name: 'MuiWithWidth'
+        }).initialWidth
+      }, other);
+
+      const more = {};
+
+      if (withThemeOption) {
+        more.theme = theme;
+      } // When rendering the component on the server,
+      // we have no idea about the client browser screen width.
+      // In order to prevent blinks and help the reconciliation of the React tree
+      // we are not rendering the child component.
+      //
+      // An alternative is to use the `initialWidth` property.
+
+
+      if (props.width === undefined) {
+        return null;
+      }
+
+      return React.createElement(EventListener, {
+        target: "window",
+        onResize: this.handleResize
+      }, React.createElement(Component, _extends({}, more, props)));
+    }
+
+  }
+
+  WithWidth.propTypes = process.env.NODE_ENV !== "production" ? {
+    /**
+     * As `window.innerWidth` is unavailable on the server,
+     * we default to rendering an empty component during the first mount.
+     * In some situation, you might want to use an heuristic to approximate
+     * the screen width of the client browser screen width.
+     *
+     * For instance, you could be using the user-agent or the client-hints.
+     * http://caniuse.com/#search=client%20hint
+     */
+    initialWidth: PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']),
+
+    /**
+     * @ignore
+     */
+    theme: PropTypes.object.isRequired,
+
+    /**
+     * Bypass the width calculation logic.
+     */
+    width: PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl'])
+  } : {};
+
+  if (process.env.NODE_ENV !== 'production') {
+    WithWidth.displayName = wrapDisplayName(Component, 'WithWidth');
+  }
+
+  hoistNonReactStatics(WithWidth, Component);
+  return withTheme()(WithWidth);
+};
+
+export default withWidth;

package/hi-svg-icons/HiAccount.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _pure = _interopRequireDefault(require("recompose/pure"));
+
+var _styles = require("../styles");
+
+/**
+ * @ignore - internal component.
+ */
+var HiAccount = (0, _pure.default)(function (props) {
+  var classes = props.classes,
+      _props$color = props.color,
+      color = _props$color === void 0 ? props.theme.palette.neutral.main : _props$color,
+      theme = props.theme,
+      other = (0, _objectWithoutProperties2.default)(props, ["classes", "color", "theme"]);
+  return _react.default.createElement("svg", (0, _extends2.default)({
+    viewBox: "0 0 37.5 39"
+  }, other), _react.default.createElement("g", {
+    transform: "translate(-8111 -110)"
+  }, _react.default.createElement("circle", {
+    cx: 8124.9,
+    cy: 134.9,
+    r: 13.9,
+    opacity: 0.16,
+    fill: color
+  }), _react.default.createElement("path", {
+    // eslint-disable-next-line max-len
+    d: "M8117 118.1H8144V124.8h-1.1v18H8118.2v-18h-1.1V118.1zm2.3 2.3v2.2h22.5v-2.2h-22.5zm1.1 4.5v15.8h20.2v-15.8h-20.2zm6.6 2.2h7c.3 0 .6.1.8.3s.3.5.3.8c0 .3-.1.6-.3.8s-.5.3-.8.3h-6.8-.1c-.3 0-.5-.1-.8-.3-.2-.2-.4-.5-.4-.8 0-.3.1-.5.3-.7s.5-.3.8-.4z",
+    fill: color
+  })));
+});
+HiAccount.muiName = 'SvgIcon';
+
+var _default = (0, _styles.withStyles)({}, {
+  hiComponent: true,
+  withTheme: true
+})(HiAccount);
+
+exports.default = _default;