@elliemae/ds-popper 2.3.0-alpha.8 → 2.3.0-next.2

package/cjs/DSPopper.js

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('react');
+var reactDesc = require('react-desc');
+var PopperImpl = require('./PopperImpl.js');
+var positions = require('./positions.js');
+var interaction = require('./interaction.js');
+var props = require('./props.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+const DSPopper = _ref => {
+  let {
+    containerProps,
+    arrowGap,
+    arrowSize,
+    blockName,
+    contentOffset,
+    contentStyle,
+    contentComponent,
+    delayClose,
+    delayOpen,
+    interactionType,
+    isOpen,
+    // if this is set DSPopper would be a controlled component if not, an uncontrolled one
+    onOpen,
+    onClose,
+    onPlacementChange,
+    placement,
+    preventOverflow,
+    showArrow,
+    closeAnimationConfig,
+    openAnimationConfig,
+    usePortal,
+    triggerComponent,
+    wrapExtraComponent,
+    getTargetFromChildren,
+    getContentFromChildren,
+    modifiers,
+    triggerRef,
+    children: customPopper,
+    renderReference,
+    referenceNode,
+    zIndex,
+    hideIfNotVisible
+  } = _ref;
+  return /*#__PURE__*/_jsx__default["default"](PopperImpl["default"], {
+    arrowGap: arrowGap,
+    arrowSize: arrowSize,
+    blockName: blockName,
+    closeAnimationConfig: closeAnimationConfig,
+    containerProps: containerProps,
+    contentComponent: contentComponent,
+    contentOffset: contentOffset,
+    contentStyle: contentStyle,
+    delayClose: delayClose,
+    delayOpen: delayOpen,
+    getContentFromChildren: getContentFromChildren,
+    getTargetFromChildren: getTargetFromChildren,
+    interactionType: interactionType,
+    isOpen: isOpen,
+    modifiers: modifiers,
+    onOpen: onOpen,
+    onClose: onClose,
+    onPlacementChange: onPlacementChange,
+    openAnimationConfig: openAnimationConfig,
+    placement: placement,
+    preventOverflow: preventOverflow,
+    referenceNode: referenceNode,
+    renderReference: renderReference,
+    showArrow: showArrow,
+    triggerComponent: triggerComponent,
+    triggerRef: triggerRef,
+    usePortal: usePortal,
+    wrapExtraComponent: wrapExtraComponent,
+    zIndex: zIndex,
+    hideIfNotVisible: hideIfNotVisible
+  }, void 0, customPopper);
+}; // @deprecated: There's the NEW (not finished) popover that uses its own popper implementation.
+
+
+DSPopper.defaultProps = props.defaultProps;
+const DSPopperWithSchema = reactDesc.describe(DSPopper);
+DSPopperWithSchema.propTypes = props.popperProps;
+
+exports.PopperPositions = positions.Position;
+exports.positions = positions.positions;
+exports.PopperInteractions = interaction.Interaction;
+exports.interactions = interaction.interactions;
+exports.DSPopper = DSPopper;
+exports.DSPopperWithSchema = DSPopperWithSchema;
+exports["default"] = DSPopper;

package/cjs/PopperContent.js

