fe-fabric-react 0.0.1-security → 2.864.3

package/lib/core/components/FeProgressBar.js

@@ -0,0 +1,282 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+}
+
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a 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);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+var _RADIUS = {
+  'xxl': 29,
+  'xl': 14,
+  'l': 7,
+  's': 3.5
+};
+
+var FeProgressBar =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeProgressBar, _Component);
+
+  function FeProgressBar() {
+    _classCallCheck(this, FeProgressBar);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(FeProgressBar).apply(this, arguments));
+  }
+
+  _createClass(FeProgressBar, [{
+    key: "render",
+    value: function render() {
+      /** Minimum condition required to render*/
+
+      /** Rendering of component */
+      var className = (0, _classnames.default)({
+        'fe-progress': this.props.feStyle === 'linear',
+        'fe-circular-progress': this.props.feStyle === 'circular',
+        'fe-circular-progress--compact': this.props.feStyle === 'circular' && this.props.isCaptionInline,
+        'fe-circular-progress--stacked': this.props.feStyle === 'circular' && !this.props.isCaptionInline
+      }, this.props.className);
+      return _react.default.createElement("div", {
+        className: className
+      }, this.props.label && this.props.feStyle === 'linear' ? _react.default.createElement("h6", {
+        className: "fe-progress__label"
+      }, this.props.label) : null, this.props.feStyle === 'linear' ? _react.default.createElement(LinearProgress, {
+        feType: this.props.feType,
+        completionLevel: this.props.completionLevel
+      }) : _react.default.createElement(CircularProgress, {
+        feType: this.props.feType,
+        feSize: this.props.feSize,
+        completionLevel: this.props.completionLevel
+      }), this.props.caption ? _react.default.createElement("span", {
+        className: "caption fe-progress__caption"
+      }, this.props.caption) : null, this.props.optionalComponent);
+    }
+  }]);
+
+  return FeProgressBar;
+}(_react.Component);
+
+var LinearProgress = function LinearProgress(props) {
+  var percentage = props.completionLevel;
+
+  if (percentage < 0) {
+    percentage = 0;
+  }
+
+  if (percentage > 100) {
+    percentage = 100;
+  }
+
+  var style = {
+    'width': "".concat(percentage, "%")
+  };
+  var progressClassName = (0, _classnames.default)({
+    'fe-progress__bar-level': props.feType === 'info',
+    'fe-progress__bar-level--success': props.feType === 'success',
+    'fe-progress__bar-level--warn': props.feType === 'warning',
+    'fe-progress__bar-level--error': props.feType === 'error'
+  });
+  return _react.default.createElement("div", {
+    className: "fe-progress__bar"
+  }, _react.default.createElement("div", {
+    className: progressClassName,
+    style: style
+  }));
+};
+
+var CircularProgress = function CircularProgress(props) {
+  var percentage = props.completionLevel;
+
+  if (percentage < 0) {
+    percentage = 0;
+  }
+
+  if (percentage > 100) {
+    percentage = 100;
+  }
+
+  var c = Math.PI * (_RADIUS[props.feSize] * 2);
+  var pct = (100 - percentage) / 100 * c;
+  var style = {
+    'strokeDasharray': "".concat(c),
+    'strokeDashoffset': '0'
+  };
+  var styleProgress = {
+    'strokeDasharray': "".concat(c),
+    'strokeDashoffset': "".concat(pct)
+  };
+  var sizeClassName = "fe-circular-progress__circle--".concat(props.feSize);
+  var progressClassName = (0, _classnames.default)('fe-circular-progress__circle', {
+    'fe-circular-progress__circle-level': props.feType === 'info',
+    'fe-circular-progress__circle-level--success': props.feType === 'success',
+    'fe-circular-progress__circle-level--warn': props.feType === 'warning',
+    'fe-circular-progress__circle-level--error': props.feType === 'error'
+  });
+  return _react.default.createElement("svg", {
+    className: sizeClassName
+  }, _react.default.createElement("circle", {
+    className: "fe-circular-progress__circle",
+    style: style
+  }), _react.default.createElement("circle", {
+    className: progressClassName,
+    style: styleProgress
+  }));
+};
+
+FeProgressBar.defaultProps = {
+  feStyle: 'linear',
+  feType: 'info',
+  feSize: 'xl',
+  label: null,
+  completionLevel: 0,
+  caption: null,
+  isCaptionInline: false,
+  optionalComponent: null
+};
+FeProgressBar.propTypes = {
+  /** Provide style for progress bar*/
+  feStyle: _propTypes.default.oneOf(['linear', 'circular']),
+
+  /** Provide type for progress bar*/
+  feType: _propTypes.default.oneOf(['info', 'success', 'warning', 'error']),
+
+  /** Provide size for circular progress*/
+  feSize: _propTypes.default.oneOf(['xxl', 'xl', 'l', 's']),
+
+  /** Provide label for linear progress bar*/
+  label: _propTypes.default.string,
+
+  /** Provide completion level as number and it should be between 0 to 100*/
+  completionLevel: _propTypes.default.number,
+
+  /** Provide caption for progress*/
+  caption: _propTypes.default.string,
+
+  /** Provide caption for circular progress*/
+  isCaptionInline: _propTypes.default.bool,
+
+  /** Provide optional Component for progress*/
+  optionalComponent: _propTypes.default.element
+};
+FeProgressBar.displayName = 'FeProgressBar';
+var _default = FeProgressBar;
+exports.default = _default;

