fe-fabric-react 0.0.1-security → 2.864.3

package/lib/core/components/FeFormGroup.js

@@ -0,0 +1,245 @@
+"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 _FeRadioButton = _interopRequireDefault(require("./FeRadioButton"));
+
+var _FeSelfContainedInput = _interopRequireDefault(require("./FeSelfContainedInput"));
+
+var _FeInputField = _interopRequireDefault(require("./FeInputField"));
+
+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 _TYPE = {
+  'radio': _FeRadioButton.default,
+  'selfContainedInput': _FeSelfContainedInput.default,
+  'inputField': _FeInputField.default
+};
+
+var FeFormGroup =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeFormGroup, _Component);
+
+  function FeFormGroup() {
+    _classCallCheck(this, FeFormGroup);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(FeFormGroup).apply(this, arguments));
+  }
+
+  _createClass(FeFormGroup, [{
+    key: "getLegend",
+    value: function getLegend() {
+      return _react.default.createElement("legend", {
+        className: "fe-form__fieldset-legend"
+      }, this.props.label);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this = this;
+      /** Minimum condition required to render*/
+
+
+      if (!this.props.feType && this.props.list.length === 0) {
+        return null;
+      }
+      /** Rendering of component */
+
+
+      var className = (0, _classnames.default)('fe-form__fieldset', this.props.className);
+      var legend = this.props.label && this.getLegend();
+      var fieldsetProps = Object.assign({}, this.props);
+      delete fieldsetProps.label;
+      delete fieldsetProps.list;
+      delete fieldsetProps.className;
+      return _react.default.createElement("fieldset", {
+        className: className
+      }, legend, this.props.list.map(function (item, key) {
+        var wrapperClass = (0, _classnames.default)('fe-form__input-wrapper', {
+          'fe-form__input-wrapper--inline': _this.props.isInline
+        }, item.className);
+        return _react.default.createElement(FormType, _extends({
+          key: key
+        }, fieldsetProps, item, {
+          className: wrapperClass
+        }));
+      }));
+    }
+  }]);
+
+  return FeFormGroup;
+}(_react.Component);
+
+var FormType = function FormType(props) {
+  if (!_TYPE[props.feType]) {
+    return null;
+  }
+
+  var FormTypeComponent = _TYPE[props.feType];
+  var componentProps = Object.assign({}, props);
+  delete componentProps.feType;
+  return _react.default.createElement(FormTypeComponent, componentProps);
+};
+
+FeFormGroup.defaultProps = {
+  label: null,
+  list: [],
+  feType: null,
+  isInline: false
+};
+FeFormGroup.propTypes = {
+  /** Provide label for forrm group*/
+  label: _propTypes.default.string,
+
+  /** Provide list of group items*/
+  list: _propTypes.default.arrayOf(_propTypes.default.object).isRequired,
+
+  /** Provide component type for list item like 'radio' or 'checkbox'*/
+  feType: _propTypes.default.oneOf(['radio', 'selfContainedInput', 'inputField']).isRequired,
+
+  /** Set true/false to change group item alignment*/
+  isInline: _propTypes.default.bool
+};
+FeFormGroup.displayName = 'FeFormGroup';
+var _default = FeFormGroup;
+exports.default = _default;

package/lib/core/components/FeIcon.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _FontAwesomeContext = _interopRequireDefault(require("../FontAwesomeContext"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+var FeIcon = function FeIcon(_ref) {
+  var icon = _ref.icon,
+      family = _ref.family,
+      spin = _ref.spin,
+      className = _ref.className;
+  return _react.default.createElement(_FontAwesomeContext.default.Consumer, null, function (_ref2) {
+    var Icon = _ref2.Icon;
+    return _react.default.createElement(Icon, {
+      icon: icon,
+      family: family,
+      spin: spin,
+      className: className
+    });
+  });
+};
+
+FeIcon.defaultProps = {
+  family: 'regular',
+  spin: false
+};
+FeIcon.propTypes = {
+  /** The icon name */
+  icon: _propTypes.default.string.isRequired,
+
+  /** The Icon family. Can be regular, solid, light, or brand */
+  family: _propTypes.default.oneOf(['regular', 'solid', 'light', 'brand']),
+
+  /** Whether or not the icon should spin */
+  spin: _propTypes.default.bool
+};
+FeIcon.displayName = 'FeIcon';
+var _default = FeIcon;
+exports.default = _default;

package/lib/core/components/FeIconStack.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _FontAwesomeContext = _interopRequireDefault(require("../FontAwesomeContext"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+var FeIconStack = function FeIconStack(props) {
+  return _react.default.createElement(_FontAwesomeContext.default.Consumer, null, function (_ref) {
+    var Stack = _ref.Stack;
+    return _react.default.createElement(Stack, props);
+  });
+};
+
+var _default = FeIconStack;
+exports.default = _default;