@@ -0,0 +1,156 @@
+'use strict';
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _jsx = require('@babel/runtime/helpers/jsx');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var react = require('react');
+var reactPopper = require('react-popper');
+var renderprops = require('react-spring/renderprops');
+var getComponentFromProps = require('@elliemae/ds-utilities/getComponentFromProps');
+var DSOverlay = require('@elliemae/ds-overlay');
+var getArrowStylesBySize = require('./getArrowStylesBySize.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var getComponentFromProps__default = /*#__PURE__*/_interopDefaultLegacy(getComponentFromProps);
+var DSOverlay__default = /*#__PURE__*/_interopDefaultLegacy(DSOverlay);
+
+var _svg;
+
+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__default["default"](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 Content = renderprops.Keyframes.Spring({});
+class PopperContent extends react.PureComponent {
+  // eslint-disable-next-line react/static-property-placement
+  constructor(props) {
+    super(props);
+    this.renderContent = this.renderContent.bind(this);
+    this.renderArrow = this.renderArrow.bind(this);
+    this.handleRestAnimation = this.handleRestAnimation.bind(this);
+    this.handleRestAnimation = this.handleRestAnimation.bind(this);
+  }
+
+  handleRestAnimation() {
+    const {
+      isOpen,
+      onContentDestroyed
+    } = this.props;
+
+    if (!isOpen) {
+      onContentDestroyed();
+    }
+  }
+
+  renderArrow(_ref, placement) {
+    let {
+      ref,
+      style
+    } = _ref;
+    const {
+      blockName,
+      showArrow
+    } = this.props;
+    if (!showArrow) return null;
+    return /*#__PURE__*/jsxRuntime.jsx("div", {
+      ref: ref,
+      className: "".concat(blockName || 'popper', "__arrow"),
+      "data-placement": placement,
+      style: _objectSpread(_objectSpread({}, style), getArrowStylesBySize.getArrowStylesBySize(placement, 25)),
+      children: _svg || (_svg = /*#__PURE__*/_jsx__default["default"]("svg", {
+        viewBox: "0 0 30 30"
+      }, void 0, /*#__PURE__*/_jsx__default["default"]("path", {
+        className: "stroke",
+        d: "M23.7,27.1L17,19.9C16.5,19.3,15.8,19,15,19s-1.6,0.3-2.1,0.9l-6.6,7.2C5.3,28.1,3.4,29,2,29h26 C26.7,29,24.6,28.1,23.7,27.1z"
+      }), /*#__PURE__*/_jsx__default["default"]("path", {
+        className: "fill",
+        d: "M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z"
+      })))
+    }, "popper-arrow");
+  }
+
+  renderContent(_ref2) {
+    let {
+      ref,
+      style,
+      placement,
+      arrowProps,
+      scheduleUpdate,
+      outOfBoundaries
+    } = _ref2;
+    const {
+      contentComponent,
+      contentStyle,
+      isOpen,
+      closeAnimationConfig,
+      openAnimationConfig,
+      onMouseEnter,
+      onMouseLeave,
+      containerProps,
+      zIndex,
+      hideIfNotVisible
+    } = this.props;
+
+    const computedStyle = _objectSpread(_objectSpread(_objectSpread({}, style), contentStyle), {}, {
+      zIndex
+    });
+
+    return /*#__PURE__*/jsxRuntime.jsx("div", _objectSpread(_objectSpread({}, containerProps), {}, {
+      "data-placement": placement,
+      onMouseEnter: onMouseEnter,
+      onMouseLeave: onMouseLeave,
+      style: computedStyle,
+      "data-testid": "popper-container",
+      children: /*#__PURE__*/_jsx__default["default"](Content, {
+        native: true,
+        onRest: this.handleRestAnimation,
+        state: isOpen && (!outOfBoundaries || !hideIfNotVisible) ? 'open' : 'close',
+        states: {
+          open: _objectSpread(_objectSpread({}, openAnimationConfig), {}, {
+            from: closeAnimationConfig.to
+          }),
+          close: closeAnimationConfig
+        }
+      }, void 0, animationStyle => /*#__PURE__*/jsxRuntime.jsx(renderprops.animated.div, {
+        ref: ref,
+        style: animationStyle,
+        children: getComponentFromProps__default["default"](contentComponent, {
+          scheduleUpdate
+        }, [this.renderArrow(arrowProps, placement)])
+      }))
+    }));
+  }
+
+  render() {
+    const {
+      destroyed = false,
+      onClickOutside = () => null,
+      placement = 'bottom-start',
+      modifiers = {},
+      referenceNode,
+      usePortal = true
+    } = this.props;
+    return /*#__PURE__*/_jsx__default["default"](DSOverlay__default["default"], {
+      isOpen: !destroyed,
+      onClickOutside: onClickOutside,
+      usePortal: usePortal
+    }, void 0, /*#__PURE__*/_jsx__default["default"](reactPopper.Popper, {
+      modifiers: modifiers,
+      placement: placement,
+      referenceElement: referenceNode
+    }, void 0, this.renderContent));
+  }
+
+}
+PopperContent.defaultProps = {
+  onContentDestroyed: () => null
+};
+
+module.exports = PopperContent;

package/cjs/PopperImpl.js

@@ -0,0 +1,335 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _jsx = require('@babel/runtime/helpers/jsx');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var react = require('react');
+var dsUtilities = require('@elliemae/ds-utilities');
+var reactPopper = require('react-popper');
+var memoizeOne = require('memoize-one');
+var PopperContent = require('./PopperContent.js');
+var interaction = require('./interaction.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var memoizeOne__default = /*#__PURE__*/_interopDefaultLegacy(memoizeOne);
+
+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__default["default"](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; }
+class PopperImpl extends react.Component {
+  // we use safeIsMounted because isMounted is not allowed by React.
+  constructor(props) {
+    super(props);
+    this.safeIsMounted = false;
+    this.handlePopperPlacementChange = memoizeOne__default["default"](placement => {
+      const {
+        onPlacementChange
+      } = this.props;
+      onPlacementChange(placement);
+    });
+    this.state = {
+      isOpen: false,
+      destroyed: true
+    }; // TODO: Fix the autobinding to remove 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
+
+
+  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
+      });
+    }
+  }
+
+  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
+      };
+    }
+
+    return null;
+  }
+
+  getInteractionObject(interaction$1) {
+    let referenceProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      isOpen
+    } = this.props;
+    if (isOpen !== undefined) return {};
+    return {
+      [interaction.Interaction.CLICK]: {
+        handlers: {
+          onClick: this.handleTriggerClick
+        },
+        canClose: () => true
+      },
+      [interaction.Interaction.HOVER]: {
+        handlers: {
+          onMouseEnter: referenceProps.onMouseEnter || this.handleMouseEnter,
+          onPointerEnter: referenceProps.onMouseEnter || this.handleMouseEnter,
+          onMouseLeave: referenceProps.onMouseLeave || this.handleMouseLeave,
+          onPointerLeave: referenceProps.onMouseLeave || this.handleMouseLeave,
+          onClick: this.handleTriggerClick
+        },
+        canClose: (isOnTrigger, isOnPopper) => !isOnTrigger && !isOnPopper
+      }
+    }[interaction$1] || {
+      handlers: {},
+      canClose: () => true
+    };
+  }
+
+  setOpen(opening) {
+    const {
+      onOpen
+    } = this.props;
+    const {
+      prevPropIsOpen
+    } = this.state;
+    if (!this.safeIsMounted) return;
+
+    if (prevPropIsOpen === undefined) {
+      this.setState({
+        isOpen: opening,
+        destroyed: false
+      });
+    }
+
+    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
+    } = dsUtilities.get(triggerComponent, 'props') || {};
+    this.open();
+    if (dsUtilities.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);
+  }
+
+  updatePopoverState(popperData) {
+    this.handlePopperPlacementChange(popperData.placement);
+    return popperData;
+  }
+
+  handleDestroyContent() {
+    this.setState({
+      destroyed: true
+    });
+  }
+
+  renderTarget(_ref) {
+    let {
+      ref
+    } = _ref;
+    const {
+      isOpen
+    } = this.state;
+    const {
+      triggerComponent,
+      interactionType,
+      renderReference
+    } = this.props;
+    const componentInnerRef = dsUtilities.get(triggerComponent, ['props', 'innerRef'], () => null);
+    const compRef = dsUtilities.isDOMTypeElement(triggerComponent) ? {
+      ref
+    } : {
+      innerRef: dsUtilities.mergeRefs(ref, componentInnerRef)
+    };
+    const triggerHandler = this.getInteractionObject(interactionType, triggerComponent.props).handlers;
+
+    const targetProps = _objectSpread(_objectSpread(_objectSpread({}, triggerHandler), compRef), {}, {
+      'aria-haspopup': true,
+      'aria-expanded': isOpen
+    });
+
+    if (renderReference) {
+      return renderReference(_objectSpread({
+        ref
+      }, targetProps));
+    }
+
+    return dsUtilities.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.Interaction.HOVER ? this.handleContentMouseEnter : undefined,
+      onMouseLeave: interactionType === interaction.Interaction.HOVER ? this.handleContentMouseLeave : undefined,
+      referenceNode,
+      zIndex
+    };
+
+    if (customPopper && typeof customPopper === 'function') {
+      return /*#__PURE__*/_jsx__default["default"](reactPopper.Manager, {}, void 0, customPopper({
+        Reference: reactPopper.Reference,
+        triggerHandler,
+        content: /*#__PURE__*/jsxRuntime.jsx(PopperContent, _objectSpread({}, popperContentProps))
+      }));
+    }
+
+    return /*#__PURE__*/_jsx__default["default"](reactPopper.Manager, {}, void 0, /*#__PURE__*/_jsx__default["default"](reactPopper.Reference, {}, void 0, this.renderTarget), /*#__PURE__*/jsxRuntime.jsx(PopperContent, _objectSpread({}, popperContentProps)));
+  }
+
+}
+
+Object.defineProperty(exports, 'Reference', {
+  enumerable: true,
+  get: function () { return reactPopper.Reference; }
+});
+exports.PopperContent = PopperContent;
+exports["default"] = PopperImpl;

