@zohodesk/utils 1.3.15 → 1.3.17

package/lib/createTemplateLiteral.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = createTemplateLiteral;
+
+function createTemplateLiteral(templateStrings) {
+  for (var _len = arguments.length, expressionKeys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    expressionKeys[_key - 1] = arguments[_key];
+  }
+
+  return function () {
+    for (var _len2 = arguments.length, expressionValues = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      expressionValues[_key2] = arguments[_key2];
+    }
+
+    var resultString = [templateStrings[0]];
+    expressionKeys.forEach(function (expressionKey, i) {
+      var expressionValue = expressionValues[i];
+      var nextTemplateString = templateStrings[i + 1];
+
+      if (expressionValue === null || expressionValue === undefined || expressionValue === "") {
+        nextTemplateString = nextTemplateString.replace(/^_/, '');
+      }
+
+      resultString.push(expressionValue, nextTemplateString);
+    });
+    var resultStr = resultString.join('');
+    resultStr = resultStr.replace(/_$/, '');
+    return resultStr;
+  };
+}
+/* refer the doc https://developers.google.com/web/updates/2015/01/ES6-Template-Strings
+
+UnderSatnd the terms - String interpolation, Embedded expressions
+
+Go through the topic https://developers.google.com/web/updates/2015/01/ES6-Template-Strings#tagged_templates
+
+Things to note fn`Hello ${you}! You're looking ${adjective} today!` desugars to fn(["Hello ", "! You're looking ", " today!"], you, adjective);
+
+Please go through the example code
+
+Our implementation constructCustomMessage is the handler for the tagged template function. 
+It receives the static words and its substitutions as seen above as the arguments.
+
+It returns a function that receives the values for the substitutions. Upon passing the values for the inner function
+it executes the algorithm as mentioned in the doc to construct the final message.
+"The (n + 1)th argument corresponds to the substitution that takes place between the nth and (n + 1)th entries in the string array"
+
+
+function constructCustomMessage(staticWordsList, ...embeddedExpressionKeyList)
+{
+    return (...valuesForEmbeddedExpressionList)=>{
+
+        let finalMessage = staticWordsList[0];
+        embeddedExpressionKeyList.forEach(function(expressionKey, index) {
+            let expressionValue = valuesForEmbeddedExpressionList[index];
+            let nextStaticWord = staticWordsList[index+1];
+            if(expressionValue===null || expressionValue === undefined || expressionValue === ""){
+               // Replace the underscore '_' present at the beginning of string with empty value.  
+                    nextStaticWord = nextStaticWord.replace(/^_/, '');
+            }
+             finalMessage += expressionValue + nextStaticWord;
+
+        });
+          // Replace the underscore '_' present at the end of string with empty value.  
+         finalMessage = finalMessage.replace(/_$/,'');
+        return finalMessage ;
+    };
+
+}
+*/
+
+/*
+Sample Invocation Format
+
+var username;
+var tag;
+var handlerFunctiontoFormMessage = constructCustomMessage`<b>${username} says</b>: "${tag}"`;
+var outputString = handlerFunctiontoFormMessage('Mani Venkat', '& is a fun tag');
+console.log(outputString);
+
+*/

