fe-fabric-react 0.0.1-security → 2.864.3

package/lib/core/components/FeBreadcrumb.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _FeButton = _interopRequireDefault(require("./FeButton"));
+
+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 FeBreadcrumb =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeBreadcrumb, _Component);
+
+  function FeBreadcrumb() {
+    _classCallCheck(this, FeBreadcrumb);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(FeBreadcrumb).apply(this, arguments));
+  }
+
+  _createClass(FeBreadcrumb, [{
+    key: "render",
+    value: function render() {
+      var _this = this;
+      /** Minimum condition required to render*/
+
+
+      if (!this.props.breadcrumbList.length) {
+        return null;
+      }
+
+      var customProps = Object.assign({}, this.props);
+      delete customProps.breadcrumbList;
+      return _react.default.createElement("nav", _extends({
+        "aria-label": "breadcrumb"
+      }, customProps), _react.default.createElement("ol", {
+        className: "fe-breadcrumb"
+      }, this.props.breadcrumbList.map(function (item, i) {
+        return _react.default.createElement(BreadcrumbItem, _extends({
+          key: i
+        }, item, {
+          active: i === _this.props.breadcrumbList.length - 1
+        }));
+      })));
+    }
+  }]);
+
+  return FeBreadcrumb;
+}(_react.Component);
+
+var BreadcrumbItem = function BreadcrumbItem(props) {
+  return _react.default.createElement("li", {
+    className: "fe-breadcrumb__item"
+  }, _react.default.createElement(_FeButton.default, _extends({}, props, {
+    feStyle: "link",
+    size: "md"
+  }), props.label));
+};
+
+FeBreadcrumb.defaultProps = {
+  breadcrumbList: []
+};
+FeBreadcrumb.propTypes = {
+  /** Provide link items*/
+  breadcrumbList: _propTypes.default.arrayOf(_propTypes.default.object)
+};
+FeBreadcrumb.displayName = 'FeBreadcrumb';
+var _default = FeBreadcrumb;
+exports.default = _default;

package/lib/core/components/FeButton.js

@@ -0,0 +1,185 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.renderIcon = 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 _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;
+}
+
+var renderIcon = function renderIcon(_ref) {
+  var icon = _ref.icon,
+      iconFamily = _ref.iconFamily,
+      iconPosition = _ref.iconPosition,
+      children = _ref.children;
+  var positionClass = iconPosition ? "fe-icon--".concat(iconPosition) : undefined;
+
+  var feIcon = _react.default.createElement(_FeIcon.default, {
+    key: "icon",
+    family: iconFamily,
+    icon: icon,
+    className: positionClass
+  });
+
+  var output = [feIcon, _react.default.createElement(_react.Fragment, {
+    key: "children"
+  }, children)];
+  if (iconPosition === 'right') output = [_react.default.createElement(_react.Fragment, {
+    key: "children"
+  }, children), feIcon];
+  return output;
+};
+
+exports.renderIcon = renderIcon;
+
+var FeButton = function FeButton(props) {
+  var active = props.active,
+      background = props.background,
+      children = props.children,
+      className = props.className,
+      disabled = props.disabled,
+      icon = props.icon,
+      iconFamily = props.iconFamily,
+      iconPosition = props.iconPosition,
+      size = props.size,
+      feStyle = props.feStyle,
+      buttonProps = _objectWithoutProperties(props, ["active", "background", "children", "className", "disabled", "icon", "iconFamily", "iconPosition", "size", "feStyle"]);
+
+  var buttonClass = (0, _classnames.default)('fe-btn', "fe-btn--".concat(feStyle), "fe-btn--".concat(size), {
+    'fe-btn--link-light': feStyle === 'link-secondary' && background === 'light',
+    active: active,
+    disabled: disabled
+  }, className);
+  return _react.default.createElement("button", _extends({
+    type: "button"
+  }, buttonProps, {
+    className: buttonClass,
+    disabled: disabled
+  }), icon ? renderIcon(props) : children);
+};
+
+FeButton.defaultProps = {
+  active: false,
+  background: 'default',
+  disabled: false,
+  size: 'md',
+  feStyle: 'primary'
+};
+FeButton.propTypes = {
+  /** Set true/false to change button active state*/
+  active: _propTypes.default.bool,
+
+  /** Button style, either regular or danger. Default is regular */
+  background: _propTypes.default.oneOf(['default', 'light']),
+
+  /** Set true/false to change button disabled state*/
+  disabled: _propTypes.default.bool,
+
+  /** If an icon is needed in the button add a font awesome icon name here*/
+  icon: _propTypes.default.string,
+
+  /** The icon family for the button icon. Can be regular, solid, light, or brand */
+  iconFamily: _propTypes.default.oneOf(['regular', 'solid', 'light', 'brand']),
+
+  /** Position of the optional icon. Use 'only' if there's no text with an icon*/
+  iconPosition: _propTypes.default.oneOf(['left', 'right']),
+
+  /** Button size 'xs', 'sm', 'md', or 'lg'. Default is medium */
+  size: _propTypes.default.oneOf(['xs', 'sm', 'md', 'lg']),
+
+  /** The button style primary, link, secondary-danger,etc. Default is primary */
+  feStyle: _propTypes.default.oneOf(['primary', 'primary-danger', 'secondary', 'secondary-danger', 'link', 'link-secondary', 'link-danger'])
+};
+var _default = FeButton;
+exports.default = _default;

