@elliemae/ds-shared 1.57.1-rc.0 → 2.0.0-alpha.11

package/esm/createDataInstance/createInstanceRef.js

@@ -1,17 +1,17 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
 import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import { v4 } from 'uuid';
 import { useRef, useState, useMemo } from 'react';
 import { orderBy } from 'lodash';
 import { mergeInstance, registerStateHookToInstance, registerHotKeysHookToInstance } from './utils.js';
 
-var _excluded = ["uuid", "data", "renderers", "plugins", "customDecorators"];
+const _excluded = ["uuid", "data", "renderers", "plugins", "customDecorators"];
 
 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; }
-var defaultDecorators = {
+const defaultDecorators = {
   instance: [],
   state: [],
   hotKeys: [],
@@ -19,24 +19,21 @@ var defaultDecorators = {
   composeData: []
 };
 function createDataInstanceRef(_ref) {
-  var uuidProp = _ref.uuid,
-      data = _ref.data,
-      renderers = _ref.renderers,
-      plugins = _ref.plugins,
-      customDecorators = _ref.customDecorators,
+  let {
+    uuid: uuidProp,
+    data,
+    renderers,
+    plugins,
+    customDecorators
+  } = _ref,
       props = _objectWithoutProperties(_ref, _excluded);
 
   // eslint-disable-next-line react-hooks/rules-of-hooks
-  var instance = useRef(); // eslint-disable-next-line react-hooks/rules-of-hooks
-
-  var _useState = useState(uuidProp || function () {
-    return v4();
-  }),
-      _useState2 = _slicedToArray(_useState, 1),
-      uuid = _useState2[0];
+  const instance = useRef(); // eslint-disable-next-line react-hooks/rules-of-hooks
 
+  const [uuid] = useState(uuidProp || (() => v4()));
   instance.current = {
-    uuid: uuid,
+    uuid,
     state: {},
     actions: {},
     hotKeys: {},
@@ -44,30 +41,29 @@ function createDataInstanceRef(_ref) {
     originalData: data,
     records: [],
     // item abstraction with meta data for originalData
-    renderers: renderers,
-    ref: function ref(key) {
+    renderers,
+
+    ref(key) {
       // eslint-disable-next-line no-return-assign
-      return function (node) {
-        return instance.current.refs[key] = node;
-      };
+      return node => instance.current.refs[key] = node;
     },
-    getInstance: function getInstance() {
+
+    getInstance() {
       return instance.current;
     },
-    props: props
+
+    props
   }; // eslint-disable-next-line react-hooks/rules-of-hooks
 
-  var decorators = useMemo(function () {
-    var nextDecorators = _objectSpread(_objectSpread({}, defaultDecorators), customDecorators);
+  const decorators = useMemo(() => {
+    let nextDecorators = _objectSpread(_objectSpread({}, defaultDecorators), customDecorators);
 
-    plugins.forEach(function (plugin) {
+    plugins.forEach(plugin => {
       if (!plugin) return;
       nextDecorators = plugin(nextDecorators);
     });
-    Object.keys(nextDecorators).forEach(function (key) {
-      if (Array.isArray(nextDecorators[key])) nextDecorators[key] = orderBy(nextDecorators[key], function (item) {
-        return item.order;
-      });
+    Object.keys(nextDecorators).forEach(key => {
+      if (Array.isArray(nextDecorators[key])) nextDecorators[key] = orderBy(nextDecorators[key], item => item.order);
     });
     return nextDecorators;
   }, []); // the plugins are defined on creation, but not changed at runtime
@@ -77,14 +73,11 @@ function createDataInstanceRef(_ref) {
   instance.current = decorators.instance.reduce(mergeInstance, instance.current);
   instance.current = decorators.state.reduce(registerStateHookToInstance, instance.current);
   instance.current = decorators.hotKeys.reduce(registerHotKeysHookToInstance, instance.current);
-  instance.current.renderers = decorators.renderers.reduce(function (result, decorator) {
-    return decorator(result, instance.current);
-  }, renderers);
+  instance.current.renderers = decorators.renderers.reduce((result, decorator) => decorator(result, instance.current), renderers);
   return {
-    instance: instance,
-    decorators: decorators
+    instance,
+    decorators
   };
 }
 
 export { createDataInstanceRef as default };
-//# sourceMappingURL=createInstanceRef.js.map

package/esm/createDataInstance/utils.js

@@ -1,102 +1,69 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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; }
-
-var reducePropsGetter = function reducePropsGetter() {
-  var decorators = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  var grid = arguments.length > 1 ? arguments[1] : undefined;
-  return function () {
-    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var extraParams = arguments.length > 1 ? arguments[1] : undefined;
-    var nextProps = props;
-    decorators.forEach(function (decorator) {
-      nextProps = decorator(nextProps, grid, extraParams);
-    });
-    return nextProps;
-  };
+const reducePropsGetter = (decorators = [], grid) => (props = {}, extraParams) => {
+  let nextProps = props;
+  decorators.forEach(decorator => {
+    nextProps = decorator(nextProps, grid, extraParams);
+  });
+  return nextProps;
 };
 /* eslint-disable-next-line max-params */
 
-function evaluateTransforms(transforms, value) {
-  var extraParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var props = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  var grid = arguments.length > 4 ? arguments[4] : undefined;
-  var nextProps = props;
-  transforms.forEach(function (transform) {
+function evaluateTransforms(transforms, value, extraParams = {}, props = {}, grid) {
+  let nextProps = props;
+  transforms.forEach(transform => {
     nextProps = transform(value, extraParams, nextProps, grid);
   });
   return nextProps;
 }
 /* eslint-disable-next-line max-params */
 
-function evaluateFormatters(formatters, value) {
-  var extraParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var grid = arguments.length > 3 ? arguments[3] : undefined;
-  return formatters.reduce(function (result, formatter) {
-    return formatter(result, extraParams, grid);
-  }, value);
+function evaluateFormatters(formatters, value, extraParams = {}, grid) {
+  return formatters.reduce((result, formatter) => formatter(result, extraParams, grid), value);
 }
-function composeFormatters(formatters, instance) {
-  var getItemValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (record) {
-    return record.data.name;
-  };
+function composeFormatters(formatters, instance, getItemValue = record => record.data.name) {
   // todo: make the formatters subscribe to the item props instead of getting the whole instance
   // todo: addd should formatter update to memoize specific ones
-  return function (props) {
-    return formatters.reduce(function (result, formatter) {
-      return formatter(result, props, instance);
-    }, getItemValue(props.record));
-  };
+  return props => formatters.reduce((result, formatter) => formatter(result, props, instance), getItemValue(props.record));
 }
-var applyDecorators = function applyDecorators(subject) {
-  var decorators = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-
-  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-    args[_key - 2] = arguments[_key];
-  }
-
-  return decorators.reduce(function (nextSubject, decorator) {
-    return decorator.apply(void 0, [nextSubject].concat(args));
-  }, subject);
+const applyDecorators = (subject, decorators = [], ...args) => decorators.reduce((nextSubject, decorator) => decorator(nextSubject, ...args), subject);
+const decorateColumns = (columns, decorators, grid) => {
+  const nextColumns = applyDecorators(columns, decorators.decorateColumns, grid);
+  return nextColumns.map((column, index) => applyDecorators(column, decorators.decorateColumn, grid, index));
 };
-var decorateColumns = function decorateColumns(columns, decorators, grid) {
-  var nextColumns = applyDecorators(columns, decorators.decorateColumns, grid);
-  return nextColumns.map(function (column, index) {
-    return applyDecorators(column, decorators.decorateColumn, grid, index);
-  });
-};
-var mergeInstance = function mergeInstance(instance, instanceHook) {
-  return _objectSpread(_objectSpread({}, instance), instanceHook(instance));
-};
-var registerStateHookToInstance = function registerStateHookToInstance(instance, stateHook) {
-  var _stateHook = stateHook(instance),
-      state = _stateHook.state,
-      actions = _stateHook.actions;
-
+const mergeInstance = (instance, instanceHook) => _objectSpread(_objectSpread({}, instance), instanceHook(instance));
+const registerStateHookToInstance = (instance, stateHook) => {
+  const {
+    state,
+    actions
+  } = stateHook(instance);
   return _objectSpread(_objectSpread({}, instance), {}, {
     state: _objectSpread(_objectSpread({}, instance.state), state),
     actions: _objectSpread(_objectSpread({}, instance.actions), actions)
   });
 };
 
-var reduceHotKey = function reduceHotKey(instance, _ref) {
-  var key = _ref.key,
-      handler = _ref.handler,
-      options = _ref.options,
-      allowDocumentHandler = _ref.allowDocumentHandler;
-  return _objectSpread(_objectSpread({}, instance), {}, {
-    hotKeys: _objectSpread(_objectSpread({}, instance.hotKeys), {}, _defineProperty({}, key, {
-      handler: handler,
-      options: options,
-      allowDocumentHandler: allowDocumentHandler
-    }))
-  });
-};
+const reduceHotKey = (instance, {
+  key,
+  handler,
+  options,
+  allowDocumentHandler
+}) => _objectSpread(_objectSpread({}, instance), {}, {
+  hotKeys: _objectSpread(_objectSpread({}, instance.hotKeys), {}, {
+    [key]: {
+      handler,
+      options,
+      allowDocumentHandler
+    }
+  })
+});
 
-var registerHotKeysHookToInstance = function registerHotKeysHookToInstance(instance, hotKeysHook) {
-  var hotKeys = hotKeysHook(instance);
+const registerHotKeysHookToInstance = (instance, hotKeysHook) => {
+  const hotKeys = hotKeysHook(instance);
 
   if (Array.isArray(hotKeys)) {
     return hotKeys.reduce(reduceHotKey, instance);
@@ -106,4 +73,3 @@ var registerHotKeysHookToInstance = function registerHotKeysHookToInstance(insta
 };
 
 export { applyDecorators, composeFormatters, decorateColumns, evaluateFormatters, evaluateTransforms, mergeInstance, reducePropsGetter, registerHotKeysHookToInstance, registerStateHookToInstance };
-//# sourceMappingURL=utils.js.map

package/esm/defer-render-hoc/index.js

@@ -1,75 +1,37 @@
-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 _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import React, { PureComponent } from 'react';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { PureComponent } from 'react';
 import raf from 'raf';
 import hoistNonReactStatic from 'hoist-non-react-statics';
+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 _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; } }
-/**
- * Allows two animation frames to complete to allow other components to update
- * and re-render before mounting and rendering an expensive `WrappedComponent`.
- *
- * @param WrappedComponent
- * @param fallback
- */
+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 deferComponentRender(WrappedComponent, fallback) {
-  var DeferredRenderWrapper = /*#__PURE__*/function (_PureComponent) {
-    _inherits(DeferredRenderWrapper, _PureComponent);
-
-    var _super = _createSuper(DeferredRenderWrapper);
-
-    function DeferredRenderWrapper() {
-      var _this;
-
-      _classCallCheck(this, DeferredRenderWrapper);
-
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
+  class DeferredRenderWrapper extends PureComponent {
+    constructor(...args) {
+      super(...args);
 
-      _this = _super.call.apply(_super, [this].concat(args));
-
-      _defineProperty(_assertThisInitialized(_this), "state", {
+      _defineProperty(this, "state", {
         shouldRender: false
       });
-
-      return _this;
     }
 
-    _createClass(DeferredRenderWrapper, [{
-      key: "componentDidMount",
-      value: function componentDidMount() {
-        var _this2 = this;
+    componentDidMount() {
+      raf(() => raf(() => this.setState({
+        shouldRender: true
+      })));
+    }
 
-        raf(function () {
-          return raf(function () {
-            return _this2.setState({
-              shouldRender: true
-            });
-          });
-        });
-      }
-    }, {
-      key: "render",
-      value: function render() {
-        // eslint-disable-next-line react/destructuring-assignment
-        return this.state.shouldRender ? /*#__PURE__*/React.createElement(WrappedComponent, this.props) : fallback;
-      }
-    }]);
+    render() {
+      // eslint-disable-next-line react/destructuring-assignment
+      return this.state.shouldRender ? /*#__PURE__*/jsx(WrappedComponent, _objectSpread({}, this.props)) : fallback;
+    }
 
-    return DeferredRenderWrapper;
-  }(PureComponent);
+  }
 
   return hoistNonReactStatic(DeferredRenderWrapper, WrappedComponent);
 }
 
 export { deferComponentRender as default };
-//# sourceMappingURL=index.js.map

package/esm/dimsum.config.js

@@ -0,0 +1,5 @@
+var dimsum_config = {
+  classNamePrefix: 'em-ds'
+};
+
+export { dimsum_config as default };

package/esm/index.js

@@ -3,14 +3,3 @@ export { default as ScrollSyncPane } from './ScrollSync/ScrollSyncPane.js';
 export { default as Group } from './GroupContext/Group.js';
 export { GroupContext } from './GroupContext/GroupContext.js';
 export { default as GroupItem } from './GroupContext/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 '@babel/runtime/helpers/esm/defineProperty';
-import 'react';
-import '@babel/runtime/helpers/esm/extends';
-import 'prop-types';
-//# sourceMappingURL=index.js.map

package/esm/prop-types.js

@@ -0,0 +1,43 @@
+const dsBasicSizes = ['s', 'm', 'l'];
+const sizes = ['xsmall', 'small', 'medium', 'large', 'xlarge'];
+const iconSizes = ['xxs', 'xs', 's', 'm', 'l', 'xl', 'xxl'];
+const iconColors = [['neutral', '900'], ['neutral', '0'], ['danger', '900'], ['warning', '500'], ['success', '900'], ['brand-primary', '600']];
+const CHECKBOX_VARIANT = {
+  DEFAULT: 'variant-default',
+  FOCUS: 'variant-focus',
+  ACTIVE: 'variant-active',
+  DISABLED: 'variant-disabled',
+  ERROR: 'variant-error'
+};
+const checkboxVariants = [CHECKBOX_VARIANT.DEFAULT, CHECKBOX_VARIANT.FOCUS, CHECKBOX_VARIANT.ACTIVE, CHECKBOX_VARIANT.DISABLED, CHECKBOX_VARIANT.ERROR];
+const COMBOBOX_VARIANT = {
+  DEFAULT: 'variant-default',
+  FOCUS: 'variant-focus-input',
+  FOCUS_ICON: 'variant-focus-icon',
+  ACTIVE: 'variant-active-input',
+  ACTIVE_ICON: 'variant-active-icon',
+  DISABLED: 'variant-disabled',
+  ERROR: 'variant-error'
+};
+const comboBoxVariants = [COMBOBOX_VARIANT.DEFAULT, COMBOBOX_VARIANT.FOCUS, COMBOBOX_VARIANT.FOCUS_ICON, COMBOBOX_VARIANT.ACTIVE, COMBOBOX_VARIANT.ACTIVE_ICON, COMBOBOX_VARIANT.DISABLED, COMBOBOX_VARIANT.ERROR];
+const sizeVariants = {
+  S: 's',
+  M: 'm',
+  L: 'l'
+};
+const position = {
+  LEFT: 'left',
+  RIGHT: 'right',
+  CENTER: 'center'
+};
+const fontColor = {
+  NEUTRAL500: 'neutral500',
+  NEUTRAL700: 'neutral700'
+};
+const orientation = ['horizontal', 'vertical'];
+const orientationVariants = {
+  HORIZONTAL: 'horizontal',
+  VERTICAL: 'vertical'
+};
+
+export { CHECKBOX_VARIANT, COMBOBOX_VARIANT, checkboxVariants, comboBoxVariants, dsBasicSizes, fontColor, iconColors, iconSizes, orientation, orientationVariants, position, sizeVariants, sizes };

package/esm/react-spring/index.js

@@ -1,2 +1 @@
-export * from 'react-spring/web.cjs';
-//# sourceMappingURL=index.js.map
+export * from 'react-spring/web';

package/esm/react-spring/renderprops.js

@@ -1,2 +1 @@
-export * from 'react-spring/renderprops.cjs';
-//# sourceMappingURL=renderprops.js.map
+export * from 'react-spring/renderprops';

package/esm/toolbar/ToolbarProvider.js

@@ -1,116 +1,97 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+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 DSPopover from '@elliemae/ds-basic/Popover';
+import { useOnClickOutside } from '@elliemae/ds-utilities/hooks';
+import { jsx } from 'react/jsx-runtime';
 
 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; }
-var ToolbarContext = /*#__PURE__*/React.createContext();
-var Provider = ToolbarContext.Provider;
+const ToolbarContext = /*#__PURE__*/React.createContext();
+const {
+  Provider
+} = ToolbarContext;
 
-var useScrollListener = function useScrollListener(callback, dependencies) {
-  useEffect(function () {
+const useScrollListener = (callback, dependencies) => {
+  useEffect(() => {
     window.addEventListener('scroll', callback, true);
-    return function () {
+    return () => {
       window.removeEventListener('scroll', callback, true);
     };
   }, [dependencies]);
 };
 
-var noop = function noop() {
-  return null;
-};
-
-function ToolbarProvider(_ref) {
-  var _ref$delay = _ref.delay,
-      delay = _ref$delay === void 0 ? 200 : _ref$delay,
-      children = _ref.children,
-      _ref$onHide = _ref.onHide,
-      onHide = _ref$onHide === void 0 ? noop : _ref$onHide,
-      _ref$onShow = _ref.onShow,
-      onShow = _ref$onShow === void 0 ? noop : _ref$onShow;
-  var showTimer = useRef();
-  var hideTimer = useRef();
-  var toolbarRef = useRef();
+const noop = () => null;
 
-  var _useState = useState({}),
-      _useState2 = _slicedToArray(_useState, 2),
-      tooltipState = _useState2[0],
-      setTooltipState = _useState2[1];
+function ToolbarProvider({
+  delay = 200,
+  children,
+  onHide = noop,
+  onShow = noop
+}) {
+  const showTimer = useRef();
+  const hideTimer = useRef();
+  const toolbarRef = useRef();
+  const [tooltipState, setTooltipState] = useState({});
 
-  var show = function show(state) {
+  const show = state => {
     if (state.reference === tooltipState.reference) clearTimeout(hideTimer.current);
-    showTimer.current = setTimeout(function () {
-      return setTooltipState(_objectSpread(_objectSpread({}, state), {}, {
-        visible: true
-      }));
-    }, delay);
+    showTimer.current = setTimeout(() => setTooltipState(_objectSpread(_objectSpread({}, state), {}, {
+      visible: true
+    })), delay);
     onShow();
   };
 
-  var hide = function hide(e, force) {
+  const hide = (e, force) => {
     if (!force) clearTimeout(showTimer.current);
-    hideTimer.current = setTimeout(function () {
-      return setTooltipState(function (prevState) {
-        return _objectSpread(_objectSpread({}, prevState), {}, {
-          visible: false
-        });
-      });
-    }, 100);
+    hideTimer.current = setTimeout(() => setTooltipState(prevState => _objectSpread(_objectSpread({}, prevState), {}, {
+      visible: false
+    })), 100);
     onHide(tooltipState, e);
   };
 
-  useScrollListener(function (e) {
-    return hide(e, true);
-  }, tooltipState.visible);
-  useOnClickOutside(toolbarRef, function () {
-    return hide();
-  });
+  useScrollListener(e => hide(e, true), tooltipState.visible);
+  useOnClickOutside(toolbarRef, () => hide());
 
-  var keyDownHandler = function keyDownHandler(e) {
+  const keyDownHandler = e => {
     if (e.key === 'Escape') {
       hide(e);
     }
   };
 
-  useEffect(function () {
+  useEffect(() => {
     window.addEventListener('keydown', keyDownHandler);
-    return function () {
+    return () => {
       window.removeEventListener('keydown', keyDownHandler);
     };
   });
-  var value = useMemo(function () {
-    return {
-      state: tooltipState,
-      show: show,
-      hide: hide
-    };
-  }, [tooltipState.reference]);
-  return /*#__PURE__*/React.createElement(Provider, {
+  const value = useMemo(() => ({
+    state: tooltipState,
+    show,
+    hide
+  }), [tooltipState.reference]);
+  return /*#__PURE__*/_jsx(Provider, {
     value: value
-  }, children, /*#__PURE__*/React.createElement(DSPopover, _extends({
+  }, void 0, children, /*#__PURE__*/jsx(DSPopover, _objectSpread(_objectSpread({
     boundaries: "scrollParent"
-  }, tooltipState.options || {}, {
+  }, tooltipState.options || {}), {}, {
     content: tooltipState.renderer,
     placement: "left",
     referenceEl: tooltipState.reference,
-    renderer: function renderer(_ref2) {
-      var Component = _ref2.as,
-          style = _ref2.style,
-          Content = _ref2.children;
-      return /*#__PURE__*/React.createElement("div", {
-        ref: toolbarRef,
-        onMouseEnter: function onMouseEnter(e) {
-          return show(tooltipState);
-        },
-        onMouseLeave: hide
-      }, /*#__PURE__*/React.createElement(Component, {
+    renderer: ({
+      as: Component,
+      style,
+      children: Content
+    }) => /*#__PURE__*/jsx("div", {
+      ref: toolbarRef,
+      onMouseEnter: e => show(tooltipState),
+      onMouseLeave: hide,
+      children: /*#__PURE__*/_jsx(Component, {
         style: style
-      }, Content));
-    },
+      }, void 0, Content)
+    }),
     style: tooltipState.style,
     visible: tooltipState.visible
   })));
@@ -119,4 +100,3 @@ function ToolbarProvider(_ref) {
 var ToolbarProvider$1 = /*#__PURE__*/React.memo(ToolbarProvider);
 
 export { ToolbarContext, ToolbarProvider$1 as default };
-//# sourceMappingURL=ToolbarProvider.js.map