@elliemae/ds-shared 2.2.0-alpha.3 → 3.0.0-next.0

package/esm/toolbar/ToolbarProvider.js

@@ -1,52 +1,76 @@
-import * as React from "react";
-import React2, { useMemo, useRef, useState, useEffect, memo } from "react";
-import { DSPopover } from "@elliemae/ds-popper";
-import { useOnClickOutside } from "@elliemae/ds-utilities";
-const ToolbarContext = React2.createContext();
-const { Provider } = ToolbarContext;
+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 _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 React, { useRef, useState, useEffect, useMemo } from 'react';
+import DSPopover from '@elliemae/ds-popper';
+import { useOnClickOutside } from '@elliemae/ds-utilities';
+import { jsx } from 'react/jsx-runtime';
+
+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 ToolbarContext = /*#__PURE__*/React.createContext();
+const {
+  Provider
+} = ToolbarContext;
+
 const useScrollListener = (callback, dependencies) => {
   useEffect(() => {
-    window.addEventListener("scroll", callback, true);
+    window.addEventListener('scroll', callback, true);
     return () => {
-      window.removeEventListener("scroll", callback, true);
+      window.removeEventListener('scroll', callback, true);
     };
   }, [dependencies]);
 };
+
 const noop = () => null;
-const ToolbarProvider = memo(({ delay = 200, children, onHide = noop, onShow = noop }) => {
+
+function ToolbarProvider(_ref) {
+  let {
+    delay = 200,
+    children,
+    onHide = noop,
+    onShow = noop
+  } = _ref;
   const showTimer = useRef();
   const hideTimer = useRef();
   const toolbarRef = useRef();
   const [tooltipState, setTooltipState] = useState({});
-  const show = (state) => {
-    if (state.reference === tooltipState.reference)
-      clearTimeout(hideTimer.current);
-    showTimer.current = setTimeout(() => setTooltipState({
-      ...state,
+
+  const show = state => {
+    if (state.reference === tooltipState.reference) clearTimeout(hideTimer.current);
+    showTimer.current = setTimeout(() => setTooltipState(_objectSpread(_objectSpread({}, state), {}, {
       visible: true
-    }), delay);
+    })), delay);
     onShow();
   };
+
   const hide = (e, force) => {
-    if (!force)
-      clearTimeout(showTimer.current);
-    hideTimer.current = setTimeout(() => setTooltipState((prevState) => ({
-      ...prevState,
+    if (!force) clearTimeout(showTimer.current);
+    hideTimer.current = setTimeout(() => setTooltipState(prevState => _objectSpread(_objectSpread({}, prevState), {}, {
       visible: false
     })), 100);
     onHide(tooltipState, e);
   };
-  useScrollListener((e) => hide(e, true), tooltipState.visible);
+
+  useScrollListener(e => hide(e, true), tooltipState.visible);
   useOnClickOutside(toolbarRef, () => hide());
-  const keyDownHandler = (e) => {
-    if (e.key === "Escape") {
+
+  const keyDownHandler = e => {
+    if (e.key === 'Escape') {
       hide(e);
     }
   };
+
   useEffect(() => {
-    window.addEventListener("keydown", keyDownHandler);
+    window.addEventListener('keydown', keyDownHandler);
     return () => {
-      window.removeEventListener("keydown", keyDownHandler);
+      window.removeEventListener('keydown', keyDownHandler);
     };
   });
   const value = useMemo(() => ({
@@ -54,29 +78,34 @@ const ToolbarProvider = memo(({ delay = 200, children, onHide = noop, onShow = n
     show,
     hide
   }), [tooltipState.reference]);
-  return /* @__PURE__ */ React2.createElement(Provider, {
-    value
-  }, children, /* @__PURE__ */ React2.createElement(DSPopover, {
-    boundaries: "scrollParent",
-    ...tooltipState.options || {},
+  return /*#__PURE__*/_jsx(Provider, {
+    value: value
+  }, void 0, children, /*#__PURE__*/jsx(DSPopover, _objectSpread(_objectSpread({
+    boundaries: "scrollParent"
+  }, tooltipState.options || {}), {}, {
     content: tooltipState.renderer,
     placement: "left",
     referenceEl: tooltipState.reference,
-    renderer: ({ as: Component, style, children: Content }) => /* @__PURE__ */ React2.createElement("div", {
-      ref: toolbarRef,
-      onMouseEnter: (e) => show(tooltipState, e),
-      onMouseLeave: hide
-    }, /* @__PURE__ */ React2.createElement(Component, {
-      style
-    }, Content)),
+    renderer: _ref2 => {
+      let {
+        as: Component,
+        style,
+        children: Content
+      } = _ref2;
+      return /*#__PURE__*/jsx("div", {
+        ref: toolbarRef,
+        onMouseEnter: e => show(tooltipState),
+        onMouseLeave: hide,
+        children: /*#__PURE__*/_jsx(Component, {
+          style: style
+        }, void 0, Content)
+      });
+    },
     style: tooltipState.style,
     visible: tooltipState.visible
-  }));
-});
-var ToolbarProvider_default = ToolbarProvider;
-export {
-  ToolbarContext,
-  ToolbarProvider,
-  ToolbarProvider_default as default
-};
-//# sourceMappingURL=ToolbarProvider.js.map
+  })));
+}
+
+var ToolbarProvider$1 = /*#__PURE__*/React.memo(ToolbarProvider);
+
+export { ToolbarContext, ToolbarProvider$1 as default };

package/esm/useDataGrid/VolatileRowsListener.js

@@ -1,20 +1,22 @@
-import * as React from "react";
-import { safeCall } from "@elliemae/ds-utilities";
+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 { safeCall } from '@elliemae/ds-utilities';
+
 class VolatileRowsListener {
   constructor() {
     this.observers = [];
   }
+
   observe(listener) {
     this.observers.push(listener);
   }
+
   notify(nextRows) {
-    this.observers.forEach((observer) => safeCall(observer, nextRows));
+    this.observers.forEach(observer => safeCall(observer, nextRows));
     this.observers = [];
   }
+
 }
-var VolatileRowsListener_default = VolatileRowsListener;
-export {
-  VolatileRowsListener,
-  VolatileRowsListener_default as default
-};
-//# sourceMappingURL=VolatileRowsListener.js.map
+
+export { VolatileRowsListener as default };

package/esm/useDataGrid/index.js

@@ -1,7 +1 @@
-import * as React from "react";
-import { default as default2, default as default3 } from "./useDataGrid";
-export {
-  default2 as default,
-  default3 as useDataGrid
-};
-//# sourceMappingURL=index.js.map
+export { default } from './useDataGrid.js';

package/esm/useDataGrid/initColumnDefinition.js

@@ -1,34 +1,41 @@
-import * as React from "react";
-import React2 from "react";
-import { v4 as uuidv4 } from "uuid";
-import {
-  get,
-  curry,
-  set,
-  cloneDeep,
-  isFunction
-} from "@elliemae/ds-utilities";
-const appendHeaderFormatter = curry((formatter, column) => ({
-  ...column,
-  header: {
-    ...column.header,
-    formatters: [...get(column, "header.formatters", []), formatter]
-  }
+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 _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/es.string.replace.js';
+import 'react';
+import { v4 } from 'uuid';
+import { curry, get, cloneDeep, set, isFunction } 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; }
+
+const appendHeaderFormatter = curry((formatter, column) => _objectSpread(_objectSpread({}, column), {}, {
+  header: _objectSpread(_objectSpread({}, column.header), {}, {
+    formatters: [...get(column, 'header.formatters', []), formatter]
+  })
 }));
-const appendCellFormatter = curry((formatter, column, path = "formatters") => {
+const appendCellFormatter = curry(function (formatter, column) {
+  let path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'formatters';
   const nextColumn = cloneDeep(column);
-  const formatters = get(nextColumn, ["cell", path], []);
-  const scrollingFormatters = get(nextColumn, "cell.scrollingFormatters", []);
+  const formatters = get(nextColumn, ['cell', path], []);
+  const scrollingFormatters = get(nextColumn, 'cell.scrollingFormatters', []);
+
   if (Array.isArray(formatter)) {
-    if (formatter[1])
-      scrollingFormatters.push(formatter[1]);
+    if (formatter[1]) scrollingFormatters.push(formatter[1]);
     formatters.push(formatter[0]);
   } else {
     formatters.push(formatter);
     scrollingFormatters.push(formatter);
   }
-  set(nextColumn, ["cell", path], formatters);
-  set(nextColumn, "cell.scrollingFormatters", scrollingFormatters);
+
+  set(nextColumn, ['cell', path], formatters);
+  set(nextColumn, 'cell.scrollingFormatters', scrollingFormatters);
   return nextColumn;
 });
 const defaultColumnDefinitionOptions = {
@@ -38,81 +45,90 @@ const defaultColumnDefinitionOptions = {
   visible: true
 };
 const mergeClassNameToColumnHeader = curry((className, column) => {
-  const headerProps = get(column, ["header", "props"], {});
-  const headerClassName = headerProps.className || "";
-  return {
-    ...column,
-    header: {
-      ...column.header,
-      props: {
-        ...headerProps,
-        className: `${headerClassName} ${className}`
-      }
-    }
-  };
+  const headerProps = get(column, ['header', 'props'], {});
+  const headerClassName = headerProps.className || '';
+  return _objectSpread(_objectSpread({}, column), {}, {
+    header: _objectSpread(_objectSpread({}, column.header), {}, {
+      props: _objectSpread(_objectSpread({}, headerProps), {}, {
+        className: "".concat(headerClassName, " ").concat(className)
+      })
+    })
+  });
 });
-const initColumnDefinition = (options = {}) => {
-  return (column) => {
-    if (column.type === "number") {
+function initColumnDefinition() {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // eslint-disable-next-line complexity
+  return column => {
+    // todo: clean this
+    if (column.type === 'number') {
+      // eslint-disable-next-line no-param-reassign
       column.cellStyle = {
-        textAlign: "right"
+        textAlign: 'right'
       };
     }
-    const { useTextTruncation = true, isUserColumn, visible, normalize } = {
-      ...defaultColumnDefinitionOptions,
-      ...options
-    };
+
+    const {
+      useTextTruncation = true,
+      isUserColumn,
+      visible,
+      normalize
+    } = _objectSpread(_objectSpread({}, defaultColumnDefinitionOptions), options);
+
     if (normalize) {
-      column.originalProperty = column.property;
-      column.property = column.property.replace(/\s+/g, "");
-    }
-    column.props = {
-      ...column.props,
+      // eslint-disable-next-line no-param-reassign
+      column.originalProperty = column.property; // eslint-disable-next-line no-param-reassign
+
+      column.property = column.property.replace(/\s+/g, '');
+    } // eslint-disable-next-line no-param-reassign
+
+
+    column.props = _objectSpread(_objectSpread({}, column.props), {}, {
       style: {}
-    };
-    column.header = {
-      ...column.header,
+    }); // eslint-disable-next-line no-param-reassign
+
+    column.header = _objectSpread(_objectSpread({}, column.header), {}, {
       label: column.label,
-      formatters: [...get(column, ["header", "formatters"], [])],
+      formatters: [...get(column, ['header', 'formatters'], [])],
       props: {
         style: column.headerStyle || {}
       }
-    };
+    });
+
     if (useTextTruncation && !(isFunction(column.customHeaderRenderer) || column.header.formatters.length)) {
-      column.header.formatters.push((value) => /* @__PURE__ */ React2.createElement("span", {
+      column.header.formatters.push(value => /*#__PURE__*/_jsx("span", {
         className: "cell-value"
-      }, value));
-    }
-    column.cell = {
-      ...column.cell,
+      }, void 0, value));
+    } // eslint-disable-next-line no-param-reassign
+
+
+    column.cell = _objectSpread(_objectSpread({}, column.cell), {}, {
       transforms: [],
-      formatters: [...get(column, ["cell", "formatters"], [])],
-      scrollingFormatters: [...get(column, ["cell", "formatters"], [])],
+      formatters: [...get(column, ['cell', 'formatters'], [])],
+      scrollingFormatters: [...get(column, ['cell', 'formatters'], [])],
       props: {
         style: column.cellStyle || {}
       }
-    };
+    });
+
     if (useTextTruncation && !(isFunction(column.customRenderer) || column.cell.formatters.length)) {
-      column.cell.formatters.push((value) => /* @__PURE__ */ React2.createElement("span", {
+      column.cell.formatters.push(value => /*#__PURE__*/_jsx("span", {
         className: "cell-value",
         style: {
-          justifyContent: column.type === "number" ? "flex-end" : "flex-start"
+          justifyContent: column.type === 'number' ? 'flex-end' : 'flex-start'
         }
-      }, value));
-    }
-    column.uuid = column.uuid || uuidv4();
-    column.visible = column.visible === void 0 ? visible : column.visible;
-    column.isUserColumn = column.isUserColumn || isUserColumn;
+      }, void 0, value));
+    } // eslint-disable-next-line no-param-reassign
+
+
+    column.uuid = column.uuid || v4(); // eslint-disable-next-line no-param-reassign
+
+    column.visible = column.visible === undefined ? visible : column.visible; // eslint-disable-next-line no-param-reassign, max-lines
+
+    column.isUserColumn = column.isUserColumn || isUserColumn; // eslint-disable-next-line no-param-reassign
+
     column.headerHookEffects = [];
     return column;
   };
-};
-var initColumnDefinition_default = initColumnDefinition;
-export {
-  appendCellFormatter,
-  appendHeaderFormatter,
-  initColumnDefinition_default as default,
-  initColumnDefinition,
-  mergeClassNameToColumnHeader
-};
-//# sourceMappingURL=initColumnDefinition.js.map
+}
+
+export { appendCellFormatter, appendHeaderFormatter, initColumnDefinition as default, mergeClassNameToColumnHeader };

package/esm/useDataGrid/useDataGrid.js

@@ -1,49 +1,61 @@
-import * as React from "react";
-import {
-  cloneDeep,
-  compose,
-  isEqual,
-  isObject,
-  setRef,
-  usePrevious,
-  useDerivedStateFromProps
-} from "@elliemae/ds-utilities";
-import { useMemo, useRef, useState } from "react";
-import { v4 as uuidv4 } from "uuid";
-import * as resolve from "table-resolver";
-import { initColumnDefinition } from "./initColumnDefinition";
-import {
-  applyDecorators,
-  decorateColumns,
-  reducePropsGetter
-} from "../createDataInstance/utils";
-import { VolatileRowsListener } from "./VolatileRowsListener";
-import { isInternetExplorer } from "../utils";
-const IS_INTERNET_EXPLORER = isInternetExplorer();
-const useDataGrid = ({
-  uuid: uuidProp,
-  plugins: pluginsFromProps,
-  rows,
-  columns,
-  renderers = {},
-  ...props
-}) => {
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+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.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.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import { useDerivedStateFromProps, compose, cloneDeep, usePrevious, isObject, isEqual, setRef } from '@elliemae/ds-utilities';
+import { useRef, useState, useMemo } from 'react';
+import { v4 } from 'uuid';
+import * as resolve from 'table-resolver';
+import initColumnDefinition from './initColumnDefinition.js';
+import { applyDecorators, decorateColumns, reducePropsGetter } from '../createDataInstance/utils.js';
+import VolatileRowsListener from './VolatileRowsListener.js';
+import { isInternetExplorer } from '../utils.js';
+
+const _excluded = ["uuid", "plugins", "rows", "columns", "renderers"];
+
+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 IS_INTERNET_EXPLORER = isInternetExplorer(); // TODO: Reuse createDataInstance for the grid the same
+//  way as the list does ex: packages/ds-shared/src/useDataList/useDataList.js
+// eslint-disable-next-line max-statements
+
+function useDataGrid(_ref) {
+  let {
+    uuid: uuidProp,
+    plugins: pluginsFromProps,
+    rows,
+    columns,
+    renderers = {}
+  } = _ref,
+      props = _objectWithoutProperties(_ref, _excluded);
+
   const plugins = pluginsFromProps;
   const instance = useRef();
   const tableRef = useRef();
   const headerRef = useRef();
   const bodyRef = useRef();
   const bodyInnerRef = useRef();
-  const [uuid] = useState(uuidProp || (() => uuidv4()));
+  const [uuid] = useState(uuidProp || (() => v4()));
   const [hasScroll, setHasScroll] = useState(false);
   const [isRowDragging, setIsRowDragging] = useState(false);
   const isScrolling = useRef();
-  const shouldRefocus = useRef();
-  const [RowsObserver] = useState(() => new VolatileRowsListener());
+  const shouldRefocus = useRef(); // todo: we probably need a plugin for focus related stuff
+
+  const [RowsObserver] = useState(() => new VolatileRowsListener()); // todo move this with rows composition
+
   const [originalRows, updateRows] = useDerivedStateFromProps(rows, {
     onUpdate: resolve.resolve({
       columns,
-      method: (extra) => compose(resolve.byFunction("valueTransformation")(extra), resolve.nested(extra))
+      method: extra => compose(resolve.byFunction('valueTransformation')(extra), resolve.nested(extra))
     }),
     updateOnStateChange: true
   });
@@ -73,9 +85,11 @@ const useDataGrid = ({
       updateRows
     },
     updateRows,
-    enableEvents: () => document.body.style.pointerEvents = IS_INTERNET_EXPLORER ? "" : null,
-    disableEvents: () => document.body.style.pointerEvents = "none",
-    observeRows: (observer) => RowsObserver.observe(observer),
+    // eslint-disable-next-line no-return-assign
+    enableEvents: () => document.body.style.pointerEvents = IS_INTERNET_EXPLORER ? '' : null,
+    // eslint-disable-next-line no-return-assign
+    disableEvents: () => document.body.style.pointerEvents = 'none',
+    observeRows: observer => RowsObserver.observe(observer),
     hotKeys: {},
     shouldRefocus,
     isScrolling,
@@ -84,20 +98,21 @@ const useDataGrid = ({
     isRowDragging,
     plugins
   };
+
   instance.current.getState = () => instance.current.state;
+
   instance.current.getInstance = () => instance.current;
+
   const defaultDecorators = {
     decorateGrid: [],
     registerStateHook: [],
     registerHotKeys: [],
     decorateColumn: [],
-    decorateColumns: [
-      (cols) => cols.map((col) => initColumnDefinition({
-        useTextTruncation: col.useTextTruncation,
-        wrapText: props.wrapText,
-        normalize: props.normalizeDataKeys
-      })(col))
-    ],
+    decorateColumns: [cols => cols.map(col => initColumnDefinition({
+      useTextTruncation: col.useTextTruncation,
+      wrapText: props.wrapText,
+      normalize: props.normalizeDataKeys
+    })(col))],
     decorateRenderers: [],
     getRowProps: [],
     getHeaderRowProps: [],
@@ -107,45 +122,51 @@ const useDataGrid = ({
     composeRows: []
   };
   const decorators = useMemo(() => {
-    let nextDecorators = defaultDecorators;
-    plugins.forEach((plugin) => nextDecorators = plugin(nextDecorators));
+    let nextDecorators = defaultDecorators; // eslint-disable-next-line no-return-assign
+
+    plugins.forEach(plugin => nextDecorators = plugin(nextDecorators));
     return nextDecorators;
   }, [plugins]);
-  instance.current = decorators.decorateGrid.reduce((nextInstance, decorator) => ({
-    ...nextInstance,
-    ...decorator(instance.current)
-  }), instance.current);
+  instance.current = decorators.decorateGrid.reduce((nextInstance, decorator) => _objectSpread(_objectSpread({}, nextInstance), decorator(instance.current)), instance.current);
   instance.current = decorators.registerStateHook.reduce((nextInstance, decorator) => {
-    const { state, actions } = decorator(instance.current);
-    return {
-      ...nextInstance,
-      state: {
-        ...nextInstance.state,
-        ...state
-      },
-      actions: {
-        ...nextInstance.actions,
-        ...actions
-      }
-    };
+    const {
+      state,
+      actions
+    } = decorator(instance.current);
+    return _objectSpread(_objectSpread({}, nextInstance), {}, {
+      state: _objectSpread(_objectSpread({}, nextInstance.state), state),
+      actions: _objectSpread(_objectSpread({}, nextInstance.actions), actions)
+    });
   }, instance.current);
-  const reduceHotKey = (nextInstance, { key, handler, options }) => ({
-    ...nextInstance,
-    hotKeys: {
-      ...nextInstance.hotKeys,
-      [key]: { handler, options }
-    }
-  });
+
+  const reduceHotKey = (nextInstance, _ref2) => {
+    let {
+      key,
+      handler,
+      options
+    } = _ref2;
+    return _objectSpread(_objectSpread({}, nextInstance), {}, {
+      hotKeys: _objectSpread(_objectSpread({}, nextInstance.hotKeys), {}, {
+        [key]: {
+          handler,
+          options
+        }
+      })
+    });
+  };
+
   instance.current = decorators.registerHotKeys.reduce((nextInstance, decorator) => {
     const hotKeys = decorator(nextInstance);
+
     if (Array.isArray(hotKeys)) {
       return hotKeys.reduce(reduceHotKey, nextInstance);
     }
+
     return reduceHotKey(nextInstance, hotKeys);
   }, instance.current);
   instance.current.decoratedRenderers = applyDecorators(instance.current.decoratedRenderers, decorators.decorateRenderers, instance.current);
   instance.current.decoratedColumns = useMemo(() => {
-    const visibleColumns = cloneDeep(columns).filter((column) => typeof column.visible === "undefined" || column.visible);
+    const visibleColumns = cloneDeep(columns).filter(column => typeof column.visible === 'undefined' || column.visible);
     return visibleColumns.length ? decorateColumns(visibleColumns, decorators, instance.current) : [];
   }, [columns]);
   instance.current.getBodyProps = reducePropsGetter(decorators.getBodyProps, instance.current);
@@ -157,21 +178,17 @@ const useDataGrid = ({
   RowsObserver.notify(instance.current.composedRows);
   const currentShouldRefocus = instance.current.shouldRefocus.current;
   const prevState = usePrevious(instance.current.state);
+
   if (isObject(currentShouldRefocus) && currentShouldRefocus.forced) {
     instance.current.shouldRefocus.current = currentShouldRefocus.value;
   } else {
     instance.current.shouldRefocus.current = !isEqual(prevState, instance.current.state);
   }
-  if (props.instanceRef)
-    setRef(props.instanceRef, instance.current);
-  return {
-    ...instance.current,
+
+  if (props.instanceRef) setRef(props.instanceRef, instance.current);
+  return _objectSpread(_objectSpread({}, instance.current), {}, {
     decorators
-  };
-};
-var useDataGrid_default = useDataGrid;
-export {
-  useDataGrid_default as default,
-  useDataGrid
-};
-//# sourceMappingURL=useDataGrid.js.map
+  });
+}
+
+export { useDataGrid as default };