@elliemae/ds-shared 2.3.0-alpha.8 → 2.3.0-next.10

package/cjs/Animations/BaseAnimation.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('react');
+var renderprops = require('react-spring/renderprops');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+const BaseAnimation = _ref => {
+  let {
+    keys = undefined,
+    items = [],
+    duration = 100,
+    enter = {},
+    from = {},
+    leave = {},
+    onRest = () => null,
+    children
+  } = _ref;
+  return /*#__PURE__*/_jsx__default["default"](renderprops.Transition, {
+    config: {
+      duration
+    },
+    enter: enter,
+    from: from,
+    items: items,
+    keys: keys,
+    leave: leave,
+    onRest: onRest
+  }, void 0, children);
+};
+
+module.exports = BaseAnimation;

package/cjs/Animations/Grow.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('react');
+var BaseAnimation = require('./BaseAnimation.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+const Grow = _ref => {
+  let {
+    keys = undefined,
+    duration,
+    items = undefined,
+    from = 0,
+    to = 1,
+    children,
+    onRest = () => null
+  } = _ref;
+  return /*#__PURE__*/_jsx__default["default"](BaseAnimation, {
+    duration: duration,
+    enter: {
+      opacity: 1,
+      transform: "scale(".concat(to, ")")
+    },
+    from: {
+      opacity: 0,
+      transform: "scale(".concat(from, ")")
+    },
+    items: items,
+    keys: keys,
+    leave: {
+      opacity: 0,
+      transform: "scale(".concat(from, ")")
+    },
+    onRest: onRest
+  }, void 0, children);
+};
+
+module.exports = Grow;

package/cjs/Animations/GrowRight.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('react');
+var BaseAnimation = require('./BaseAnimation.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+const GrowRight = _ref => {
+  let {
+    keys = undefined,
+    items = undefined,
+    duration = 200,
+    from = 0,
+    to = 1,
+    children,
+    onRest = () => null
+  } = _ref;
+  return /*#__PURE__*/_jsx__default["default"](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);
+};
+
+module.exports = GrowRight;

package/cjs/Animations/GrowVertical.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('react');
+require('react-spring/renderprops');
+

package/cjs/CheckableGroup.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.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 dsUtilities = require('@elliemae/ds-utilities');
+
+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 useCheckableGroup(_ref) {
+  let {
+    children,
+    active: activeProp,
+    multi,
+    onCheck = () => null
+  } = _ref;
+  const [active, setActive] = dsUtilities.useDerivedStateFromProps(activeProp);
+
+  const handleCheck = (_ref2, item) => {
+    let {
+      target: {
+        value
+      }
+    } = _ref2;
+    setActive(prevActive => {
+      const nextActive = multi ? dsUtilities.addOrRemove(prevActive, value) : value;
+      onCheck(nextActive, item);
+      return nextActive;
+    });
+  };
+
+  return React__default["default"].Children.map(children, child => {
+    const {
+      props
+    } = child;
+    const checked = Array.isArray(active) ? active.indexOf(props.name) !== -1 : active === props.name;
+    return /*#__PURE__*/React.cloneElement(child, _objectSpread(_objectSpread({}, props), {}, {
+      checked,
+      onClick: dsUtilities.runAll(handleCheck, props.onClick)
+    }));
+  });
+}
+
+function CheckableGroup(_ref3) {
+  let {
+    active = [],
+    multi = false,
+    // checkbox or radio
+    children
+  } = _ref3;
+  return useCheckableGroup({
+    active,
+    multi,
+    children
+  });
+}
+
+exports["default"] = CheckableGroup;
+exports.useCheckableGroup = useCheckableGroup;

package/cjs/DeferRenderAfterComputation.js

@@ -0,0 +1,28 @@
+'use strict';
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+var raf = require('raf');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var raf__default = /*#__PURE__*/_interopDefaultLegacy(raf);
+
+function DeferRenderAfterComputation(_ref) {
+  let {
+    children,
+    resolve,
+    fallback,
+    timeout = 2000
+  } = _ref;
+  const [shouldRender, setShouldRender] = React.useState(false);
+  React.useEffect(() => {
+    // eslint-disable-next-line max-nested-callbacks
+    raf__default["default"](() => raf__default["default"](() => resolve().then(() => {
+      setShouldRender(true);
+    })));
+  }, []);
+  return shouldRender ? children : fallback;
+}
+
+module.exports = DeferRenderAfterComputation;

package/cjs/FocusGroup/FocusGrid.js

