@elliemae/ds-utilities 2.3.0-alpha.9 → 2.3.0-next.0

package/cjs/capitalize.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const capitalize = string => string.charAt(0).toUpperCase() + string.slice(1);
+
+exports.capitalize = capitalize;

package/cjs/compose.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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');
+
+/**
+ * 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;
+  }
+
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+
+  return funcs.reduce((a, b) => function () {
+    return a(b(...arguments));
+  });
+}
+
+exports.compose = compose;

package/cjs/getComponentFromProps.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+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; }
+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__*/jsxRuntime.jsx(Component, _objectSpread(_objectSpread({}, props), {}, {
+    children: children
+  })) : /*#__PURE__*/React__default["default"].cloneElement(Component, _objectSpread(_objectSpread({}, Component.props), props), componentChildren ? [...componentChildren, ...children] : [...children]);
+}
+
+module.exports = getComponentFromProps;

package/cjs/hooks/index.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useMeasure = require('use-measure');
+var useExecutionTimer = require('./useExecutionTimer.js');
+var useExpandState = require('./useExpandState.js');
+var useHotkeys = require('./useHotkeys.js');
+var useHoverHandlersDelay = require('./useHoverHandlersDelay.js');
+var useResizeObserver = require('./useResizeObserver.js');
+var useShouldRecalculate = require('./useShouldRecalculate.js');
+var useWindowScrollerList = require('./useWindowScrollerList.js');
+var useWindowSize = require('./useWindowSize.js');
+var useForceUpdate = require('use-force-update');
+var useOnclickoutside = require('use-onclickoutside');
+var uncontrollable = require('uncontrollable');
+var usePrevious = require('./usePrevious.js');
+var useCancellableDelayedCallback = require('./useCancellableDelayedCallback.js');
+var useDerivedStateFromProps = require('./useDerivedStateFromProps.js');
+var useSetRef = require('./useSetRef.js');
+var useParentElement = require('./useParentElement.js');
+var useOnElementResize = require('./useOnElementResize.js');
+var useIsShowingEllipsis = require('./useIsShowingEllipsis.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var useMeasure__default = /*#__PURE__*/_interopDefaultLegacy(useMeasure);
+var useForceUpdate__default = /*#__PURE__*/_interopDefaultLegacy(useForceUpdate);
+var useOnclickoutside__default = /*#__PURE__*/_interopDefaultLegacy(useOnclickoutside);
+
+
+
+Object.defineProperty(exports, 'useMeasure', {
+	enumerable: true,
+	get: function () { return useMeasure__default["default"]; }
+});
+exports.useExecutionTimer = useExecutionTimer;
+exports.useExpandState = useExpandState;
+exports.useHotkeys = useHotkeys;
+exports.useHoverHandlersDelay = useHoverHandlersDelay;
+exports.useResizeObserver = useResizeObserver;
+exports.useShouldRecalculate = useShouldRecalculate;
+exports.useWindowScrollerList = useWindowScrollerList;
+exports.useWindowSize = useWindowSize;
+Object.defineProperty(exports, 'useForceUpdate', {
+	enumerable: true,
+	get: function () { return useForceUpdate__default["default"]; }
+});
+Object.defineProperty(exports, 'useOnClickOutside', {
+	enumerable: true,
+	get: function () { return useOnclickoutside__default["default"]; }
+});
+Object.defineProperty(exports, 'useUncontrolled', {
+	enumerable: true,
+	get: function () { return uncontrollable.useUncontrolled; }
+});
+exports.usePrevious = usePrevious;
+exports.useCancellableDelayedCallback = useCancellableDelayedCallback;
+exports.useDerivedStateFromProps = useDerivedStateFromProps;
+exports.useSetRef = useSetRef.useSetRef;
+exports.useParentElement = useParentElement.useParentElement;
+exports.useOnElementResize = useOnElementResize.useOnElementResize;
+exports.useIsShowingEllipsis = useIsShowingEllipsis.useIsShowingEllipsis;

package/cjs/hooks/useCancellableDelayedCallback.js

@@ -0,0 +1,26 @@
+'use strict';
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+
+function useCancellableDelayedCallback(cb, delay) {
+  const timeoutRef = React.useRef();
+  const cancel = React.useCallback(() => {
+    const timeoutId = timeoutRef.current;
+
+    if (timeoutId) {
+      timeoutRef.current = undefined;
+      clearTimeout(timeoutId);
+    }
+  }, [timeoutRef]);
+  const delayedCb = React.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];
+}
+
+module.exports = useCancellableDelayedCallback;

