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

package/esm/Animations/GrowRight.js

@@ -1,35 +1,36 @@
-import * as React from "react";
-import React2 from "react";
-import { BaseAnimation } from "./BaseAnimation";
-const GrowRight = ({
-  keys = void 0,
-  items = void 0,
-  duration = 200,
-  from = 0,
-  to = 1,
-  children,
-  onRest = () => null
-}) => /* @__PURE__ */ React2.createElement(BaseAnimation, {
-  duration,
-  enter: {
-    opacity: `${to}`,
-    transform: "translateX(0px)"
-  },
-  from: {
-    opacity: `${from}`,
-    transform: "translateX(100%)"
-  },
-  items,
-  keys,
-  leave: {
-    opacity: `${from}`,
-    transform: "translateX(100%)"
-  },
-  onRest
-}, children);
-var GrowRight_default = GrowRight;
-export {
-  GrowRight,
-  GrowRight_default as default
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'react';
+import BaseAnimation from './BaseAnimation.js';
+
+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),
+      transform: 'translateX(0px)'
+    },
+    from: {
+      opacity: "".concat(from),
+      transform: 'translateX(100%)'
+    },
+    items: items,
+    keys: keys,
+    leave: {
+      opacity: "".concat(from),
+      transform: 'translateX(100%)'
+    },
+    onRest: onRest
+  }, void 0, children);
 };
-//# sourceMappingURL=GrowRight.js.map
+
+export { GrowRight as default };

package/esm/Animations/GrowVertical.js

@@ -1,29 +1,4 @@
-import * as React from "react";
-import React2 from "react";
-import { BaseAnimation } from "./BaseAnimation";
-const GrowVertical = ({
-  keys = void 0,
-  duration,
-  items = void 0,
-  from = 0,
-  to = 1,
-  children,
-  onRest = () => null
-}) => /* @__PURE__ */ React2.createElement(BaseAnimation, {
-  duration,
-  enter: { opacity: 1, transform: `scaleY(${to})`, transformOrigin: "top" },
-  from: {
-    opacity: 0,
-    transform: `scaleY(${from})`,
-    transformOrigin: "top"
-  },
-  items,
-  keys,
-  leave: {
-    opacity: 0,
-    transform: `scaleY(${from})`,
-    transformOrigin: "top"
-  },
-  onRest
-}, children);
-//# sourceMappingURL=GrowVertical.js.map
+import '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'react';
+import 'react-spring/renderprops';

package/esm/CheckableGroup.js