package/lib/core/components/FeCheckbox.js

@@ -0,0 +1,91 @@
+"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"));
+
+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 FeCheckbox = function FeCheckbox(props) {
+  /** Minimum condition required to render*/
+  if (!(props.name && props.value)) {
+    return null;
+  }
+  /** Rendering of component */
+
+
+  var wrapperClass = (0, _classnames.default)('fe-checkbox', {
+    'fe-checkbox--inline': props.isInline
+  }, props.className);
+  var id = props.id || "".concat(props.name, "-").concat(props.value);
+  var checkboxProps = Object.assign({}, props);
+  delete checkboxProps.label;
+  delete checkboxProps.isInline;
+  delete checkboxProps.className;
+  return _react.default.createElement("div", {
+    className: wrapperClass
+  }, _react.default.createElement("label", {
+    className: "fe-checkbox__label",
+    htmlFor: id
+  }, _react.default.createElement("input", _extends({}, checkboxProps, {
+    id: id,
+    type: "checkbox",
+    className: "fe-checkbox__input"
+  })), _react.default.createElement("span", {
+    className: "fe-checkbox__checkbox"
+  }, props.label && _react.default.createElement("span", {
+    className: "fe-checkbox__text"
+  }, props.label))));
+};
+
+FeCheckbox.defaultProps = {
+  name: null,
+  value: null,
+  label: null,
+  isInline: false
+};
+FeCheckbox.propTypes = {
+  /** Provide group name for checkbox*/
+  name: _propTypes.default.string.isRequired,
+
+  /** Provide value for checkbox*/
+  value: _propTypes.default.string.isRequired,
+
+  /** Provide lable for checkbox*/
+  label: _propTypes.default.string,
+
+  /** Set true/false to change radio item alignment*/
+  isInline: _propTypes.default.bool
+};
+FeCheckbox.displayName = 'FeCheckbox';
+var _default = FeCheckbox;
+exports.default = _default;

package/lib/core/components/FeCogButton.js

@@ -0,0 +1,204 @@
+"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 _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 FeCogButton =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeCogButton, _Component);
+
+  function FeCogButton() {
+    _classCallCheck(this, FeCogButton);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(FeCogButton).apply(this, arguments));
+  }
+
+  _createClass(FeCogButton, [{
+    key: "render",
+    value: function render() {
+      /** Minimum condition required to render*/
+
+      /** Rendering of component */
+      var className = (0, _classnames.default)('fe-cog', {
+        'active': this.props.active,
+        'disabled': this.props.disabled
+      }, this.props.className);
+      var buttonProps = Object.assign({}, this.props);
+      delete buttonProps.icon;
+      delete buttonProps.active;
+      delete buttonProps.className;
+      return _react.default.createElement("button", _extends({
+        type: "button"
+      }, buttonProps, {
+        className: className
+      }), _react.default.createElement(_FeIcon.default, {
+        family: "solid",
+        icon: "cog"
+      }));
+    }
+  }]);
+
+  return FeCogButton;
+}(_react.Component);
+
+FeCogButton.defaultProps = {
+  icon: 'fas fa-cog',
+  active: false,
+  disabled: false
+};
+FeCogButton.propTypes = {
+  /** Provide icon class */
+  icon: _propTypes.default.string,
+
+  /** Set true/false to change button active state*/
+  active: _propTypes.default.bool,
+
+  /** Set true/false to change button disabled state*/
+  disabled: _propTypes.default.bool
+};
+FeCogButton.displayName = 'FeCogButton';
+var _default = FeCogButton;
+exports.default = _default;