fe-fabric-react 0.0.1-security → 2.864.3

package/lib/core/components/FeSearchField.js

@@ -0,0 +1,322 @@
+"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 _feFilter = _interopRequireDefault(require("../utils/fe-filter"));
+
+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 _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 FeSearchField =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeSearchField, _Component);
+
+  function FeSearchField(props) {
+    var _this;
+
+    _classCallCheck(this, FeSearchField);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FeSearchField).call(this, props));
+    _this.state = {
+      inputValue: ''
+    };
+    _this.onClearHandler = _this.onClearHandler.bind(_assertThisInitialized(_this));
+    _this.onChangeHandler = _this.onChangeHandler.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(FeSearchField, [{
+    key: "onChangeHandler",
+    value: function onChangeHandler(event) {
+      var inputValue = event.currentTarget.value;
+      this.setState({
+        inputValue: inputValue
+      });
+      var filteredList = this.filterList(inputValue, this.props.list);
+
+      if (this.props.onChange) {
+        this.props.onChange({
+          subStr: inputValue,
+          queryAt: this.props.queryAt,
+          list: filteredList
+        });
+      }
+    }
+  }, {
+    key: "filterList",
+    value: function filterList(subStr, list) {
+      var config = {
+        queryAt: this.props.queryAt,
+        isMultiLevel: this.props.isMultiLevel,
+        multiLevelKey: this.props.multiLevelKey,
+        isDeepSearch: this.props.isDeepSearch
+      };
+
+      var filteredList = _feFilter.default.filter(subStr, list, config);
+
+      return filteredList;
+    }
+  }, {
+    key: "onClearHandler",
+    value: function onClearHandler() {
+      this.clear();
+
+      if (this.props.onChange) {
+        this.props.onChange({
+          subStr: '',
+          queryAt: this.props.queryAt,
+          list: this.props.list
+        });
+      }
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.setState({
+        inputValue: ''
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      /** Minimum condition required to render*/
+
+      /** Rendering of component */
+
+
+      var className = (0, _classnames.default)('fe-search', {
+        'fe-search__background--light': this.props.feBackground === 'light'
+      }, this.props.className);
+      var leftSectionClassName = (0, _classnames.default)('fe-search__section--left', 'fe-search__icon--section');
+      var inputClassName = (0, _classnames.default)({
+        'filled': this.state.inputValue ? true : false
+      });
+      var rightSectionClassName = (0, _classnames.default)('fe-search__section--right', 'fe-search__icon--section');
+      var inputProps = Object.assign({}, this.props);
+      delete inputProps.iconSearch;
+      delete inputProps.iconClear;
+      delete inputProps.list;
+      delete inputProps.feBackground;
+      delete inputProps.queryAt;
+      delete inputProps.isMultiLevel;
+      delete inputProps.multiLevelKey;
+      delete inputProps.isDeepSearch;
+      delete inputProps.onChange;
+      delete inputProps.className;
+      return _react.default.createElement("div", {
+        className: className,
+        ref: function ref(node) {
+          return _this2.node = node;
+        }
+      }, _react.default.createElement("input", _extends({
+        "aria-label": "search input"
+      }, inputProps, {
+        type: "text",
+        value: this.state.inputValue,
+        className: inputClassName,
+        onChange: this.onChangeHandler,
+        required: true
+      })), _react.default.createElement("span", {
+        className: leftSectionClassName
+      }, _react.default.createElement(_FeIcon.default, {
+        family: "regular",
+        icon: "search"
+      })), _react.default.createElement("span", {
+        className: rightSectionClassName,
+        role: "button",
+        "aria-label": "clear",
+        onClick: this.onClearHandler
+      }, _react.default.createElement(_FeIcon.default, {
+        family: "regular",
+        icon: "times-circle"
+      })));
+    }
+  }]);
+
+  return FeSearchField;
+}(_react.Component);
+
+FeSearchField.defaultProps = {
+  feBackground: 'default',
+  onChange: null,
+  placeholder: 'Search',
+  list: [],
+  queryAt: 'label',
+  isMultiLevel: true,
+  multiLevelKey: 'list',
+  isDeepSearch: false,
+  disabled: false
+};
+FeSearchField.propTypes = {
+  /** Set to 'light' for dark theme  containers with light backgrounds */
+  feBackground: _propTypes.default.oneOf(['default', 'light']),
+
+  /** Function to trigger when input value changes */
+  onChange: _propTypes.default.func,
+
+  /** Provide icon placeholder for search field*/
+  placeholder: _propTypes.default.string,
+
+  /** Provide list[{`FeListItem` props}] for search field to search*/
+  list: _propTypes.default.array,
+
+  /** Provide key to apply search incase array of Object is passed*/
+  queryAt: _propTypes.default.string,
+
+  /** Set true/false incase to support multi-level search*/
+  isMultiLevel: _propTypes.default.bool,
+
+  /** Provide multi level search key*/
+  multiLevelKey: _propTypes.default.string,
+
+  /** Set true/false incase to support deep search*/
+  isDeepSearch: _propTypes.default.bool,
+
+  /** Set true/false to change search field disabled state*/
+  disabled: _propTypes.default.bool
+};
+FeSearchField.displayName = 'FeSearchField';
+var _default = FeSearchField;
+exports.default = _default;

package/lib/core/components/FeSelfContainedInput.js

@@ -0,0 +1,215 @@
+"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"));
+
+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 FeSelfContainedInput =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FeSelfContainedInput, _Component);
+
+  function FeSelfContainedInput() {
+    _classCallCheck(this, FeSelfContainedInput);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(FeSelfContainedInput).apply(this, arguments));
+  }
+
+  _createClass(FeSelfContainedInput, [{
+    key: "render",
+    value: function render() {
+      var _this = this;
+      /** Minimum condition required to render*/
+
+      /** Rendering of component */
+
+
+      var WrapperClassName = (0, _classnames.default)({
+        'fe-form__input-wrapper--has-icon': this.props.optionalComponent
+      }, this.props.className);
+      var className = (0, _classnames.default)('fe-input', {
+        'fe-input--light-bg': this.props.feBackground === 'light'
+      }, 'fe-input--self-contained');
+      var inputProps = Object.assign({}, this.props);
+      delete inputProps.isInline;
+      delete inputProps.feBackground;
+      delete inputProps.optionalComponent;
+      return _react.default.createElement("div", {
+        className: WrapperClassName
+      }, _react.default.createElement("input", _extends({
+        type: "text"
+      }, inputProps, {
+        className: className,
+        ref: function ref(node) {
+          return _this.input = node;
+        }
+      })), this.props.optionalComponent ? _react.default.createElement("div", {
+        className: "fe-input-icon"
+      }, this.props.optionalComponent) : null);
+    }
+  }]);
+
+  return FeSelfContainedInput;
+}(_react.Component);
+
+FeSelfContainedInput.defaultProps = {
+  feBackground: 'default',
+  placeholder: '',
+  optionalComponent: null,
+  disabled: false
+};
+FeSelfContainedInput.propTypes = {
+  /** Provide background for input */
+  feBackground: _propTypes.default.oneOf(['default', 'light']),
+
+  /** Provide placeholder for input */
+  placeholder: _propTypes.default.string,
+
+  /** Provide optional custom componentr*/
+  optionalComponent: _propTypes.default.element,
+
+  /** Set true/false to change button disabled state*/
+  disabled: _propTypes.default.bool
+};
+FeSelfContainedInput.displayName = 'FeSelfContainedInput';
+var _default = FeSelfContainedInput;
+exports.default = _default;

package/lib/core/components/FeTableCell.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+var FeTableCell = function FeTableCell(props) {
+  var className = (0, _classnames.default)('fe-table__cell', props.columnClass, props.className);
+  return _react.default.createElement("div", {
+    className: className,
+    role: "cell"
+  }, props.children);
+};
+
+var _default = FeTableCell;
+exports.default = _default;