fe-fabric-react 0.0.1-security → 2.864.3

package/lib/fe-topnav/FeTopNav.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _FeTopNavList = _interopRequireDefault(require("./FeTopNavList"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: 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);
+}
+
+var FeTopNav = function FeTopNav(_ref) {
+  var feStyle = _ref.feStyle,
+      className = _ref.className,
+      navList = _ref.navList,
+      productType = _ref.productType,
+      leftContent = _ref.leftContent,
+      rightContent = _ref.rightContent,
+      additionalProps = _ref.additionalProps,
+      customRenderLink = _ref.customRenderLink;
+  var headerClassName = (0, _classnames.default)('fe-top-nav', {
+    'fe-top-nav__topbar': feStyle === 'topbar',
+    'fe-top-nav__topnav': feStyle === 'topnav'
+  }, className);
+  var leftClassName = (0, _classnames.default)('fe-top-nav__title', {
+    'fe-top-nav__bookend fe-top-nav__bookend--left': feStyle === 'topnav'
+  });
+  var rightClassName = (0, _classnames.default)('fe-top-nav__action-container', {
+    'fe-top-nav__bookend fe-top-nav__bookend--right': feStyle === 'topnav'
+  });
+  var headerProps = Object.assign({}, additionalProps);
+  return _react.default.createElement("header", _extends({}, headerProps, {
+    className: headerClassName
+  }), _react.default.createElement("div", {
+    className: leftClassName
+  }, productType && _react.default.createElement("div", {
+    className: "fe-product fe-product--".concat(productType)
+  }), leftContent), _react.default.createElement(_FeTopNavList.default, {
+    navList: navList,
+    customRenderLink: customRenderLink
+  }), _react.default.createElement("div", {
+    className: rightClassName
+  }, rightContent));
+};
+
+FeTopNav.defaultProps = {
+  feStyle: 'topnav',
+  productType: null,
+  navList: [],
+  onItemClick: null,
+  customRenderLink: null
+};
+FeTopNav.propTypes = {
+  /** Provide top navigation variants like 'topbar' or 'topnav'*/
+  feStyle: _propTypes.default.oneOf(['topbar', 'topnav']),
+
+  /** Provide productType like 'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta'*/
+  productType: _propTypes.default.oneOf(['alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta']),
+
+  /** Provide top nav list*/
+  navList: _propTypes.default.arrayOf(_propTypes.default.object),
+
+  /** Space for user defined node in left bookend*/
+  leftContent: _propTypes.default.node,
+
+  /** Space for user defined node in right bookend*/
+  rightContent: _propTypes.default.node,
+
+  /** Provide item click handler for nav items*/
+  onItemClick: _propTypes.default.func,
+
+  /** Additional props to pass on to the anchor */
+  additionalProps: _propTypes.default.object,
+
+  /** A function that returns a react element to render the wrapping link.
+   *  Will receive url, className, and children props
+   */
+  customRenderLink: _propTypes.default.func
+};
+FeTopNav.displayName = 'FeTopNav';
+var _default = FeTopNav;
+exports.default = _default;

package/lib/fe-topnav/FeTopNavList.js

