fe-fabric-react 0.0.1-security → 2.864.3

package/lib/fe-sidenav/FeSideNavList.js

@@ -0,0 +1,346 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _core = require("../core");
+
+var _utils = require("../core/utils");
+
+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 _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+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 FeSideNavList =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeSideNavList, _Component);
+
+  function FeSideNavList(props) {
+    var _this;
+
+    _classCallCheck(this, FeSideNavList);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FeSideNavList).call(this, props));
+    var currentPathname = document.location.pathname;
+
+    var _getActiveIndex = (0, _utils.getActiveIndex)(props.navList, currentPathname),
+        _getActiveIndex2 = _slicedToArray(_getActiveIndex, 2),
+        activeItemIndex = _getActiveIndex2[0],
+        activeSubItemIndex = _getActiveIndex2[1];
+
+    _this.state = {
+      activeItemIndex: activeItemIndex >= 0 && "".concat(activeItemIndex),
+      activeSubItemIndex: activeSubItemIndex >= 0 && "".concat(activeSubItemIndex),
+      expandedIndex: activeItemIndex >= 0 && "".concat(activeItemIndex),
+      activeRoute: currentPathname,
+      displayList: _this.props.navList,
+      expandAll: false
+    };
+    _this.onItemClickHandler = _this.onItemClickHandler.bind(_assertThisInitialized(_this));
+    _this.searchEvent = _this.searchEvent.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(FeSideNavList, [{
+    key: "onItemClickHandler",
+    value: function onItemClickHandler(event) {
+      var _this$state = this.state,
+          activeItemIndex = _this$state.activeItemIndex,
+          activeSubItemIndex = _this$state.activeSubItemIndex,
+          expandedIndex = _this$state.expandedIndex;
+      var itemIndex = event.itemIndex,
+          subItemIndex = event.subItemIndex,
+          hasSubItems = event.hasSubItems;
+      var state = {};
+
+      if (hasSubItems) {
+        state = {
+          activeItemIndex: activeItemIndex,
+          activeSubItemIndex: activeSubItemIndex,
+          expandedIndex: itemIndex !== expandedIndex ? itemIndex : null
+        };
+      } else {
+        state = {
+          activeItemIndex: itemIndex,
+          activeSubItemIndex: subItemIndex,
+          expandedIndex: subItemIndex ? itemIndex : null,
+          activeRoute: event.originalEvent.currentTarget.pathname
+        };
+      }
+
+      this.setState(state);
+
+      if (this.props.onItemClick) {
+        var options = Object.assign({}, event, state);
+        this.props.onItemClick(options);
+      }
+    }
+  }, {
+    key: "searchEvent",
+    value: function searchEvent(resp) {
+      var expanded;
+
+      if (resp.subStr !== null && resp.subStr !== '') {
+        expanded = true;
+      } else {
+        expanded = false;
+      }
+
+      this.setState({
+        displayList: resp.list,
+        expandAll: expanded
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      if (this.props.navList && this.props.navList.length === 0) {
+        return null;
+      } //Aria attributes
+
+
+      var ariaProps = {
+        'aria-label': 'mainmenu',
+        'role': 'menubar'
+      };
+      return _react.default.createElement("div", {
+        className: "fe-side-nav-list"
+      }, this.props.withSearch && _react.default.createElement(_core.FeSearchField, {
+        list: this.props.navList,
+        isMultiLevel: true,
+        multiLevelKey: "list",
+        onChange: function onChange(resp) {
+          return _this2.searchEvent(resp);
+        }
+      }), _react.default.createElement("nav", {
+        className: "fe-sidenav"
+      }, _react.default.createElement(_core.FeListItemGroup, _extends({}, ariaProps, {
+        onItemClick: this.onItemClickHandler,
+        list: this.state.displayList,
+        activeItemIndex: "".concat(this.state.activeItemIndex),
+        activeSubItemIndex: "".concat(this.state.activeSubItemIndex),
+        expandedIndex: "".concat(this.state.expandedIndex),
+        isExpandAll: this.state.expandAll,
+        customRenderLink: this.props.customRenderLink
+      }))));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, state) {
+      var currentPathname = document.location.pathname;
+
+      if (currentPathname !== state.activeRoute) {
+        var _getActiveIndex3 = (0, _utils.getActiveIndex)(props.navList, currentPathname),
+            _getActiveIndex4 = _slicedToArray(_getActiveIndex3, 2),
+            activeItemIndex = _getActiveIndex4[0],
+            activeSubItemIndex = _getActiveIndex4[1];
+
+        return {
+          activeItemIndex: activeItemIndex >= 0 && "".concat(activeItemIndex),
+          activeSubItemIndex: activeSubItemIndex >= 0 && "".concat(activeSubItemIndex),
+          expandedIndex: activeItemIndex >= 0 && "".concat(activeItemIndex),
+          activeRoute: currentPathname
+        };
+      }
+
+      return null;
+    }
+  }]);
+
+  return FeSideNavList;
+}(_react.Component);
+
+FeSideNavList.defaultProps = {
+  withSearch: false,
+  navList: [],
+  customRenderLink: null
+};
+FeSideNavList.propTypes = {
+  /** Array of navigation items */
+  navList: _propTypes.default.array.isRequired,
+
+  /** Set to true to have seacrh box for nav items */
+  withSearch: _propTypes.default.bool,
+
+  /** A function that returns a react element to render the wrapping link.
+   *  Will receive url, className, and children props
+   */
+  customRenderLink: _propTypes.default.func
+};
+var _default = FeSideNavList;
+exports.default = _default;

package/lib/fe-sidenav/index.js

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