intergalactic 15.123.0 → 15.124.0

package/popper/lib/es6/Popper.js

@@ -0,0 +1,676 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _createSuper from "@babel/runtime/helpers/createSuper";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+import { sstyled as _sstyled } from 'intergalactic/utils/lib/core/index';
+import { assignProps as _assignProps2 } from 'intergalactic/core';
+import { assignProps as _assignProps } from 'intergalactic/core';
+var _excluded = ["placement", "modifiers", "strategy", "onFirstUpdate"],
+  _excluded2 = ["onKeyDown"],
+  _excluded3 = ["onKeyDown"];
+import React from 'react';
+import canUseDOM from 'intergalactic/utils/lib/canUseDOM';
+import createComponent, { Component, sstyled, Root } from 'intergalactic/core';
+import { Box } from 'intergalactic/flex-box';
+import OutsideClick from 'intergalactic/outside-click';
+import Portal, { PortalProvider } from 'intergalactic/portal';
+import NeighborLocation from 'intergalactic/neighbor-location';
+import { setRef } from 'intergalactic/utils/lib/ref';
+import { useFocusLock, isFocusInside, setFocus, makeFocusLockSyntheticEvent } from 'intergalactic/utils/lib/use/useFocusLock';
+import { callAllEventHandlers } from 'intergalactic/utils/lib/assignProps';
+import pick from 'intergalactic/utils/lib/pick';
+import uniqueIDEnhancement from 'intergalactic/utils/lib/uniqueID';
+import { Scale, animationContext } from 'intergalactic/animation';
+import { cssVariableEnhance } from 'intergalactic/utils/lib/useCssVariable';
+import { useContextTheme } from 'intergalactic/utils/lib/ThemeProvider';
+import { ScreenReaderOnly } from 'intergalactic/flex-box';
+import keyboardFocusEnhance, { useFocusSource } from 'intergalactic/utils/lib/enhances/keyboardFocusEnhance';
+import { hasParent } from 'intergalactic/utils/lib/hasParent';
+import logger from 'intergalactic/utils/lib/logger';
+import _createPopper from './createPopper';
+/*__reshadow-styles__:"./style/popper.shadow.css"*/
+var style = ( /*__reshadow_css_start__*/_sstyled.insert( /*__inner_css_start__*/".___SPopper_mau2k_gg_{outline:0;color:var(--intergalactic-text-primary, #191b23)}.___SPopper_mau2k_gg_.__keyboardFocused_mau2k_gg_:focus:after{position:absolute;display:block;content:\"\";top:0;right:0;bottom:0;left:0;box-shadow:var(--intergalactic-keyboard-focus, 0px 0px 0px 3px rgba(0, 143, 248, 0.5));pointer-events:none;border-radius:var(--intergalactic-popper-rounded, 6px)}.___SPopper_mau2k_gg_.__keyboardFocused_mau2k_gg_.__hideFocus_mau2k_gg_:focus:after{box-shadow:none}.___SFocusHint_mau2k_gg_{display:none}.___STrigger_mau2k_gg_:focus .___SFocusHint_mau2k_gg_,.___STrigger_mau2k_gg_:focus-within .___SFocusHint_mau2k_gg_{display:inline}" /*__inner_css_end__*/, "mau2k_gg_") /*__reshadow_css_end__*/, {
+  "__SPopper": "___SPopper_mau2k_gg_",
+  "_keyboardFocused": "__keyboardFocused_mau2k_gg_",
+  "_hideFocus": "__hideFocus_mau2k_gg_",
+  "__SFocusHint": "___SFocusHint_mau2k_gg_",
+  "__STrigger": "___STrigger_mau2k_gg_"
+});
+import { useZIndexStacking, ZIndexStackingContextProvider } from 'intergalactic/utils/lib/zIndexStacking';
+import { forkRef } from 'intergalactic/utils/lib/ref';
+function isObject(obj) {
+  return _typeof(obj) === 'object' && !Array.isArray(obj);
+}
+function someArray(arr1, arr2) {
+  return arr1.filter(function (i) {
+    return arr2.indexOf(i) !== -1;
+  });
+}
+var useUpdatePopperEveryFrame = function useUpdatePopperEveryFrame(popperRef) {
+  var nextAnimationFrameRef = React.useRef(-1);
+  var handleAnimationFrame = React.useCallback(function (until) {
+    var _popperRef$current;
+    if (until < Date.now()) return;
+    (_popperRef$current = popperRef.current) === null || _popperRef$current === void 0 ? void 0 : _popperRef$current.update();
+    nextAnimationFrameRef.current = requestAnimationFrame(function () {
+      return handleAnimationFrame(until);
+    });
+  }, []);
+  React.useEffect(function () {
+    return function () {
+      return cancelAnimationFrame(nextAnimationFrameRef.current);
+    };
+  }, []);
+  return handleAnimationFrame;
+};
+export var isInputTriggerTag = function isInputTriggerTag(tag) {
+  var _tag$render;
+  if (typeof tag === 'string') return tag.toLowerCase().includes('input');
+  if (_typeof(tag) === 'object' && tag !== null && typeof tag.displayName === 'string') return tag.displayName.toLowerCase().includes('input');
+  if (_typeof(tag) === 'object' && tag !== null && typeof ((_tag$render = tag.render) === null || _tag$render === void 0 ? void 0 : _tag$render.displayName) === 'string') return tag.render.displayName.toLowerCase().includes('input');
+  return false;
+};
+var mouseMoveListenerAdded = false;
+var lastMouseMove = 0;
+var MODIFIERS_OPTIONS = ['offset', 'preventOverflow', 'arrow', 'flip', 'computeStyles', 'eventListeners'];
+var PopperRoot = /*#__PURE__*/function (_Component) {
+  _inherits(PopperRoot, _Component);
+  var _super = _createSuper(PopperRoot);
+  function PopperRoot(props) {
+    var _this;
+    _classCallCheck(this, PopperRoot);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "eventsInteractionMap", {
+      click: {
+        trigger: [['onClick'], ['onClick']],
+        popper: []
+      },
+      hover: {
+        trigger: [['onMouseEnter', 'onKeyboardFocus', 'onTouchStart'], ['onMouseLeave', 'onBlur']],
+        popper: [['onMouseEnter', 'onFocusCapture', 'onTouchStart'], ['onMouseLeave']]
+      },
+      focus: {
+        trigger: [['onFocus', 'onClick'], ['onBlur']],
+        // to intercept faster than onBlur on the trigger
+        popper: [['onFocusCapture'], ['onBlur']]
+      },
+      none: {
+        trigger: [],
+        popper: []
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "triggerRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "popperRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "popper", /*#__PURE__*/React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "lastPopperReference", null);
+    _defineProperty(_assertThisInitialized(_this), "ignoreTriggerFocus", false);
+    _defineProperty(_assertThisInitialized(_this), "mouseEnterCursorPositionRef", {
+      current: null
+    });
+    _defineProperty(_assertThisInitialized(_this), "createTriggerRef", function (ref) {
+      if (ref && _this.triggerRef.current !== ref) {
+        setRef(_this.triggerRef, ref);
+        _this.createPopper();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "createPopperRef", function (ref) {
+      if (ref && _this.popperRef.current !== ref) {
+        setRef(_this.popperRef, ref);
+        _this.createPopper();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "getPopperOptions", function () {
+      var _this$asProps = _this.asProps,
+        placement = _this$asProps.placement,
+        modifiers = _this$asProps.modifiers,
+        strategy = _this$asProps.strategy,
+        onFirstUpdate = _this$asProps.onFirstUpdate,
+        other = _objectWithoutProperties(_this$asProps, _excluded);
+      var optionsModifiers = pick(other, MODIFIERS_OPTIONS);
+      var modifiersFallback = [];
+      if (typeof optionsModifiers.offset === 'number') {
+        optionsModifiers.offset = [0, optionsModifiers.offset];
+      }
+      var modifiersOptions = MODIFIERS_OPTIONS.filter(function (name) {
+        return optionsModifiers[name] !== undefined;
+      }).map(function (name) {
+        return {
+          name: name,
+          options: isObject(optionsModifiers[name]) ? optionsModifiers[name] : _defineProperty({}, name, optionsModifiers[name])
+        };
+      });
+      modifiersOptions.push({
+        name: 'computeStyles',
+        options: {
+          gpuAcceleration: false
+        }
+      });
+      if (_this.asProps.cursorAnchoring) {
+        modifiersOptions.push({
+          name: 'cursorAnchoring',
+          options: {
+            cursorAnchoring: _this.asProps.cursorAnchoring,
+            mouseEnterCursorPositionRef: _this.mouseEnterCursorPositionRef
+          }
+        });
+      }
+      if (_this.asProps.popperMargin) {
+        modifiersOptions.push({
+          name: 'applyMaxSize',
+          enabled: true,
+          options: {
+            margin: _this.asProps.popperMargin,
+            popperCtx: _assertThisInitialized(_this)
+          }
+        });
+      }
+      var modifiersMerge = [].concat(modifiersFallback, _toConsumableArray(modifiersOptions)).concat(modifiers);
+      return {
+        placement: placement,
+        strategy: strategy,
+        onFirstUpdate: callAllEventHandlers(onFirstUpdate, function () {
+          var _this$observer, _this$observer2, _this$popperRef$curre;
+          (_this$observer = _this.observer) === null || _this$observer === void 0 ? void 0 : _this$observer.observe(_this.triggerRef.current);
+          (_this$observer2 = _this.observer) === null || _this$observer2 === void 0 ? void 0 : _this$observer2.observe(_this.popperRef.current);
+          if (_this.asProps.disablePortal) return;
+          var parent = (_this$popperRef$curre = _this.popperRef.current) === null || _this$popperRef$curre === void 0 ? void 0 : _this$popperRef$curre.parentElement;
+          var traversingLimit = 10;
+          for (var i = 0; i < traversingLimit; i++) {
+            var _this$observer3;
+            if (!parent) break;
+            (_this$observer3 = _this.observer) === null || _this$observer3 === void 0 ? void 0 : _this$observer3.observe(parent);
+            if (parent === document.body) break;
+            parent = parent.parentElement;
+          }
+        }),
+        modifiers: modifiersMerge
+      };
+    });
+    _defineProperty(_assertThisInitialized(_this), "makeKeyDownHandler", function (component) {
+      return function (e) {
+        var visible = _this.asProps.visible;
+        if (visible && e.key === 'Escape') {
+          e.stopPropagation();
+          _this.bindHandlerChangeVisibleWithTimer(false, component, 'onKeyDown')(e);
+        }
+      };
+    });
+    _defineProperty(_assertThisInitialized(_this), "bindHandlerKeyDown", function (onKeyDown, component) {
+      return callAllEventHandlers(onKeyDown, _this.makeKeyDownHandler(component));
+    });
+    _defineProperty(_assertThisInitialized(_this), "lastPopperClick", 0);
+    _defineProperty(_assertThisInitialized(_this), "bindHandlerChangeVisibleWithTimer", function (visible, component, action) {
+      return function (e) {
+        var trigger = _this.triggerRef.current;
+        if (component === 'trigger' && action === 'onBlur') {
+          var focused = e.relatedTarget;
+          var blurred = e.target;
+          if (focused && blurred && hasParent(focused, trigger) && hasParent(blurred, trigger)) {
+            return;
+          }
+        }
+        if (component === 'trigger' && action === 'onClick') {
+          var triggerClick = hasParent(e.target, trigger);
+          var associatedLabels = _toConsumableArray((trigger === null || trigger === void 0 ? void 0 : trigger.labels) || []);
+          var popperInsideOfLabel = associatedLabels.some(function (label) {
+            return hasParent(_this.popperRef.current, label);
+          });
+          if (triggerClick && popperInsideOfLabel && Date.now() - _this.lastPopperClick < 100) {
+            return;
+          }
+        }
+        /**
+         * When popper appears right under mouse that doesn't move, it gets undesired onMouseEnter event.
+         * That may cause hover interaction poppers to display two closely placed poppers.
+         * That check ensures that onMouseEnter means mouse entered the popper, not popper entered the mouse.
+         */
+        if (component === 'popper' && action === 'onMouseEnter' && Date.now() - lastMouseMove > 100) return;
+        if (action === 'onMouseEnter') {
+          _this.mouseEnterCursorPositionRef.current = {
+            x: e.clientX,
+            y: e.clientY
+          };
+        }
+        var focusAction = ['onFocus', 'onKeyboardFocus', 'onFocusCapture'].includes(action);
+        if (_this.ignoreTriggerFocus && visible && component === 'trigger' && focusAction) {
+          return;
+        }
+        if (!visible) {
+          /**
+           * When sibling popovers triggers with hover/focus interactions are navigated fast,
+           * sometimes focus moves into closing popovers and prevents it from closing. It may cause
+           * multiple popovers to be opened at the same time.
+           */
+          setTimeout(function () {
+            var node = _this.popperRef.current;
+            if ((node === null || node === void 0 ? void 0 : node.getAttribute('tabindex')) === '0') {
+              node.setAttribute('tabindex', '-1');
+            }
+          }, 0);
+        }
+        var target = e === null || e === void 0 ? void 0 : e.currentTarget;
+        if (component === 'trigger' && target && target instanceof HTMLElement) {
+          _this.lastPopperReference = target;
+        }
+        _this.handlerChangeVisibleWithTimer(visible, e, function () {
+          clearTimeout(_this.timerMultiTrigger);
+          // instance popper is not here yet because the popperRef did not have time to come
+          _this.timerMultiTrigger = setTimeout(function () {
+            if (visible && component === 'trigger' && _this.popper.current && _this.lastPopperReference) {
+              if (_this.popper.current.state.elements.reference !== _this.lastPopperReference) {
+                _this.popper.current.state.elements.reference = _this.lastPopperReference;
+                // for update
+                _this.popper.current.setOptions({});
+              }
+            }
+            if (!visible && component === 'popper') {
+              setTimeout(function () {
+                _this.ignoreTriggerFocus = false;
+              }, 0);
+            }
+          }, 0);
+        });
+        if (component === 'popper' && !visible && ['onClick', 'onBlur', 'onKeyDown'].includes(action)) {
+          _this.ignoreTriggerFocus = true;
+        }
+      };
+    });
+    _defineProperty(_assertThisInitialized(_this), "handlerChangeVisibleWithTimer", function (visible, e, cb) {
+      var _this$asProps2 = _this.asProps,
+        timeout = _this$asProps2.timeout,
+        disabled = _this$asProps2.disabled;
+      if (typeof disabled === 'boolean' && disabled && visible) return;
+      var handlers = _this.handlers;
+      var timeoutConfig = typeof timeout === 'number' ? [timeout, timeout] : timeout;
+      var latency = visible ? timeoutConfig[0] : timeoutConfig[1];
+      clearTimeout(_this.timer);
+      _this.timer = setTimeout(function () {
+        handlers.visible(visible, e);
+      }, latency);
+      cb();
+    });
+    _defineProperty(_assertThisInitialized(_this), "handlePopperFocusOut", function (event) {
+      if (_this.asProps.focusLoop) return;
+      if (hasParent(event.target, _this.triggerRef.current)) return;
+      _this.bindHandlerChangeVisibleWithTimer(false, 'popper', 'onBlur')(event);
+    });
+    _defineProperty(_assertThisInitialized(_this), "handlePopperClick", function () {
+      _this.lastPopperClick = Date.now();
+    });
+    if (canUseDOM()) {
+      _this.observer = new ResizeObserver(function () {
+        requestAnimationFrame(function () {
+          var _this$popper$current;
+          (_this$popper$current = _this.popper.current) === null || _this$popper$current === void 0 ? void 0 : _this$popper$current.update();
+        });
+      });
+    }
+    return _this;
+  }
+  _createClass(PopperRoot, [{
+    key: "uncontrolledProps",
+    value: function uncontrolledProps() {
+      return {
+        visible: null
+      };
+    }
+  }, {
+    key: "createPopper",
+    value: function createPopper() {
+      var _this$lastPopperRefer;
+      if (!this.triggerRef.current || !this.popperRef.current) return;
+      if (this.asProps.__disablePopper) return;
+      var lastPopperReferenceMounted = Boolean((_this$lastPopperRefer = this.lastPopperReference) === null || _this$lastPopperRefer === void 0 ? void 0 : _this$lastPopperRefer.parentElement);
+      this.popper.current = _createPopper(lastPopperReferenceMounted ? this.lastPopperReference : this.triggerRef.current, this.popperRef.current, this.getPopperOptions());
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (canUseDOM() && !mouseMoveListenerAdded) {
+        mouseMoveListenerAdded = true;
+        document.addEventListener('mousemove', function () {
+          lastMouseMove = Date.now();
+        }, {
+          capture: true
+        });
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var _this2 = this;
+      var popperProps = ['strategy', 'placement', 'offset', 'preventOverflow', 'arrow', 'flip', 'computeStyles', 'eventListeners', 'onFirstUpdate', 'cursorAnchoring'];
+      if (this.popper.current && popperProps.some(function (propName) {
+        return prevProps[propName] !== _this2.asProps[propName];
+      })) {
+        this.popper.current.setOptions(this.getPopperOptions());
+      }
+    }
+  }, {
+    key: "destroyPopper",
+    value: function destroyPopper() {
+      var _this$observer4;
+      clearTimeout(this.timer);
+      clearTimeout(this.timerMultiTrigger);
+      (_this$observer4 = this.observer) === null || _this$observer4 === void 0 ? void 0 : _this$observer4.disconnect();
+      if (this.popper.current) {
+        this.popper.current.destroy();
+        this.popper.current = null;
+      }
+    }
+  }, {
+    key: "handlersFromInteraction",
+    value: function handlersFromInteraction(interaction, component, visible) {
+      var _this3 = this;
+      var eventInteraction = typeof interaction === 'string' ? this.eventsInteractionMap[interaction] : interaction;
+      var _eventInteraction$com = _slicedToArray(eventInteraction[component], 2),
+        _eventInteraction$com2 = _eventInteraction$com[0],
+        showEvents = _eventInteraction$com2 === void 0 ? [] : _eventInteraction$com2,
+        _eventInteraction$com3 = _eventInteraction$com[1],
+        hideEvents = _eventInteraction$com3 === void 0 ? [] : _eventInteraction$com3;
+      var crossEvents = someArray(showEvents, hideEvents);
+      var handlers = {};
+      showEvents.forEach(function (action) {
+        handlers[action] = _this3.bindHandlerChangeVisibleWithTimer(true, component, action);
+      });
+      hideEvents.forEach(function (action) {
+        handlers[action] = _this3.bindHandlerChangeVisibleWithTimer(false, component, action);
+      });
+      crossEvents.forEach(function (action) {
+        handlers[action] = visible ? _this3.bindHandlerChangeVisibleWithTimer(false, component, action) : _this3.bindHandlerChangeVisibleWithTimer(true, component, action);
+      });
+      return handlers;
+    }
+  }, {
+    key: "getTriggerProps",
+    value: function getTriggerProps() {
+      var _this$asProps3 = this.asProps,
+        visible = _this$asProps3.visible,
+        interaction = _this$asProps3.interaction,
+        disableEnforceFocus = _this$asProps3.disableEnforceFocus,
+        explicitTriggerSet = _this$asProps3.explicitTriggerSet;
+      // @ts-ignore
+      var _this$handlersFromInt = this.handlersFromInteraction(interaction, 'trigger', visible),
+        onKeyDown = _this$handlersFromInt.onKeyDown,
+        interactionProps = _objectWithoutProperties(_this$handlersFromInt, _excluded2);
+      return _objectSpread(_objectSpread({
+        ref: explicitTriggerSet ? undefined : this.createTriggerRef,
+        active: visible,
+        interaction: interaction
+      }, interactionProps), {}, {
+        onKeyDown: this.bindHandlerKeyDown(onKeyDown, 'trigger'),
+        disableEnforceFocus: disableEnforceFocus,
+        popperRef: this.popperRef
+      });
+    }
+  }, {
+    key: "getPopperProps",
+    value: function getPopperProps() {
+      var _this$asProps4 = this.asProps,
+        visible = _this$asProps4.visible,
+        disablePortal = _this$asProps4.disablePortal,
+        interaction = _this$asProps4.interaction,
+        placement = _this$asProps4.placement,
+        duration = _this$asProps4.duration,
+        animationsDisabled = _this$asProps4.animationsDisabled,
+        disableEnforceFocus = _this$asProps4.disableEnforceFocus;
+      // @ts-ignore
+      var _this$handlersFromInt2 = this.handlersFromInteraction(interaction, 'popper', visible),
+        onKeyDown = _this$handlersFromInt2.onKeyDown,
+        interactionProps = _objectWithoutProperties(_this$handlersFromInt2, _excluded3);
+      return _objectSpread(_objectSpread({
+        ref: this.createPopperRef,
+        triggerRef: this.triggerRef,
+        visible: visible,
+        interaction: interaction,
+        disablePortal: disablePortal
+      }, interactionProps), {}, {
+        onKeyDown: this.bindHandlerKeyDown(onKeyDown, 'popper'),
+        placement: placement,
+        duration: duration,
+        animationsDisabled: animationsDisabled,
+        popper: this.popper,
+        disableEnforceFocus: disableEnforceFocus,
+        handleFocusOut: this.handlePopperFocusOut,
+        onClick: this.handlePopperClick
+      });
+    }
+  }, {
+    key: "setContext",
+    value: function setContext() {
+      return {
+        popper: this.popper,
+        setTrigger: this.createTriggerRef,
+        setPopper: this.createPopperRef
+      };
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.destroyPopper();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$asProps5 = this.asProps,
+        Children = _this$asProps5.Children,
+        visible = _this$asProps5.visible,
+        root = _this$asProps5.root,
+        onOutsideClick = _this$asProps5.onOutsideClick,
+        excludeRefs = _this$asProps5.excludeRefs;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, visible ? /*#__PURE__*/React.createElement(OutsideClick, {
+        root: root,
+        excludeRefs: [this.triggerRef, this.popperRef].concat(_toConsumableArray(excludeRefs)),
+        onOutsideClick: callAllEventHandlers(onOutsideClick, this.bindHandlerChangeVisibleWithTimer(false))
+      }) : null, /*#__PURE__*/React.createElement(Children, null));
+    }
+  }]);
+  return PopperRoot;
+}(Component);
+_defineProperty(PopperRoot, "displayName", 'Popper');
+_defineProperty(PopperRoot, "style", style);
+_defineProperty(PopperRoot, "defaultProps", {
+  defaultVisible: false,
+  placement: 'auto',
+  modifiers: [],
+  arrow: {
+    padding: 6
+  },
+  strategy: 'absolute',
+  interaction: 'click',
+  timeout: 0,
+  excludeRefs: [],
+  focusLoop: true,
+  cursorAnchoring: false
+});
+_defineProperty(PopperRoot, "enhance", [uniqueIDEnhancement(), cssVariableEnhance({
+  variable: '--intergalactic-duration-popper',
+  fallback: '200',
+  map: Number.parseInt,
+  prop: 'duration'
+})]);
+function Trigger(props) {
+  var _ref = arguments[0];
+  var STrigger = Box;
+  var SFocusHint = 'span';
+  var Children = props.Children,
+    focusHint = props.focusHint,
+    onKeyboardFocus = props.onKeyboardFocus,
+    highlighted = props.highlighted,
+    active = props.active,
+    popperRef = props.popperRef,
+    forwardRef = props.forwardRef;
+  var triggerRef = React.useRef();
+  React.useEffect(function () {
+    if (highlighted === true) {
+      onKeyboardFocus({
+        currentTarget: triggerRef.current
+      });
+    }
+  }, [highlighted]);
+  var focusSourceRef = useFocusSource();
+  var handleFocus = React.useCallback(function (e) {
+    if (focusSourceRef.current === 'keyboard' && hasParent(e.target, triggerRef.current)) {
+      onKeyboardFocus === null || onKeyboardFocus === void 0 ? void 0 : onKeyboardFocus();
+    }
+  }, [onKeyboardFocus, focusSourceRef.current, triggerRef.current]);
+  React.useEffect(function () {
+    var _triggerRef$current;
+    (_triggerRef$current = triggerRef.current) === null || _triggerRef$current === void 0 ? void 0 : _triggerRef$current.addEventListener('focusin', handleFocus);
+    return function () {
+      var _triggerRef$current2;
+      (_triggerRef$current2 = triggerRef.current) === null || _triggerRef$current2 === void 0 ? void 0 : _triggerRef$current2.removeEventListener('focusin', handleFocus);
+    };
+  }, [triggerRef.current, handleFocus]);
+  var activeRef = React.useRef(active);
+  activeRef.current = active;
+  React.useEffect(function () {
+    if (!active) return;
+    if (!popperRef.current) return;
+    return function () {
+      setTimeout(function () {
+        if (activeRef.current) return;
+        if (!isFocusInside(popperRef.current) && document.activeElement !== document.body) return;
+        if (focusSourceRef.current !== 'keyboard') return;
+        setFocus(triggerRef.current);
+      }, 1);
+    };
+  }, [active]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(STrigger, _assignProps({
+    "inline": true,
+    "aria-haspopup": true,
+    "ref": forkRef(triggerRef, forwardRef),
+    "onBlur": props.onBlur
+  }, _ref), /*#__PURE__*/React.createElement(Children, null)), focusHint && false && /*#__PURE__*/React.createElement(SFocusHint, {
+    "aria-live": "polite"
+  }, /*#__PURE__*/React.createElement(ScreenReaderOnly, null, focusHint)));
+}
+function PopperPopper(props) {
+  var _ref2 = arguments[0],
+    _ref3;
+  var SPopper = Scale;
+  var Children = props.Children,
+    styles = props.styles,
+    visible = props.visible,
+    disablePortal = props.disablePortal,
+    ignorePortalsStacking = props.ignorePortalsStacking,
+    disableEnforceFocus = props.disableEnforceFocus,
+    triggerRef = props.triggerRef,
+    autoFocus = props.autoFocus,
+    controlsLength = props.controlsLength,
+    duration = props.duration,
+    animationsDisabled = props.animationsDisabled,
+    popper = props.popper,
+    _props$focusMaster = props.focusMaster,
+    focusMaster = _props$focusMaster === void 0 ? false : _props$focusMaster,
+    handleFocusOut = props.handleFocusOut,
+    role = props.role,
+    providedZIndex = props.zIndex;
+  var ref = React.useRef(null);
+  var zIndex = useZIndexStacking('z-index-popper');
+
+  // https://github.com/facebook/react/issues/11387
+  var stopPropagation = React.useCallback(function (event) {
+    event.stopPropagation();
+  }, []);
+  var propagateFocusLockSyntheticEvent = React.useCallback(function (event) {
+    var _ref$current;
+    event.nativeEvent.stopImmediatePropagation();
+    (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.dispatchEvent(makeFocusLockSyntheticEvent(event));
+  }, []);
+  var _React$useState = React.useState(disablePortal),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    portalMounted = _React$useState2[0],
+    setPortalMounted = _React$useState2[1];
+  useFocusLock(ref, autoFocus, triggerRef, !visible || disableEnforceFocus || !portalMounted, focusMaster, handleFocusOut);
+  useContextTheme(ref, visible);
+  var updatePopperEveryFrame = useUpdatePopperEveryFrame(popper);
+  var handleAnimationStart = React.useCallback(function (duration) {
+    if (duration > 0) {
+      updatePopperEveryFrame(Date.now() + Math.min(duration, 2000));
+    }
+  }, [updatePopperEveryFrame]);
+  var handleAnimationEnd = React.useCallback(function () {
+    var _popper$current;
+    (_popper$current = popper.current) === null || _popper$current === void 0 ? void 0 : _popper$current.update();
+  }, []);
+  var animationCtx = React.useContext(animationContext);
+  React.useEffect(function () {
+    if (!ignorePortalsStacking) return;
+    if (!animationCtx) return;
+    var unsubscribeAnimationStart = animationCtx.onAnimationStart(handleAnimationStart);
+    var unsubscribeAnimationEnd = animationCtx.onAnimationEnd(handleAnimationEnd);
+    return function () {
+      unsubscribeAnimationStart();
+      unsubscribeAnimationEnd();
+    };
+  }, [animationCtx, ignorePortalsStacking]);
+  React.useEffect(function () {
+    if (role === 'dialog' && visible && process.env.NODE_ENV !== 'production') {
+      var hasTitle = function hasTitle(node) {
+        if (node.hasAttribute('aria-label')) return true;
+        if (node.hasAttribute('aria-labelledby')) return true;
+        if (node.hasAttribute('title')) return true;
+        return false;
+      };
+      logger.warn(ref.current && !hasTitle(ref.current), "'title' or 'aria-label' or 'aria-labelledby' are required props for popper with role dialog", props['data-ui-name'] || PopperPopper.displayName);
+    }
+  }, [visible, role]);
+  return _ref3 = sstyled(styles), /*#__PURE__*/React.createElement(Portal, _ref3.cn("Portal", {
+    "disablePortal": disablePortal,
+    "ignorePortalsStacking": ignorePortalsStacking,
+    "onMount": setPortalMounted
+  }), /*#__PURE__*/React.createElement(NeighborLocation, _ref3.cn("NeighborLocation", {
+    "controlsLength": controlsLength
+  }), /*#__PURE__*/React.createElement(ZIndexStackingContextProvider, _ref3.cn("ZIndexStackingContextProvider", {
+    "designToken": 'z-index-popper'
+  }), /*#__PURE__*/React.createElement(SPopper, _ref3.cn("SPopper", _objectSpread({}, _assignProps2({
+    "animationsDisabled": animationsDisabled,
+    "visible": visible,
+    "duration": [duration, duration / 2],
+    "ref": ref,
+    "onClick": stopPropagation,
+    "onContextMenu": stopPropagation,
+    "onDoubleClick": stopPropagation,
+    "onDrag": stopPropagation,
+    "onDragEnd": stopPropagation,
+    "onDragEnter": stopPropagation,
+    "onDragExit": stopPropagation,
+    "onDragLeave": stopPropagation,
+    "onDragOver": stopPropagation,
+    "onDragStart": stopPropagation,
+    "onDrop": stopPropagation,
+    "onMouseDown": stopPropagation,
+    "onMouseMove": stopPropagation,
+    "onMouseOver": stopPropagation,
+    "onMouseOut": stopPropagation,
+    "onMouseUp": stopPropagation,
+    "onKeyDown": propagateFocusLockSyntheticEvent,
+    "onKeyPress": stopPropagation,
+    "onKeyUp": stopPropagation,
+    "onFocus": stopPropagation,
+    "onBlur": propagateFocusLockSyntheticEvent,
+    "onChange": stopPropagation,
+    "onInput": stopPropagation,
+    "onInvalid": stopPropagation,
+    "onReset": stopPropagation,
+    "onSubmit": stopPropagation,
+    "use:zIndex": providedZIndex !== null && providedZIndex !== void 0 ? providedZIndex : zIndex
+  }, _ref2))), /*#__PURE__*/React.createElement(PortalProvider, _ref3.cn("PortalProvider", {
+    "value": ref
+  }), /*#__PURE__*/React.createElement(Children, _ref3.cn("Children", {})))))));
+}
+PopperPopper.enhance = [keyboardFocusEnhance(false)];
+var Popper = createComponent(PopperRoot, {
+  Trigger: Trigger,
+  Popper: PopperPopper
+});
+export default Popper;
+//# sourceMappingURL=Popper.js.map