fe-fabric-react 0.0.1-security → 2.864.3

package/lib/fe-modal/FeModal.js

@@ -0,0 +1,409 @@
+"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 _utils = require("../core/utils");
+
+var _core = require("../core");
+
+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 _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);
+}
+
+var FeModal =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeModal, _Component);
+
+  function FeModal(props) {
+    var _this;
+
+    _classCallCheck(this, FeModal);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FeModal).call(this, props));
+    _this.state = {
+      isOpen: false
+    };
+    _this.hide = _this.hide.bind(_assertThisInitialized(_this));
+    _this.checkDocumentKeyDown = _this.checkDocumentKeyDown.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(FeModal, [{
+    key: "hide",
+    value: function hide() {
+      this.setState({
+        isOpen: false
+      });
+      this.restore();
+
+      if (this.props.onHide) {
+        this.props.onHide({
+          isOpen: false
+        });
+      }
+    }
+  }, {
+    key: "restore",
+    value: function restore() {
+      //restore focus
+      if (this.props.referId) {
+        var referElement = document.getElementById(this.props.referId);
+        referElement && referElement.focus();
+      }
+
+      document.body.classList.remove('fe-modal-open');
+    }
+  }, {
+    key: "getTitleIcon",
+    value: function getTitleIcon() {
+      return _react.default.createElement("div", {
+        className: "fe-modal__header--with-icon"
+      }, _react.default.createElement(_core.FeIcon, {
+        family: this.props.iconTitle.family,
+        icon: this.props.iconTitle.icon
+      }));
+    }
+  }, {
+    key: "getTitle",
+    value: function getTitle() {
+      return _react.default.createElement("h4", {
+        className: "fe-modal__title"
+      }, this.props.title);
+    }
+  }, {
+    key: "getAction",
+    value: function getAction(props, style) {
+      var autoFocus = style === 'primary';
+      var className = (0, _classnames.default)({
+        'pull-left': style === 'primary-danger'
+      });
+
+      var label = props.label,
+          buttonProps = _objectWithoutProperties(props, ["label"]);
+
+      return _react.default.createElement(_core.FeButton, _extends({}, buttonProps, {
+        feStyle: style,
+        className: className,
+        autoFocus: autoFocus
+      }), label);
+    }
+  }, {
+    key: "checkDocumentKeyDown",
+    value: function checkDocumentKeyDown(event) {
+      if (!this.state.isOpen) {
+        return false;
+      }
+
+      if (event.keyCode === 27) {
+        //Escape
+        this.hide();
+      } else if (event.keyCode === 9) {
+        //Tab
+        (0, _utils.trapFocus)(event, this.node);
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      //add keydown event
+      document.addEventListener('keydown', this.checkDocumentKeyDown);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      //remove keydown event
+      document.removeEventListener('keydown', this.checkDocumentKeyDown);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      /** Minimum condition required to render*/
+
+
+      if (!(this.props.isOpen && this.props.children)) {
+        this.restore();
+        return null;
+      }
+      /** Rendering of component */
+
+
+      document.body.classList.add('fe-modal-open');
+      var wrapperClass = (0, _classnames.default)('fe-modal', this.props.className);
+      var className = (0, _classnames.default)('fe-modal__dialog', ["fe-modal__dialog--".concat(this.props.size)]);
+      var iconTitle = this.props.iconTitle && this.getTitleIcon();
+      var title = this.props.title && this.getTitle();
+      var primaryAction = this.props.primaryAction && this.getAction(this.props.primaryAction, 'primary');
+      var secondaryAction = this.props.secondaryAction && this.getAction(this.props.secondaryAction, 'secondary');
+      var dangerAction = this.props.dangerAction && this.getAction(this.props.dangerAction, 'primary-danger'); //Aria attributes
+
+      var ariaAttributesForModal = {
+        'role': 'dialog',
+        'aria-labelledby': "".concat(this.props.referId),
+        'aria-modal': "".concat(this.state.isOpen)
+      };
+      var ariaAttributesForBody = {};
+
+      if (this.props.size === 'large') {
+        ariaAttributesForBody['tabIndex'] = '0';
+      }
+
+      return _react.default.createElement("div", _extends({
+        className: wrapperClass
+      }, ariaAttributesForModal, {
+        ref: function ref(node) {
+          return _this2.node = node;
+        }
+      }), _react.default.createElement("div", {
+        className: className
+      }, _react.default.createElement("section", {
+        className: "fe-modal__content"
+      }, _react.default.createElement("header", null, _react.default.createElement("div", {
+        className: "fe-modal__header"
+      }, iconTitle, title, _react.default.createElement("button", {
+        className: "fe-modal-close",
+        "aria-label": "Close modal",
+        onClick: this.hide
+      }, _react.default.createElement(_core.FeIcon, {
+        family: "light",
+        icon: "times"
+      })))), _react.default.createElement("div", _extends({
+        className: "fe-modal__body"
+      }, ariaAttributesForBody), this.props.children), dangerAction || secondaryAction || primaryAction ? _react.default.createElement("footer", {
+        className: "fe-modal__footer"
+      }, dangerAction, secondaryAction, primaryAction) : null)));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, state) {
+      if (props.isOpen !== state.isOpen) {
+        return {
+          isOpen: props.isOpen
+        };
+      }
+
+      return null;
+    }
+  }]);
+
+  return FeModal;
+}(_react.Component);
+
+FeModal.defaultProps = {
+  referId: null,
+  title: null,
+  size: 'small',
+  isOpen: false,
+  primaryAction: null,
+  secondaryAction: null,
+  dangerAction: null,
+  children: null
+};
+FeModal.propTypes = {
+  /** Provide id of refer button, its required for aria attributes and restore focus*/
+  referId: _propTypes.default.string,
+
+  /** Provide modal title*/
+  title: _propTypes.default.string,
+
+  /** Provide icon name and family for title title*/
+  iconTitle: _propTypes.default.exact({
+    icon: _propTypes.default.string.isRequired,
+    family: _propTypes.default.string.isRequired
+  }),
+
+  /** Provide modal size like 'small', 'medium', 'large'*/
+  size: _propTypes.default.oneOf(['small', 'medium', 'large']),
+
+  /** Set true/false to toggle modal*/
+  isOpen: _propTypes.default.bool,
+
+  /** Provide primary action like FeButton Attributes*/
+  primaryAction: _propTypes.default.object,
+
+  /** Provide secondary action like FeButton Attributes*/
+  secondaryAction: _propTypes.default.object,
+
+  /** Provide danger action like FeButton Attributes*/
+  dangerAction: _propTypes.default.object,
+
+  /** Provide body children*/
+  children: _propTypes.default.element
+};
+FeModal.displayName = 'FeModal';
+var _default = FeModal;
+exports.default = _default;

