fe-fabric-react 0.0.1-security → 2.864.3

package/lib/core/utils/fe-filter.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _isObject = _interopRequireDefault(require("lodash/isObject"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+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;
+}
+
+var FeFilter =
+/*#__PURE__*/
+function () {
+  function FeFilter() {
+    _classCallCheck(this, FeFilter);
+  }
+
+  _createClass(FeFilter, [{
+    key: "filter",
+    value: function filter(subStr, collection, config) {
+      var _subStr = this.getSubString(subStr, config.matchExact);
+
+      var _regx;
+
+      try {
+        if (config.matchExact) {
+          _regx = _subStr;
+        } else {
+          _regx = new RegExp(_subStr, 'gi');
+        }
+      } catch (err) {
+        return [];
+      }
+
+      var _collection = (0, _cloneDeep.default)(collection);
+
+      var _filteredList = this.apply(_regx, _collection, config);
+
+      return _filteredList;
+    }
+  }, {
+    key: "getSubString",
+    value: function getSubString(subStr, matchExact) {
+      var _length = subStr.length,
+          _subStr = subStr;
+
+      if (_length === 2 && _subStr[_length - 1] === '*') {
+        _subStr = _subStr.substring(0, 1);
+      } else if (_subStr[_length - 1] === '*') {
+        _subStr = _subStr.substring(0, _length - 1).replace(/\*/g, '.') + '*';
+      } else {
+        _subStr = _subStr.replace(/\*/g, '.');
+      }
+
+      return _subStr;
+    }
+  }, {
+    key: "apply",
+    value: function apply(regx, collection, config) {
+      var _this = this;
+
+      var _list = [];
+      collection.forEach(function (o) {
+        var _listItem;
+
+        _listItem = _this.match(regx, o, config);
+
+        if (_listItem) {
+          _list.push(_listItem);
+        }
+      });
+      return _list;
+    }
+  }, {
+    key: "match",
+    value: function match(regx, o, config) {
+      var _this2 = this;
+
+      var _matched = null;
+
+      if ((0, _isObject.default)(o)) {
+        if (config.queryAt) {
+          if (config.matchExact) {
+            _matched = o[config.queryAt] && o[config.queryAt] === regx;
+          } else {
+            _matched = o[config.queryAt] && o[config.queryAt].search(regx) > -1;
+          }
+        } else if (config.isDeepSearch) {
+          o.forEach(function (key, value) {
+            var i = _this2.match(regx, value, config);
+
+            _matched = _matched ? true : i !== null;
+          });
+        } else {
+          _matched = null;
+        }
+      } else if (Array.isArray(o)) {
+        return this.apply(regx, o, config);
+      } else {
+        if (config.matchExact) {
+          _matched = o && o === regx;
+        } else {
+          _matched = o.search(regx) > -1;
+        }
+      }
+
+      if (_matched) {
+        return o;
+      } else if (!_matched && config.isMultiLevel && config.multiLevelKey && o[config.multiLevelKey]) {
+        var _matchedList = [];
+        _matchedList = this.apply(regx, o[config.multiLevelKey], config);
+
+        if (_matchedList.length) {
+          o[config.multiLevelKey] = _matchedList;
+          return o;
+        }
+      }
+
+      return null;
+    }
+  }]);
+
+  return FeFilter;
+}();
+
+var _default = new FeFilter();
+
+exports.default = _default;

package/lib/core/utils/helper.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stopPropagation = stopPropagation;
+
+function stopPropagation(event) {
+  event.nativeEvent.stopPropagation();
+  event.nativeEvent.stopImmediatePropagation();
+}

package/lib/core/utils/index.js

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEmpty = isEmpty;
+exports.isEqual = isEqual;
+exports.find = find;
+exports.findIndex = findIndex;
+exports.findLastIndex = findLastIndex;
+exports.getActiveIndex = getActiveIndex;
+exports.getFocusableElements = getFocusableElements;
+exports.trapFocus = trapFocus;
+exports.textHighlight = textHighlight;
+exports.truncateString = truncateString;
+
+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);
+}
+
+var isEqualArray = function isEqualArray(arr1, arr2) {
+  var length = arr1.length;
+
+  if (length !== arr2.length) {
+    return false;
+  }
+
+  for (var i = 0; i < length; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+var isEqualObject = function isEqualObject(obj1, obj2) {
+  var keys = Object.keys(obj1),
+      length = keys.length;
+
+  if (length !== Object.keys(obj2).length) {
+    return false;
+  }
+
+  for (var i = 0; i < length; i++) {
+    if (obj1[keys[i]] !== obj2[keys[i]]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+var includeObject = function includeObject(obj1, obj2) {
+  var keys = Object.keys(obj2),
+      length = keys.length;
+
+  for (var i = 0; i < length; i++) {
+    if (obj1[keys[i]] !== obj2[keys[i]]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+var flattenDeep = function flattenDeep(arr) {
+  var flattened = Array.isArray(arr) ? arr.reduce(function (a, b) {
+    return a.concat(flattenDeep(b));
+  }, []) : [arr];
+  return flattened.filter(function (item) {
+    return item !== null;
+  });
+};
+
+var withHash = function withHash(item, route) {
+  if (item.isHashRoute === true) return route + document.location.hash;
+  return route;
+};
+
+var findRouteIndex = function findRouteIndex(list, route) {
+  var indexes = [];
+
+  for (var i = 0; i < list.length; i++) {
+    indexes = [];
+    var item = list[i];
+    var currentRoute = withHash(item, route);
+
+    if (item.route === currentRoute || item.href === currentRoute) {
+      indexes.push(i);
+      break;
+    } else if (item.list) {
+      var index = findRouteIndex(item.list, route);
+
+      if (index !== null) {
+        indexes.push(i, index);
+        break;
+      }
+    }
+  }
+
+  return indexes.length ? indexes : null;
+};
+
+function isEmpty(obj) {
+  return obj ? [Object, Array].includes(obj.constructor) && !Object.entries(obj).length : true;
+}
+
+function isEqual(value1, value2) {
+  if (Array.isArray(value1) && Array.isArray(value2)) {
+    return isEqualArray(value1, value2);
+  } else if (_typeof(value1) === 'object' && _typeof(value2) === 'object') {
+    return isEqualObject(value1, value2);
+  } else {
+    return value1 === value2;
+  }
+}
+
+function find(list, comparator) {
+  if (!Array.isArray(list)) {
+    return undefined;
+  }
+
+  if (Array.isArray(comparator)) {
+    return list.find(function (item) {
+      return Array.isArray(item) && isEqualArray(item, comparator);
+    });
+  } else if (_typeof(comparator) === 'object') {
+    return list.find(function (item) {
+      return _typeof(item) === 'object' && includeObject(item, comparator);
+    });
+  } else if (typeof comparator === 'function') {
+    return list.find(comparator);
+  } else {
+    return undefined;
+  }
+}
+
+function findIndex(list, comparator) {
+  if (!Array.isArray(list) || comparator === undefined) {
+    return undefined;
+  }
+
+  if (Array.isArray(comparator)) {
+    return list.findIndex(function (item) {
+      return Array.isArray(item) && isEqualArray(item, comparator);
+    });
+  } else if (_typeof(comparator) === 'object') {
+    return list.findIndex(function (item) {
+      return _typeof(item) === 'object' && includeObject(item, comparator);
+    });
+  } else if (typeof comparator === 'function') {
+    return list.findIndex(comparator);
+  } else {
+    return -1;
+  }
+}
+
+function findLastIndex(list, filterFunction) {
+  if (!Array.isArray(list) || filterFunction === undefined) {
+    return undefined;
+  }
+
+  var reversed = [];
+  list.forEach(function (item) {
+    return reversed.unshift(item);
+  });
+  var index = reversed.findIndex(filterFunction);
+
+  if (index === -1) {
+    return index;
+  } else {
+    return list.length - 1 - index;
+  }
+}
+
+function getActiveIndex(list, pathname) {
+  return flattenDeep(findRouteIndex(list, pathname));
+}
+
+function getFocusableElements(parent, includeAll) {
+  var selector = 'button:not([disabled]), [href], input:not([disabled]), select:not([disabled]), textarea:not([disabled])';
+
+  if (includeAll) {
+    selector += ', [tabindex]:not([disabled])';
+  } else {
+    selector += ', [tabindex]:not([tabindex="-1"  ]):not([disabled])';
+  }
+
+  if (parent) {
+    return parent.querySelectorAll(selector);
+  } else {
+    return document.querySelectorAll(selector);
+  }
+}
+
+function trapFocus(event, node, includeAll) {
+  var focusableElements = getFocusableElements(node, includeAll);
+  var length = focusableElements.length;
+
+  if (!length) {
+    return;
+  }
+
+  var elements = Object.assign([], focusableElements);
+  var index = elements.findIndex(function (el) {
+    return document.activeElement === el;
+  });
+
+  if (index < 0) {
+    focusableElements[0].focus();
+    event.preventDefault();
+  } else if (event.shiftKey && event.keyCode === 9 || event.keyCode === 38) {
+    //Shift+Tab || ArrowUp
+    index === 0 ? focusableElements[length - 1].focus() : focusableElements[index - 1].focus();
+    event.preventDefault();
+  } else if (event.keyCode === 9 || event.keyCode === 40) {
+    //Tab || ArrowDown
+    index === length - 1 ? focusableElements[0].focus() : focusableElements[index + 1].focus();
+    event.preventDefault();
+  }
+}
+
+function textHighlight(queryString, text) {
+  var regx;
+
+  try {
+    regx = new RegExp(queryString, 'ig');
+  } catch (error) {
+    regx = queryString;
+  }
+
+  var highlightedText = text.replace(regx, function (str) {
+    return "<strong>".concat(str, "</strong>");
+  });
+  return highlightedText;
+}
+
+function truncateString(_string, _max_char_limit, _atCenter) {
+  var truncatedString = _string,
+      leftLimit = 0,
+      rightLimit = 0,
+      truncChar = ' ... ';
+
+  if (_string && _max_char_limit > 0) {
+    if (_max_char_limit < _string.length) {
+      if (!_atCenter) {
+        truncatedString = _string.substr(0, _max_char_limit - 1) + truncChar;
+      } else {
+        leftLimit = Math.round((_max_char_limit - 1) / 2);
+        rightLimit = _max_char_limit - 1 - leftLimit;
+        truncatedString = _string.substr(0, leftLimit) + truncChar + _string.slice(-rightLimit);
+      }
+    }
+  }
+
+  return truncatedString;
+}

package/lib/customPropTypes.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectOptionPropType = exports.iconPropType = exports.tagPropType = exports.stringOrNumber = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+var stringOrNumber = _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]);
+
+exports.stringOrNumber = stringOrNumber;
+
+var tagPropType = _propTypes.default.oneOfType([
+/* Function that returns a component to render */
+_propTypes.default.func,
+/* Name of a tag to render */
+_propTypes.default.string,
+/* render prop */
+_propTypes.default.shape({
+  $$typeof: _propTypes.default.symbol,
+  render: _propTypes.default.func
+})]);
+
+exports.tagPropType = tagPropType;
+
+var iconPropType = _propTypes.default.shape({
+  /** Font Awesome icon name (omit fa-) */
+  name: _propTypes.default.string.isRequired,
+
+  /** Icon family: regular, solid, light, or brand (regular is default) */
+  family: _propTypes.default.oneOf(['regular', 'solid', 'light', 'brand'])
+});
+
+exports.iconPropType = iconPropType;
+
+var selectOptionPropType = _propTypes.default.exact({
+  /* text for a select option, what is visible to the user */
+  text: _propTypes.default.string.isRequired,
+
+  /* value of the select box, can be a string or a number */
+  value: stringOrNumber.isRequired
+});
+
+exports.selectOptionPropType = selectOptionPropType;