package/cjs/hooks/useDerivedStateFromProps.js

@@ -0,0 +1,56 @@
+'use strict';
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+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/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');
+
+const defaultPropUpdateOnChange = prop => prop;
+
+function defaultShouldUpdate(_ref) {
+  let {
+    prop,
+    prevProp,
+    stateValue
+  } = _ref;
+  return !lodash.isEqual(prop, prevProp) && !lodash.isEqual(prop, stateValue);
+}
+
+function setStateWithUpdate(onUpdate, setState) {
+  return state => {
+    setState(prevState => onUpdate(lodash.isFunction(state) ? state(prevState) : state, prevState));
+  };
+}
+
+function useDerivedStateFromProp(prop) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const {
+    onUpdate = defaultPropUpdateOnChange,
+    shouldUpdate = defaultShouldUpdate,
+    updateOnStateChange = false
+  } = options;
+  const [stateValue, setState] = React.useState(onUpdate(prop, {}));
+  const handleSetState = updateOnStateChange ? setStateWithUpdate(onUpdate, setState) : setState;
+  const prevProp = React.useRef(prop);
+
+  if (shouldUpdate({
+    prop,
+    prevProp: prevProp.current,
+    stateValue
+  })) {
+    const nextProp = onUpdate(prop, prevProp.current);
+    setState(nextProp);
+  }
+
+  prevProp.current = prop;
+  return [stateValue, handleSetState];
+}
+
+module.exports = useDerivedStateFromProp;

package/cjs/hooks/useExecutionTimer.js

@@ -0,0 +1,31 @@
+'use strict';
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+
+function useExecutionDelay(startFn, cleanFn, delayTime) {
+  const startTimer = React.useRef();
+  const closeTimer = React.useRef();
+
+  const startFunction = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    clearTimeout(closeTimer.current);
+    startTimer.current = setTimeout(() => startFn(...args), delayTime);
+  };
+
+  const cleanFunction = function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    clearTimeout(startTimer.current);
+    closeTimer.current = setTimeout(() => cleanFn(...args), 30);
+  };
+
+  return [startFunction, cleanFunction];
+}
+
+module.exports = useExecutionDelay;

package/cjs/hooks/useExpandState.js

@@ -0,0 +1,133 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+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.constructor.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 React = require('react');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+var lodash = require('lodash');
+var useDerivedStateFromProps = require('./useDerivedStateFromProps.js');
+
+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; }
+
+const toggleStateInObject = (obj, key, value) => {
+  const nextObj = _objectSpread({}, obj);
+
+  if (nextObj[key]) {
+    delete nextObj[key];
+  } else {
+    nextObj[key] = value;
+  }
+
+  return nextObj;
+};
+
+const noop = () => null;
+
+function useExpandState(_ref) {
+  let {
+    items = [],
+    itemKey = 'id',
+    expanded: expandedProp = {},
+    onExpand,
+    onExpandChange = noop,
+    onExpandAll = noop,
+    onToggleExpand,
+    onCollapse
+  } = _ref;
+  const [expanded, setExpanded] = useDerivedStateFromProps(expandedProp);
+  const isExpandedAll = React.useMemo(() => Object.keys(expanded).length === items.length, [expanded, items]);
+
+  const toggleExpandAll = function () {
+    let stateData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    setExpanded(() => {
+      const nextState = {};
+
+      if (!isExpandedAll) {
+        items.forEach(item => {
+          nextState[item[itemKey]] = stateData;
+        });
+      }
+
+      onExpandChange(nextState);
+      onExpandAll(nextState);
+      return nextState;
+    });
+  };
+
+  const expand = function (item) {
+    let stateData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    if (!item) return;
+
+    if (lodash.isFunction(onExpand)) {
+      onExpand(item);
+    }
+
+    setExpanded(prevState => {
+      const key = item[itemKey];
+
+      const nextState = _objectSpread(_objectSpread({}, prevState), {}, {
+        [key]: stateData
+      });
+
+      onExpandChange(nextState, item);
+      return nextState;
+    });
+  };
+
+  const toggleExpand = function (item) {
+    let stateData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+    if (lodash.isFunction(onToggleExpand)) {
+      onToggleExpand(item);
+    }
+
+    setExpanded(prevState => {
+      const key = item[itemKey];
+      const nextState = toggleStateInObject(prevState, key, stateData);
+      onExpandChange(nextState, item);
+      return nextState;
+    });
+  };
+
+  const collapse = item => {
+    if (lodash.isFunction(onCollapse)) {
+      onCollapse(item);
+    }
+
+    setExpanded(prevState => {
+      const nextState = _objectSpread({}, prevState);
+
+      delete nextState[item[itemKey]];
+      onExpandChange(nextState, item);
+      return nextState;
+    });
+  };
+
+  return {
+    state: {
+      expanded,
+      isExpandedAll
+    },
+    actions: {
+      expand,
+      toggleExpandAll,
+      toggleExpand,
+      collapse
+    },
+    setExpanded
+  };
+}
+
+module.exports = useExpandState;