@@ -0,0 +1,401 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+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 _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 _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 FeTopNavList =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeTopNavList, _Component);
+
+  function FeTopNavList(props) {
+    var _this;
+
+    _classCallCheck(this, FeTopNavList);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FeTopNavList).call(this, props));
+    var currentPathname = document.location.pathname;
+
+    var _getActiveIndex = (0, _utils.getActiveIndex)(props.navList, currentPathname),
+        _getActiveIndex2 = _slicedToArray(_getActiveIndex, 3),
+        activeItemIndex = _getActiveIndex2[0],
+        activeSubItemIndex = _getActiveIndex2[1],
+        activeSubSubItemIndex = _getActiveIndex2[2];
+
+    _this.state = {
+      activeItemIndex: activeItemIndex >= 0 && "".concat(activeItemIndex),
+      activeSubItemIndex: activeSubItemIndex >= 0 && "".concat(activeSubItemIndex),
+      activeSubSubItemIndex: activeSubSubItemIndex >= 0 && "".concat(activeSubSubItemIndex),
+      activeRoute: currentPathname
+    };
+    _this.onButtonClick = _this.onButtonClick.bind(_assertThisInitialized(_this));
+    _this.onDropdownItemClick = _this.onDropdownItemClick.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(FeTopNavList, [{
+    key: "onButtonClick",
+    value: function onButtonClick(event) {
+      var itemIndex;
+      var attribute = event.currentTarget.attributes.getNamedItem('data-id');
+
+      if (attribute) {
+        itemIndex = attribute.value;
+      }
+
+      this.setState({
+        activeItemIndex: itemIndex,
+        activeSubItemIndex: null
+      });
+
+      if (this.props.navList[itemIndex] && this.props.navList[itemIndex]['onClick']) {
+        this.props.navList[itemIndex]['onClick']({
+          originalEvent: event,
+          itemIndex: itemIndex
+        });
+      }
+    }
+  }, {
+    key: "onDropdownItemClick",
+    value: function onDropdownItemClick(_ref) {
+      var originalEvent = _ref.originalEvent,
+          otherProps = _ref.otherProps,
+          itemIndex = _ref.itemIndex,
+          subItemIndex = _ref.subItemIndex,
+          hasSubItems = _ref.hasSubItems;
+
+      if (!hasSubItems) {
+        this.setState({
+          activeItemIndex: otherProps['data-id'],
+          activeSubItemIndex: itemIndex ? itemIndex : null,
+          activeSubSubItemIndex: subItemIndex ? subItemIndex : null
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      return _react.default.createElement("nav", {
+        className: "fe-top-nav__bar",
+        role: "menu"
+      }, _react.default.createElement("ul", {
+        className: "fe-top-nav__bar-nav"
+      }, this.props.navList.map(function (item, key) {
+        var active = _this2.state.activeItemIndex && parseInt(_this2.state.activeItemIndex) === key;
+        return _react.default.createElement("li", {
+          className: "fe-top-nav__bar-nav-items",
+          key: key
+        }, _react.default.createElement(NavButtonWrapper, _extends({
+          "data-id": key,
+          isNavLink: true,
+          size: "lg",
+          role: "menuitem"
+        }, item, {
+          active: active,
+          activeItemIndex: "".concat(_this2.state.activeSubItemIndex),
+          activeSubItemIndex: "".concat(_this2.state.activeSubSubItemIndex),
+          onButtonClick: _this2.onButtonClick,
+          onItemClick: _this2.onDropdownItemClick,
+          customRenderLink: _this2.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, 3),
+            activeItemIndex = _getActiveIndex4[0],
+            activeSubItemIndex = _getActiveIndex4[1],
+            activeSubSubItemIndex = _getActiveIndex4[2];
+
+        return {
+          activeItemIndex: activeItemIndex >= 0 && "".concat(activeItemIndex),
+          activeSubItemIndex: activeSubItemIndex >= 0 && "".concat(activeSubItemIndex),
+          activeSubSubItemIndex: activeSubSubItemIndex >= 0 && "".concat(activeSubSubItemIndex),
+          activeRoute: currentPathname
+        };
+      }
+
+      return null;
+    }
+  }]);
+
+  return FeTopNavList;
+}(_react.Component);
+
+var NavButtonWrapper = function NavButtonWrapper(_ref2) {
+  var list = _ref2.list,
+      active = _ref2.active,
+      activeItemIndex = _ref2.activeItemIndex,
+      activeSubItemIndex = _ref2.activeSubItemIndex,
+      onItemClick = _ref2.onItemClick,
+      customRenderLink = _ref2.customRenderLink,
+      onButtonClick = _ref2.onButtonClick,
+      itemProps = _objectWithoutProperties(_ref2, ["list", "active", "activeItemIndex", "activeSubItemIndex", "onItemClick", "customRenderLink", "onButtonClick"]);
+
+  if (list && list.length) {
+    return _react.default.createElement(_core.FeDropdown, _extends({
+      list: list
+    }, itemProps, {
+      buttonStyle: "link",
+      role: "menu",
+      feType: "menu",
+      activeItemIndex: active ? activeItemIndex : null,
+      activeSubItemIndex: active ? activeSubItemIndex : null,
+      onItemClick: onItemClick,
+      customRenderLink: customRenderLink
+    }));
+  } else {
+    var isNavLink = itemProps.isNavLink,
+        label = itemProps.label,
+        buttonProps = _objectWithoutProperties(itemProps, ["isNavLink", "label"]);
+
+    return _react.default.createElement(_core.FeButton, _extends({}, buttonProps, {
+      feStyle: "link",
+      role: "menuitem",
+      onClick: onButtonClick
+    }), label);
+  }
+};
+
+FeTopNavList.defaultProps = {
+  navList: [],
+  customRenderLink: null
+};
+FeTopNavList.propTypes = {
+  /** Provide top nav list*/
+  navList: _propTypes.default.arrayOf(_propTypes.default.object),
+
+  /** Provide item click handler for nav items*/
+  onItemClick: _propTypes.default.func,
+
+  /** A function that returns a react element to render the wrapping link.
+   *  Will receive url, className, and children props
+   */
+  customRenderLink: _propTypes.default.func
+};
+FeTopNavList.displayName = 'FeTopNavList';
+var _default = FeTopNavList;
+exports.default = _default;

package/lib/fe-topnav/index.js

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

package/lib/index.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  FeFilter: true,
+  FeFooter: true,
+  FeHero: true,
+  FeModal: true,
+  FeNotifications: true,
+  FePagination: true,
+  FePanel: true,
+  FeSideNav: true,
+  FeTable: true,
+  FeTopNav: true
+};
+Object.defineProperty(exports, "FeFilter", {
+  enumerable: true,
+  get: function get() {
+    return _feFilter.default;
+  }
+});
+Object.defineProperty(exports, "FeFooter", {
+  enumerable: true,
+  get: function get() {
+    return _feFooter.default;
+  }
+});
+Object.defineProperty(exports, "FeHero", {
+  enumerable: true,
+  get: function get() {
+    return _feHero.default;
+  }
+});
+Object.defineProperty(exports, "FeModal", {
+  enumerable: true,
+  get: function get() {
+    return _feModal.default;
+  }
+});
+Object.defineProperty(exports, "FeNotifications", {
+  enumerable: true,
+  get: function get() {
+    return _feNotifications.default;
+  }
+});
+Object.defineProperty(exports, "FePagination", {
+  enumerable: true,
+  get: function get() {
+    return _fePagination.default;
+  }
+});
+Object.defineProperty(exports, "FePanel", {
+  enumerable: true,
+  get: function get() {
+    return _fePanel.default;
+  }
+});
+Object.defineProperty(exports, "FeSideNav", {
+  enumerable: true,
+  get: function get() {
+    return _feSidenav.default;
+  }
+});
+Object.defineProperty(exports, "FeTable", {
+  enumerable: true,
+  get: function get() {
+    return _feTable.default;
+  }
+});
+Object.defineProperty(exports, "FeTopNav", {
+  enumerable: true,
+  get: function get() {
+    return _feTopnav.default;
+  }
+});
+
+var _core = require("./core");
+
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _core[key];
+    }
+  });
+});
+
+var _layout = require("./layout");
+
+Object.keys(_layout).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _layout[key];
+    }
+  });
+});
+
+var _feFilter = _interopRequireDefault(require("./fe-filter"));
+
+var _feFooter = _interopRequireDefault(require("./fe-footer"));
+
+var _feHero = _interopRequireDefault(require("./fe-hero"));
+
+var _feModal = _interopRequireDefault(require("./fe-modal"));
+
+var _feNotifications = _interopRequireDefault(require("./fe-notifications"));
+
+var _fePagination = _interopRequireDefault(require("./fe-pagination"));
+
+var _fePanel = _interopRequireDefault(require("./fe-panel"));
+
+var _feSidenav = _interopRequireDefault(require("./fe-sidenav"));
+
+var _feTable = _interopRequireDefault(require("./fe-table"));
+
+var _feTopnav = _interopRequireDefault(require("./fe-topnav"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}