@elliemae/ds-utilities 2.2.0-alpha.4 → 3.0.0-next.2

package/esm/hooks/useDerivedStateFromProps.js

@@ -1,16 +1,34 @@
-import * as React from "react";
-import { useRef, useState } from "react";
-import { isEqual, isFunction } from "../utils";
-const defaultPropUpdateOnChange = (prop) => prop;
-function defaultShouldUpdate({ prop, prevProp, stateValue }) {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useRef } from 'react';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import '@babel/runtime/helpers/esm/defineProperty';
+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/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { isFunction, isEqual } from 'lodash';
+
+const defaultPropUpdateOnChange = prop => prop;
+
+function defaultShouldUpdate(_ref) {
+  let {
+    prop,
+    prevProp,
+    stateValue
+  } = _ref;
   return !isEqual(prop, prevProp) && !isEqual(prop, stateValue);
 }
+
 function setStateWithUpdate(onUpdate, setState) {
-  return (state) => {
-    setState((prevState) => onUpdate(isFunction(state) ? state(prevState) : state, prevState));
+  return state => {
+    setState(prevState => onUpdate(isFunction(state) ? state(prevState) : state, prevState));
   };
 }
-const useDerivedStateFromProps = (prop, options = {}) => {
+
+function useDerivedStateFromProp(prop) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   const {
     onUpdate = defaultPropUpdateOnChange,
     shouldUpdate = defaultShouldUpdate,
@@ -19,6 +37,7 @@ const useDerivedStateFromProps = (prop, options = {}) => {
   const [stateValue, setState] = useState(onUpdate(prop, {}));
   const handleSetState = updateOnStateChange ? setStateWithUpdate(onUpdate, setState) : setState;
   const prevProp = useRef(prop);
+
   if (shouldUpdate({
     prop,
     prevProp: prevProp.current,
@@ -27,12 +46,9 @@ const useDerivedStateFromProps = (prop, options = {}) => {
     const nextProp = onUpdate(prop, prevProp.current);
     setState(nextProp);
   }
+
   prevProp.current = prop;
   return [stateValue, handleSetState];
-};
-var useDerivedStateFromProps_default = useDerivedStateFromProps;
-export {
-  useDerivedStateFromProps_default as default,
-  useDerivedStateFromProps
-};
-//# sourceMappingURL=useDerivedStateFromProps.js.map
+}
+
+export { useDerivedStateFromProp as default };

package/esm/hooks/useExecutionTimer.js

@@ -1,21 +1,29 @@
-import * as React from "react";
-import { useRef } from "react";
-const useExecutionTimer = (startFn, cleanFn, delayTime) => {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useRef } from 'react';
+
+function useExecutionDelay(startFn, cleanFn, delayTime) {
   const startTimer = useRef();
   const closeTimer = useRef();
-  const startFunction = (...args) => {
+
+  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 = (...args) => {
+
+  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];
-};
-var useExecutionTimer_default = useExecutionTimer;
-export {
-  useExecutionTimer_default as default,
-  useExecutionTimer
-};
-//# sourceMappingURL=useExecutionTimer.js.map
+}
+
+export { useExecutionDelay as default };

package/esm/hooks/useExpandState.js

@@ -1,79 +1,119 @@
-import * as React from "react";
-import { useMemo } from "react";
-import { isFunction } from "../utils";
-import { useDerivedStateFromProps } from "./useDerivedStateFromProps";
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { useMemo } from 'react';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import { isFunction } from 'lodash';
+import useDerivedStateFromProp from './useDerivedStateFromProps.js';
+
+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; }
+
 const toggleStateInObject = (obj, key, value) => {
-  const nextObj = { ...obj };
+  const nextObj = _objectSpread({}, obj);
+
   if (nextObj[key]) {
     delete nextObj[key];
   } else {
     nextObj[key] = value;
   }
+
   return nextObj;
 };
+
 const noop = () => null;
-const useExpandState = ({
-  items = [],
-  itemKey = "id",
-  expanded: expandedProp = {},
-  onExpand,
-  onExpandChange = noop,
-  onExpandAll = noop,
-  onToggleExpand,
-  onCollapse
-}) => {
-  const [expanded, setExpanded] = useDerivedStateFromProps(expandedProp);
+
+function useExpandState(_ref) {
+  let {
+    items = [],
+    itemKey = 'id',
+    expanded: expandedProp = {},
+    onExpand,
+    onExpandChange = noop,
+    onExpandAll = noop,
+    onToggleExpand,
+    onCollapse
+  } = _ref;
+  const [expanded, setExpanded] = useDerivedStateFromProp(expandedProp);
   const isExpandedAll = useMemo(() => Object.keys(expanded).length === items.length, [expanded, items]);
-  const toggleExpandAll = (stateData = true) => {
+
+  const toggleExpandAll = function () {
+    let stateData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     setExpanded(() => {
       const nextState = {};
+
       if (!isExpandedAll) {
-        items.forEach((item) => {
+        items.forEach(item => {
           nextState[item[itemKey]] = stateData;
         });
       }
+
       onExpandChange(nextState);
       onExpandAll(nextState);
       return nextState;
     });
   };
-  const expand = (item, stateData = true) => {
-    if (!item)
-      return;
+
+  const expand = function (item) {
+    let stateData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    if (!item) return;
+
     if (isFunction(onExpand)) {
       onExpand(item);
     }
-    setExpanded((prevState) => {
+
+    setExpanded(prevState => {
       const key = item[itemKey];
-      const nextState = { ...prevState, [key]: stateData };
+
+      const nextState = _objectSpread(_objectSpread({}, prevState), {}, {
+        [key]: stateData
+      });
+
       onExpandChange(nextState, item);
       return nextState;
     });
   };
-  const toggleExpand = (item, stateData = true) => {
+
+  const toggleExpand = function (item) {
+    let stateData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
     if (isFunction(onToggleExpand)) {
       onToggleExpand(item);
     }
-    setExpanded((prevState) => {
+
+    setExpanded(prevState => {
       const key = item[itemKey];
       const nextState = toggleStateInObject(prevState, key, stateData);
       onExpandChange(nextState, item);
       return nextState;
     });
   };
-  const collapse = (item) => {
+
+  const collapse = item => {
     if (isFunction(onCollapse)) {
       onCollapse(item);
     }
-    setExpanded((prevState) => {
-      const nextState = { ...prevState };
+
+    setExpanded(prevState => {
+      const nextState = _objectSpread({}, prevState);
+
       delete nextState[item[itemKey]];
       onExpandChange(nextState, item);
       return nextState;
     });
   };
+
   return {
-    state: { expanded, isExpandedAll },
+    state: {
+      expanded,
+      isExpandedAll
+    },
     actions: {
       expand,
       toggleExpandAll,
@@ -82,10 +122,6 @@ const useExpandState = ({
     },
     setExpanded
   };
-};
-var useExpandState_default = useExpandState;
-export {
-  useExpandState_default as default,
-  useExpandState
-};
-//# sourceMappingURL=useExpandState.js.map
+}
+
+export { useExpandState as default };

package/esm/hooks/useHotkeys.js

@@ -1,16 +1,19 @@
-import * as React from "react";
-import hotkeys from "hotkeys-js";
-import { useCallback, useEffect } from "react";
-const useHotkeys = ({ keys, handler, options = {} }, deps = []) => {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import hotkeys from 'hotkeys-js';
+import { useCallback, useEffect } from 'react';
+
+function useHotkeys(_ref) {
+  let {
+    keys,
+    handler,
+    options = {}
+  } = _ref;
+  let deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   const memoizedCallback = useCallback(handler, deps);
   useEffect(() => {
     hotkeys(keys, options, memoizedCallback);
     return () => hotkeys.unbind(keys);
   }, [memoizedCallback]);
-};
-var useHotkeys_default = useHotkeys;
-export {
-  useHotkeys_default as default,
-  useHotkeys
-};
-//# sourceMappingURL=useHotkeys.js.map
+}
+
+export { useHotkeys as default };

package/esm/hooks/useHoverHandlersDelay.js

@@ -1,11 +1,12 @@
-import * as React from "react";
-import { useCallback, useRef } from "react";
-const useHoverHandlersDelay = ({
-  onMouseOver,
-  onMouseLeave,
-  hideDelay = 300,
-  showDelay = 300
-}) => {
+import { useRef, useCallback } from 'react';
+
+function useHoverHandlersDelay(_ref) {
+  let {
+    onMouseOver,
+    onMouseLeave,
+    hideDelay = 300,
+    showDelay = 300
+  } = _ref;
   const hideTimer = useRef();
   const showTimer = useRef();
   const delayedHide = useCallback(() => {
@@ -20,10 +21,6 @@ const useHoverHandlersDelay = ({
     onMouseOver: delayedShow,
     onMouseLeave: delayedHide
   };
-};
-var useHoverHandlersDelay_default = useHoverHandlersDelay;
-export {
-  useHoverHandlersDelay_default as default,
-  useHoverHandlersDelay
-};
-//# sourceMappingURL=useHoverHandlersDelay.js.map
+}
+
+export { useHoverHandlersDelay as default };

package/esm/hooks/useOnElementResize.js

@@ -1,17 +1,27 @@
-import * as React from "react";
-import { useState, useEffect, useRef, useMemo } from "react";
-const useOnElementResize = (targetRef) => {
-  const [width, setWidth] = useState(targetRef.current ? targetRef.current?.offsetWidth : 0);
-  const [height, setHeight] = useState(targetRef.current ? targetRef.current?.offsetWidth : 0);
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useRef, useEffect, useMemo } from 'react';
+
+// Taken and modified from https://stackoverflow.com/a/60218754
+
+const useOnElementResize = targetRef => {
+  var _targetRef$current, _targetRef$current2;
+
+  const [width, setWidth] = useState(targetRef.current ? (_targetRef$current = targetRef.current) === null || _targetRef$current === void 0 ? void 0 : _targetRef$current.offsetWidth : 0);
+  const [height, setHeight] = useState(targetRef.current ? (_targetRef$current2 = targetRef.current) === null || _targetRef$current2 === void 0 ? void 0 : _targetRef$current2.offsetWidth : 0);
   const observer = useRef(null);
   useEffect(() => {
     function outputsize() {
-      setWidth(targetRef.current?.offsetWidth);
-      setHeight(targetRef.current?.offsetHeight);
+      var _targetRef$current3, _targetRef$current4;
+
+      setWidth((_targetRef$current3 = targetRef.current) === null || _targetRef$current3 === void 0 ? void 0 : _targetRef$current3.offsetWidth);
+      setHeight((_targetRef$current4 = targetRef.current) === null || _targetRef$current4 === void 0 ? void 0 : _targetRef$current4.offsetHeight);
     }
+
     observer.current = new ResizeObserver(outputsize).observe(targetRef.current);
     return () => {
-      observer.current?.disconnect();
+      var _observer$current;
+
+      (_observer$current = observer.current) === null || _observer$current === void 0 ? void 0 : _observer$current.disconnect();
     };
   }, [targetRef]);
   return useMemo(() => ({
@@ -19,7 +29,5 @@ const useOnElementResize = (targetRef) => {
     height
   }), [width, height]);
 };
-export {
-  useOnElementResize
-};
-//# sourceMappingURL=useOnElementResize.js.map
+
+export { useOnElementResize };

package/esm/hooks/useParentElement.js

@@ -1,14 +1,12 @@
-import * as React from "react";
-import { useEffect, useState } from "react";
-const useParentElement = (ref) => {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useEffect } from 'react';
+
+const useParentElement = ref => {
   const [parent, setParent] = useState(ref.current);
   useEffect(() => {
-    if (ref.current)
-      setParent(ref.current.parentNode);
+    if (ref.current) setParent(ref.current.parentNode);
   });
   return parent;
 };
-export {
-  useParentElement
-};
-//# sourceMappingURL=useParentElement.js.map
+
+export { useParentElement };

package/esm/hooks/usePrevious.js

@@ -1,15 +1,11 @@
-import * as React from "react";
-import { useEffect, useRef } from "react";
-const usePrevious = (value) => {
+import { useRef, useEffect } from 'react';
+
+function usePrevious(value) {
   const ref = useRef();
   useEffect(() => {
     ref.current = value;
   }, [value]);
   return ref.current;
-};
-var usePrevious_default = usePrevious;
-export {
-  usePrevious_default as default,
-  usePrevious
-};
-//# sourceMappingURL=usePrevious.js.map
+}
+
+export { usePrevious as default };

package/esm/hooks/useResizeObserver.js

@@ -1,15 +1,15 @@
-import * as React from "react";
-import { useEffect, useState } from "react";
-import raf from "raf";
-import ResizeObserver from "resize-observer-polyfill";
-const useResizeObserver = (handler, el) => {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useEffect } from 'react';
+import raf from 'raf';
+import ResizeObserver from 'resize-observer-polyfill';
+
+function useResizeObserver(handler, el) {
   const [node, setRef] = useState(el);
-  const resizeObserver = new ResizeObserver((entries) => {
-    if (!Array.isArray(entries))
-      return;
-    if (!entries.length)
-      return;
-    const entry = entries[0];
+  const resizeObserver = new ResizeObserver(entries => {
+    if (!Array.isArray(entries)) return;
+    if (!entries.length) return;
+    const entry = entries[0]; // execute on the next animation frame
+
     raf(() => handler({
       width: entry.target.offsetWidth,
       height: entry.target.offsetHeight
@@ -17,15 +17,10 @@ const useResizeObserver = (handler, el) => {
   });
   const htmlEl = el || node;
   useEffect(() => {
-    if (htmlEl)
-      resizeObserver.observe(htmlEl);
+    if (htmlEl) resizeObserver.observe(htmlEl);
     return () => htmlEl && resizeObserver.unobserve(htmlEl);
   }, [htmlEl]);
   return [setRef];
-};
-var useResizeObserver_default = useResizeObserver;
-export {
-  useResizeObserver_default as default,
-  useResizeObserver
-};
-//# sourceMappingURL=useResizeObserver.js.map
+}
+
+export { useResizeObserver as default };

package/esm/hooks/useSetRef.js

@@ -1,13 +1,11 @@
-import * as React from "react";
-import { useCallback, useRef } from "react";
-const useSetRef = (initial) => {
+import { useRef, useCallback } from 'react';
+
+const useSetRef = initial => {
   const ref = useRef(initial);
-  const setRef = useCallback((node) => {
+  const setRef = useCallback(node => {
     ref.current = node;
   }, []);
   return [ref, setRef];
 };
-export {
-  useSetRef
-};
-//# sourceMappingURL=useSetRef.js.map
+
+export { useSetRef };

package/esm/hooks/useShouldRecalculate.js

@@ -1,15 +1,15 @@
-import * as React from "react";
-import { useRef } from "react";
-const useShouldRecalculate = (bool) => {
+import { useRef } from 'react';
+
+function useShouldRecalculate(bool) {
   const prevValueRef = 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;
-};
-var useShouldRecalculate_default = useShouldRecalculate;
-export {
-  useShouldRecalculate_default as default,
-  useShouldRecalculate
-};
-//# sourceMappingURL=useShouldRecalculate.js.map
+}
+
+export { useShouldRecalculate as default };

package/esm/hooks/useWindowScrollerList.js

@@ -1,11 +1,16 @@
-import * as React from "react";
-import { useEffect, useRef } from "react";
-function getScrollOffset(element = { scrollTop: 0, scrollLeft: 0 }) {
+import { useRef, useEffect } from 'react';
+
+function getScrollOffset() {
+  let element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+    scrollTop: 0,
+    scrollLeft: 0
+  };
   return {
     top: element.scrollTop,
     left: element.scrollLeft
   };
 }
+
 function getPositionOffset(listEl, scrollableEl) {
   const scrollOffset = getScrollOffset(scrollableEl);
   const elementRect = listEl.getBoundingClientRect();
@@ -15,40 +20,44 @@ function getPositionOffset(listEl, scrollableEl) {
     left: elementRect.left + scrollOffset.top - containerRect.left
   };
 }
+
 function isParent(parentNode, childNode) {
   return childNode.parentNode === parentNode || childNode.parentNode && isParent(parentNode, childNode.parentNode);
 }
-const useWindowScrollerList = ({ listInstance, outerListRef }) => {
+
+function useWindowScrollerList(_ref) {
+  let {
+    listInstance,
+    outerListRef
+  } = _ref;
   const scrollableParent = useRef();
   const listOffset = useRef();
+
   const getElementOffset = () => {
     listOffset.current = getPositionOffset(outerListRef.current, scrollableParent.current);
   };
-  const handleScroll = (e) => {
+
+  const handleScroll = e => {
     if (!scrollableParent.current) {
       const containerTarget = e.target === document ? document.body : e.target;
       scrollableParent.current = isParent(containerTarget, outerListRef.current) && containerTarget;
     }
-    if (!scrollableParent.current)
-      return;
+
+    if (!scrollableParent.current) return;
     getElementOffset();
     const scrollOffset = getScrollOffset(scrollableParent.current);
     const scrollTop = Math.max(0, scrollOffset.top - listOffset.current.top);
-    if (listInstance.current)
-      listInstance.current.scrollTo(scrollTop);
+    if (listInstance.current) listInstance.current.scrollTo(scrollTop);
   };
+
   useEffect(() => {
-    window.addEventListener("scroll", handleScroll, true);
-    window.addEventListener("resize", getElementOffset, true);
+    window.addEventListener('scroll', handleScroll, true);
+    window.addEventListener('resize', getElementOffset, true);
     return () => {
-      window.removeEventListener("scroll", handleScroll, true);
-      window.removeEventListener("resize", getElementOffset, true);
+      window.removeEventListener('scroll', handleScroll, true);
+      window.removeEventListener('resize', getElementOffset, true);
     };
   }, []);
-};
-var useWindowScrollerList_default = useWindowScrollerList;
-export {
-  useWindowScrollerList_default as default,
-  useWindowScrollerList
-};
-//# sourceMappingURL=useWindowScrollerList.js.map
+}
+
+export { useWindowScrollerList as default };

package/esm/hooks/useWindowSize.js

@@ -1,28 +1,25 @@
-import * as React from "react";
-import { useLayoutEffect, useState } from "react";
-const useWindowSize = () => {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useLayoutEffect } from 'react';
+
+function useWindowSize() {
   const [size, setSize] = useState([0, 0]);
   useLayoutEffect(() => {
-    if (!window)
-      return false;
+    if (!window) return false;
+
     function updateSize() {
       setSize([window.innerWidth, window.innerHeight]);
     }
-    window.addEventListener("resize", updateSize);
-    window.addEventListener("orientationchange", updateSize);
+
+    window.addEventListener('resize', updateSize);
+    window.addEventListener('orientationchange', updateSize);
     updateSize();
     return () => {
-      window.removeEventListener("resize", updateSize);
-      window.removeEventListener("orientationchange", updateSize);
+      window.removeEventListener('resize', updateSize);
+      window.removeEventListener('orientationchange', updateSize);
     };
   }, []);
-  if (!window)
-    return false;
+  if (!window) return false;
   return size;
-};
-var useWindowSize_default = useWindowSize;
-export {
-  useWindowSize_default as default,
-  useWindowSize
-};
-//# sourceMappingURL=useWindowSize.js.map
+}
+
+export { useWindowSize as default };