tg-core-components 5.2.1-history-time-label.0 → 5.3.0-master.1

package/es/widgets/Subscriptions/index.js

@@ -12,8 +12,6 @@ import React from 'react';
 import { injectIntl } from 'react-intl';
 import PropTypes from 'prop-types';
 import translate from '../../lib/utils/translate';
-import Button from '../../components/Button';
-import Input from '../../components/Input';
 
 /**
  * @component Subscriptions
@@ -145,10 +143,10 @@ var Subscriptions = function (_React$Component) {
           return React.createElement(
             'div',
             { key: index, className: 'subscribe-item' },
-            React.createElement(Input, {
+            React.createElement('input', {
               id: 'newsletter-checkbox-' + index,
               type: 'checkbox',
-              value: option.OptIn,
+              checked: option.OptIn,
               onChange: function onChange(e) {
                 return _this3.onClickCheckbox({ e: e, option: option });
               }
@@ -163,7 +161,7 @@ var Subscriptions = function (_React$Component) {
           );
         }),
         React.createElement(
-          Button,
+          'button',
           {
             className: 'button primary',
             disabled: isLoading,

package/lib/components/AcceptUpdatedTaC/index.js

@@ -18,6 +18,10 @@ var _marked = require('marked');
 
 var _marked2 = _interopRequireDefault(_marked);
 
+var _Button = require('../../components/Button');
+
+var _Button2 = _interopRequireDefault(_Button);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -41,7 +45,8 @@ var AcceptUpdatedTaC = function (_Component) {
       var _props = this.props,
           onAccept = _props.onAccept,
           termsContent = _props.termsContent,
-          current = _props.current;
+          current = _props.current,
+          isLoading = _props.isLoading;
 
 
       return _react2.default.createElement(
@@ -67,8 +72,11 @@ var AcceptUpdatedTaC = function (_Component) {
           dangerouslySetInnerHTML: { __html: (0, _marked2.default)(termsContent || '') }
         }),
         _react2.default.createElement(
-          'button',
-          { className: 'button primary', onClick: onAccept },
+          _Button2.default,
+          {
+            className: 'button primary',
+            onClick: onAccept,
+            isLoading: isLoading },
           _react2.default.createElement(_Translate2.default, { id: 'action.accept' })
         )
       );

package/lib/components/Checkbox/index.js

@@ -0,0 +1,106 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Checkbox = function (_React$Component) {
+  _inherits(Checkbox, _React$Component);
+
+  function Checkbox() {
+    _classCallCheck(this, Checkbox);
+
+    return _possibleConstructorReturn(this, (Checkbox.__proto__ || Object.getPrototypeOf(Checkbox)).apply(this, arguments));
+  }
+
+  _createClass(Checkbox, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          className = _props.className,
+          _onChange = _props.onChange,
+          title = _props.title,
+          name = _props.name,
+          error = _props.error,
+          checked = _props.checked;
+
+      if (!_onChange) {
+        throw new Error('You need to provide onChange function');
+      }
+
+      var randomId = Math.floor(Math.random() * 100000);
+      var wrapperClassName = 'Checkbox';
+
+      if (className) {
+        wrapperClassName += ' ' + className;
+      }
+
+      return _react2.default.createElement(
+        'div',
+        { className: wrapperClassName },
+        _react2.default.createElement(
+          'div',
+          { className: 'flex' },
+          _react2.default.createElement('input', {
+            id: 'checkbox-' + randomId,
+            type: 'checkbox',
+            defaultValue: null,
+            defaultChecked: this.props.value === 'true' ? true : false,
+            onChange: function onChange(e) {
+              _onChange(e, name, e.target.checked ? true : '');
+            },
+            name: name ? name : '',
+            checked: checked
+          }),
+          !_react2.default.isValidElement(title) ? _react2.default.createElement('label', {
+            htmlFor: 'checkbox-' + randomId,
+            dangerouslySetInnerHTML: { __html: title }
+          }) : _react2.default.createElement(
+            'label',
+            { htmlFor: 'checkbox-' + randomId },
+            title
+          )
+        ),
+        error && _react2.default.createElement(
+          'p',
+          { className: 'error-text' },
+          error
+        )
+      );
+    }
+  }]);
+
+  return Checkbox;
+}(_react2.default.Component);
+
+Checkbox.propTypes = {
+  /** Listens for value changes */
+  onChange: _propTypes2.default.func.isRequired,
+  /** Title for the checkboxes */
+  title: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.element]),
+  /** Css class name */
+  className: _propTypes2.default.string,
+  /** Name of the input element */
+  name: _propTypes2.default.string,
+  /** Errors output */
+  error: _propTypes2.default.array
+};
+exports.default = Checkbox;