package/lib/core/components/FeRadioButton.js

@@ -0,0 +1,234 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+}
+
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function _extends() {
+  _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;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a 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);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+var FeRadioButton =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeRadioButton, _Component);
+
+  function FeRadioButton() {
+    _classCallCheck(this, FeRadioButton);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(FeRadioButton).apply(this, arguments));
+  }
+
+  _createClass(FeRadioButton, [{
+    key: "render",
+    value: function render() {
+      /** Minimum condition required to render*/
+      if (!(this.props.name && this.props.value)) {
+        return null;
+      }
+      /** Rendering of component */
+
+
+      var wrapperClass = (0, _classnames.default)('fe-radio', {
+        'fe-radio--inline': this.props.isInline
+      }, this.props.className);
+      var inputClass = (0, _classnames.default)('fe-radio__input');
+      var id = this.props.id || "".concat(this.props.name, "-").concat(this.props.value);
+      var radioButtonProps = Object.assign({}, this.props);
+      delete radioButtonProps.name;
+      delete radioButtonProps.value;
+      delete radioButtonProps.label;
+      delete radioButtonProps.id;
+      delete radioButtonProps.isChecked;
+      delete radioButtonProps.isInline;
+      delete radioButtonProps.disabled;
+      delete radioButtonProps.className;
+      return _react.default.createElement("div", {
+        className: wrapperClass
+      }, _react.default.createElement("input", _extends({}, radioButtonProps, {
+        className: inputClass,
+        type: "radio",
+        id: id,
+        name: this.props.name,
+        value: this.props.value,
+        disabled: this.props.disabled,
+        defaultChecked: this.props.isChecked
+      })), _react.default.createElement("span", {
+        className: "fe-radio__overlay"
+      }), _react.default.createElement("span", {
+        className: "fe-radio__radio"
+      }), _react.default.createElement("label", {
+        htmlFor: id,
+        className: "fe-radio__label"
+      }, this.props.label || this.props.value));
+    }
+  }]);
+
+  return FeRadioButton;
+}(_react.Component);
+
+FeRadioButton.defaultProps = {
+  name: null,
+  value: null,
+  label: null,
+  isChecked: false,
+  isInline: false,
+  disabled: false
+};
+FeRadioButton.propTypes = {
+  /** Provide group name for radio button*/
+  name: _propTypes.default.string.isRequired,
+
+  /** Provide value for radio element */
+  value: _propTypes.default.string.isRequired,
+
+  /** Provide lable for radio*/
+  label: _propTypes.default.string,
+
+  /** Set true/false to change checked state for radio*/
+  isChecked: _propTypes.default.bool,
+
+  /** Set true/false to change radio item alignment*/
+  isInline: _propTypes.default.bool,
+
+  /** Set true/false to change disabled state*/
+  disabled: _propTypes.default.bool
+};
+FeRadioButton.displayName = 'FeRadioButton';
+var _default = FeRadioButton;
+exports.default = _default;