package/cjs/hooks/useHotkeys.js

@@ -0,0 +1,25 @@
+'use strict';
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var hotkeys = require('hotkeys-js');
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var hotkeys__default = /*#__PURE__*/_interopDefaultLegacy(hotkeys);
+
+function useHotkeys(_ref) {
+  let {
+    keys,
+    handler,
+    options = {}
+  } = _ref;
+  let deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  const memoizedCallback = React.useCallback(handler, deps);
+  React.useEffect(() => {
+    hotkeys__default["default"](keys, options, memoizedCallback);
+    return () => hotkeys__default["default"].unbind(keys);
+  }, [memoizedCallback]);
+}
+
+module.exports = useHotkeys;

package/cjs/hooks/useHoverHandlersDelay.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var React = require('react');
+
+function useHoverHandlersDelay(_ref) {
+  let {
+    onMouseOver,
+    onMouseLeave,
+    hideDelay = 300,
+    showDelay = 300
+  } = _ref;
+  const hideTimer = React.useRef();
+  const showTimer = React.useRef();
+  const delayedHide = React.useCallback(() => {
+    clearTimeout(showTimer.current);
+    hideTimer.current = setTimeout(onMouseLeave, hideDelay);
+  }, []);
+  const delayedShow = React.useCallback(() => {
+    clearTimeout(hideTimer.current);
+    showTimer.current = setTimeout(onMouseOver, showDelay);
+  }, []);
+  return {
+    onMouseOver: delayedShow,
+    onMouseLeave: delayedHide
+  };
+}
+
+module.exports = useHoverHandlersDelay;

package/cjs/hooks/useIsShowingEllipsis.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+
+const useIsShowingEllipsis = () => {
+  const [element, setElement] = React.useState();
+  const [isShowingEllipsis, setIsShowingEllipsis] = React.useState(false);
+  const resizeObserver = React.useMemo(() => new ResizeObserver(entries => {
+    if (entries.length) {
+      const [textWrapperEntry] = entries;
+      const el = textWrapperEntry.target;
+      setIsShowingEllipsis((el === null || el === void 0 ? void 0 : el.scrollWidth) > (el === null || el === void 0 ? void 0 : el.clientWidth));
+    }
+  }), []);
+  React.useEffect(() => {
+    if (element) {
+      setIsShowingEllipsis(element.scrollWidth > element.clientWidth);
+      resizeObserver.observe(element);
+    }
+
+    return () => {
+      if (element) {
+        resizeObserver.unobserve(element);
+      }
+    };
+  }, [resizeObserver, element]);
+  return {
+    setElement,
+    isShowingEllipsis
+  };
+};
+
+exports.useIsShowingEllipsis = useIsShowingEllipsis;

