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

package/cjs/FocusGroup/FocusGroup.js

@@ -1,26 +1,30 @@
 'use strict';
 
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _createClass = require('@babel/runtime/helpers/createClass');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/web.dom-collections.iterator.js');
+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.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.filter.js');
 var dsUtilities = require('@elliemae/ds-utilities');
 var hotkeys = require('hotkeys-js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
 var hotkeys__default = /*#__PURE__*/_interopDefaultLegacy(hotkeys);
 
 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__default['default'](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 defaultOptions = {
+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__default["default"](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; }
+const defaultOptions = {
   orientation: 'vertical'
 };
 
-var safeCallAction = function safeCallAction(e, fun) {
+const safeCallAction = function (e, fun) {
   if (dsUtilities.isFunction(fun)) {
     e.preventDefault();
 
@@ -28,56 +32,51 @@ var safeCallAction = function safeCallAction(e, fun) {
       args[_key - 2] = arguments[_key];
     }
 
-    fun.apply(void 0, args);
+    fun(...args);
   }
 };
 
-var registerHotkeys = function registerHotkeys() {
-  var hotKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var params = arguments.length > 1 ? arguments[1] : undefined;
-  var getContainer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
-    return document;
-  };
-  Object.keys(hotKeys).forEach(function (hotkey) {
-    var _hotKeys$hotkey = hotKeys[hotkey],
-        options = _hotKeys$hotkey.options,
-        handler = _hotKeys$hotkey.handler,
-        _hotKeys$hotkey$allow = _hotKeys$hotkey.allowDocumentHandler,
-        allowDocumentHandler = _hotKeys$hotkey$allow === void 0 ? false : _hotKeys$hotkey$allow;
-
-    var parameterizedHandler = function parameterizedHandler(e) {
-      var handlerParams = dsUtilities.isFunction(params) ? params() : params;
+const registerHotkeys = function () {
+  let hotKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let params = arguments.length > 1 ? arguments[1] : undefined;
+  let getContainer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => document;
+  Object.keys(hotKeys).forEach(hotkey => {
+    const {
+      options,
+      handler,
+      allowDocumentHandler = false
+    } = hotKeys[hotkey];
+
+    const parameterizedHandler = e => {
+      const handlerParams = dsUtilities.isFunction(params) ? params() : params;
       if (!allowDocumentHandler && handlerParams.item !== document.activeElement) return;
       e.preventDefault();
       handler(handlerParams);
     };
 
-    hotkeys__default['default'](hotkey, _objectSpread({
+    hotkeys__default["default"](hotkey, _objectSpread({
       element: getContainer()
     }, options), parameterizedHandler);
   });
 };
 
-var unregisterHotKeys = function unregisterHotKeys() {
-  var hotKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  Object.keys(hotKeys).forEach(function (hotkey) {
-    hotkeys__default['default'].unbind(hotkey);
+const unregisterHotKeys = function () {
+  let hotKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  Object.keys(hotKeys).forEach(hotkey => {
+    hotkeys__default["default"].unbind(hotkey);
   });
 };
 
-var noop = function noop() {
-  return null;
-};
-
-var FocusGroup = /*#__PURE__*/function () {
-  function FocusGroup() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-    _classCallCheck__default['default'](this, FocusGroup);
+const noop = () => null;
 
+class FocusGroup {
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     this.items = [];
     this.options = _objectSpread(_objectSpread({}, defaultOptions), options);
-    var orientation = this.options.orientation;
+    const {
+      orientation
+    } = this.options;
     this.keyBindings = _objectSpread({
       ArrowUp: orientation !== 'horizontal' && 'previous',
       ArrowRight: orientation !== 'vertical' && 'next',
@@ -97,9 +96,7 @@ var FocusGroup = /*#__PURE__*/function () {
       first: this.focusFirst.bind(this),
       last: this.focusLast.bind(this),
       exit: this.exit.bind(this),
-      enter: function enter() {
-        return null;
-      }
+      enter: () => null
     };
     this.handleKeyDown = this.handleKeyDown.bind(this);
     this.register = this.register.bind(this);
@@ -113,233 +110,199 @@ var FocusGroup = /*#__PURE__*/function () {
     this.getHotKeysParams = this.getHotKeysParams.bind(this);
   }
 
-  _createClass__default['default'](FocusGroup, [{
-    key: "getHotKeysParams",
-    value: function getHotKeysParams() {
-      var item = this.currentFocusedItem;
+  getHotKeysParams() {
+    const item = this.currentFocusedItem;
+    const {
+      index
+    } = dsUtilities.get(item, ['dataset'], {});
+    return {
+      item,
+      index
+    };
+  }
 
-      var _get = dsUtilities.get(item, ['dataset'], {}),
-          index = _get.index;
+  activate() {
+    const {
+      getContainer
+    } = this.options;
+    document.addEventListener('keydown', this.handleKeyDown, true);
+    registerHotkeys(this.options.hotKeys, this.getHotKeysParams, getContainer);
+  }
 
-      return {
-        item: item,
-        index: index
-      };
-    }
-  }, {
-    key: "activate",
-    value: function activate() {
-      var getContainer = this.options.getContainer;
-      document.addEventListener('keydown', this.handleKeyDown, true);
-      registerHotkeys(this.options.hotKeys, this.getHotKeysParams, getContainer);
-    }
-  }, {
-    key: "deactivate",
-    value: function deactivate() {
-      document.removeEventListener('keydown', this.handleKeyDown, true);
-      unregisterHotKeys(this.options.hotKeys);
-    }
-  }, {
-    key: "handleKeyDown",
-    value: function handleKeyDown(e) {
-      if (!this.isGroupActive()) return;
-      this.executeActionByEvent(e);
-    }
-  }, {
-    key: "executeActionByEvent",
-    value: function executeActionByEvent(e) {
-      var _this = this;
-
-      var actions = Array.isArray(this.keyBindings[e.key]) ? this.keyBindings[e.key] : [this.keyBindings[e.key]];
-      return actions.map(function (action) {
-        return typeof action === 'string' ? safeCallAction(e, _this.mapActions[action]) : safeCallAction(e, action);
-      });
-    }
-  }, {
-    key: "register",
-    value: function register(node) {
-      var _this2 = this;
-
-      var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var afterIndex = this.items.findIndex(function (item) {
-        return item.compareDocumentPosition(node) === Node.DOCUMENT_POSITION_PRECEDING;
-      });
-      node.specialOnFocus = props.onFocus || noop;
-      node.specialOnBlur = props.onBlur || noop;
-
-      node.onclick = function () {
-        return _this2.focusItem(node);
-      };
-
-      node.onfocus = function () {
-        _this2.focusItem(node);
-      };
-
-      if (afterIndex === -1) {
-        this.items.push(node);
-      } else {
-        this.items.splice(afterIndex, 0, node);
-      }
-    }
-  }, {
-    key: "unregister",
-    value: function unregister(node) {
-      var index = this.getItemIndexByNode(node);
-      if (index > -1) this.items.splice(index, 1);
-    }
-  }, {
-    key: "exit",
-    value: function exit() {
-      var onExitFocusGroup = this.options.onExitFocusGroup;
-      onExitFocusGroup();
-    }
-  }, {
-    key: "focusItem",
-    value: function focusItem(node) {
-      if (this.currentFocusedItem && this.currentFocusedItem !== node) {
-        this.currentFocusedItem.specialOnBlur();
-        this.currentFocusedItem.setAttribute('tabindex', -1);
-      }
-
-      if (!node) return;
-      this.currentFocusedItem = node;
-      node.setAttribute('tabindex', 0);
-      node.focus();
-      node.specialOnFocus();
-    }
-  }, {
-    key: "focusNext",
-    value: function focusNext() {
-      var item = this.getNextItem();
-      this.focusItem(item);
-    }
-  }, {
-    key: "focusByNode",
-    value: function focusByNode(node) {
-      var index = this.getItemIndexByNode(node);
-      this.focusByIndex(index);
-    }
-  }, {
-    key: "focusByIndex",
-    value: function focusByIndex(index) {
-      var item = this.getItemByIndex(index);
-      this.focusItem(item);
-    }
-  }, {
-    key: "focusPrevious",
-    value: function focusPrevious() {
-      var prevItem = this.getPreviousItem();
-      this.focusItem(prevItem);
-    }
-  }, {
-    key: "focusFirst",
-    value: function focusFirst() {
-      var item = this.getFirstItem();
-      this.focusItem(item);
-    }
-  }, {
-    key: "focusLast",
-    value: function focusLast() {
-      var item = this.getLastItem();
-      this.focusItem(item);
-    }
-  }, {
-    key: "focusCurrent",
-    value: function focusCurrent() {
-      this.focusItem(this.currentFocusedItem);
-    }
-  }, {
-    key: "focusNextGroup",
-    value: function focusNextGroup() {
-      var onFocusNextGroup = this.options.onFocusNextGroup;
-      this.exit();
-      onFocusNextGroup();
-    }
-  }, {
-    key: "focusPreviousGroup",
-    value: function focusPreviousGroup() {
-      var onFocusPreviousGroup = this.options.onFocusPreviousGroup;
-      this.exit();
-      onFocusPreviousGroup();
-    }
-  }, {
-    key: "getNextItem",
-    value: function getNextItem() {
-      var loop = this.options.loop;
-      var currentIndex = this.getFocusedIndex();
-      var supposedNextIndex = currentIndex + 1;
-
-      if (!this.checkCanFocusNext(supposedNextIndex)) {
-        return loop ? this.getFirstItem() : this.focusNextGroup();
-      }
-
-      return this.getItemByIndex(supposedNextIndex);
-    }
-  }, {
-    key: "getPreviousItem",
-    value: function getPreviousItem() {
-      var loop = this.options.loop;
-      var currentIndex = this.getFocusedIndex();
-      var supposedPrevIndex = currentIndex - 1;
-
-      if (!this.checkCanFocusPrev(supposedPrevIndex)) {
-        return loop ? this.getLastItem() : this.focusPreviousGroup();
-      }
-
-      return this.getItemByIndex(supposedPrevIndex);
-    }
-  }, {
-    key: "checkCanFocusNext",
-    value: function checkCanFocusNext(index) {
-      return this.items.length > index;
-    }
-  }, {
-    key: "checkCanFocusPrev",
-    value: function checkCanFocusPrev(index) {
-      return index >= 0;
-    }
-  }, {
-    key: "getItemByIndex",
-    value: function getItemByIndex(index) {
-      return this.items[index];
-    }
-  }, {
-    key: "getItemIndexByNode",
-    value: function getItemIndexByNode(node) {
-      return this.items.findIndex(function (item) {
-        return item === node;
-      });
-    }
-  }, {
-    key: "getFocusedIndex",
-    value: function getFocusedIndex() {
-      return this.getItemIndexByNode(document.activeElement);
-    }
-  }, {
-    key: "getFocusedItem",
-    value: function getFocusedItem() {
-      var index = this.getFocusedIndex();
-      return index > -1 && this.items[index];
+  deactivate() {
+    document.removeEventListener('keydown', this.handleKeyDown, true);
+    unregisterHotKeys(this.options.hotKeys);
+  }
+
+  handleKeyDown(e) {
+    if (!this.isGroupActive()) return;
+    this.executeActionByEvent(e);
+  }
+
+  executeActionByEvent(e) {
+    const actions = Array.isArray(this.keyBindings[e.key]) ? this.keyBindings[e.key] : [this.keyBindings[e.key]];
+    return actions.map(action => typeof action === 'string' ? safeCallAction(e, this.mapActions[action]) : safeCallAction(e, action));
+  }
+
+  register(node) {
+    let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const afterIndex = this.items.findIndex(item => item.compareDocumentPosition(node) === Node.DOCUMENT_POSITION_PRECEDING);
+    node.specialOnFocus = props.onFocus || noop;
+    node.specialOnBlur = props.onBlur || noop;
+
+    node.onclick = () => this.focusItem(node);
+
+    node.onfocus = () => {
+      this.focusItem(node);
+    };
+
+    if (afterIndex === -1) {
+      this.items.push(node);
+    } else {
+      this.items.splice(afterIndex, 0, node);
     }
-  }, {
-    key: "isGroupActive",
-    value: function isGroupActive() {
-      return this.getFocusedIndex() !== -1;
+  }
+
+  unregister(node) {
+    const index = this.getItemIndexByNode(node);
+    if (index > -1) this.items.splice(index, 1);
+  }
+
+  exit() {
+    const {
+      onExitFocusGroup
+    } = this.options;
+    onExitFocusGroup();
+  }
+
+  focusItem(node) {
+    if (this.currentFocusedItem && this.currentFocusedItem !== node) {
+      this.currentFocusedItem.specialOnBlur();
+      this.currentFocusedItem.setAttribute('tabindex', -1);
     }
-  }, {
-    key: "getFirstItem",
-    value: function getFirstItem() {
-      return !!this.items.length && this.items[0];
+
+    if (!node) return;
+    this.currentFocusedItem = node;
+    node.setAttribute('tabindex', 0);
+    node.focus();
+    node.specialOnFocus();
+  }
+
+  focusNext() {
+    const item = this.getNextItem();
+    this.focusItem(item);
+  }
+
+  focusByNode(node) {
+    const index = this.getItemIndexByNode(node);
+    this.focusByIndex(index);
+  }
+
+  focusByIndex(index) {
+    const item = this.getItemByIndex(index);
+    this.focusItem(item);
+  }
+
+  focusPrevious() {
+    const prevItem = this.getPreviousItem();
+    this.focusItem(prevItem);
+  }
+
+  focusFirst() {
+    const item = this.getFirstItem();
+    this.focusItem(item);
+  }
+
+  focusLast() {
+    const item = this.getLastItem();
+    this.focusItem(item);
+  }
+
+  focusCurrent() {
+    this.focusItem(this.currentFocusedItem);
+  }
+
+  focusNextGroup() {
+    const {
+      onFocusNextGroup
+    } = this.options;
+    this.exit();
+    onFocusNextGroup();
+  }
+
+  focusPreviousGroup() {
+    const {
+      onFocusPreviousGroup
+    } = this.options;
+    this.exit();
+    onFocusPreviousGroup();
+  }
+
+  getNextItem() {
+    const {
+      loop
+    } = this.options;
+    const currentIndex = this.getFocusedIndex();
+    const supposedNextIndex = currentIndex + 1;
+
+    if (!this.checkCanFocusNext(supposedNextIndex)) {
+      return loop ? this.getFirstItem() : this.focusNextGroup();
     }
-  }, {
-    key: "getLastItem",
-    value: function getLastItem() {
-      return !!this.items.length && this.items[this.items.length - 1];
+
+    return this.getItemByIndex(supposedNextIndex);
+  }
+
+  getPreviousItem() {
+    const {
+      loop
+    } = this.options;
+    const currentIndex = this.getFocusedIndex();
+    const supposedPrevIndex = currentIndex - 1;
+
+    if (!this.checkCanFocusPrev(supposedPrevIndex)) {
+      return loop ? this.getLastItem() : this.focusPreviousGroup();
     }
-  }]);
 
-  return FocusGroup;
-}();
+    return this.getItemByIndex(supposedPrevIndex);
+  }
+
+  checkCanFocusNext(index) {
+    return this.items.length > index;
+  }
+
+  checkCanFocusPrev(index) {
+    return index >= 0;
+  }
+
+  getItemByIndex(index) {
+    return this.items[index];
+  }
+
+  getItemIndexByNode(node) {
+    return this.items.findIndex(item => item === node);
+  }
+
+  getFocusedIndex() {
+    return this.getItemIndexByNode(document.activeElement);
+  }
+
+  getFocusedItem() {
+    const index = this.getFocusedIndex();
+    return index > -1 && this.items[index];
+  }
+
+  isGroupActive() {
+    return this.getFocusedIndex() !== -1;
+  }
+
+  getFirstItem() {
+    return !!this.items.length && this.items[0];
+  }
+
+  getLastItem() {
+    return !!this.items.length && this.items[this.items.length - 1];
+  }
+
+}
 
 module.exports = FocusGroup;
-//# sourceMappingURL=FocusGroup.js.map

package/cjs/FocusGroup/FocusGroupContext.js

@@ -6,7 +6,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
-var FocusGroupContext = /*#__PURE__*/React__default['default'].createContext();
+var FocusGroupContext = /*#__PURE__*/React__default["default"].createContext();
 
 module.exports = FocusGroupContext;
-//# sourceMappingURL=FocusGroupContext.js.map