@elliemae/ds-utilities 2.2.0-alpha.3 → 3.0.0-next.0

package/cjs/utils.js

@@ -1,127 +1,263 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+var lodash = require('lodash');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+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__default["default"](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; }
+/**
+ * Concatenates classNames from arguments
+ *
+ * @param {...any} classnames
+ */
+
+const cx = function () {
+  for (var _len = arguments.length, classnames = new Array(_len), _key = 0; _key < _len; _key++) {
+    classnames[_key] = arguments[_key];
   }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var utils_exports = {};
-__export(utils_exports, {
-  addOrRemove: () => addOrRemove,
-  arrayMove: () => arrayMove,
-  cloneDeep: () => import_lodash.cloneDeep,
-  curry: () => import_lodash.curry,
-  cx: () => cx,
-  debounce: () => import_lodash.debounce,
-  default: () => utils_default,
-  differenceBy: () => import_lodash.differenceBy,
-  differenceWith: () => import_lodash.differenceWith,
-  filter: () => import_lodash.filter,
-  findIndex: () => import_lodash.findIndex,
-  get: () => import_lodash.get,
-  groupBy: () => import_lodash.groupBy,
-  hashArray: () => hashArray,
-  isBoolean: () => import_lodash.isBoolean,
-  isEmpty: () => import_lodash.isEmpty,
-  isEqual: () => import_lodash.isEqual,
-  isEqualWith: () => import_lodash.isEqualWith,
-  isFunction: () => import_lodash.isFunction,
-  isNaN: () => import_lodash.isNaN,
-  isObject: () => import_lodash.isObject,
-  isString: () => import_lodash.isString,
-  maxBy: () => import_lodash.maxBy,
-  meanBy: () => import_lodash.meanBy,
-  noop: () => import_lodash.noop,
-  omit: () => import_lodash.omit,
-  orderBy: () => import_lodash.orderBy,
-  padStart: () => import_lodash.padStart,
-  parseInt: () => import_lodash.parseInt,
-  pick: () => import_lodash.pick,
-  pickBy: () => import_lodash.pickBy,
-  property: () => import_lodash.property,
-  pull: () => import_lodash.pull,
-  range: () => import_lodash.range,
-  removeUndefinedProperties: () => removeUndefinedProperties,
-  runAll: () => runAll,
-  safeCall: () => safeCall,
-  set: () => import_lodash.set,
-  sortBy: () => import_lodash.sortBy,
-  sumBy: () => import_lodash.sumBy,
-  throttle: () => import_lodash.throttle,
-  toggleInArray: () => toggleInArray,
-  toggleInObject: () => toggleInObject,
-  transform: () => import_lodash.transform,
-  uniq: () => import_lodash.uniq,
-  uniqBy: () => import_lodash.uniqBy,
-  values: () => import_lodash.values
-});
-var React = __toESM(require("react"));
-var import_lodash = __toESM(require("lodash"));
-const cx = (...classnames) => classnames.reduce((result, cn) => `${result} ${cn || ""}`, "");
-const toggleInObject = (obj, key, value) => obj[key] !== void 0 ? (0, import_lodash.omit)(obj, [key]) : { ...obj, [key]: value };
+
+  return classnames.reduce((result, cn) => "".concat(result, " ").concat(cn || ''), '');
+}; // if entry exists, remove it, if not, add it
+
+const toggleInObject = (obj, key, value) => obj[key] !== undefined ? lodash.omit(obj, [key]) : _objectSpread(_objectSpread({}, obj), {}, {
+  [key]: value
+});
+
 const toggleInArray = (array, value) => array.indexOf(value) === -1 ? [value] : [];
+
 const arrayMoveMutate = (array, from, to) => {
   array.splice(to < 0 ? array.length + to : to, 0, array.splice(from, 1)[0]);
 };
+
 const arrayMove = (array, from, to) => {
   array = array.slice();
   arrayMoveMutate(array, from, to);
   return array;
 };
