fe-fabric-react 0.0.1-security → 2.864.3

package/lib/core/components/FeNotification.js

@@ -0,0 +1,351 @@
+"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"));
+
+var _FeIcon = _interopRequireDefault(require("./FeIcon"));
+
+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 _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+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 FeNotification =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeNotification, _Component);
+
+  function FeNotification(props) {
+    var _this;
+
+    _classCallCheck(this, FeNotification);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FeNotification).call(this, props));
+    _this.state = {
+      dismissed: false
+    };
+    _this.unmount = _this.unmount.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(FeNotification, [{
+    key: "unmount",
+    value: function unmount() {
+      var _this2 = this;
+
+      this.setState({
+        dismissed: true
+      }, function () {
+        if (_this2.props.onDismiss) {
+          _this2.props.onDismiss(_this2.props.index || _this2.props);
+        }
+      });
+
+      if (this.timerNode) {
+        this.timerNode.removeEventListener('animationend', this.unmount);
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.feStyle === 'default' && this.props.autoDismiss) {
+        this.timerNode.style.animationDuration = "".concat(this.props.autoDismissTimeout, "s");
+        this.timerNode.addEventListener('animationend', this.unmount, false);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+      /** Minimum condition required to render*/
+
+
+      if (!this.props.message || this.state.dismissed) {
+        return null;
+      }
+      /** Rendering of component */
+
+
+      var className = (0, _classnames.default)("fe".concat(this.props.feStyle === 'list' ? '-list' : '', "-notice"), "fe".concat(this.props.feStyle === 'list' ? '-list' : '', "-notice--").concat(this.props.feType), {
+        'fe-notice--auto-dismiss': this.props.feStyle === 'default' && this.props.autoDismiss,
+        'fe-list-notice--unread': this.props.feStyle === 'list' && !this.props.isRead
+      }, this.props.className);
+      var otherProps = Object.assign({}, this.props);
+      delete otherProps.label;
+      delete otherProps.message;
+      delete otherProps.feStyle;
+      delete otherProps.feType;
+      delete otherProps.withIcon;
+      delete otherProps.autoDismiss;
+      delete otherProps.autoDismissTimeout;
+      delete otherProps.timestamp;
+      delete otherProps.iconInfo;
+      delete otherProps.iconSuccess;
+      delete otherProps.iconWarning;
+      delete otherProps.iconError;
+      delete otherProps.isRead;
+      delete otherProps.onDismiss;
+      delete otherProps.optionalComponent;
+      delete otherProps.className;
+      return _react.default.createElement("div", _extends({
+        className: className
+      }, otherProps), this.props.feStyle === 'default' && this.props.autoDismiss ? _react.default.createElement("div", {
+        ref: function ref(node) {
+          return _this3.timerNode = node;
+        },
+        className: "fe-notice__dismiss-timer"
+      }) : null, this.props.feStyle === 'default' ? _react.default.createElement(DefaultNotification, _extends({}, this.props, {
+        unmount: this.unmount
+      })) : _react.default.createElement(ListNotification, this.props));
+    }
+  }]);
+
+  return FeNotification;
+}(_react.Component);
+
+var DefaultNotification = function DefaultNotification(props) {
+  var indicatorClass = (0, _classnames.default)('fe-notice__indicator', {
+    'fe-notice__indicator--icon': props.withIcon
+  });
+  var iconClass = props.withIcon && (0, _classnames.default)({
+    'info-circle': props.feType === 'info',
+    'check-circle': props.feType === 'success',
+    'exclamation-circle': props.feType === 'warning',
+    'exclamation-triangle': props.feType === 'error'
+  });
+  return _react.default.createElement(_react.Fragment, null, _react.default.createElement("button", {
+    type: "button",
+    name: "button",
+    className: "fe-notice__close",
+    onClick: props.unmount
+  }, _react.default.createElement(_FeIcon.default, {
+    family: "light",
+    icon: "times"
+  })), _react.default.createElement("div", {
+    className: indicatorClass
+  }, props.withIcon ? _react.default.createElement(_FeIcon.default, {
+    family: "light",
+    icon: iconClass
+  }) : null), _react.default.createElement("div", {
+    className: "fe-notice__message"
+  }, props.label ? _react.default.createElement("p", {
+    className: "fe-notice__label"
+  }, props.label) : null, _react.default.createElement("p", {
+    className: "fe-notice__text"
+  }, props.message), props.optionalComponent ? _react.default.createElement("p", {
+    className: "fe-notice__actions"
+  }, props.optionalComponent) : null));
+};
+
+var ListNotification = function ListNotification(props) {
+  var iconClass = props.withIcon && (0, _classnames.default)({
+    'info-circle': props.feType === 'info',
+    'check-circle': props.feType === 'success',
+    'exclamation-circle': props.feType === 'warning',
+    'exclamation-triangle': props.feType === 'error'
+  });
+  return _react.default.createElement(_react.Fragment, null, _react.default.createElement("div", {
+    className: "fe-list-notice__indicator"
+  }), _react.default.createElement("div", {
+    className: "fe-list-notice__container"
+  }, _react.default.createElement("p", {
+    className: "fe-list-notice__label clearfix"
+  }, props.label, props.timestamp ? _react.default.createElement("span", {
+    className: "fe-list-notice__timestamp pull-right"
+  }, props.timestamp) : null), _react.default.createElement("div", {
+    className: "fe-list-notice__message"
+  }, props.withIcon ? _react.default.createElement("span", {
+    className: "fe-list-notice__icon"
+  }, _react.default.createElement(_FeIcon.default, {
+    family: "light",
+    icon: iconClass
+  })) : null, _react.default.createElement("p", {
+    className: "fe-list-notice__text"
+  }, props.message))));
+};
+
+FeNotification.defaultProps = {
+  label: null,
+  message: null,
+  feStyle: 'default',
+  feType: 'info',
+  withIcon: false,
+  autoDismiss: false,
+  autoDismissTimeout: 5,
+  timestamp: null,
+  isRead: false,
+  onDismiss: null,
+  optionalComponent: null
+};
+FeNotification.propTypes = {
+  /** Provide notification label*/
+  label: _propTypes.default.string,
+
+  /** Provide notification message*/
+  message: _propTypes.default.string,
+
+  /** Provide style like 'default' or 'list'*/
+  feStyle: _propTypes.default.oneOf(['default', 'list']),
+
+  /** Provide type like 'info', 'success', 'warning' or 'error'*/
+  feType: _propTypes.default.oneOf(['info', 'success', 'warning', 'error']),
+
+  /** Set true/false to add/remove type icon*/
+  withIcon: _propTypes.default.bool,
+
+  /** Set true/false to make auto dismissable*/
+  autoDismiss: _propTypes.default.bool,
+
+  /** Provide auto dismissable timeout*/
+  autoDismissTimeout: _propTypes.default.number,
+
+  /** Provide timestamp for notification generated*/
+  timestamp: _propTypes.default.string,
+
+  /** Set true/false to make it read or unread*/
+  isRead: _propTypes.default.bool,
+
+  /** Provide handler on dismiss of notification*/
+  onDismiss: _propTypes.default.func,
+
+  /** Provide optional component*/
+  optionalComponent: _propTypes.default.element
+};
+FeNotification.displayName = 'FeNotification';
+var _default = FeNotification;
+exports.default = _default;