@@ -1,47 +1,64 @@
-import * as React from "react";
-import React2, { cloneElement } from "react";
-import PropTypes from "prop-types";
-import { addOrRemove, runAll, useDerivedStateFromProps } from "@elliemae/ds-utilities";
-function useCheckableGroup({
-  children,
-  active: activeProp,
-  multi,
-  onCheck = () => null
-}) {
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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 { useDerivedStateFromProps, runAll, addOrRemove } from '@elliemae/ds-utilities';
+
+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 useCheckableGroup(_ref) {
+  let {
+    children,
+    active: activeProp,
+    multi,
+    onCheck = () => null
+  } = _ref;
   const [active, setActive] = useDerivedStateFromProps(activeProp);
-  const handleCheck = ({ target: { value } }, item) => {
-    setActive((prevActive) => {
+
+  const handleCheck = (_ref2, item) => {
+    let {
+      target: {
+        value
+      }
+    } = _ref2;
+    setActive(prevActive => {
       const nextActive = multi ? addOrRemove(prevActive, value) : value;
       onCheck(nextActive, item);
       return nextActive;
     });
   };
-  return React2.Children.map(children, (child) => {
-    const { props } = child;
+
+  return React.Children.map(children, child => {
+    const {
+      props
+    } = child;
     const checked = Array.isArray(active) ? active.indexOf(props.name) !== -1 : active === props.name;
-    return cloneElement(child, {
-      ...props,
+    return /*#__PURE__*/cloneElement(child, _objectSpread(_objectSpread({}, props), {}, {
       checked,
       onClick: runAll(handleCheck, props.onClick)
-    });
+    }));
   });
 }
-function CheckableGroup({
-  active = [],
-  multi = false,
-  children
-}) {
-  return useCheckableGroup({ active, multi, children });
+
+function CheckableGroup(_ref3) {
+  let {
+    active = [],
+    multi = false,
+    // checkbox or radio
+    children
+  } = _ref3;
+  return useCheckableGroup({
+    active,
+    multi,
+    children
+  });
 }
-CheckableGroup.propTypes = {
-  active: PropTypes.arrayOf(PropTypes.string),
-  multi: PropTypes.bool,
-  onCheck: PropTypes.func
-};
-var CheckableGroup_default = CheckableGroup;
-export {
-  CheckableGroup,
-  CheckableGroup_default as default,
-  useCheckableGroup
-};
-//# sourceMappingURL=CheckableGroup.js.map
+
+export { CheckableGroup as default, useCheckableGroup };

package/esm/DeferRenderAfterComputation.js

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

package/esm/FocusGroup/FocusGrid.js

@@ -1,16 +1,37 @@
-import * as React from "react";
-import React2, { createContext, useEffect, useMemo, useRef } from "react";
-import { isFunction, runAll, get, useHotkeys, mergeRefs } from "@elliemae/ds-utilities";
-import { getNextCellPosition } from "./utils/getNextCellPosition";
-const FocusGridContext = createContext();
-const { Provider } = FocusGridContext;
-const preventDefault = (e) => e.preventDefault();
-function registerHotKeysHooks(hotKeys, { focusedRow, focusedCell }) {
-  Object.keys(hotKeys).forEach((key) => {
-    const { handler, options } = hotKeys[key];
+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';
+
+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 FocusGridContext = /*#__PURE__*/createContext();
+const {
+  Provider
+} = FocusGridContext;
+
+const preventDefault = e => e.preventDefault();
+
+function registerHotKeysHooks(hotKeys, _ref) {
+  let {
+    focusedRow,
+    focusedCell
+  } = _ref;
+  Object.keys(hotKeys).forEach(key => {
+    const {
+      handler,
+      options
+    } = hotKeys[key];
     useHotkeys({
       keys: key,
-      handler: (e) => {
+      handler: e => {
         e.preventDefault();
         handler({
           rowIndex: focusedRow.current,
@@ -20,59 +41,76 @@ function registerHotKeysHooks(hotKeys, { focusedRow, focusedCell }) {
       options
     });
   });
-}
-const FocusGridProvider = ({
-  shouldWrapRows = false,
-  shouldWrapCells = false,
-  shouldRefocus = true,
-  children,
-  keyBindings,
-  hotKeys
-}) => {
+} // eslint-disable-next-line max-statements
+
+
+function FocusGridProvider(_ref2) {
+  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 = React2.Children.only(children);
-  const decoratedChild = React2.cloneElement(child, {
+  const child = React.Children.only(children);
+  const decoratedChild = /*#__PURE__*/React.cloneElement(child, {
     innerRef: mergeRefs(child.props.innerRef, containerRef)
   });
-  const getNode = ({ rowIndex, cellIndex }) => get(grid.current, [rowIndex, cellIndex]);
+
+  const getNode = _ref3 => {
+    let {
+      rowIndex,
+      cellIndex
+    } = _ref3;
+    return get(grid.current, [rowIndex, cellIndex]);
+  };
+
   const register = (node, rowIndex, columnIndex) => {
-    if (!node)
-      return;
+    if (!node) return;
+
     if (!Array.isArray(grid.current[rowIndex])) {
       grid.current[rowIndex] = [];
     }
+
     if (rowIndex === 0 && columnIndex === 0) {
-      node.setAttribute("tabindex", 0);
+      node.setAttribute('tabindex', 0);
     } else {
-      node.setAttribute("tabindex", -1);
+      node.setAttribute('tabindex', -1);
     }
+
     node.onfocus = () => {
       const prevNode = getNode({
         rowIndex: focusedRow.current,
         cellIndex: focusedCell.current
       });
-      if (prevNode)
-        prevNode.setAttribute("tabindex", -1);
-      node.setAttribute("tabindex", 0);
+      if (prevNode) prevNode.setAttribute('tabindex', -1);
+      node.setAttribute('tabindex', 0);
       focusedRow.current = rowIndex;
       focusedCell.current = columnIndex;
     };
+
     grid.current[rowIndex][columnIndex] = node;
   };
+
   useEffect(() => {
     if (shouldRefocus) {
       const rowIndex = focusedRow.current;
       const cellIndex = focusedCell.current;
       const node = get(grid.current, [rowIndex, cellIndex]);
-      if (node)
-        node.focus();
+      if (node) node.focus();
     }
   });
+
   const focusNextCell = (directionY, directionX, position) => {
-    const { rowIndex, cellIndex } = position || getNextCellPosition({
+    const {
+      rowIndex,
+      cellIndex
+    } = position || getNextCellPosition({
       grid: grid.current,
       currentCell: focusedCell.current,
       currentRow: focusedRow.current,
@@ -81,53 +119,74 @@ const FocusGridProvider = ({
       shouldWrapCells,
       shouldWrapRows
     });
-    const node = getNode({ rowIndex, cellIndex });
+    const node = getNode({
+      rowIndex,
+      cellIndex
+    }); // can focus
+
     if (node) {
       node.focus();
       focusedRow.current = rowIndex;
       focusedCell.current = cellIndex;
     }
   };
-  registerHotKeysHooks(hotKeys, { focusedCell, focusedRow });
-  const defaultKeyBindings = {
+
+  registerHotKeysHooks(hotKeys, {
+    focusedCell,
+    focusedRow
+  });
+
+  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) => {
+    Home: runAll(preventDefault, e => {
       let rowIndex = focusedRow.current;
+
       if (e.ctrlKey) {
         rowIndex = 0;
       }
-      focusNextCell(0, 0, { rowIndex, cellIndex: 0 });
+
+      focusNextCell(0, 0, {
+        rowIndex,
+        cellIndex: 0
+      });
     }),
-    End: runAll(preventDefault, (e) => {
+    End: runAll(preventDefault, e => {
       let rowIndex = focusedRow.current;
+
       if (e.ctrlKey) {
         rowIndex = grid.current.length - 1;
       }
-      focusNextCell(0, 0, { rowIndex, cellIndex: grid.current[0].length - 1 });
-    }),
-    ...keyBindings
-  };
+
+      focusNextCell(0, 0, {
+        rowIndex,
+        cellIndex: grid.current[0].length - 1
+      });
+    })
+  }, keyBindings);
+
   const nextKeyBindings = isFunction(keyBindings) ? keyBindings({
     defaultBindings: defaultKeyBindings,
     rowIndex: focusedRow.current,
     cellIndex: focusedCell.current
-  }) : { ...defaultKeyBindings, ...keyBindings };
-  const onKeyDown = (e) => {
-    if (e.target.tagName.toLowerCase() === "input")
-      return;
+  }) : _objectSpread(_objectSpread({}, defaultKeyBindings), keyBindings);
+
+  const onKeyDown = e => {
+    if (e.target.tagName.toLowerCase() === 'input') return;
     const action = nextKeyBindings[e.key];
-    if (isFunction(action))
-      action(e);
+    if (isFunction(action)) action(e);
   };
-  const activate = (container) => {
-    container.addEventListener("keydown", onKeyDown, true);
+
+  const activate = container => {
+    container.addEventListener('keydown', onKeyDown, true);
   };
-  const deactivate = (container) => {
-    container.removeEventListener("keydown", onKeyDown, true);
+
+  const deactivate = container => {
+    container.removeEventListener('keydown', onKeyDown, true);
   };
+
   useEffect(() => {
     activate(containerRef.current);
     return () => {
@@ -137,15 +196,9 @@ const FocusGridProvider = ({
   const valueProvider = useMemo(() => ({
     register
   }), []);
-  return /* @__PURE__ */ React2.createElement(Provider, {
+  return /*#__PURE__*/_jsx(Provider, {
     value: valueProvider
-  }, decoratedChild);
-};
-var FocusGrid_default = FocusGridProvider;
-export {
-  FocusGridProvider as FocusGrid,
-  FocusGridContext,
-  FocusGridProvider,
-  FocusGrid_default as default
-};
-//# sourceMappingURL=FocusGrid.js.map
+  }, void 0, decoratedChild);
+}
+
+export { FocusGridContext, FocusGridProvider as default };