package/cjs/getArrowStylesBySize.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+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__default["default"](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 getArrowStylesBySize = function (position) {
+  let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 30;
+  const basePosition = position && position.split('-')[0];
+  return _objectSpread({
+    borderWidth: size
+  }, {
+    top: {
+      top: '100% !important',
+      transform: "rotateZ(".concat(180, "deg)")
+    },
+    right: {
+      right: '100%',
+      transform: "rotateZ(".concat(-90, "deg)")
+    },
+    bottom: {
+      bottom: '100%',
+      transform: "rotateZ(".concat(0, "deg)")
+    },
+    left: {
+      left: '100%',
+      transform: "rotateZ(".concat(90, "deg)")
+    }
+  }[basePosition]);
+};
+
+exports["default"] = getArrowStylesBySize;
+exports.getArrowStylesBySize = getArrowStylesBySize;

package/cjs/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DSPopper = require('./DSPopper.js');
+var getArrowStylesBySize = require('./getArrowStylesBySize.js');
+var interaction = require('./interaction.js');
+var positions = require('./positions.js');
+
+
+
+exports.DSPopper = DSPopper.DSPopper;
+exports.DSPopperWithSchema = DSPopper.DSPopperWithSchema;
+exports["default"] = DSPopper.DSPopper;
+exports.getArrowStylesBySize = getArrowStylesBySize.getArrowStylesBySize;
+exports.PopperInteractions = interaction.Interaction;
+exports.interactions = interaction.interactions;
+exports.PopperPositions = positions.Position;
+exports.positions = positions.positions;

package/cjs/interaction.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const Interaction = {
+  CLICK: 'click',
+  HOVER: 'hover'
+};
+const interactions = [Interaction.CLICK, Interaction.HOVER];
+
+exports.Interaction = Interaction;
+exports.interactions = interactions;

package/cjs/positions.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const Position = {
+  AUTO: 'auto',
+  AUTO_START: 'auto-start',
+  AUTO_END: 'auto-end',
+  BOTTOM: 'bottom',
+  BOTTOM_START: 'bottom-start',
+  BOTTOM_END: 'bottom-end',
+  LEFT: 'left',
+  LEFT_END: 'left-end',
+  LEFT_START: 'left-start',
+  RIGHT: 'right',
+  RIGHT_END: 'right-end',
+  RIGHT_START: 'right-start',
+  TOP: 'top',
+  TOP_START: 'top-start',
+  TOP_END: 'top-end'
+};
+const positions = [Position.AUTO_START, Position.AUTO_END, Position.AUTO, Position.TOP_START, Position.TOP, Position.TOP_END, Position.RIGHT_START, Position.RIGHT, Position.RIGHT_END, Position.BOTTOM_START, Position.BOTTOM, Position.BOTTOM_END, Position.LEFT_START, Position.LEFT, Position.LEFT_END];
+
+exports.Position = Position;
+exports.positions = positions;