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

package/esm/PopperImpl.js

@@ -1,11 +1,11 @@
+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 _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 React, { Component } from 'react';
+import { Component } from 'react';
 import { get, isFunction, isDOMTypeElement, mergeRefs, getComponentFromProps } from '@elliemae/ds-utilities';
 import { Manager, Reference } from 'react-popper';
 export { Reference } from 'react-popper';
@@ -13,94 +13,93 @@ import memoizeOne from 'memoize-one';
 import PopperContent from './PopperContent.js';
 export { default as PopperContent } from './PopperContent.js';
 import { Interaction } from './interaction.js';
-import '@babel/runtime/helpers/esm/extends';
-import 'react-spring/renderprops.cjs';
-import '@elliemae/ds-overlay';
-import './getArrowStylesBySize.js';
+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; }
-
-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 PopperImpl = /*#__PURE__*/function (_Component) {
-  _inherits(PopperImpl, _Component);
-
-  var _super = _createSuper(PopperImpl);
-
+class PopperImpl extends Component {
   // we use safeIsMounted because isMounted is not allowed by React.
-  function PopperImpl(props) {
-    var _this;
-
-    _classCallCheck(this, PopperImpl);
-
-    _this = _super.call(this, props);
-    _this.safeIsMounted = false;
-    _this.handlePopperPlacementChange = memoizeOne(function (placement) {
-      var onPlacementChange = _this.props.onPlacementChange;
+  constructor(props) {
+    super(props);
+    this.safeIsMounted = false;
+    this.handlePopperPlacementChange = memoizeOne(placement => {
+      const {
+        onPlacementChange
+      } = this.props;
       onPlacementChange(placement);
     });
-    _this.state = {
+    this.state = {
       isOpen: false,
       destroyed: true
     }; // TODO: Fix the autobinding to remove this!!
 
-    _this.handleMouseEnter = _this.handleMouseEnter.bind(_assertThisInitialized(_this));
-    _this.handleMouseLeave = _this.handleMouseLeave.bind(_assertThisInitialized(_this));
-    _this.handleTriggerClick = _this.handleTriggerClick.bind(_assertThisInitialized(_this));
-    _this.renderTarget = _this.renderTarget.bind(_assertThisInitialized(_this));
-    _this.updatePopoverState = _this.updatePopoverState.bind(_assertThisInitialized(_this));
-    _this.handlePopperPlacementChange = _this.handlePopperPlacementChange.bind(_assertThisInitialized(_this));
-    _this.handleDestroyContent = _this.handleDestroyContent.bind(_assertThisInitialized(_this));
-    _this.handleContentMouseEnter = _this.handleContentMouseEnter.bind(_assertThisInitialized(_this));
-    _this.handleContentMouseLeave = _this.handleContentMouseLeave.bind(_assertThisInitialized(_this));
-    return _this;
+    this.handleMouseEnter = this.handleMouseEnter.bind(this);
+    this.handleMouseLeave = this.handleMouseLeave.bind(this);
+    this.handleTriggerClick = this.handleTriggerClick.bind(this);
+    this.renderTarget = this.renderTarget.bind(this);
+    this.updatePopoverState = this.updatePopoverState.bind(this);
+    this.handlePopperPlacementChange = this.handlePopperPlacementChange.bind(this);
+    this.handleDestroyContent = this.handleDestroyContent.bind(this);
+    this.handleContentMouseEnter = this.handleContentMouseEnter.bind(this);
+    this.handleContentMouseLeave = this.handleContentMouseLeave.bind(this);
   } // this is needed to prevent setState on unmounted components
 
 
-  _createClass(PopperImpl, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      this.safeIsMounted = true;
-    }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate() {
-      var _this$state = this.state,
-          isOpen = _this$state.isOpen,
-          destroyed = _this$state.destroyed;
-
-      if (isOpen === true && destroyed === true) {
-        // eslint-disable-next-line react/no-did-update-set-state
-        this.setState({
-          destroyed: false
-        });
-      }
+  componentDidMount() {
+    this.safeIsMounted = true;
+  }
+
+  componentDidUpdate() {
+    const {
+      isOpen,
+      destroyed
+    } = this.state;
+
+    if (isOpen === true && destroyed === true) {
+      // eslint-disable-next-line react/no-did-update-set-state
+      this.setState({
+        destroyed: false
+      });
     }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.safeIsMounted = false;
+  }
+
+  componentWillUnmount() {
+    this.safeIsMounted = false;
+  }
+
+  static getDerivedStateFromProps(nextProps, prevState) {
+    const {
+      isOpen
+    } = nextProps;
+    const {
+      prevPropIsOpen
+    } = prevState; // todo: this causes multiple rerenders
+
+    if (isOpen !== prevPropIsOpen) {
+      return {
+        isOpen,
+        prevPropIsOpen: isOpen
+      };
     }
-  }, {
-    key: "getInteractionObject",
-    value: function getInteractionObject(interaction) {
-      var _Interaction$CLICK$In;
-
-      var referenceProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var isOpen = this.props.isOpen;
-      if (isOpen !== undefined) return {};
-      return (_Interaction$CLICK$In = {}, _defineProperty(_Interaction$CLICK$In, Interaction.CLICK, {
+
+    return null;
+  }
+
+  getInteractionObject(interaction) {
+    let referenceProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      isOpen
+    } = this.props;
+    if (isOpen !== undefined) return {};
+    return {
+      [Interaction.CLICK]: {
         handlers: {
           onClick: this.handleTriggerClick
         },
-        canClose: function canClose() {
-          return true;
-        }
-      }), _defineProperty(_Interaction$CLICK$In, Interaction.HOVER, {
+        canClose: () => true
+      },
+      [Interaction.HOVER]: {
         handlers: {
           onMouseEnter: referenceProps.onMouseEnter || this.handleMouseEnter,
           onPointerEnter: referenceProps.onMouseEnter || this.handleMouseEnter,
@@ -108,256 +107,216 @@ var PopperImpl = /*#__PURE__*/function (_Component) {
           onPointerLeave: referenceProps.onMouseLeave || this.handleMouseLeave,
           onClick: this.handleTriggerClick
         },
-        canClose: function canClose(isOnTrigger, isOnPopper) {
-          return !isOnTrigger && !isOnPopper;
-        }
-      }), _Interaction$CLICK$In)[interaction] || {
-        handlers: {},
-        canClose: function canClose() {
-          return true;
-        }
-      };
-    }
-  }, {
-    key: "setOpen",
-    value: function setOpen(opening) {
-      var onOpen = this.props.onOpen;
-      var prevPropIsOpen = this.state.prevPropIsOpen;
-      if (!this.safeIsMounted) return;
-
-      if (prevPropIsOpen === undefined) {
-        this.setState({
-          isOpen: opening,
-          destroyed: false
-        });
+        canClose: (isOnTrigger, isOnPopper) => !isOnTrigger && !isOnPopper
       }
-
-      onOpen(opening);
-    }
-  }, {
-    key: "open",
-    value: function open() {
-      var _this2 = this;
-
-      clearTimeout(this.closeTimer);
-      var delayOpen = this.props.delayOpen;
-      this.openTimer = setTimeout(function () {
-        return _this2.setOpen(true);
-      }, delayOpen);
-    }
-  }, {
-    key: "close",
-    value: function close() {
-      var _this3 = this;
-
-      clearTimeout(this.openTimer);
-      var _this$props = this.props,
-          delayClose = _this$props.delayClose,
-          _this$props$onClose = _this$props.onClose,
-          onClose = _this$props$onClose === void 0 ? function () {
-        return null;
-      } : _this$props$onClose;
-      this.closeTimer = setTimeout(function () {
-        _this3.setOpen(false);
-
-        onClose();
-      }, delayClose);
-    }
-  }, {
-    key: "handleTriggerClick",
-    value: function handleTriggerClick(e) {
-      var triggerComponent = this.props.triggerComponent;
-
-      var _ref = get(triggerComponent, 'props') || {},
-          onClick = _ref.onClick;
-
-      this.open();
-      if (isFunction(onClick)) onClick(e);
-    }
-  }, {
-    key: "handleContentMouseEnter",
-    value: function handleContentMouseEnter() {
-      this.isMouseOverContent = true;
-    }
-  }, {
-    key: "handleContentMouseLeave",
-    value: function handleContentMouseLeave() {
-      var _this4 = this;
-
-      this.isMouseOverContent = false;
-      var _this$props$onClose2 = this.props.onClose,
-          onClose = _this$props$onClose2 === void 0 ? function () {
-        return null;
-      } : _this$props$onClose2;
-      setTimeout(function () {
-        if (!_this4.isMouseOverTarget) {
-          _this4.setOpen(false);
-
-          onClose();
-        }
-      }, 10);
-    }
-  }, {
-    key: "handleMouseEnter",
-    value: function handleMouseEnter() {
-      this.isMouseOverTarget = true;
-      this.open();
-    }
-  }, {
-    key: "handleMouseLeave",
-    value: function handleMouseLeave() {
-      var _this5 = this;
-
-      this.isMouseOverTarget = false;
-      setTimeout(function () {
-        if (!_this5.isMouseOverContent) {
-          _this5.close();
-        }
-      }, 10);
-    }
-  }, {
-    key: "updatePopoverState",
-    value: function updatePopoverState(popperData) {
-      this.handlePopperPlacementChange(popperData.placement);
-      return popperData;
-    }
-  }, {
-    key: "handleDestroyContent",
-    value: function handleDestroyContent() {
+    }[interaction] || {
+      handlers: {},
+      canClose: () => true
+    };
+  }
+
+  setOpen(opening) {
+    const {
+      onOpen
+    } = this.props;
+    const {
+      prevPropIsOpen
+    } = this.state;
+    if (!this.safeIsMounted) return;
+
+    if (prevPropIsOpen === undefined) {
       this.setState({
-        destroyed: true
+        isOpen: opening,
+        destroyed: false
       });
     }
-  }, {
-    key: "renderTarget",
-    value: function renderTarget(_ref2) {
-      var ref = _ref2.ref;
-      var isOpen = this.state.isOpen;
-      var _this$props2 = this.props,
-          triggerComponent = _this$props2.triggerComponent,
-          interactionType = _this$props2.interactionType,
-          renderReference = _this$props2.renderReference;
-      var componentInnerRef = get(triggerComponent, ['props', 'innerRef'], function () {
-        return null;
-      });
-      var compRef = isDOMTypeElement(triggerComponent) ? {
-        ref: ref
-      } : {
-        innerRef: mergeRefs(ref, componentInnerRef)
-      };
-      var triggerHandler = this.getInteractionObject(interactionType, triggerComponent.props).handlers;
-
-      var targetProps = _objectSpread(_objectSpread(_objectSpread({}, triggerHandler), compRef), {}, {
-        'aria-haspopup': true,
-        'aria-expanded': isOpen
-      });
 
-      if (renderReference) {
-        return renderReference(_objectSpread({
-          ref: ref
-        }, targetProps));
+    onOpen(opening);
+  }
+
+  open() {
+    clearTimeout(this.closeTimer);
+    const {
+      delayOpen
+    } = this.props;
+    this.openTimer = setTimeout(() => this.setOpen(true), delayOpen);
+  }
+
+  close() {
+    clearTimeout(this.openTimer);
+    const {
+      delayClose,
+      onClose = () => null
+    } = this.props;
+    this.closeTimer = setTimeout(() => {
+      this.setOpen(false);
+      onClose();
+    }, delayClose);
+  }
+
+  handleTriggerClick(e) {
+    const {
+      triggerComponent
+    } = this.props;
+    const {
+      onClick
+    } = get(triggerComponent, 'props') || {};
+    this.open();
+    if (isFunction(onClick)) onClick(e);
+  }
+
+  handleContentMouseEnter() {
+    this.isMouseOverContent = true;
+  }
+
+  handleContentMouseLeave() {
+    this.isMouseOverContent = false;
+    const {
+      onClose = () => null
+    } = this.props;
+    setTimeout(() => {
+      if (!this.isMouseOverTarget) {
+        this.setOpen(false);
+        onClose();
+      }
+    }, 10);
+  }
+
+  handleMouseEnter() {
+    this.isMouseOverTarget = true;
+    this.open();
+  }
+
+  handleMouseLeave() {
+    this.isMouseOverTarget = false;
+    setTimeout(() => {
+      if (!this.isMouseOverContent) {
+        this.close();
       }
+    }, 10);
+  }
 
-      return getComponentFromProps(triggerComponent, targetProps);
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this6 = this;
-
-      var _this$state2 = this.state,
-          isOpen = _this$state2.isOpen,
-          destroyed = _this$state2.destroyed;
-      var _this$props3 = this.props,
-          placement = _this$props3.placement,
-          interactionType = _this$props3.interactionType,
-          showArrow = _this$props3.showArrow,
-          arrowSize = _this$props3.arrowSize,
-          arrowGap = _this$props3.arrowGap,
-          preventOverflow = _this$props3.preventOverflow,
-          customPopper = _this$props3.children,
-          usePortal = _this$props3.usePortal,
-          blockName = _this$props3.blockName,
-          contentComponent = _this$props3.contentComponent,
-          openAnimationConfig = _this$props3.openAnimationConfig,
-          closeAnimationConfig = _this$props3.closeAnimationConfig,
-          modifiers = _this$props3.modifiers,
-          referenceNode = _this$props3.referenceNode,
-          containerProps = _this$props3.containerProps,
-          zIndex = _this$props3.zIndex,
-          hideIfNotVisible = _this$props3.hideIfNotVisible;
-
-      var allModifiers = _objectSpread({
-        offset: {
-          enabled: showArrow,
-          offset: "0, ".concat(arrowSize + arrowGap)
-        },
-        preventOverflow: {
-          enabled: true,
-          padding: 0,
-          boundariesElement: preventOverflow
-        },
-        updatePopoverState: {
-          enabled: true,
-          fn: this.updatePopoverState,
-          order: 900
-        }
-      }, modifiers);
-
-      var triggerHandler = this.getInteractionObject(interactionType).handlers;
-      var popperContentProps = {
-        hideIfNotVisible: hideIfNotVisible,
-        containerProps: containerProps,
-        isOpen: isOpen,
-        destroyed: isOpen ? false : destroyed,
-        arrowSize: arrowSize,
-        blockName: blockName,
-        showArrow: showArrow,
-        modifiers: allModifiers,
-        contentComponent: contentComponent,
-        onContentDestroyed: this.handleDestroyContent,
-        onClickOutside: function onClickOutside() {
-          return _this6.close();
-        },
-        placement: placement,
-        usePortal: usePortal,
-        openAnimationConfig: openAnimationConfig,
-        closeAnimationConfig: closeAnimationConfig,
-        onMouseEnter: interactionType === Interaction.HOVER ? this.handleContentMouseEnter : undefined,
-        onMouseLeave: interactionType === Interaction.HOVER ? this.handleContentMouseLeave : undefined,
-        referenceNode: referenceNode,
-        zIndex: zIndex
-      };
+  updatePopoverState(popperData) {
+    this.handlePopperPlacementChange(popperData.placement);
+    return popperData;
+  }
 
-      if (customPopper && typeof customPopper === 'function') {
-        return /*#__PURE__*/React.createElement(Manager, null, customPopper({
-          Reference: Reference,
-          triggerHandler: triggerHandler,
-          content: /*#__PURE__*/React.createElement(PopperContent, popperContentProps)
-        }));
-      }
+  handleDestroyContent() {
+    this.setState({
+      destroyed: true
+    });
+  }
+
+  renderTarget(_ref) {
+    let {
+      ref
+    } = _ref;
+    const {
+      isOpen
+    } = this.state;
+    const {
+      triggerComponent,
+      interactionType,
+      renderReference
+    } = this.props;
+    const componentInnerRef = get(triggerComponent, ['props', 'innerRef'], () => null);
+    const compRef = isDOMTypeElement(triggerComponent) ? {
+      ref
+    } : {
+      innerRef: mergeRefs(ref, componentInnerRef)
+    };
+    const triggerHandler = this.getInteractionObject(interactionType, triggerComponent.props).handlers;
+
+    const targetProps = _objectSpread(_objectSpread(_objectSpread({}, triggerHandler), compRef), {}, {
+      'aria-haspopup': true,
+      'aria-expanded': isOpen
+    });
 
-      return /*#__PURE__*/React.createElement(Manager, null, /*#__PURE__*/React.createElement(Reference, null, this.renderTarget), /*#__PURE__*/React.createElement(PopperContent, popperContentProps));
+    if (renderReference) {
+      return renderReference(_objectSpread({
+        ref
+      }, targetProps));
     }
-  }], [{
-    key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(nextProps, prevState) {
-      var isOpen = nextProps.isOpen;
-      var prevPropIsOpen = prevState.prevPropIsOpen; // todo: this causes multiple rerenders
-
-      if (isOpen !== prevPropIsOpen) {
-        return {
-          isOpen: isOpen,
-          prevPropIsOpen: isOpen
-        };
-      }
 
-      return null;
+    return getComponentFromProps(triggerComponent, targetProps);
+  }
+
+  render() {
+    const {
+      isOpen,
+      destroyed
+    } = this.state;
+    const {
+      placement,
+      interactionType,
+      showArrow,
+      arrowSize,
+      arrowGap,
+      preventOverflow,
+      children: customPopper,
+      usePortal,
+      blockName,
+      contentComponent,
+      openAnimationConfig,
+      closeAnimationConfig,
+      modifiers,
+      referenceNode,
+      containerProps,
+      zIndex,
+      hideIfNotVisible
+    } = this.props;
+
+    const allModifiers = _objectSpread({
+      offset: {
+        enabled: showArrow,
+        offset: "0, ".concat(arrowSize + arrowGap)
+      },
+      preventOverflow: {
+        enabled: true,
+        padding: 0,
+        boundariesElement: preventOverflow
+      },
+      updatePopoverState: {
+        enabled: true,
+        fn: this.updatePopoverState,
+        order: 900
+      }
+    }, modifiers);
+
+    const triggerHandler = this.getInteractionObject(interactionType).handlers;
+    const popperContentProps = {
+      hideIfNotVisible,
+      containerProps,
+      isOpen,
+      destroyed: isOpen ? false : destroyed,
+      arrowSize,
+      blockName,
+      showArrow,
+      modifiers: allModifiers,
+      contentComponent,
+      onContentDestroyed: this.handleDestroyContent,
+      onClickOutside: () => this.close(),
+      placement,
+      usePortal,
+      openAnimationConfig,
+      closeAnimationConfig,
+      onMouseEnter: interactionType === Interaction.HOVER ? this.handleContentMouseEnter : undefined,
+      onMouseLeave: interactionType === Interaction.HOVER ? this.handleContentMouseLeave : undefined,
+      referenceNode,
+      zIndex
+    };
+
+    if (customPopper && typeof customPopper === 'function') {
+      return /*#__PURE__*/_jsx(Manager, {}, void 0, customPopper({
+        Reference,
+        triggerHandler,
+        content: /*#__PURE__*/jsx(PopperContent, _objectSpread({}, popperContentProps))
+      }));
     }
-  }]);
 
-  return PopperImpl;
-}(Component);
+    return /*#__PURE__*/_jsx(Manager, {}, void 0, /*#__PURE__*/_jsx(Reference, {}, void 0, this.renderTarget), /*#__PURE__*/jsx(PopperContent, _objectSpread({}, popperContentProps)));
+  }
+
+}
 
 export { PopperImpl as default };
-//# sourceMappingURL=PopperImpl.js.map

package/esm/getArrowStylesBySize.js

@@ -1,12 +1,17 @@
+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 _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 
 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 getArrowStylesBySize = function getArrowStylesBySize(position) {
-  var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 30;
-  var basePosition = position && position.split('-')[0];
+const getArrowStylesBySize = function (position) {
+  let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 30;
+  const basePosition = position && position.split('-')[0];
   return _objectSpread({
     borderWidth: size
   }, {
@@ -30,4 +35,3 @@ var getArrowStylesBySize = function getArrowStylesBySize(position) {
 };
 
 export { getArrowStylesBySize as default, getArrowStylesBySize };
-//# sourceMappingURL=getArrowStylesBySize.js.map

package/esm/index.js

@@ -2,22 +2,3 @@ export { DSPopper, DSPopperWithSchema, DSPopper as default } from './DSPopper.js
 export { getArrowStylesBySize } from './getArrowStylesBySize.js';
 export { Interaction as PopperInteractions, interactions } from './interaction.js';
 export { Position as PopperPositions, positions } from './positions.js';
-import 'react';
-import 'react-desc';
-import './PopperImpl.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-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 '@elliemae/ds-utilities';
-import 'react-popper';
-import 'memoize-one';
-import './PopperContent.js';
-import '@babel/runtime/helpers/esm/extends';
-import 'react-spring/renderprops.cjs';
-import '@elliemae/ds-overlay';
-import './props.js';
-//# sourceMappingURL=index.js.map