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

package/esm/Animations/Grow.js

@@ -0,0 +1,36 @@
+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 Grow = _ref => {
+  let {
+    keys = undefined,
+    duration,
+    items = undefined,
+    from = 0,
+    to = 1,
+    children,
+    onRest = () => null
+  } = _ref;
+  return /*#__PURE__*/_jsx(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);
+};
+
+export { Grow as default };

package/esm/Animations/GrowRight.js

@@ -0,0 +1,36 @@
+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);
+};
+
+export { GrowRight as default };

package/esm/Animations/GrowVertical.js

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,64 @@
+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 = (_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, 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,
+      onClick: runAll(handleCheck, props.onClick)
+    }));
+  });
+}
+
+function CheckableGroup(_ref3) {
+  let {
+    active = [],
+    multi = false,
+    // checkbox or radio
+    children
+  } = _ref3;
+  return useCheckableGroup({
+    active,
+    multi,
+    children
+  });
+}
+
+export { CheckableGroup as default, useCheckableGroup };

package/esm/DeferRenderAfterComputation.js

@@ -0,0 +1,22 @@
+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;
+}
+
+export { DeferRenderAfterComputation as default };

package/esm/FocusGroup/FocusGrid.js

@@ -0,0 +1,204 @@
+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 => {
+        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 = 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)
+  });
+
+  const getNode = _ref3 => {
+    let {
+      rowIndex,
+      cellIndex
+    } = _ref3;
+    return 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;
+  };
+
+  useEffect(() => {
+    if (shouldRefocus) {
+      const rowIndex = focusedRow.current;
+      const cellIndex = focusedCell.current;
+      const node = 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: 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,
+        cellIndex: 0
+      });
+    }),
+    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);
+
+  const nextKeyBindings = 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 (isFunction(action)) action(e);
+  };
+
+  const activate = container => {
+    container.addEventListener('keydown', onKeyDown, true);
+  };
+
+  const deactivate = container => {
+    container.removeEventListener('keydown', onKeyDown, true);
+  };
+
+  useEffect(() => {
+    activate(containerRef.current);
+    return () => {
+      deactivate(containerRef.current);
+    };
+  }, []);
+  const valueProvider = useMemo(() => ({
+    register
+  }), []);
+  return /*#__PURE__*/_jsx(Provider, {
+    value: valueProvider
+  }, void 0, decoratedChild);
+}
+
+export { FocusGridContext, FocusGridProvider as default };