@elliemae/ds-shared 1.60.0 → 2.0.0-alpha.12

package/esm/Animations/GrowRight.js

@@ -1,24 +1,19 @@
-import React from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'react';
 import BaseAnimation from './BaseAnimation.js';
-import 'react-spring/renderprops.cjs';
 
-var GrowRight = function GrowRight(_ref) {
-  var _ref$keys = _ref.keys,
-      keys = _ref$keys === void 0 ? undefined : _ref$keys,
-      _ref$items = _ref.items,
-      items = _ref$items === void 0 ? undefined : _ref$items,
-      _ref$duration = _ref.duration,
-      duration = _ref$duration === void 0 ? 200 : _ref$duration,
-      _ref$from = _ref.from,
-      from = _ref$from === void 0 ? 0 : _ref$from,
-      _ref$to = _ref.to,
-      to = _ref$to === void 0 ? 1 : _ref$to,
-      children = _ref.children,
-      _ref$onRest = _ref.onRest,
-      onRest = _ref$onRest === void 0 ? function () {
-    return null;
-  } : _ref$onRest;
-  return /*#__PURE__*/React.createElement(BaseAnimation, {
+const GrowRight = _ref => {
+  let {
+    keys = undefined,
+    items = undefined,
+    duration = 200,
+    from = 0,
+    to = 1,
+    children,
+    onRest = () => null
+  } = _ref;
+  return /*#__PURE__*/_jsx(BaseAnimation, {
     duration: duration,
     enter: {
       opacity: "".concat(to),
@@ -35,8 +30,7 @@ var GrowRight = function GrowRight(_ref) {
       transform: 'translateX(100%)'
     },
     onRest: onRest
-  }, children);
+  }, void 0, children);
 };
 
 export { GrowRight as default };
-//# sourceMappingURL=GrowRight.js.map

package/esm/Animations/GrowVertical.js

@@ -1,3 +1,4 @@
+import '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import 'react';
-import 'react-spring/renderprops.cjs';
-//# sourceMappingURL=GrowVertical.js.map
+import 'react-spring/renderprops';

package/esm/CheckableGroup.js

@@ -1,68 +1,64 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+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 React, { cloneElement } from 'react';
-import PropTypes from 'prop-types';
 import { useDerivedStateFromProps, runAll, addOrRemove } from '@elliemae/ds-utilities';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 function useCheckableGroup(_ref) {
-  var children = _ref.children,
-      activeProp = _ref.active,
-      multi = _ref.multi,
-      _ref$onCheck = _ref.onCheck,
-      onCheck = _ref$onCheck === void 0 ? function () {
-    return null;
-  } : _ref$onCheck;
+  let {
+    children,
+    active: activeProp,
+    multi,
+    onCheck = () => null
+  } = _ref;
+  const [active, setActive] = useDerivedStateFromProps(activeProp);
 
-  var _useDerivedStateFromP = useDerivedStateFromProps(activeProp),
-      _useDerivedStateFromP2 = _slicedToArray(_useDerivedStateFromP, 2),
-      active = _useDerivedStateFromP2[0],
-      setActive = _useDerivedStateFromP2[1];
-
-  var handleCheck = function handleCheck(_ref2, item) {
-    var value = _ref2.target.value;
-    setActive(function (prevActive) {
-      var nextActive = multi ? addOrRemove(prevActive, value) : value;
+  const handleCheck = (_ref2, item) => {
+    let {
+      target: {
+        value
+      }
+    } = _ref2;
+    setActive(prevActive => {
+      const nextActive = multi ? addOrRemove(prevActive, value) : value;
       onCheck(nextActive, item);
       return nextActive;
     });
   };
 
-  return React.Children.map(children, function (child) {
-    var props = child.props;
-    var checked = Array.isArray(active) ? active.indexOf(props.name) !== -1 : active === props.name;
+  return React.Children.map(children, child => {
+    const {
+      props
+    } = child;
+    const checked = Array.isArray(active) ? active.indexOf(props.name) !== -1 : active === props.name;
     return /*#__PURE__*/cloneElement(child, _objectSpread(_objectSpread({}, props), {}, {
-      checked: checked,
+      checked,
       onClick: runAll(handleCheck, props.onClick)
     }));
   });
 }
 
 function CheckableGroup(_ref3) {
-  var _ref3$active = _ref3.active,
-      active = _ref3$active === void 0 ? [] : _ref3$active,
-      _ref3$multi = _ref3.multi,
-      multi = _ref3$multi === void 0 ? false : _ref3$multi,
-      children = _ref3.children;
+  let {
+    active = [],
+    multi = false,
+    // checkbox or radio
+    children
+  } = _ref3;
   return useCheckableGroup({
-    active: active,
-    multi: multi,
-    children: children
+    active,
+    multi,
+    children
   });
 }
 
-CheckableGroup.propTypes = {
-  /* The item (if multi false) or items (if multi true) selected */
-  active: PropTypes.arrayOf(PropTypes.string),
-
-  /* Whether is multi select or not */
-  multi: PropTypes.bool,
-
-  /* Handler when a user checks an item */
-  onCheck: PropTypes.func
-};
-
 export { CheckableGroup as default, useCheckableGroup };
-//# sourceMappingURL=CheckableGroup.js.map

package/esm/DeferRenderAfterComputation.js

@@ -1,30 +1,22 @@
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import { useState, useEffect } from 'react';
 import raf from 'raf';
 
 function DeferRenderAfterComputation(_ref) {
-  var children = _ref.children,
-      resolve = _ref.resolve,
-      fallback = _ref.fallback;
-      _ref.timeout;
-
-  var _useState = useState(false),
-      _useState2 = _slicedToArray(_useState, 2),
-      shouldRender = _useState2[0],
-      setShouldRender = _useState2[1];
-
-  useEffect(function () {
+  let {
+    children,
+    resolve,
+    fallback,
+    timeout = 2000
+  } = _ref;
+  const [shouldRender, setShouldRender] = useState(false);
+  useEffect(() => {
     // eslint-disable-next-line max-nested-callbacks
-    raf(function () {
-      return raf(function () {
-        return resolve().then(function () {
-          setShouldRender(true);
-        });
-      });
-    });
+    raf(() => raf(() => resolve().then(() => {
+      setShouldRender(true);
+    })));
   }, []);
   return shouldRender ? children : fallback;
 }
 
 export { DeferRenderAfterComputation as default };
-//# sourceMappingURL=DeferRenderAfterComputation.js.map

package/esm/FocusGroup/FocusGrid.js

@@ -1,4 +1,10 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
 import React, { useRef, useEffect, useMemo, createContext } from 'react';
 import { mergeRefs, get, runAll, isFunction, useHotkeys } from '@elliemae/ds-utilities';
 import getNextCellPosition from './utils/getNextCellPosition.js';
@@ -6,62 +12,65 @@ import getNextCellPosition from './utils/getNextCellPosition.js';
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-var FocusGridContext = /*#__PURE__*/createContext();
-var Provider = FocusGridContext.Provider;
+const FocusGridContext = /*#__PURE__*/createContext();
+const {
+  Provider
+} = FocusGridContext;
 
-var preventDefault = function preventDefault(e) {
-  return e.preventDefault();
-};
+const preventDefault = e => e.preventDefault();
 
 function registerHotKeysHooks(hotKeys, _ref) {
-  var focusedRow = _ref.focusedRow,
-      focusedCell = _ref.focusedCell;
-  Object.keys(hotKeys).forEach(function (key) {
-    var _hotKeys$key = hotKeys[key],
-        _handler = _hotKeys$key.handler,
-        options = _hotKeys$key.options;
+  let {
+    focusedRow,
+    focusedCell
+  } = _ref;
+  Object.keys(hotKeys).forEach(key => {
+    const {
+      handler,
+      options
+    } = hotKeys[key];
     useHotkeys({
       keys: key,
-      handler: function handler(e) {
+      handler: e => {
         e.preventDefault();
-
-        _handler({
+        handler({
           rowIndex: focusedRow.current,
           cellIndex: focusedCell.current
         });
       },
-      options: options
+      options
     });
   });
 } // eslint-disable-next-line max-statements
 
 
 function FocusGridProvider(_ref2) {
-  var _ref2$shouldWrapRows = _ref2.shouldWrapRows,
-      shouldWrapRows = _ref2$shouldWrapRows === void 0 ? false : _ref2$shouldWrapRows,
-      _ref2$shouldWrapCells = _ref2.shouldWrapCells,
-      shouldWrapCells = _ref2$shouldWrapCells === void 0 ? false : _ref2$shouldWrapCells,
-      _ref2$shouldRefocus = _ref2.shouldRefocus,
-      shouldRefocus = _ref2$shouldRefocus === void 0 ? true : _ref2$shouldRefocus,
-      children = _ref2.children,
-      keyBindings = _ref2.keyBindings,
-      hotKeys = _ref2.hotKeys;
-  var focusedRow = useRef();
-  var focusedCell = useRef();
-  var grid = useRef([]);
-  var containerRef = useRef(document);
-  var child = React.Children.only(children);
-  var decoratedChild = /*#__PURE__*/React.cloneElement(child, {
+  let {
+    shouldWrapRows = false,
+    shouldWrapCells = false,
+    shouldRefocus = true,
+    children,
+    keyBindings,
+    hotKeys
+  } = _ref2;
+  const focusedRow = useRef();
+  const focusedCell = useRef();
+  const grid = useRef([]);
+  const containerRef = useRef(document);
+  const child = React.Children.only(children);
+  const decoratedChild = /*#__PURE__*/React.cloneElement(child, {
     innerRef: mergeRefs(child.props.innerRef, containerRef)
   });
 
-  var getNode = function getNode(_ref3) {
-    var rowIndex = _ref3.rowIndex,
-        cellIndex = _ref3.cellIndex;
+  const getNode = _ref3 => {
+    let {
+      rowIndex,
+      cellIndex
+    } = _ref3;
     return get(grid.current, [rowIndex, cellIndex]);
   };
 
-  var register = function register(node, rowIndex, columnIndex) {
+  const register = (node, rowIndex, columnIndex) => {
     if (!node) return;
 
     if (!Array.isArray(grid.current[rowIndex])) {
@@ -74,8 +83,8 @@ function FocusGridProvider(_ref2) {
       node.setAttribute('tabindex', -1);
     }
 
-    node.onfocus = function () {
-      var prevNode = getNode({
+    node.onfocus = () => {
+      const prevNode = getNode({
         rowIndex: focusedRow.current,
         cellIndex: focusedCell.current
       });
@@ -88,31 +97,31 @@ function FocusGridProvider(_ref2) {
     grid.current[rowIndex][columnIndex] = node;
   };
 
-  useEffect(function () {
+  useEffect(() => {
     if (shouldRefocus) {
-      var rowIndex = focusedRow.current;
-      var cellIndex = focusedCell.current;
-      var node = get(grid.current, [rowIndex, cellIndex]);
+      const rowIndex = focusedRow.current;
+      const cellIndex = focusedCell.current;
+      const node = get(grid.current, [rowIndex, cellIndex]);
       if (node) node.focus();
     }
   });
 
-  var focusNextCell = function focusNextCell(directionY, directionX, position) {
-    var _ref4 = position || getNextCellPosition({
+  const focusNextCell = (directionY, directionX, position) => {
+    const {
+      rowIndex,
+      cellIndex
+    } = position || getNextCellPosition({
       grid: grid.current,
       currentCell: focusedCell.current,
       currentRow: focusedRow.current,
-      directionX: directionX,
-      directionY: directionY,
-      shouldWrapCells: shouldWrapCells,
-      shouldWrapRows: shouldWrapRows
-    }),
-        rowIndex = _ref4.rowIndex,
-        cellIndex = _ref4.cellIndex;
-
-    var node = getNode({
-      rowIndex: rowIndex,
-      cellIndex: cellIndex
+      directionX,
+      directionY,
+      shouldWrapCells,
+      shouldWrapRows
+    });
+    const node = getNode({
+      rowIndex,
+      cellIndex
     }); // can focus
 
     if (node) {
@@ -123,84 +132,73 @@ function FocusGridProvider(_ref2) {
   };
 
   registerHotKeysHooks(hotKeys, {
-    focusedCell: focusedCell,
-    focusedRow: focusedRow
+    focusedCell,
+    focusedRow
   });
 
-  var defaultKeyBindings = _objectSpread({
-    ArrowUp: runAll(preventDefault, function () {
-      return focusNextCell(-1, 0);
-    }),
-    ArrowRight: runAll(preventDefault, function () {
-      return focusNextCell(0, 1);
-    }),
-    ArrowDown: runAll(preventDefault, function () {
-      return focusNextCell(1, 0);
-    }),
-    ArrowLeft: runAll(preventDefault, function () {
-      return focusNextCell(0, -1);
-    }),
-    Home: runAll(preventDefault, function (e) {
-      var rowIndex = focusedRow.current;
+  const defaultKeyBindings = _objectSpread({
+    ArrowUp: runAll(preventDefault, () => focusNextCell(-1, 0)),
+    ArrowRight: runAll(preventDefault, () => focusNextCell(0, 1)),
+    ArrowDown: runAll(preventDefault, () => focusNextCell(1, 0)),
+    ArrowLeft: runAll(preventDefault, () => focusNextCell(0, -1)),
+    Home: runAll(preventDefault, e => {
+      let rowIndex = focusedRow.current;
 
       if (e.ctrlKey) {
         rowIndex = 0;
       }
 
       focusNextCell(0, 0, {
-        rowIndex: rowIndex,
+        rowIndex,
         cellIndex: 0
       });
     }),
-    End: runAll(preventDefault, function (e) {
-      var rowIndex = focusedRow.current;
+    End: runAll(preventDefault, e => {
+      let rowIndex = focusedRow.current;
 
       if (e.ctrlKey) {
         rowIndex = grid.current.length - 1;
       }
 
       focusNextCell(0, 0, {
-        rowIndex: rowIndex,
+        rowIndex,
         cellIndex: grid.current[0].length - 1
       });
     })
   }, keyBindings);
 
-  var nextKeyBindings = isFunction(keyBindings) ? keyBindings({
+  const nextKeyBindings = isFunction(keyBindings) ? keyBindings({
     defaultBindings: defaultKeyBindings,
     rowIndex: focusedRow.current,
     cellIndex: focusedCell.current
   }) : _objectSpread(_objectSpread({}, defaultKeyBindings), keyBindings);
 
-  var onKeyDown = function onKeyDown(e) {
+  const onKeyDown = e => {
     if (e.target.tagName.toLowerCase() === 'input') return;
-    var action = nextKeyBindings[e.key];
+    const action = nextKeyBindings[e.key];
     if (isFunction(action)) action(e);
   };
 
-  var activate = function activate(container) {
+  const activate = container => {
     container.addEventListener('keydown', onKeyDown, true);
   };
 
-  var deactivate = function deactivate(container) {
+  const deactivate = container => {
     container.removeEventListener('keydown', onKeyDown, true);
   };
 
-  useEffect(function () {
+  useEffect(() => {
     activate(containerRef.current);
-    return function () {
+    return () => {
       deactivate(containerRef.current);
     };
   }, []);
-  var valueProvider = useMemo(function () {
-    return {
-      register: register
-    };
-  }, []);
-  return /*#__PURE__*/React.createElement(Provider, {
+  const valueProvider = useMemo(() => ({
+    register
+  }), []);
+  return /*#__PURE__*/_jsx(Provider, {
     value: valueProvider
-  }, decoratedChild);
+  }, void 0, decoratedChild);
 }
 
 export { FocusGridContext, FocusGridProvider as default };
-//# sourceMappingURL=FocusGrid.js.map