package/lib/core/components/FePillBox.js

@@ -0,0 +1,353 @@
+"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"));
+
+var _FeIcon = _interopRequireDefault(require("./FeIcon"));
+
+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 _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+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 _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+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);
+}
+
+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);
+}
+
+var FePillBoxIcon = function FePillBoxIcon(_ref) {
+  var onIconClick = _ref.onIconClick,
+      feType = _ref.feType,
+      iconClear = _ref.iconClear,
+      iconAdd = _ref.iconAdd;
+  var iconAttributes = {
+    role: 'button',
+    tabIndex: '0',
+    onClick: onIconClick,
+    onKeyDown: function onKeyDown(event) {
+      if (event.keyCode === 13) {
+        //Enter
+        onIconClick(event);
+      }
+    }
+  };
+
+  if (feType === 'clear') {
+    return _react.default.createElement("a", _extends({}, iconAttributes, {
+      "aria-label": "clear"
+    }), _react.default.createElement(_FeIcon.default, {
+      family: "solid",
+      icon: "times-circle",
+      className: "close"
+    }));
+  } else if (feType === 'add') {
+    return _react.default.createElement("a", _extends({}, iconAttributes, {
+      "aria-label": "add"
+    }), _react.default.createElement(_FeIcon.default, {
+      family: "solid",
+      icon: "plus-circle",
+      className: "add"
+    }));
+  }
+
+  return null;
+};
+
+var FePillBox =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FePillBox, _Component);
+
+  function FePillBox(props) {
+    var _this;
+
+    _classCallCheck(this, FePillBox);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FePillBox).call(this, props));
+    _this.onButtonClick = _this.onButtonClick.bind(_assertThisInitialized(_this));
+    _this.onIconClick = _this.onIconClick.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(FePillBox, [{
+    key: "onButtonClick",
+    value: function onButtonClick(event) {
+      if (this.props.onClick) {
+        this.props.onClick({
+          originalEvent: event,
+          buttonClick: true,
+          props: this.props
+        });
+      }
+    }
+  }, {
+    key: "onIconClick",
+    value: function onIconClick(event) {
+      event.stopPropagation();
+
+      if (this.props.onClick) {
+        this.props.onClick({
+          originalEvent: event,
+          iconClick: true,
+          props: this.props
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          feType = _this$props.feType,
+          iconClear = _this$props.iconClear,
+          iconAdd = _this$props.iconAdd,
+          disabled = _this$props.disabled,
+          active = _this$props.active,
+          feKey = _this$props.feKey,
+          feValue = _this$props.feValue,
+          label = _this$props.label,
+          pillBoxProps = _objectWithoutProperties(_this$props, ["feType", "iconClear", "iconAdd", "disabled", "active", "feKey", "feValue", "label"]);
+
+      var isKeyValueAvailable = !!feKey && !!feValue;
+      var isLabelAvailable = !!label;
+
+      if (!isKeyValueAvailable && !isLabelAvailable) {
+        return null;
+      }
+
+      var Tag = this.props.href ? 'a' : 'button';
+      var className = (0, _classnames.default)('fe-pill-box', {
+        'with-icon clear': !disabled && feType === 'clear',
+        'with-icon create': !disabled && feType === 'add',
+        'active': active,
+        'disabled': disabled
+      }, this.props.className);
+
+      var key = isKeyValueAvailable && _react.default.createElement("span", {
+        className: "key"
+      }, "".concat(feKey, ": "));
+
+      var value = isKeyValueAvailable && _react.default.createElement("span", {
+        className: "value"
+      }, feValue);
+
+      var pillBoxLabel = !isKeyValueAvailable && isLabelAvailable && _react.default.createElement("span", {
+        className: "label"
+      }, label);
+
+      var icon = !disabled && _react.default.createElement(FePillBoxIcon, {
+        onIconClick: this.onIconClick,
+        feType: feType,
+        iconClear: iconClear,
+        iconAdd: iconAdd
+      });
+
+      return _react.default.createElement(Tag, _extends({}, pillBoxProps, {
+        className: className,
+        disabled: disabled,
+        onClick: this.onButtonClick
+      }), key, value, pillBoxLabel, icon);
+    }
+  }]);
+
+  return FePillBox;
+}(_react.Component);
+
+FePillBox.defaultProps = {
+  label: null,
+  feKey: null,
+  feValue: null,
+  feType: 'default',
+  active: false,
+  disabled: false
+};
+FePillBox.propTypes = {
+  /** Provide label attribute*/
+  label: _propTypes.default.string,
+
+  /** Provide key attribute*/
+  feKey: _propTypes.default.string,
+
+  /** Provide value attribute*/
+  feValue: _propTypes.default.string,
+
+  /** Render the PillBox as an HTML Anchor with the provided HREF **/
+  href: _propTypes.default.string,
+
+  /** Provide type for pillbox like 'default', 'clear', 'add'*/
+  feType: _propTypes.default.oneOf(['default', 'clear', 'add']),
+
+  /** Set true/false to change active state*/
+  active: _propTypes.default.bool,
+
+  /** Set true/false to change disabled state*/
+  disabled: _propTypes.default.bool
+};
+FePillBox.displayName = 'FePillBox';
+var _default = FePillBox;
+exports.default = _default;