package/lib/components/Deposit/CardInput/index.js

@@ -54,9 +54,7 @@ var Input = exports.Input = function (_Component) {
     return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Input.__proto__ || Object.getPrototypeOf(Input)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
       isFocusing: false
     }, _this.formatInput = function (value) {
-      var _this$props = _this.props,
-          type = _this$props.type,
-          provider = _this$props.provider;
+      var type = _this.props.type;
 
 
       if (!value) {

package/lib/components/Input/index.js

@@ -4,47 +4,244 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
 var _react = require('react');
 
 var _react2 = _interopRequireDefault(_react);
 
-var _PasswordInput = require('./PasswordInput');
+var _propTypes = require('prop-types');
 
-var _PasswordInput2 = _interopRequireDefault(_PasswordInput);
+var _propTypes2 = _interopRequireDefault(_propTypes);
 
-var _BirthdateInput = require('./BirthdateInput');
+var _ButtonLoader = require('../ButtonLoader');
 
-var _BirthdateInput2 = _interopRequireDefault(_BirthdateInput);
+var _ButtonLoader2 = _interopRequireDefault(_ButtonLoader);
 
-var _PhoneNumberInput = require('./PhoneNumberInput');
+var _classnames = require('classnames');
 
-var _PhoneNumberInput2 = _interopRequireDefault(_PhoneNumberInput);
+var _classnames2 = _interopRequireDefault(_classnames);
 
-var _Checkbox = require('./Checkbox');
+var _Icon = require('../Icon');
 
-var _Checkbox2 = _interopRequireDefault(_Checkbox);
+var _Icon2 = _interopRequireDefault(_Icon);
 
-var _Input = require('./Input');
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _Input2 = _interopRequireDefault(_Input);
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Input = function (_PureComponent) {
+  _inherits(Input, _PureComponent);
+
+  function Input(props) {
+    _classCallCheck(this, Input);
+
+    var _this = _possibleConstructorReturn(this, (Input.__proto__ || Object.getPrototypeOf(Input)).call(this, props));
+
+    _this._onTogglePassword = function () {
+      _this.setState({ showPassword: !_this.state.showPassword });
+    };
+
+    _this.getInputRef = function () {
+      return _this.input;
+    };
+
+    _this._handleChange = function (e) {
+      var _this$props = _this.props,
+          onChange = _this$props.onChange,
+          name = _this$props.name;
+
+      var value = e.currentTarget.value;
 
-var InputDispatcher = function InputDispatcher(props) {
-  switch (props.type) {
-    case 'hidden':
-      return _react2.default.createElement('input', { type: props.type, name: props.name, value: props.value });
-    case 'password':
-      return _react2.default.createElement(_PasswordInput2.default, props);
-    case 'birthdate':
-      return _react2.default.createElement(_BirthdateInput2.default, props);
-    case 'tel':
-      return _react2.default.createElement(_PhoneNumberInput2.default, props);
-    case 'checkbox':
-      return _react2.default.createElement(_Checkbox2.default, props);
-    default:
-      return _react2.default.createElement(_Input2.default, props);
+      _this.setState({
+        value: value
+      });
+
+      onChange && onChange(e, name, value);
+    };
+
+    _this._handleFocus = function (e) {
+      var _this$props2 = _this.props,
+          onFocus = _this$props2.onFocus,
+          name = _this$props2.name;
+      var value = _this.state.value;
+
+
+      _this.setState({
+        isFocusing: true
+      });
+
+      onFocus && onFocus(e, name, value);
+    };
+
+    _this._handleBlur = function () {
+      var onBlur = _this.props.onBlur;
+      var value = _this.state.value;
+
+
+      _this.setState({
+        isFocusing: false
+      });
+      onBlur && onBlur(value);
+    };
+
+    _this._handleAutoFill = function (e) {
+      if (e.animationName === 'onAutoFill') {
+        _this.setState({
+          isAutoFill: true
+        });
+      }
+    };
+
+    _this.state = {
+      isFocusing: false,
+      showPassword: false,
+      value: props.value || '',
+      isAutoFill: false
+    };
+    return _this;
   }
+
+  _createClass(Input, [{
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps(nextProps) {
+      if (!this.props.isControlled && typeof nextProps.value === 'undefined') {
+        return;
+      }
+
+      if (this.state.value !== nextProps.value) {
+        this.setState({ value: nextProps.value });
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          title = _props.title,
+          error = _props.error,
+          require = _props.require,
+          innerRef = _props.innerRef,
+          autoFocus = _props.autoFocus,
+          isLoading = _props.isLoading,
+          description = _props.description,
+          _props$type = _props.type,
+          type = _props$type === undefined ? 'text' : _props$type,
+          _props$className = _props.className,
+          className = _props$className === undefined ? '' : _props$className,
+          _props$showToggleIcon = _props.showToggleIcon,
+          showToggleIcon = _props$showToggleIcon === undefined ? false : _props$showToggleIcon,
+          rest = _objectWithoutProperties(_props, ['title', 'error', 'require', 'innerRef', 'autoFocus', 'isLoading', 'description', 'type', 'className', 'showToggleIcon']);
+
+      var _state = this.state,
+          value = _state.value,
+          isFocusing = _state.isFocusing,
+          showPassword = _state.showPassword,
+          isAutoFill = _state.isAutoFill;
+
+      var hasValue = !!value;
+
+      if (type === 'hidden') return _react2.default.createElement('input', _extends({}, rest, { type: type, value: value || '' }));
+
+      return _react2.default.createElement(
+        'div',
+        {
+          className: (0, _classnames2.default)('tg_input', className, {
+            input_focus: isFocusing,
+            tg_input_value: hasValue,
+            error: error,
+            has_title: title,
+            input_autofill: isAutoFill
+          }) },
+        _react2.default.createElement(
+          'div',
+          { className: 'input-wrapper' },
+          title && _react2.default.createElement(
+            'div',
+            { className: 'input_title' },
+            title + ' ' + (require ? '*' : '')
+          ),
+          _react2.default.createElement('input', _extends({}, rest, {
+            ref: innerRef,
+            type: showToggleIcon && showPassword ? 'text' : type,
+            value: value || '',
+            autoFocus: autoFocus,
+            onChange: this._handleChange,
+            onFocus: this._handleFocus,
+            onBlur: this._handleBlur,
+            onAnimationStart: this._handleAutoFill
+          })),
+          isLoading && _react2.default.createElement(_ButtonLoader2.default, null),
+          showToggleIcon && _react2.default.createElement(_Icon2.default, {
+            icon: this.state.showPassword ? 'eye-slash' : 'eye',
+            className: 'toggle-password',
+            onClick: this._onTogglePassword
+          })
+        ),
+        _react2.default.createElement('div', { className: 'bottom-line' }),
+        error && _react2.default.createElement(
+          'div',
+          { className: 'error-message' },
+          error
+        ),
+        !error && description && _react2.default.createElement(
+          'div',
+          { className: 'input_description' },
+          description
+        )
+      );
+    }
+  }]);
+
+  return Input;
+}(_react.PureComponent);
+
+Input.propTypes = {
+  /** Type of value */
+  type: _propTypes2.default.string,
+  /** Represents the label for each input field */
+  title: _propTypes2.default.string,
+  /** The validation error message */
+  error: _propTypes2.default.string,
+  /** Name associated with each input field */
+  name: _propTypes2.default.string,
+  /** Minimal amount of characters required */
+  min: _propTypes2.default.string,
+  /** Boolean props deciding whether to disable or enable input field */
+  disabled: _propTypes2.default.bool,
+  /** Boolean props deciding whether a field is required to have a value or not */
+  require: _propTypes2.default.bool,
+  /** Optional description text */
+  description: _propTypes2.default.string,
+  /** Placeholder text used on the input */
+  placeholder: _propTypes2.default.string,
+  /** Classnames that should be used on the input */
+  className: _propTypes2.default.string,
+  /** Boolean to show toggle password icon or not */
+  showToggleIcon: _propTypes2.default.bool
+};
+
+Input.defaultProps = {
+  type: 'text',
+  title: '',
+  error: '',
+  name: '',
+  min: '',
+  disabled: false,
+  require: false,
+  description: '',
+  placeholder: '',
+  className: '',
+  showToggleIcon: false
 };
 
-exports.default = InputDispatcher;
+exports.default = _react2.default.forwardRef(function (props, ref) {
+  return _react2.default.createElement(Input, _extends({}, props, { innerRef: ref }));
+});