@@ -0,0 +1,215 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+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');
+var dsUtilities = require('@elliemae/ds-utilities');
+var getNextCellPosition = require('./utils/getNextCellPosition.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+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; }
+const FocusGridContext = /*#__PURE__*/React.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];
+    dsUtilities.useHotkeys({
+      keys: key,
+      handler: e => {
+        e.preventDefault();
+        handler({
+          rowIndex: focusedRow.current,
+          cellIndex: focusedCell.current
+        });
+      },
+      options
+    });
+  });
+} // eslint-disable-next-line max-statements
+
+
+function FocusGridProvider(_ref2) {
+  let {
+    shouldWrapRows = false,
+    shouldWrapCells = false,
+    shouldRefocus = true,
+    children,
+    keyBindings,
+    hotKeys
+  } = _ref2;
+  const focusedRow = React.useRef();
+  const focusedCell = React.useRef();
+  const grid = React.useRef([]);
+  const containerRef = React.useRef(document);
+  const child = React__default["default"].Children.only(children);
+  const decoratedChild = /*#__PURE__*/React__default["default"].cloneElement(child, {
+    innerRef: dsUtilities.mergeRefs(child.props.innerRef, containerRef)
+  });
+
+  const getNode = _ref3 => {
+    let {
+      rowIndex,
+      cellIndex
+    } = _ref3;
+    return dsUtilities.get(grid.current, [rowIndex, cellIndex]);
+  };
+
+  const register = (node, rowIndex, columnIndex) => {
+    if (!node) return;
+
+    if (!Array.isArray(grid.current[rowIndex])) {
+      grid.current[rowIndex] = [];
+    }
+
+    if (rowIndex === 0 && columnIndex === 0) {
+      node.setAttribute('tabindex', 0);
+    } else {
+      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);
+      focusedRow.current = rowIndex;
+      focusedCell.current = columnIndex;
+    };
+
+    grid.current[rowIndex][columnIndex] = node;
+  };
+
+  React.useEffect(() => {
+    if (shouldRefocus) {
+      const rowIndex = focusedRow.current;
+      const cellIndex = focusedCell.current;
+      const node = dsUtilities.get(grid.current, [rowIndex, cellIndex]);
+      if (node) node.focus();
+    }
+  });
+
+  const focusNextCell = (directionY, directionX, position) => {
+    const {
+      rowIndex,
+      cellIndex
+    } = position || getNextCellPosition({
+      grid: grid.current,
+      currentCell: focusedCell.current,
+      currentRow: focusedRow.current,
+      directionX,
+      directionY,
+      shouldWrapCells,
+      shouldWrapRows
+    });
+    const node = getNode({
+      rowIndex,
+      cellIndex
+    }); // can focus
+
+    if (node) {
+      node.focus();
+      focusedRow.current = rowIndex;
+      focusedCell.current = cellIndex;
+    }
+  };
+
+  registerHotKeysHooks(hotKeys, {
+    focusedCell,
+    focusedRow
+  });
+
+  const defaultKeyBindings = _objectSpread({
+    ArrowUp: dsUtilities.runAll(preventDefault, () => focusNextCell(-1, 0)),
+    ArrowRight: dsUtilities.runAll(preventDefault, () => focusNextCell(0, 1)),
+    ArrowDown: dsUtilities.runAll(preventDefault, () => focusNextCell(1, 0)),
+    ArrowLeft: dsUtilities.runAll(preventDefault, () => focusNextCell(0, -1)),
+    Home: dsUtilities.runAll(preventDefault, e => {
+      let rowIndex = focusedRow.current;
+
+      if (e.ctrlKey) {
+        rowIndex = 0;
+      }
+
+      focusNextCell(0, 0, {
+        rowIndex,
+        cellIndex: 0
+      });
+    }),
+    End: dsUtilities.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);
+
+  const nextKeyBindings = dsUtilities.isFunction(keyBindings) ? keyBindings({
+    defaultBindings: defaultKeyBindings,
+    rowIndex: focusedRow.current,
+    cellIndex: focusedCell.current
+  }) : _objectSpread(_objectSpread({}, defaultKeyBindings), keyBindings);
+
+  const onKeyDown = e => {
+    if (e.target.tagName.toLowerCase() === 'input') return;
+    const action = nextKeyBindings[e.key];
+    if (dsUtilities.isFunction(action)) action(e);
+  };
+
+  const activate = container => {
+    container.addEventListener('keydown', onKeyDown, true);
+  };
+
+  const deactivate = container => {
+    container.removeEventListener('keydown', onKeyDown, true);
+  };
+
+  React.useEffect(() => {
+    activate(containerRef.current);
+    return () => {
+      deactivate(containerRef.current);
+    };
+  }, []);
+  const valueProvider = React.useMemo(() => ({
+    register
+  }), []);
+  return /*#__PURE__*/_jsx__default["default"](Provider, {
+    value: valueProvider
+  }, void 0, decoratedChild);
+}
+
+exports.FocusGridContext = FocusGridContext;
+exports["default"] = FocusGridProvider;