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

package/esm/GroupContext/index.js

@@ -1,12 +1,3 @@
 export { default as Group } from './Group.js';
 export { GroupContext } from './GroupContext.js';
 export { default as GroupItem } from './GroupItem.js';
-import '@babel/runtime/helpers/esm/classCallCheck';
-import '@babel/runtime/helpers/esm/createClass';
-import '@babel/runtime/helpers/esm/assertThisInitialized';
-import '@babel/runtime/helpers/esm/inherits';
-import '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import '@babel/runtime/helpers/esm/getPrototypeOf';
-import 'react';
-import 'prop-types';
-//# sourceMappingURL=index.js.map

package/esm/ScrollSync/ScrollSync.js

@@ -1,154 +1,138 @@
-import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
-import _createClass from '@babel/runtime/helpers/esm/createClass';
-import _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/esm/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/esm/getPrototypeOf';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+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.find.js';
+import 'core-js/modules/esnext.iterator.find.js';
 import React, { Component } from 'react';
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-var ScrollSyncContext = /*#__PURE__*/React.createContext();
-var Provider = ScrollSyncContext.Provider;
-
-var ScrollSync = /*#__PURE__*/function (_Component) {
-  _inherits(ScrollSync, _Component);
-
-  var _super = _createSuper(ScrollSync);
-
-  function ScrollSync(props) {
-    var _this;
-
-    _classCallCheck(this, ScrollSync);
-
-    _this = _super.call(this, props);
-    _this.panes = {};
-
-    _this.registerPane = function (node, groups) {
-      groups.forEach(function (group) {
-        if (!_this.panes[group]) {
-          _this.panes[group] = [];
+const ScrollSyncContext = /*#__PURE__*/React.createContext();
+const {
+  Provider
+} = ScrollSyncContext;
+class ScrollSync extends Component {
+  constructor(props) {
+    super(props);
+    this.panes = {};
+
+    this.registerPane = (node, groups) => {
+      groups.forEach(group => {
+        if (!this.panes[group]) {
+          this.panes[group] = [];
         }
 
-        if (_this.panes[group].length > 0) {
-          _this.syncScrollPosition(_this.panes[group][0], node);
+        if (this.panes[group].length > 0) {
+          this.syncScrollPosition(this.panes[group][0], node);
         }
 
-        _this.panes[group].push(node);
+        this.panes[group].push(node);
       });
-
-      _this.addEvents(node, groups);
+      this.addEvents(node, groups);
     };
 
-    _this.unregisterPane = function (node, groups) {
-      groups.forEach(function (group) {
-        if (_this.findPane(node, group)) {
-          _this.removeEvents(node);
-
-          _this.panes[group].splice(_this.panes[group].indexOf(node), 1);
+    this.unregisterPane = (node, groups) => {
+      groups.forEach(group => {
+        if (this.findPane(node, group)) {
+          this.removeEvents(node);
+          this.panes[group].splice(this.panes[group].indexOf(node), 1);
         }
       });
     };
 
-    _this.addEvents = function (node, groups) {
+    this.addEvents = (node, groups) => {
       /* For some reason element.addEventListener doesnt work with document.body */
-      node.onscroll = _this.handlePaneScroll.bind(_assertThisInitialized(_this), node, groups); // eslint-disable-line
+      node.onscroll = this.handlePaneScroll.bind(this, node, groups); // eslint-disable-line
     };
 
-    _this.removeEvents = function (node) {
+    this.removeEvents = node => {
       /* For some reason element.removeEventListener doesnt work with document.body */
       node.onscroll = null; // eslint-disable-line
     };
 
-    _this.findPane = function (node, group) {
-      if (!_this.panes[group]) {
+    this.findPane = (node, group) => {
+      if (!this.panes[group]) {
         return false;
       }
 
-      return _this.panes[group].find(function (pane) {
-        return pane === node;
-      });
+      return this.panes[group].find(pane => pane === node);
     };
 
-    _this.handlePaneScroll = function (node, groups, e) {
-      var enabled = _this.props.enabled;
-      if (_this.props.onScroll) _this.props.onScroll(e);
+    this.handlePaneScroll = (node, groups, e) => {
+      const {
+        enabled
+      } = this.props;
+      if (this.props.onScroll) this.props.onScroll(e);
       if (!enabled) return;
-      window.requestAnimationFrame(function () {
-        _this.syncScrollPositions(node, groups);
+      window.requestAnimationFrame(() => {
+        this.syncScrollPositions(node, groups);
       });
     };
 
-    _this.syncScrollPositions = function (scrolledPane, groups) {
-      groups.forEach(function (group) {
-        _this.panes[group].forEach(function (pane) {
+    this.syncScrollPositions = (scrolledPane, groups) => {
+      groups.forEach(group => {
+        this.panes[group].forEach(pane => {
           /* For all panes beside the currently scrolling one */
           if (scrolledPane !== pane) {
             /* Remove event listeners from the node that we'll manipulate */
-            _this.removeEvents(pane, group);
-
-            _this.syncScrollPosition(scrolledPane, pane);
+            this.removeEvents(pane, group);
+            this.syncScrollPosition(scrolledPane, pane);
             /* Re-attach event listeners after we're done scrolling */
 
-
-            window.requestAnimationFrame(function () {
-              _this.addEvents(pane, groups);
+            window.requestAnimationFrame(() => {
+              this.addEvents(pane, groups);
             });
           }
         });
       });
     };
 
-    _this.syncContext = {
-      registerPane: _this.registerPane,
-      unregisterPane: _this.unregisterPane
+    this.syncContext = {
+      registerPane: this.registerPane,
+      unregisterPane: this.unregisterPane
     };
-    return _this;
   }
 
-  _createClass(ScrollSync, [{
-    key: "syncScrollPosition",
-    value: function syncScrollPosition(scrolledPane, pane) {
-      var scrollTop = scrolledPane.scrollTop,
-          scrollHeight = scrolledPane.scrollHeight,
-          clientHeight = scrolledPane.clientHeight,
-          scrollLeft = scrolledPane.scrollLeft,
-          scrollWidth = scrolledPane.scrollWidth,
-          clientWidth = scrolledPane.clientWidth;
-      var scrollTopOffset = scrollHeight - clientHeight;
-      var scrollLeftOffset = scrollWidth - clientWidth;
-      var _this$props = this.props,
-          proportional = _this$props.proportional,
-          vertical = _this$props.vertical,
-          horizontal = _this$props.horizontal;
-      /* Calculate the actual pane height */
-
-      var paneHeight = pane.scrollHeight - clientHeight;
-      var paneWidth = pane.scrollWidth - clientWidth;
-      /* Adjust the scrollTop position of it accordingly */
-
-      if (vertical && scrollTopOffset > 0) {
-        pane.scrollTop = proportional ? paneHeight * scrollTop / scrollTopOffset : scrollTop; // eslint-disable-line
-      }
-
-      if (horizontal && scrollLeftOffset > 0) {
-        pane.scrollLeft = proportional ? paneWidth * scrollLeft / scrollLeftOffset : scrollLeft; // eslint-disable-line
-      }
+  syncScrollPosition(scrolledPane, pane) {
+    const {
+      scrollTop,
+      scrollHeight,
+      clientHeight,
+      scrollLeft,
+      scrollWidth,
+      clientWidth
+    } = scrolledPane;
+    const scrollTopOffset = scrollHeight - clientHeight;
+    const scrollLeftOffset = scrollWidth - clientWidth;
+    const {
+      proportional,
+      vertical,
+      horizontal
+    } = this.props;
+    /* Calculate the actual pane height */
+
+    const paneHeight = pane.scrollHeight - clientHeight;
+    const paneWidth = pane.scrollWidth - clientWidth;
+    /* Adjust the scrollTop position of it accordingly */
+
+    if (vertical && scrollTopOffset > 0) {
+      pane.scrollTop = proportional ? paneHeight * scrollTop / scrollTopOffset : scrollTop; // eslint-disable-line
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var children = this.props.children;
-      return /*#__PURE__*/React.createElement(Provider, {
-        value: this.syncContext
-      }, React.Children.only(children));
+
+    if (horizontal && scrollLeftOffset > 0) {
+      pane.scrollLeft = proportional ? paneWidth * scrollLeft / scrollLeftOffset : scrollLeft; // eslint-disable-line
     }
-  }]);
+  }
 
-  return ScrollSync;
-}(Component);
+  render() {
+    const {
+      children
+    } = this.props;
+    return /*#__PURE__*/_jsx(Provider, {
+      value: this.syncContext
+    }, void 0, React.Children.only(children));
+  }
 
+}
 ScrollSync.defaultProps = {
   proportional: true,
   vertical: true,
@@ -157,4 +141,3 @@ ScrollSync.defaultProps = {
 };
 
 export { ScrollSyncContext, ScrollSync as default };
-//# sourceMappingURL=ScrollSync.js.map

package/esm/ScrollSync/ScrollSyncPane.js

@@ -1,101 +1,74 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
-import _createClass from '@babel/runtime/helpers/esm/createClass';
-import _inherits from '@babel/runtime/helpers/esm/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/esm/getPrototypeOf';
-import React, { Component } from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.constructor.js';
+import 'core-js/modules/esnext.async-iterator.to-array.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.to-array.js';
+import 'core-js/modules/esnext.async-iterator.filter.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 { Component } from 'react';
 import { ScrollSyncContext } from './ScrollSync.js';
-import '@babel/runtime/helpers/esm/assertThisInitialized';
+import { jsx } from 'react/jsx-runtime';
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+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 _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-/**
- * MODIFIED FROM react-scroll-sync
- *
- * ScrollSyncPane Component
- *
- * Wrap your content in it to keep its scroll position in sync with other panes
- *
- * @param groups
- * @example ./example.md
- */
+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 ScrollSyncPane = /*#__PURE__*/function (_Component) {
-  _inherits(ScrollSyncPane, _Component);
+class ScrollSyncPane extends Component {
+  constructor() {
+    super(...arguments);
 
-  var _super = _createSuper(ScrollSyncPane);
-
-  function ScrollSyncPane() {
-    var _this;
-
-    _classCallCheck(this, ScrollSyncPane);
-
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
-    _this = _super.call.apply(_super, [this].concat(args));
-
-    _this.toArray = function (groups) {
-      return [].concat(groups);
-    };
-
-    return _this;
+    this.toArray = groups => [].concat(groups);
   }
 
-  _createClass(ScrollSyncPane, [{
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      var _this$props = this.props,
-          enabled = _this$props.enabled,
-          group = _this$props.group,
-          syncContext = _this$props.syncContext;
-      var unregisterPane = syncContext.unregisterPane;
-      if (enabled) unregisterPane(this.node, this.toArray(group));
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this2 = this;
-
-      var _this$props2 = this.props,
-          children = _this$props2.children,
-          group = _this$props2.group,
-          syncContext = _this$props2.syncContext,
-          notPaginated = _this$props2.notPaginated;
-      var _registerPane = syncContext.registerPane;
-      return children({
-        registerPane: function registerPane(node) {
-          if (notPaginated) {
-            var virtualizedBody = node.querySelector('.virtualized-body-wrapper');
+  componentWillUnmount() {
+    const {
+      enabled,
+      group,
+      syncContext
+    } = this.props;
+    const {
+      unregisterPane
+    } = syncContext;
+    if (enabled) unregisterPane(this.node, this.toArray(group));
+  }
 
-            if (virtualizedBody) {
-              _registerPane(virtualizedBody, _this2.toArray(group));
-            }
+  render() {
+    const {
+      children,
+      group,
+      syncContext,
+      notPaginated
+    } = this.props;
+    const {
+      registerPane
+    } = syncContext;
+    return children({
+      registerPane: node => {
+        if (notPaginated) {
+          const virtualizedBody = node.querySelector('.virtualized-body-wrapper');
+
+          if (virtualizedBody) {
+            registerPane(virtualizedBody, this.toArray(group));
           }
-
-          return _registerPane(node, _this2.toArray(group));
         }
-      });
-    }
-  }]);
 
-  return ScrollSyncPane;
-}(Component);
+        return registerPane(node, this.toArray(group));
+      }
+    });
+  }
+
+}
 
 ScrollSyncPane.defaultProps = {
   group: 'default',
   enabled: true
 };
-var ScrollSyncPane$1 = (function (props) {
-  return /*#__PURE__*/React.createElement(ScrollSyncContext.Consumer, null, function (context) {
-    return /*#__PURE__*/React.createElement(ScrollSyncPane, _extends({}, props, {
-      syncContext: context
-    }));
-  });
-});
+var ScrollSyncPane$1 = (props => /*#__PURE__*/_jsx(ScrollSyncContext.Consumer, {}, void 0, context => /*#__PURE__*/jsx(ScrollSyncPane, _objectSpread(_objectSpread({}, props), {}, {
+  syncContext: context
+}))));
 
 export { ScrollSyncPane$1 as default };
-//# sourceMappingURL=ScrollSyncPane.js.map

package/esm/ScrollSync/ScrollSyncProvider.js

@@ -1,35 +1,46 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+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.find.js';
+import 'core-js/modules/esnext.iterator.find.js';
 import React from 'react';
 import raf from 'raf';
 
-var ScrollSyncContext = /*#__PURE__*/React.createContext();
-var Provider = ScrollSyncContext.Provider;
+const ScrollSyncContext = /*#__PURE__*/React.createContext();
+const {
+  Provider
+} = ScrollSyncContext;
 
 function ScrollSyncProvider(_ref) {
-  var _this = this;
-
-  _ref.enabled;
-      _ref.horizontal;
-      _ref.vertical;
-      var children = _ref.children;
+  let {
+    enabled,
+    horizontal,
+    vertical,
+    children
+  } = _ref;
   useRef();
 
-  raf(function (scrolledPane, pane) {
-    var scrollTop = scrolledPane.scrollTop,
-        scrollHeight = scrolledPane.scrollHeight,
-        clientHeight = scrolledPane.clientHeight,
-        scrollLeft = scrolledPane.scrollLeft,
-        scrollWidth = scrolledPane.scrollWidth,
-        clientWidth = scrolledPane.clientWidth;
-    var scrollTopOffset = scrollHeight - clientHeight;
-    var scrollLeftOffset = scrollWidth - clientWidth;
-    var _this$props = _this.props,
-        proportional = _this$props.proportional,
-        vertical = _this$props.vertical,
-        horizontal = _this$props.horizontal;
+  raf((scrolledPane, pane) => {
+    const {
+      scrollTop,
+      scrollHeight,
+      clientHeight,
+      scrollLeft,
+      scrollWidth,
+      clientWidth
+    } = scrolledPane;
+    const scrollTopOffset = scrollHeight - clientHeight;
+    const scrollLeftOffset = scrollWidth - clientWidth;
+    const {
+      proportional,
+      vertical,
+      horizontal
+    } = this.props;
     /* Calculate the actual pane height */
 
-    var paneHeight = pane.scrollHeight - clientHeight;
-    var paneWidth = pane.scrollWidth - clientWidth;
+    const paneHeight = pane.scrollHeight - clientHeight;
+    const paneWidth = pane.scrollWidth - clientWidth;
     /* Adjust the scrollTop position of it accordingly */
 
     if (vertical && scrollTopOffset > 0) {
@@ -40,11 +51,9 @@ function ScrollSyncProvider(_ref) {
       pane.scrollLeft = proportional ? paneWidth * scrollLeft / scrollLeftOffset : scrollLeft; // eslint-disable-line
     }
   });
-  return /*#__PURE__*/React.createElement(Provider, null, children);
+  return /*#__PURE__*/_jsx(Provider, {}, void 0, children);
 }
 
-ScrollSyncProvider.propTypes = {};
 ScrollSyncProvider.defaultProps = {};
 
 export { ScrollSyncProvider as default };
-//# sourceMappingURL=ScrollSyncProvider.js.map

package/esm/ScrollSync/index.js

@@ -1,11 +1,2 @@
 export { default as ScrollSync } from './ScrollSync.js';
 export { default as ScrollSyncPane } from './ScrollSyncPane.js';
-import '@babel/runtime/helpers/esm/classCallCheck';
-import '@babel/runtime/helpers/esm/createClass';
-import '@babel/runtime/helpers/esm/assertThisInitialized';
-import '@babel/runtime/helpers/esm/inherits';
-import '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import '@babel/runtime/helpers/esm/getPrototypeOf';
-import 'react';
-import '@babel/runtime/helpers/esm/extends';
-//# sourceMappingURL=index.js.map

package/esm/ScrollSync/useScrollSync.js

@@ -6,4 +6,3 @@ useScrollSync.propTypes = {};
 useScrollSync.defaultProps = {};
 
 export { useScrollSync as default };
-//# sourceMappingURL=useScrollSync.js.map

package/esm/constants.js

@@ -1,6 +1,32 @@
-var DEFAULT_DELAY_OPEN = 200;
-var DEFAULT_DELAY_CLOSE = 300;
-var sizeOptions = ['small', 'medium', 'large', 'x-large'];
+const DEFAULT_DELAY_OPEN = 200;
+const DEFAULT_DELAY_CLOSE = 300;
+const sizeOptions = ['small', 'medium', 'large', 'x-large'];
+const AM = 'am';
+const PM = 'pm';
+const ARROW_UP = 'ArrowUp';
+const ARROW_DOWN = 'ArrowDown';
+const BACKSPACE = 'Backspace';
+const ESCAPE = 'Escape';
+const HOME = 'Home';
+const SHIFT = 'Shift';
+const END = 'End';
+const HOUR_RANGE_12 = {
+  min: 0,
+  max: 12
+};
+const HOUR_RANGE_24 = {
+  min: 0,
+  max: 24
+};
+const GENERAL_TIME_RANGE = {
+  min: 0,
+  max: 59
+};
+const PLACEHOLDER_TIME = {
+  hour: 'hour',
+  minutes: 'minutes',
+  seconds: 'seconds',
+  meridiem: 'meridiem'
+};
 
-export { DEFAULT_DELAY_CLOSE, DEFAULT_DELAY_OPEN, sizeOptions };
-//# sourceMappingURL=constants.js.map
+export { AM, ARROW_DOWN, ARROW_UP, BACKSPACE, DEFAULT_DELAY_CLOSE, DEFAULT_DELAY_OPEN, END, ESCAPE, GENERAL_TIME_RANGE, HOME, HOUR_RANGE_12, HOUR_RANGE_24, PLACEHOLDER_TIME, PM, SHIFT, sizeOptions };

package/esm/createDataInstance/createInstancePlugin.js

@@ -1,16 +1,21 @@
-import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
 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/web.dom-collections.iterator.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; }
 
 function getDecoratorsFromHooks(hooks, decorators) {
-  var nextDecorators = _objectSpread({}, decorators);
+  const nextDecorators = _objectSpread({}, decorators);
 
-  Object.keys(hooks).forEach(function (decorator) {
+  Object.keys(hooks).forEach(decorator => {
     if (Array.isArray(decorators[decorator])) {
-      nextDecorators[decorator] = [].concat(_toConsumableArray(decorators[decorator]), [hooks[decorator]]);
+      nextDecorators[decorator] = [...decorators[decorator], hooks[decorator]];
     } else {
       nextDecorators[decorator] = hooks[decorator];
     }
@@ -19,10 +24,7 @@ function getDecoratorsFromHooks(hooks, decorators) {
 }
 
 function createInstancePlugin(name, hooks) {
-  return function (decorators) {
-    return getDecoratorsFromHooks(hooks, decorators);
-  };
+  return decorators => getDecoratorsFromHooks(hooks, decorators);
 }
 
 export { createInstancePlugin as default };
-//# sourceMappingURL=createInstancePlugin.js.map