package/lib/crud/ArrayManager.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _arrayCRUD = require("./arrayCRUD");
+
+var _constant = require("../constantProps/constant");
+
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+var ArrayManager = /*#__PURE__*/function () {
+  function ArrayManager() {
+    var initialArray = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constant.DUMMY_ARRAY;
+
+    _classCallCheck(this, ArrayManager);
+
+    this.array = initialArray;
+  }
+
+  _createClass(ArrayManager, [{
+    key: "addValue",
+    value: function addValue(item) {
+      this.array = (0, _arrayCRUD.appendToArray)({
+        array: this.array,
+        item: item
+      });
+      return this.array;
+    }
+  }, {
+    key: "removeValueById",
+    value: function removeValueById(id) {
+      this.array = (0, _arrayCRUD.deleteFromArrayOfObjectById)({
+        arrayOfObject: this.array,
+        id: id
+      });
+      return this.array;
+    }
+  }, {
+    key: "removeValueByItem",
+    value: function removeValueByItem(item) {
+      this.array = (0, _arrayCRUD.deleteFromArrayByItem)({
+        array: this.array,
+        item: item
+      });
+      return this.array;
+    }
+  }, {
+    key: "clearValue",
+    value: function clearValue() {
+      this.array = (0, _arrayCRUD.emptyArray)();
+      return this.array;
+    }
+  }, {
+    key: "updateValueById",
+    value: function updateValueById(id, newItem) {
+      this.array = (0, _arrayCRUD.updateArrayOfObjectItemById)({
+        arrayOfObject: this.array,
+        id: id,
+        newItem: newItem
+      });
+      return this.array;
+    }
+  }, {
+    key: "updateValueByItem",
+    value: function updateValueByItem(currentItem, newItem) {
+      this.array = (0, _arrayCRUD.updateArrayItemByItem)({
+        array: this.array,
+        currentItem: currentItem,
+        newItem: newItem
+      });
+      return this.array;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue() {
+      return this.array;
+    }
+  }]);
+
+  return ArrayManager;
+}();
+
+var _default = ArrayManager;
+exports["default"] = _default;

package/lib/crud/ObjectManager.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _objectCRUD = require("./objectCRUD");
+
+var _constant = require("../constantProps/constant");
+
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+var ObjectManager = /*#__PURE__*/function () {
+  function ObjectManager() {
+    var initialObject = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constant.DUMMY_OBJECT;
+
+    _classCallCheck(this, ObjectManager);
+
+    this.object = initialObject;
+  }
+
+  _createClass(ObjectManager, [{
+    key: "setValue",
+    value: function setValue(newObject) {
+      this.object = (0, _objectCRUD.mergeObjects)({
+        object: this.object,
+        newObject: newObject
+      });
+      return this.object;
+    }
+  }, {
+    key: "clearValue",
+    value: function clearValue() {
+      this.object = (0, _objectCRUD.emptyObject)();
+      return this.object;
+    }
+  }, {
+    key: "updateValueByKey",
+    value: function updateValueByKey(key, value) {
+      this.object = (0, _objectCRUD.updateObjectValueByKey)({
+        object: this.object,
+        key: key,
+        value: value
+      });
+      return this.object;
+    }
+  }, {
+    key: "removeValueByKeys",
+    value: function removeValueByKeys(keys) {
+      this.object = (0, _objectCRUD.removeObjectByKeys)({
+        object: this.object,
+        keys: keys
+      });
+      return this.object;
+    }
+  }, {
+    key: "removeValueByKey",
+    value: function removeValueByKey(key) {
+      this.object = (0, _objectCRUD.removeObjectByKey)({
+        object: this.object,
+        key: key
+      });
+      return this.object;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue() {
+      return this.object;
+    }
+  }]);
+
+  return ObjectManager;
+}();
+
+var _default = ObjectManager;
+exports["default"] = _default;

package/lib/crud/arrayCRUD.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateArrayOfObjectItemById = exports.updateArrayItemByItem = exports.emptyArray = exports.deleteFromArrayOfObjectById = exports.deleteFromArrayByItem = exports.appendToArray = void 0;
+
+var _constant = require("../constantProps/constant");
+
+var _deepEqual = require("../deepEqual");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var appendToArray = function appendToArray(_ref) {
+  var array = _ref.array,
+      item = _ref.item;
+  return [].concat(_toConsumableArray(array), [item]);
+};
+
+exports.appendToArray = appendToArray;
+
+var updateArrayOfObjectItemById = function updateArrayOfObjectItemById(_ref2) {
+  var arrayOfObject = _ref2.arrayOfObject,
+      id = _ref2.id,
+      newItem = _ref2.newItem;
+  var found = false;
+  return arrayOfObject.map(function (object) {
+    if (!found && id !== undefined && object.id === id) {
+      found = true;
+      return Array.isArray(newItem) ? _toConsumableArray(newItem) : _typeof(newItem) === 'object' ? _objectSpread(_objectSpread({}, object), newItem) : newItem;
+    }
+
+    return object;
+  });
+};
+
+exports.updateArrayOfObjectItemById = updateArrayOfObjectItemById;
+
+var updateArrayItemByItem = function updateArrayItemByItem(_ref3) {
+  var array = _ref3.array,
+      currentItem = _ref3.currentItem,
+      newItem = _ref3.newItem;
+  var found = false;
+  return array.map(function (arrayItem) {
+    if (!found && currentItem !== undefined && (0, _deepEqual.deepEqual)(arrayItem, currentItem)) {
+      found = true;
+      return newItem;
+    }
+
+    return arrayItem;
+  });
+};
+
+exports.updateArrayItemByItem = updateArrayItemByItem;
+
+var deleteFromArrayOfObjectById = function deleteFromArrayOfObjectById(_ref4) {
+  var arrayOfObject = _ref4.arrayOfObject,
+      id = _ref4.id;
+  var found = false;
+  return arrayOfObject.filter(function (object) {
+    if (!found && id !== undefined && object.id === id) {
+      found = true;
+      return false;
+    }
+
+    return true;
+  });
+};
+
+exports.deleteFromArrayOfObjectById = deleteFromArrayOfObjectById;
+
+var deleteFromArrayByItem = function deleteFromArrayByItem(_ref5) {
+  var array = _ref5.array,
+      currentItem = _ref5.currentItem;
+  var found = false;
+  return array.filter(function (arrayItem) {
+    if (!found && currentItem !== undefined && (0, _deepEqual.deepEqual)(arrayItem, currentItem)) {
+      found = true;
+      return false;
+    }
+
+    return true;
+  });
+};
+
+exports.deleteFromArrayByItem = deleteFromArrayByItem;
+
+var emptyArray = function emptyArray() {
+  return _constant.DUMMY_ARRAY;
+};
+
+exports.emptyArray = emptyArray;

package/lib/crud/objectCRUD.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateObjectValueByKey = exports.removeObjectByKeys = exports.removeObjectByKey = exports.mergeObjects = exports.emptyObject = void 0;
+
+var _constant = require("../constantProps/constant");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var mergeObjects = function mergeObjects(_ref) {
+  var object = _ref.object,
+      newObject = _ref.newObject;
+  return _objectSpread(_objectSpread({}, object), newObject);
+};
+
+exports.mergeObjects = mergeObjects;
+
+var emptyObject = function emptyObject() {
+  return _constant.DUMMY_OBJECT;
+};
+
+exports.emptyObject = emptyObject;
+
+var updateObjectValueByKey = function updateObjectValueByKey(_ref2) {
+  var object = _ref2.object,
+      key = _ref2.key,
+      value = _ref2.value;
+  return _objectSpread(_objectSpread({}, object), {}, _defineProperty({}, key, value));
+};
+
+exports.updateObjectValueByKey = updateObjectValueByKey;
+
+var removeObjectByKeys = function removeObjectByKeys(_ref3) {
+  var object = _ref3.object,
+      keys = _ref3.keys;
+
+  var newObject = _objectSpread({}, object);
+
+  if (Array.isArray(keys)) {
+    keys.forEach(function (key) {
+      delete newObject[key];
+    });
+  }
+
+  return newObject;
+};
+
+exports.removeObjectByKeys = removeObjectByKeys;
+
+var removeObjectByKey = function removeObjectByKey(_ref4) {
+  var object = _ref4.object,
+      key = _ref4.key;
+
+  var newObject = _objectSpread({}, object);
+
+  delete newObject[key];
+  return newObject;
+};
+
+exports.removeObjectByKey = removeObjectByKey;

package/lib/dataTypes.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDataTypeOf = exports.getDataType = exports["default"] = void 0;
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+var dataTypes = {
+  "number": "number",
+  "array": "array",
+  "string": "string",
+  "object": "object",
+  "bigint": "bigint",
+  "symbol": "symbol",
+  "undefined": "undefined",
+  "function": "function",
+  "boolean": "boolean"
+};
+
+var getDataType = function getDataType(data) {
+  var typeofData = _typeof(data);
+
+  var isArrayDataType = Array.isArray(data);
+
+  if (isArrayDataType) {
+    return dataTypes.array;
+  } else {
+    return dataTypes[typeofData];
+  }
+};
+
+exports.getDataType = getDataType;
+
+var isDataTypeOf = function isDataTypeOf(data, type) {
+  return getDataType(data) === type;
+};
+
+exports.isDataTypeOf = isDataTypeOf;
+var _default = dataTypes;
+exports["default"] = _default;

package/lib/debounce.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = debounce;
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function debounce(fn, delay) {
+  var handle = null;
+  return function () {
+    var _arguments = arguments;
+
+    if (handle) {
+      handle = clearTimeout(handle);
+    }
+
+    handle = setTimeout(function () {
+      fn.apply(void 0, _toConsumableArray(_arguments));
+    }, delay);
+  };
+}

package/lib/deepEqual.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepEqual = void 0;
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+var deepEqual = function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+
+  if (_typeof(a) === 'object' && _typeof(b) === 'object' && a !== null && b !== null) {
+    if (Array.isArray(a) !== Array.isArray(b)) {
+      return false;
+    }
+
+    var keysA = Object.keys(a);
+    var keysB = Object.keys(b);
+
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+
+    return keysA.every(function (key) {
+      return deepEqual(a[key], b[key]);
+    });
+  }
+
+  if (typeof a === 'function' && typeof b === 'function') {
+    return a.toString().replace(/\s+/g, '') === b.toString().replace(/\s+/g, '');
+  }
+
+  return false;
+};
+
+exports.deepEqual = deepEqual;

package/lib/disCustomStyleProps.js

@@ -0,0 +1,46 @@
+// import PropTypes from "prop-types";
+// import mergeStyle from "./mergeStyle";
+// import { Button } from "../../base/src/Button/index";
+// export default (props)=>{
+//     let { customStyle,  openCustomStyle}  = props;
+//     return {
+//         customStyle,
+//         openDefaultToCustomize
+//     };
+// }
+// if two is same ==> do the think replace with last , append at end 
+// replace vs append ==> append 
+// append vs replace ==> replace 
+// DotButton.js
+// DotButton.module.css 
+// function DotButton({ customStyle }){
+//     dotButdefault => customStyle : {
+//         base : DotButton.style.pols 
+//     }
+//     props => customStyle {
+//         base :  
+//     }
+//     return <Button customStyle={}></Button>
+// }
+// Button => set of compoents 
+// DotButton => set of comepons
+// function creatButtonWithIcon({Button,Icon}){
+//     return (props)=>{
+//         customStyle={}
+//         return <Button customStyle={ssss}>
+//                 <Icon></Icon>   
+//         </Button>
+//     }
+// }
+// Button1.js
+// Icon1.js
+// creatButtonWithIcon({
+//     Button : Button1,
+//     Icon : Icon1
+// });
+// Button1custome(props){
+//     props.customStyle 
+//     combineCustomStyle()
+//     return Button 
+// }
+"use strict";

package/lib/eventListenerUtils.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeCustomEventListener = exports.addCustomEventListener = void 0;
+
+var addCustomEventListener = function addCustomEventListener(_ref) {
+  var eventName = _ref.eventName,
+      callback = _ref.callback,
+      targetElement = _ref.targetElement,
+      options = _ref.options;
+
+  if (!targetElement || typeof targetElement.addEventListener !== 'function') {
+    throw new Error('addCustomEventListener: targetElement is not a valid EventTarget. ' + 'Received: ' + String(targetElement));
+  }
+
+  targetElement.addEventListener(eventName, callback, options);
+};
+
+exports.addCustomEventListener = addCustomEventListener;
+
+var removeCustomEventListener = function removeCustomEventListener(_ref2) {
+  var eventName = _ref2.eventName,
+      callback = _ref2.callback,
+      targetElement = _ref2.targetElement,
+      options = _ref2.options;
+
+  if (!targetElement || typeof targetElement.removeEventListener !== 'function') {
+    throw new Error('removeCustomEventListener: targetElement is not a valid EventTarget. ' + 'Received: ' + String(targetElement));
+  }
+
+  targetElement.removeEventListener(eventName, callback, options);
+};
+
+exports.removeCustomEventListener = removeCustomEventListener;

package/lib/getCompliedClassName.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _compileClassNames = _interopRequireDefault(require("./compileClassNames"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = function _default(customClassName) {
+  var isPlainClassName = typeof customClassName === "string" ? true : false;
+
+  for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    props[_key - 1] = arguments[_key];
+  }
+
+  return _compileClassNames["default"].apply(void 0, props.concat([_defineProperty({}, customClassName, !!isPlainClassName)]));
+};
+
+exports["default"] = _default;