-const accessorDefault = (item) => item;
-const addOrRemove = (array, item, accessor = accessorDefault) => {
-  const index = array.findIndex((iItem) => accessor(iItem) === accessor(item));
+
+const accessorDefault = item => item;
+
+const addOrRemove = function (array, item) {
+  let accessor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : accessorDefault;
+  const index = array.findIndex(iItem => accessor(iItem) === accessor(item));
+
   if (index !== -1) {
-    const nextArray = (0, import_lodash.cloneDeep)(array);
+    const nextArray = lodash.cloneDeep(array);
     nextArray.splice(index, 1);
     return nextArray;
   }
+
   return [...array, item];
 };
-function runAll(...fns) {
-  return (...args) => fns.forEach((fn) => {
-    if (Array.isArray(fn))
-      runAll(fn);
-    if ((0, import_lodash.isFunction)(fn))
-      fn(...args);
-  });
+
+function runAll() {
+  for (var _len2 = arguments.length, fns = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    fns[_key2] = arguments[_key2];
+  }
+
+  return function () {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+
+    return fns.forEach(fn => {
+      if (Array.isArray(fn)) runAll(fn);
+      if (lodash.isFunction(fn)) fn(...args);
+    });
+  };
 }
 function hashArray(arr, fieldName) {
-  return arr.reduce((result, item) => ({
-    ...result,
+  return arr.reduce((result, item) => _objectSpread(_objectSpread({}, result), {}, {
     [fieldName ? item[fieldName] : item]: true
   }), {});
 }
-function safeCall(fun, ...args) {
-  if ((0, import_lodash.isFunction)(fun)) {
+function safeCall(fun) {
+  if (lodash.isFunction(fun)) {
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
+    }
+
     fun(...args);
   }
 }
-const removeUndefinedProperties = (obj) => {
-  const cleanObject = { ...obj };
-  Object.keys(obj).forEach((key) => cleanObject[key] === void 0 && delete cleanObject[key]);
+const removeUndefinedProperties = obj => {
+  const cleanObject = _objectSpread({}, obj);
+
+  Object.keys(obj).forEach(key => cleanObject[key] === undefined && delete cleanObject[key]);
   return cleanObject;
 };
-var utils_default = {};
-module.exports = __toCommonJS(utils_exports);
-//# sourceMappingURL=utils.js.map
+var utils = {};
+
+Object.defineProperty(exports, 'cloneDeep', {
+  enumerable: true,
+  get: function () { return lodash.cloneDeep; }
+});
+Object.defineProperty(exports, 'curry', {
+  enumerable: true,
+  get: function () { return lodash.curry; }
+});
+Object.defineProperty(exports, 'debounce', {
+  enumerable: true,
+  get: function () { return lodash.debounce; }
+});
+Object.defineProperty(exports, 'differenceBy', {
+  enumerable: true,
+  get: function () { return lodash.differenceBy; }
+});
+Object.defineProperty(exports, 'differenceWith', {
+  enumerable: true,
+  get: function () { return lodash.differenceWith; }
+});
+Object.defineProperty(exports, 'filter', {
+  enumerable: true,
+  get: function () { return lodash.filter; }
+});
+Object.defineProperty(exports, 'findIndex', {
+  enumerable: true,
+  get: function () { return lodash.findIndex; }
+});
+Object.defineProperty(exports, 'get', {
+  enumerable: true,
+  get: function () { return lodash.get; }
+});
+Object.defineProperty(exports, 'groupBy', {
+  enumerable: true,
+  get: function () { return lodash.groupBy; }
+});
+Object.defineProperty(exports, 'isBoolean', {
+  enumerable: true,
+  get: function () { return lodash.isBoolean; }
+});
+Object.defineProperty(exports, 'isEmpty', {
+  enumerable: true,
+  get: function () { return lodash.isEmpty; }
+});
+Object.defineProperty(exports, 'isEqual', {
+  enumerable: true,
+  get: function () { return lodash.isEqual; }
+});
+Object.defineProperty(exports, 'isEqualWith', {
+  enumerable: true,
+  get: function () { return lodash.isEqualWith; }
+});
+Object.defineProperty(exports, 'isFunction', {
+  enumerable: true,
+  get: function () { return lodash.isFunction; }
+});
+Object.defineProperty(exports, 'isNaN', {
+  enumerable: true,
+  get: function () { return lodash.isNaN; }
+});
+Object.defineProperty(exports, 'isObject', {
+  enumerable: true,
+  get: function () { return lodash.isObject; }
+});
+Object.defineProperty(exports, 'isString', {
+  enumerable: true,
+  get: function () { return lodash.isString; }
+});
+Object.defineProperty(exports, 'maxBy', {
+  enumerable: true,
+  get: function () { return lodash.maxBy; }
+});
+Object.defineProperty(exports, 'meanBy', {
+  enumerable: true,
+  get: function () { return lodash.meanBy; }
+});
+Object.defineProperty(exports, 'noop', {
+  enumerable: true,
+  get: function () { return lodash.noop; }
+});
+Object.defineProperty(exports, 'omit', {
+  enumerable: true,
+  get: function () { return lodash.omit; }
+});
+Object.defineProperty(exports, 'orderBy', {
+  enumerable: true,
+  get: function () { return lodash.orderBy; }
+});
+Object.defineProperty(exports, 'padStart', {
+  enumerable: true,
+  get: function () { return lodash.padStart; }
+});
+Object.defineProperty(exports, 'parseInt', {
+  enumerable: true,
+  get: function () { return lodash.parseInt; }
+});
+Object.defineProperty(exports, 'pick', {
+  enumerable: true,
+  get: function () { return lodash.pick; }
+});
+Object.defineProperty(exports, 'pickBy', {
+  enumerable: true,
+  get: function () { return lodash.pickBy; }
+});
+Object.defineProperty(exports, 'property', {
+  enumerable: true,
+  get: function () { return lodash.property; }
+});
+Object.defineProperty(exports, 'pull', {
+  enumerable: true,
+  get: function () { return lodash.pull; }
+});
+Object.defineProperty(exports, 'range', {
+  enumerable: true,
+  get: function () { return lodash.range; }
+});
+Object.defineProperty(exports, 'set', {
+  enumerable: true,
+  get: function () { return lodash.set; }
+});
+Object.defineProperty(exports, 'sortBy', {
+  enumerable: true,
+  get: function () { return lodash.sortBy; }
+});
+Object.defineProperty(exports, 'sumBy', {
+  enumerable: true,
+  get: function () { return lodash.sumBy; }
+});
+Object.defineProperty(exports, 'throttle', {
+  enumerable: true,
+  get: function () { return lodash.throttle; }
+});
+Object.defineProperty(exports, 'transform', {
+  enumerable: true,
+  get: function () { return lodash.transform; }
+});
+Object.defineProperty(exports, 'uniq', {
+  enumerable: true,
+  get: function () { return lodash.uniq; }
+});
+Object.defineProperty(exports, 'uniqBy', {
+  enumerable: true,
+  get: function () { return lodash.uniqBy; }
+});
+Object.defineProperty(exports, 'values', {
+  enumerable: true,
+  get: function () { return lodash.values; }
+});
+exports.addOrRemove = addOrRemove;
+exports.arrayMove = arrayMove;
+exports.cx = cx;
+exports["default"] = utils;
+exports.hashArray = hashArray;
+exports.removeUndefinedProperties = removeUndefinedProperties;
+exports.runAll = runAll;
+exports.safeCall = safeCall;
+exports.toggleInArray = toggleInArray;
+exports.toggleInObject = toggleInObject;

package/cjs/validations.js

@@ -1,57 +1,44 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var operators = require('./operators.js');
+
+const isRequired = _ref => {
+  let {
+    value,
+    help = 'Field is Required'
+  } = _ref;
+  return {
+    payload: help,
+    error: operators.checkNotEmpty(value)
   };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var validations_exports = {};
-__export(validations_exports, {
-  isGreaterThan: () => isGreaterThan,
-  isRequired: () => isRequired,
-  isValidDate: () => isValidDate
-});
-var React = __toESM(require("react"));
-var import_operators = __toESM(require("./operators"));
-const isRequired = ({ value, help = "Field is Required" }) => ({
-  payload: help,
-  error: (0, import_operators.checkNotEmpty)(value)
-});
-const isGreaterThan = ({ value, help, comparator = 0 }) => {
-  if (!help)
-    help = `Max value ${comparator}`;
+};
+const isGreaterThan = _ref2 => {
+  let {
+    value,
+    help,
+    comparator = 0
+  } = _ref2;
+  if (!help) help = "Max value ".concat(comparator);
   return {
     payload: help,
-    error: (0, import_operators.greaterThan)(value, comparator)
+    error: operators.greaterThan(value, comparator)
   };
 };
-const isValidDate = ({ value, help, format = "MM/DD/AAA" }) => {
-  if (!help)
-    help = `Valid Date is required ${format}`;
+const isValidDate = _ref3 => {
+  let {
+    value,
+    help,
+    format = 'MM/DD/AAA'
+  } = _ref3;
+  if (!help) help = "Valid Date is required ".concat(format);
   return {
     payload: help,
-    error: !(0, import_operators.validDate)(value)
+    error: !operators.validDate(value)
   };
 };
-module.exports = __toCommonJS(validations_exports);
-//# sourceMappingURL=validations.js.map
+
+exports.isGreaterThan = isGreaterThan;
+exports.isRequired = isRequired;
+exports.isValidDate = isValidDate;

package/esm/capitalize.js

@@ -1,6 +1,3 @@
-import * as React from "react";
-const capitalize = (string) => string.charAt(0).toUpperCase() + string.slice(1);
-export {
-  capitalize
-};
-//# sourceMappingURL=capitalize.js.map
+const capitalize = string => string.charAt(0).toUpperCase() + string.slice(1);
+
+export { capitalize };

package/esm/compose.js

@@ -1,16 +1,34 @@
-import * as React from "react";
-const compose = (...funcs) => {
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+/**
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for
+ * the resulting composite function. [From redux v4.0.5]
+ *
+ * @param {...Function} funcs The functions to compose.
+ * @returns {Function} A function obtained by composing the argument functions
+ * from right to left. For example, compose(f, g, h) is identical to doing
+ * (...args) => f(g(h(...args))).
+ */
+function compose() {
+  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
+    funcs[_key] = arguments[_key];
+  }
+
   if (funcs.length === 0) {
-    return (arg) => arg;
+    return arg => arg;
   }
+
   if (funcs.length === 1) {
     return funcs[0];
   }
-  return funcs.reduce((a, b) => (...args) => a(b(...args)));
-};
-var compose_default = compose;
-export {
-  compose,
-  compose_default as default
-};
-//# sourceMappingURL=compose.js.map
+
+  return funcs.reduce((a, b) => function () {
+    return a(b(...arguments));
+  });
+}
+
+export { compose };

package/esm/getComponentFromProps.js

@@ -1,19 +1,23 @@
-import * as React from "react";
-import React2 from "react";
-const getComponentFromProps = (Component, props, children = []) => {
-  if (!Component)
-    return null;
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+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 getComponentFromProps(Component, props) {
+  let children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  if (!Component) return null;
   const componentChildren = Component.props ? Array.isArray(Component.props.children) ? Component.props.children : [Component.props.children] : null;
-  return typeof Component === "function" ? /* @__PURE__ */ React2.createElement(Component, {
-    ...props
-  }, children) : React2.cloneElement(Component, {
-    ...Component.props,
-    ...props
-  }, componentChildren ? [...componentChildren, ...children] : [...children]);
-};
-var getComponentFromProps_default = getComponentFromProps;
-export {
-  getComponentFromProps_default as default,
-  getComponentFromProps
-};
-//# sourceMappingURL=getComponentFromProps.js.map
+  return typeof Component === 'function' ? /*#__PURE__*/jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
+    children: children
+  })) : /*#__PURE__*/React.cloneElement(Component, _objectSpread(_objectSpread({}, Component.props), props), componentChildren ? [...componentChildren, ...children] : [...children]);
+}
+
+export { getComponentFromProps as default };

package/esm/hooks/index.js

@@ -1,40 +1,18 @@
-import * as React from "react";
-import { default as default2 } from "use-measure";
-import { default as default3 } from "use-force-update";
-import { default as default4 } from "use-onclickoutside";
-import { useUncontrolled } from "uncontrollable";
-import { useExecutionTimer } from "./useExecutionTimer";
-import { useExpandState } from "./useExpandState";
-import { useHotkeys } from "./useHotkeys";
-import { useHoverHandlersDelay } from "./useHoverHandlersDelay";
-import { useResizeObserver } from "./useResizeObserver";
-import { useShouldRecalculate } from "./useShouldRecalculate";
-import { useWindowScrollerList } from "./useWindowScrollerList";
-import { useWindowSize } from "./useWindowSize";
-import { usePrevious } from "./usePrevious";
-import { useCancellableDelayedCallback } from "./useCancellableDelayedCallback";
-import { useDerivedStateFromProps } from "./useDerivedStateFromProps";
-import { useSetRef } from "./useSetRef";
-import { useParentElement } from "./useParentElement";
-import { useOnElementResize } from "./useOnElementResize";
-export {
-  useCancellableDelayedCallback,
-  useDerivedStateFromProps,
-  useExecutionTimer,
-  useExpandState,
-  default3 as useForceUpdate,
-  useHotkeys,
-  useHoverHandlersDelay,
-  default2 as useMeasure,
-  default4 as useOnClickOutside,
-  useOnElementResize,
-  useParentElement,
-  usePrevious,
-  useResizeObserver,
-  useSetRef,
-  useShouldRecalculate,
-  useUncontrolled,
-  useWindowScrollerList,
-  useWindowSize
-};
-//# sourceMappingURL=index.js.map
+export { default as useMeasure } from 'use-measure';
+export { default as useExecutionTimer } from './useExecutionTimer.js';
+export { default as useExpandState } from './useExpandState.js';
+export { default as useHotkeys } from './useHotkeys.js';
+export { default as useHoverHandlersDelay } from './useHoverHandlersDelay.js';
+export { default as useResizeObserver } from './useResizeObserver.js';
+export { default as useShouldRecalculate } from './useShouldRecalculate.js';
+export { default as useWindowScrollerList } from './useWindowScrollerList.js';
+export { default as useWindowSize } from './useWindowSize.js';
+export { default as useForceUpdate } from 'use-force-update';
+export { default as useOnClickOutside } from 'use-onclickoutside';
+export { useUncontrolled } from 'uncontrollable';
+export { default as usePrevious } from './usePrevious.js';
+export { default as useCancellableDelayedCallback } from './useCancellableDelayedCallback.js';
+export { default as useDerivedStateFromProps } from './useDerivedStateFromProps.js';
+export { useSetRef } from './useSetRef.js';
+export { useParentElement } from './useParentElement.js';
+export { useOnElementResize } from './useOnElementResize.js';

package/esm/hooks/useCancellableDelayedCallback.js

@@ -1,22 +1,24 @@
-import * as React from "react";
-import { useCallback, useRef } from "react";
-const useCancellableDelayedCallback = (cb, delay) => {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useRef, useCallback } from 'react';
+
+function useCancellableDelayedCallback(cb, delay) {
   const timeoutRef = useRef();
   const cancel = useCallback(() => {
     const timeoutId = timeoutRef.current;
+
     if (timeoutId) {
-      timeoutRef.current = void 0;
+      timeoutRef.current = undefined;
       clearTimeout(timeoutId);
     }
   }, [timeoutRef]);
-  const delayedCb = useCallback((...args) => {
+  const delayedCb = useCallback(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
     timeoutRef.current = setTimeout(() => cb(...args), delay);
   }, [cb, delay]);
   return [delayedCb, cancel];
-};
-var useCancellableDelayedCallback_default = useCancellableDelayedCallback;
-export {
-  useCancellableDelayedCallback_default as default,
-  useCancellableDelayedCallback
-};
-//# sourceMappingURL=useCancellableDelayedCallback.js.map
+}
+
+export { useCancellableDelayedCallback as default };