package/lib/fe-modal/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _FeModal = _interopRequireDefault(require("./FeModal"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+var _default = _FeModal.default;
+exports.default = _default;

package/lib/fe-notifications/FeNotifications.js

@@ -0,0 +1,235 @@
+"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 _toNumber = _interopRequireDefault(require("lodash/toNumber"));
+
+var _core = require("../core");
+
+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 FeNotifications =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeNotifications, _Component);
+
+  function FeNotifications(props) {
+    var _this;
+
+    _classCallCheck(this, FeNotifications);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FeNotifications).call(this, props));
+    _this.onDismiss = _this.onDismiss.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(FeNotifications, [{
+    key: "onDismiss",
+    value: function onDismiss(index) {
+      index = (0, _toNumber.default)(index);
+      var notifications = Object.assign([], this.props.notifications);
+      notifications[index]['dismissed'] = true;
+
+      if (this.props.onDismiss) {
+        this.props.onDismiss(index, notifications);
+      }
+    }
+  }, {
+    key: "isAllDismissed",
+    value: function isAllDismissed(notifications) {
+      var index = -1;
+
+      if (notifications && notifications.length) {
+        index = notifications.findIndex(function (item) {
+          return !item.dismissed;
+        });
+      }
+
+      return index < 0;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      /** Minimum condition required to render*/
+
+      /** Rendering of component */
+
+
+      var isAllDismissed = this.isAllDismissed(this.props.notifications);
+      var className = (0, _classnames.default)('fe-notice-container', {
+        'fe-notice-container--display': !isAllDismissed
+      }, this.props.className);
+      var otherProps = Object.assign({}, this.props);
+      delete otherProps.notifications;
+      delete otherProps.onDismiss;
+      delete otherProps.className;
+      return _react.default.createElement("div", _extends({
+        className: className
+      }, otherProps), this.props.notifications.map(function (notification, i) {
+        return _react.default.createElement(_core.FeNotification, _extends({
+          key: i
+        }, notification, {
+          index: "".concat(i),
+          onDismiss: _this2.onDismiss
+        }));
+      }));
+    }
+  }]);
+
+  return FeNotifications;
+}(_react.Component);
+
+FeNotifications.defaultProps = {
+  notifications: [],
+  onDismiss: null
+};
+FeNotifications.propTypes = {
+  /** Provide notifications*/
+  notifications: _propTypes.default.array,
+
+  /** Provide handler on notification dismiss*/
+  onDismiss: _propTypes.default.func
+};
+FeNotifications.displayName = 'FeNotifications';
+var _default = FeNotifications;
+exports.default = _default;

package/lib/fe-notifications/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _FeNotifications = _interopRequireDefault(require("./FeNotifications"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+var _default = _FeNotifications.default;
+exports.default = _default;