package/cjs/hooks/useOnElementResize.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+
+// Taken and modified from https://stackoverflow.com/a/60218754
+
+const useOnElementResize = targetRef => {
+  var _targetRef$current$of, _targetRef$current, _targetRef$current$of2, _targetRef$current2;
+
+  const [width, setWidth] = React.useState((_targetRef$current$of = (_targetRef$current = targetRef.current) === null || _targetRef$current === void 0 ? void 0 : _targetRef$current.offsetWidth) !== null && _targetRef$current$of !== void 0 ? _targetRef$current$of : 0);
+  const [height, setHeight] = React.useState((_targetRef$current$of2 = (_targetRef$current2 = targetRef.current) === null || _targetRef$current2 === void 0 ? void 0 : _targetRef$current2.offsetHeight) !== null && _targetRef$current$of2 !== void 0 ? _targetRef$current$of2 : 0);
+  const observer = React.useRef();
+  React.useEffect(() => {
+    function outputsize() {
+      var _targetRef$current$of3, _targetRef$current3, _targetRef$current$of4, _targetRef$current4;
+
+      setWidth((_targetRef$current$of3 = (_targetRef$current3 = targetRef.current) === null || _targetRef$current3 === void 0 ? void 0 : _targetRef$current3.offsetWidth) !== null && _targetRef$current$of3 !== void 0 ? _targetRef$current$of3 : 0);
+      setHeight((_targetRef$current$of4 = (_targetRef$current4 = targetRef.current) === null || _targetRef$current4 === void 0 ? void 0 : _targetRef$current4.offsetHeight) !== null && _targetRef$current$of4 !== void 0 ? _targetRef$current$of4 : 0);
+    }
+
+    observer.current = new ResizeObserver(outputsize);
+    observer.current.observe(targetRef.current);
+    return () => {
+      var _observer$current;
+
+      (_observer$current = observer.current) === null || _observer$current === void 0 ? void 0 : _observer$current.disconnect();
+    };
+  }, [targetRef]);
+  return React.useMemo(() => ({
+    width,
+    height
+  }), [width, height]);
+};
+
+exports.useOnElementResize = useOnElementResize;

package/cjs/hooks/useParentElement.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+
+const useParentElement = ref => {
+  const [parent, setParent] = React.useState(ref.current);
+  React.useEffect(() => {
+    if (ref.current) setParent(ref.current.parentNode);
+  });
+  return parent;
+};
+
+exports.useParentElement = useParentElement;

package/cjs/hooks/usePrevious.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var React = require('react');
+
+function usePrevious(value) {
+  const ref = React.useRef();
+  React.useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+module.exports = usePrevious;

package/cjs/hooks/useResizeObserver.js

@@ -0,0 +1,33 @@
+'use strict';
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+var raf = require('raf');
+var ResizeObserver = require('resize-observer-polyfill');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var raf__default = /*#__PURE__*/_interopDefaultLegacy(raf);
+var ResizeObserver__default = /*#__PURE__*/_interopDefaultLegacy(ResizeObserver);
+
+function useResizeObserver(handler, el) {
+  const [node, setRef] = React.useState(el);
+  const resizeObserver = new ResizeObserver__default["default"](entries => {
+    if (!Array.isArray(entries)) return;
+    if (!entries.length) return;
+    const entry = entries[0]; // execute on the next animation frame
+
+    raf__default["default"](() => handler({
+      width: entry.target.offsetWidth,
+      height: entry.target.offsetHeight
+    }, entry.target));
+  });
+  const htmlEl = el || node;
+  React.useEffect(() => {
+    if (htmlEl) resizeObserver.observe(htmlEl);
+    return () => htmlEl && resizeObserver.unobserve(htmlEl);
+  }, [htmlEl]);
+  return [setRef];
+}
+
+module.exports = useResizeObserver;

package/cjs/hooks/useSetRef.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+const useSetRef = initial => {
+  const ref = React.useRef(initial);
+  const setRef = React.useCallback(node => {
+    ref.current = node;
+  }, []);
+  return [ref, setRef];
+};
+
+exports.useSetRef = useSetRef;

package/cjs/hooks/useShouldRecalculate.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var React = require('react');
+
+function useShouldRecalculate(bool) {
+  const prevValueRef = React.useRef(0);
+
+  if (!bool) {
+    // If we need to recalculate, change the value we return
+    prevValueRef.current += 1;
+  } // else we return the same value as the previous render, which won't trigger a recalculation
+
+
+  return prevValueRef.current;
+}
+
+module.exports = useShouldRecalculate;