@atlaskit/react-select 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @atlaskit/react-select
 
+## 2.4.0
+
+### Minor Changes
+
+- [#141922](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/141922)
+  [`a48b38cffa7e6`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/a48b38cffa7e6) -
+  Create a compiled select and use feature flag to toggle it
+
+### Patch Changes
+
+- [#141922](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/141922)
+  [`a48b38cffa7e6`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/a48b38cffa7e6) -
+  Migrate emotion components to compiled components under compiled folder
+
 ## 2.3.0
 
 ### Minor Changes

package/dist/cjs/components/menu.js

@@ -7,245 +7,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.noOptionsMessageCSS = exports.menuPortalCSS = exports.menuListCSS = exports.menuCSS = exports.loadingMessageCSS = exports.default = exports.NoOptionsMessage = exports.MenuPortal = exports.MenuPlacer = exports.MenuList = exports.LoadingMessage = void 0;
 var _objectDestructuringEmpty2 = _interopRequireDefault(require("@babel/runtime/helpers/objectDestructuringEmpty"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _react = _interopRequireWildcard(require("react"));
-var _useIsomorphicLayoutEffect = _interopRequireDefault(require("use-isomorphic-layout-effect"));
+var _react = _interopRequireDefault(require("react"));
 var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _menu = _interopRequireWildcard(require("../compiled/components/menu"));
 var _menu2 = _interopRequireWildcard(require("../emotion/components/menu"));
-var _utils = require("../utils");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } /* eslint-disable @repo/internal/react/no-unsafe-spread-props */
-// ==============================
-// Menu
-// ==============================
-
-// Get Menu Placement
-// ------------------------------
-
-function getMenuPlacement(_ref) {
-  var preferredMaxHeight = _ref.maxHeight,
-    menuEl = _ref.menuEl,
-    minHeight = _ref.minHeight,
-    preferredPlacement = _ref.placement,
-    shouldScroll = _ref.shouldScroll,
-    isFixedPosition = _ref.isFixedPosition,
-    controlHeight = _ref.controlHeight;
-  var scrollParent = (0, _utils.getScrollParent)(menuEl);
-  var defaultState = {
-    placement: 'bottom',
-    maxHeight: preferredMaxHeight
-  };
-
-  // something went wrong, return default state
-  if (!menuEl || !menuEl.offsetParent) {
-    return defaultState;
-  }
-
-  // we can't trust `scrollParent.scrollHeight` --> it may increase when
-  // the menu is rendered
-  var _scrollParent$getBoun = scrollParent.getBoundingClientRect(),
-    scrollHeight = _scrollParent$getBoun.height,
-    scrollParentTop = _scrollParent$getBoun.top;
-  var _menuEl$getBoundingCl = menuEl.getBoundingClientRect(),
-    menuBottom = _menuEl$getBoundingCl.bottom,
-    menuHeight = _menuEl$getBoundingCl.height,
-    menuTop = _menuEl$getBoundingCl.top;
-  var _menuEl$offsetParent$ = menuEl.offsetParent.getBoundingClientRect(),
-    containerTop = _menuEl$offsetParent$.top;
-  var viewHeight = isFixedPosition ? window.innerHeight : (0, _utils.normalizedHeight)(scrollParent);
-  var scrollTop = (0, _utils.getScrollTop)(scrollParent);
-  // use menuTop - scrollParentTop for the actual top space of menu in the scroll container
-  var menuTopFromParent = (0, _platformFeatureFlags.fg)('design-system-select-fix-placement') ? menuTop - scrollParentTop : menuTop;
-  var marginBottom = parseInt(getComputedStyle(menuEl).marginBottom, 10);
-  var marginTop = parseInt(getComputedStyle(menuEl).marginTop, 10);
-  var viewSpaceAbove = containerTop - marginTop;
-  var viewSpaceBelow = viewHeight - menuTopFromParent;
-  var scrollSpaceAbove = viewSpaceAbove + scrollTop;
-  var scrollSpaceBelow = scrollHeight - scrollTop - menuTopFromParent;
-  var scrollDown = menuBottom - viewHeight + scrollTop + marginBottom;
-  var scrollUp = scrollTop + menuTop - marginTop;
-  var scrollDuration = 160;
-  switch (preferredPlacement) {
-    case 'auto':
-    case 'bottom':
-      // 1: the menu will fit, do nothing
-      if (viewSpaceBelow >= menuHeight) {
-        return {
-          placement: 'bottom',
-          maxHeight: preferredMaxHeight
-        };
-      }
-
-      // 2: the menu will fit, if scrolled
-      if (scrollSpaceBelow >= menuHeight && !isFixedPosition) {
-        if (shouldScroll) {
-          (0, _utils.animatedScrollTo)(scrollParent, scrollDown, scrollDuration);
-        }
-        return {
-          placement: 'bottom',
-          maxHeight: preferredMaxHeight
-        };
-      }
-
-      // 3: the menu will fit, if constrained
-      if (!isFixedPosition && scrollSpaceBelow >= minHeight || isFixedPosition && viewSpaceBelow >= minHeight) {
-        if (shouldScroll) {
-          (0, _utils.animatedScrollTo)(scrollParent, scrollDown, scrollDuration);
-        }
-
-        // we want to provide as much of the menu as possible to the user,
-        // so give them whatever is available below rather than the minHeight.
-        var constrainedHeight = isFixedPosition ? viewSpaceBelow - marginBottom : scrollSpaceBelow - marginBottom;
-        return {
-          placement: 'bottom',
-          maxHeight: constrainedHeight
-        };
-      }
-
-      // 4. Forked beviour when there isn't enough space below
-
-      // AUTO: flip the menu, render above
-      if (preferredPlacement === 'auto' || isFixedPosition) {
-        // may need to be constrained after flipping
-        var _constrainedHeight = preferredMaxHeight;
-        var spaceAbove = isFixedPosition ? viewSpaceAbove : scrollSpaceAbove;
-        if (spaceAbove >= minHeight) {
-          _constrainedHeight = Math.min(spaceAbove - marginBottom - controlHeight, preferredMaxHeight);
-        }
-        return {
-          placement: 'top',
-          maxHeight: _constrainedHeight
-        };
-      }
-
-      // BOTTOM: allow browser to increase scrollable area and immediately set scroll
-      if (preferredPlacement === 'bottom') {
-        if (shouldScroll) {
-          (0, _utils.scrollTo)(scrollParent, scrollDown);
-        }
-        return {
-          placement: 'bottom',
-          maxHeight: preferredMaxHeight
-        };
-      }
-      break;
-    case 'top':
-      // 1: the menu will fit, do nothing
-      if (viewSpaceAbove >= menuHeight) {
-        return {
-          placement: 'top',
-          maxHeight: preferredMaxHeight
-        };
-      }
-
-      // 2: the menu will fit, if scrolled
-      if (scrollSpaceAbove >= menuHeight && !isFixedPosition) {
-        if (shouldScroll) {
-          (0, _utils.animatedScrollTo)(scrollParent, scrollUp, scrollDuration);
-        }
-        return {
-          placement: 'top',
-          maxHeight: preferredMaxHeight
-        };
-      }
-
-      // 3: the menu will fit, if constrained
-      if (!isFixedPosition && scrollSpaceAbove >= minHeight || isFixedPosition && viewSpaceAbove >= minHeight) {
-        var _constrainedHeight2 = preferredMaxHeight;
-
-        // we want to provide as much of the menu as possible to the user,
-        // so give them whatever is available below rather than the minHeight.
-        if (!isFixedPosition && scrollSpaceAbove >= minHeight || isFixedPosition && viewSpaceAbove >= minHeight) {
-          _constrainedHeight2 = isFixedPosition ? viewSpaceAbove - marginTop : scrollSpaceAbove - marginTop;
-        }
-        if (shouldScroll) {
-          (0, _utils.animatedScrollTo)(scrollParent, scrollUp, scrollDuration);
-        }
-        return {
-          placement: 'top',
-          maxHeight: _constrainedHeight2
-        };
-      }
-
-      // 4. not enough space, the browser WILL NOT increase scrollable area when
-      // absolutely positioned element rendered above the viewport (only below).
-      // Flip the menu, render below
-      return {
-        placement: 'bottom',
-        maxHeight: preferredMaxHeight
-      };
-    default:
-      throw new Error("Invalid placement provided \"".concat(preferredPlacement, "\"."));
-  }
-  return defaultState;
-}
+/* eslint-disable @repo/internal/react/no-unsafe-spread-props */
 
 // Menu Component
 // ------------------------------
 
-var coercePlacement = function coercePlacement(p) {
-  return p === 'auto' ? 'bottom' : p;
-};
 var menuCSS = exports.menuCSS = function menuCSS(props) {
   return (0, _platformFeatureFlags.fg)('compiled-react-select') ? (0, _menu.menuCSS)() : (0, _menu2.menuCSS)(props);
 };
-var PortalPlacementContext = /*#__PURE__*/(0, _react.createContext)(null);
 
 // NOTE: internal only
 // eslint-disable-next-line @repo/internal/react/require-jsdoc
 var MenuPlacer = exports.MenuPlacer = function MenuPlacer(props) {
-  var children = props.children,
-    minMenuHeight = props.minMenuHeight,
-    maxMenuHeight = props.maxMenuHeight,
-    menuPlacement = props.menuPlacement,
-    menuPosition = props.menuPosition,
-    menuShouldScrollIntoView = props.menuShouldScrollIntoView;
-  var _ref2 = (0, _react.useContext)(PortalPlacementContext) || {},
-    setPortalPlacement = _ref2.setPortalPlacement;
-  var ref = (0, _react.useRef)(null);
-  var _useState = (0, _react.useState)(maxMenuHeight),
-    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
-    maxHeight = _useState2[0],
-    setMaxHeight = _useState2[1];
-  var _useState3 = (0, _react.useState)(null),
-    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
-    placement = _useState4[0],
-    setPlacement = _useState4[1];
-  // The minimum height of the control
-  var controlHeight = 38;
-  (0, _useIsomorphicLayoutEffect.default)(function () {
-    var menuEl = ref.current;
-    if (!menuEl) {
-      return;
-    }
-
-    // DO NOT scroll if position is fixed
-    var isFixedPosition = menuPosition === 'fixed';
-    var shouldScroll = menuShouldScrollIntoView && !isFixedPosition;
-    var state = getMenuPlacement({
-      maxHeight: maxMenuHeight,
-      menuEl: menuEl,
-      minHeight: minMenuHeight,
-      placement: menuPlacement,
-      shouldScroll: shouldScroll,
-      isFixedPosition: isFixedPosition,
-      controlHeight: controlHeight
-    });
-    setMaxHeight(state.maxHeight);
-    setPlacement(state.placement);
-    setPortalPlacement === null || setPortalPlacement === void 0 || setPortalPlacement(state.placement);
-  }, [maxMenuHeight, menuPlacement, menuPosition, menuShouldScrollIntoView, minMenuHeight, setPortalPlacement, controlHeight]);
-  return children({
-    ref: ref,
-    placerProps: _objectSpread(_objectSpread({}, props), {}, {
-      placement: placement || coercePlacement(menuPlacement),
-      maxHeight: maxHeight
-    })
-  });
+  return (0, _platformFeatureFlags.fg)('compiled-react-select') ? /*#__PURE__*/_react.default.createElement(_menu.MenuPlacer, props) : /*#__PURE__*/_react.default.createElement(_menu2.MenuPlacer, props);
 };
 var Menu = function Menu(props) {
   return (0, _platformFeatureFlags.fg)('compiled-react-select') ? /*#__PURE__*/_react.default.createElement(_menu.default, props) : /*#__PURE__*/_react.default.createElement(_menu2.default, props);
@@ -268,8 +48,8 @@ var MenuList = exports.MenuList = function MenuList(props) {
 // Menu Notices
 // ==============================
 
-var noticeCSS = function noticeCSS(_ref3) {
-  (0, _objectDestructuringEmpty2.default)(_ref3);
+var noticeCSS = function noticeCSS(_ref) {
+  (0, _objectDestructuringEmpty2.default)(_ref);
   return {
     textAlign: 'center',
     padding: "var(--ds-space-100, 8px)".concat(" ", "var(--ds-space-150, 12px)")

package/dist/cjs/emotion/components/internal/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "A11yText", {
+  enumerable: true,
+  get: function get() {
+    return _a11yText.default;
+  }
+});
+Object.defineProperty(exports, "DummyInput", {
+  enumerable: true,
+  get: function get() {
+    return _dummyInput.default;
+  }
+});
+Object.defineProperty(exports, "RequiredInput", {
+  enumerable: true,
+  get: function get() {
+    return _requiredInput.default;
+  }
+});
+Object.defineProperty(exports, "ScrollManager", {
+  enumerable: true,
+  get: function get() {
+    return _scrollManager.default;
+  }
+});
+var _a11yText = _interopRequireDefault(require("./a11y-text"));
+var _dummyInput = _interopRequireDefault(require("./dummy-input"));
+var _scrollManager = _interopRequireDefault(require("./scroll-manager"));
+var _requiredInput = _interopRequireDefault(require("./required-input"));

package/dist/cjs/emotion/components/internal/scroll-manager.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ScrollManager;
+var _react = require("react");
+var _react2 = require("@emotion/react");
+var _useScrollCapture = _interopRequireDefault(require("./use-scroll-capture"));
+var _useScrollLock = _interopRequireDefault(require("./use-scroll-lock"));
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+
+// eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled
+
+var styles = (0, _react2.css)({
+  position: 'fixed',
+  insetBlockEnd: 0,
+  insetBlockStart: 0,
+  insetInlineEnd: 0,
+  insetInlineStart: 0
+});
+var blurSelectInput = function blurSelectInput(event) {
+  var element = event.target;
+  return element.ownerDocument.activeElement && element.ownerDocument.activeElement.blur();
+};
+function ScrollManager(_ref) {
+  var children = _ref.children,
+    lockEnabled = _ref.lockEnabled,
+    _ref$captureEnabled = _ref.captureEnabled,
+    captureEnabled = _ref$captureEnabled === void 0 ? true : _ref$captureEnabled,
+    onBottomArrive = _ref.onBottomArrive,
+    onBottomLeave = _ref.onBottomLeave,
+    onTopArrive = _ref.onTopArrive,
+    onTopLeave = _ref.onTopLeave;
+  var setScrollCaptureTarget = (0, _useScrollCapture.default)({
+    isEnabled: captureEnabled,
+    onBottomArrive: onBottomArrive,
+    onBottomLeave: onBottomLeave,
+    onTopArrive: onTopArrive,
+    onTopLeave: onTopLeave
+  });
+  var setScrollLockTarget = (0, _useScrollLock.default)({
+    isEnabled: lockEnabled
+  });
+  var targetRef = function targetRef(element) {
+    setScrollCaptureTarget(element);
+    setScrollLockTarget(element);
+  };
+  return (0, _react2.jsx)(_react.Fragment, null, lockEnabled &&
+  // eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions
+  (0, _react2.jsx)("div", {
+    onClick: blurSelectInput,
+    css: styles
+  }), children(targetRef));
+}

package/dist/cjs/emotion/components/internal/use-scroll-capture.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useScrollCapture;
+var _react = require("react");
+var _utils = require("../../../utils");
+var cancelScroll = function cancelScroll(event) {
+  if (event.cancelable) {
+    event.preventDefault();
+  }
+  event.stopPropagation();
+};
+// TODO: Fill in the hook {description}.
+/**
+ * {description}.
+ */
+function useScrollCapture(_ref) {
+  var isEnabled = _ref.isEnabled,
+    onBottomArrive = _ref.onBottomArrive,
+    onBottomLeave = _ref.onBottomLeave,
+    onTopArrive = _ref.onTopArrive,
+    onTopLeave = _ref.onTopLeave;
+  var isBottom = (0, _react.useRef)(false);
+  var isTop = (0, _react.useRef)(false);
+  var touchStart = (0, _react.useRef)(0);
+  var scrollTarget = (0, _react.useRef)(null);
+  var handleEventDelta = (0, _react.useCallback)(function (event, delta) {
+    if (scrollTarget.current === null) {
+      return;
+    }
+    var _scrollTarget$current = scrollTarget.current,
+      scrollTop = _scrollTarget$current.scrollTop,
+      scrollHeight = _scrollTarget$current.scrollHeight,
+      clientHeight = _scrollTarget$current.clientHeight;
+    var target = scrollTarget.current;
+    var isDeltaPositive = delta > 0;
+    var availableScroll = scrollHeight - clientHeight - scrollTop;
+    var shouldCancelScroll = false;
+
+    // reset bottom/top flags
+    if (availableScroll > delta && isBottom.current) {
+      if (onBottomLeave) {
+        onBottomLeave(event);
+      }
+      isBottom.current = false;
+    }
+    if (isDeltaPositive && isTop.current) {
+      if (onTopLeave) {
+        onTopLeave(event);
+      }
+      isTop.current = false;
+    }
+
+    // bottom limit
+    if (isDeltaPositive && delta > availableScroll) {
+      if (onBottomArrive && !isBottom.current) {
+        onBottomArrive(event);
+      }
+      target.scrollTop = scrollHeight;
+      shouldCancelScroll = true;
+      isBottom.current = true;
+
+      // top limit
+    } else if (!isDeltaPositive && -delta > scrollTop) {
+      if (onTopArrive && !isTop.current) {
+        onTopArrive(event);
+      }
+      target.scrollTop = 0;
+      shouldCancelScroll = true;
+      isTop.current = true;
+    }
+
+    // cancel scroll
+    if (shouldCancelScroll) {
+      cancelScroll(event);
+    }
+  }, [onBottomArrive, onBottomLeave, onTopArrive, onTopLeave]);
+  var onWheel = (0, _react.useCallback)(function (event) {
+    handleEventDelta(event, event.deltaY);
+  }, [handleEventDelta]);
+  var onTouchStart = (0, _react.useCallback)(function (event) {
+    // set touch start so we can calculate touchmove delta
+    touchStart.current = event.changedTouches[0].clientY;
+  }, []);
+  var onTouchMove = (0, _react.useCallback)(function (event) {
+    var deltaY = touchStart.current - event.changedTouches[0].clientY;
+    handleEventDelta(event, deltaY);
+  }, [handleEventDelta]);
+  var startListening = (0, _react.useCallback)(function (el) {
+    // bail early if no element is available to attach to
+    if (!el) {
+      return;
+    }
+    var notPassive = _utils.supportsPassiveEvents ? {
+      passive: false
+    } : false;
+    // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+    el.addEventListener('wheel', onWheel, notPassive);
+    // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+    el.addEventListener('touchstart', onTouchStart, notPassive);
+    // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+    el.addEventListener('touchmove', onTouchMove, notPassive);
+  }, [onTouchMove, onTouchStart, onWheel]);
+  var stopListening = (0, _react.useCallback)(function (el) {
+    // bail early if no element is available to detach from
+    if (!el) {
+      return;
+    }
+
+    // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+    el.removeEventListener('wheel', onWheel, false);
+    // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+    el.removeEventListener('touchstart', onTouchStart, false);
+    // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+    el.removeEventListener('touchmove', onTouchMove, false);
+  }, [onTouchMove, onTouchStart, onWheel]);
+  (0, _react.useEffect)(function () {
+    if (!isEnabled) {
+      return;
+    }
+    var element = scrollTarget.current;
+    startListening(element);
+    return function () {
+      stopListening(element);
+    };
+  }, [isEnabled, startListening, stopListening]);
+  return function (element) {
+    scrollTarget.current = element;
+  };
+}

package/dist/cjs/emotion/components/internal/use-scroll-lock.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useScrollLock;
+var _react = require("react");
+var STYLE_KEYS = ['boxSizing', 'height', 'overflow', 'paddingRight', 'position'];
+var LOCK_STYLES = {
+  boxSizing: 'border-box',
+  // account for possible declaration `width: 100%;` on body
+  overflow: 'hidden',
+  position: 'relative',
+  height: '100%'
+};
+function preventTouchMove(e) {
+  e.preventDefault();
+}
+function allowTouchMove(e) {
+  e.stopPropagation();
+}
+function preventInertiaScroll() {
+  var top = this.scrollTop;
+  var totalScroll = this.scrollHeight;
+  var currentScroll = top + this.offsetHeight;
+  if (top === 0) {
+    this.scrollTop = 1;
+  } else if (currentScroll === totalScroll) {
+    this.scrollTop = top - 1;
+  }
+}
+
+// `ontouchstart` check works on most browsers
+// `maxTouchPoints` works on IE10/11 and Surface
+function isTouchDevice() {
+  // eslint-disable-next-line compat/compat
+  return 'ontouchstart' in window || navigator.maxTouchPoints;
+}
+var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+var activeScrollLocks = 0;
+var listenerOptions = {
+  capture: false,
+  passive: false
+};
+
+// TODO: Fill in the hook {description}.
+/**
+ * {description}.
+ */
+function useScrollLock(_ref) {
+  var isEnabled = _ref.isEnabled,
+    _ref$accountForScroll = _ref.accountForScrollbars,
+    accountForScrollbars = _ref$accountForScroll === void 0 ? true : _ref$accountForScroll;
+  var originalStyles = (0, _react.useRef)({});
+  var scrollTarget = (0, _react.useRef)(null);
+  var addScrollLock = (0, _react.useCallback)(function (touchScrollTarget) {
+    if (!canUseDOM) {
+      return;
+    }
+    var target = document.body;
+    var targetStyle = target && target.style;
+    if (accountForScrollbars) {
+      // store any styles already applied to the body
+      STYLE_KEYS.forEach(function (key) {
+        var val = targetStyle && targetStyle[key];
+        originalStyles.current[key] = val;
+      });
+    }
+
+    // apply the lock styles and padding if this is the first scroll lock
+    if (accountForScrollbars && activeScrollLocks < 1) {
+      var currentPadding = parseInt(originalStyles.current.paddingRight, 10) || 0;
+      var clientWidth = document.body ? document.body.clientWidth : 0;
+      var adjustedPadding = window.innerWidth - clientWidth + currentPadding || 0;
+      Object.keys(LOCK_STYLES).forEach(function (key) {
+        var val = LOCK_STYLES[key];
+        if (targetStyle) {
+          targetStyle[key] = val;
+        }
+      });
+      if (targetStyle) {
+        targetStyle.paddingRight = "".concat(adjustedPadding, "px");
+      }
+    }
+
+    // account for touch devices
+    if (target && isTouchDevice()) {
+      // Mobile Safari ignores { overflow: hidden } declaration on the body.
+      // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+      target.addEventListener('touchmove', preventTouchMove, listenerOptions);
+
+      // Allow scroll on provided target
+      if (touchScrollTarget) {
+        // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+        touchScrollTarget.addEventListener('touchstart', preventInertiaScroll, listenerOptions);
+        // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+        touchScrollTarget.addEventListener('touchmove', allowTouchMove, listenerOptions);
+      }
+    }
+
+    // increment active scroll locks
+    activeScrollLocks += 1;
+  }, [accountForScrollbars]);
+  var removeScrollLock = (0, _react.useCallback)(function (touchScrollTarget) {
+    if (!canUseDOM) {
+      return;
+    }
+    var target = document.body;
+    var targetStyle = target && target.style;
+
+    // safely decrement active scroll locks
+    activeScrollLocks = Math.max(activeScrollLocks - 1, 0);
+
+    // reapply original body styles, if any
+    if (accountForScrollbars && activeScrollLocks < 1) {
+      STYLE_KEYS.forEach(function (key) {
+        var val = originalStyles.current[key];
+        if (targetStyle) {
+          targetStyle[key] = val;
+        }
+      });
+    }
+
+    // remove touch listeners
+    if (target && isTouchDevice()) {
+      // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+      target.removeEventListener('touchmove', preventTouchMove, listenerOptions);
+      if (touchScrollTarget) {
+        // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+        touchScrollTarget.removeEventListener('touchstart', preventInertiaScroll, listenerOptions);
+        // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+        touchScrollTarget.removeEventListener('touchmove', allowTouchMove, listenerOptions);
+      }
+    }
+  }, [accountForScrollbars]);
+  (0, _react.useEffect)(function () {
+    if (!isEnabled) {
+      return;
+    }
+    var element = scrollTarget.current;
+    addScrollLock(element);
+    return function () {
+      removeScrollLock(element);
+    };
+  }, [isEnabled, addScrollLock, removeScrollLock]);
+  return function (element) {
+    scrollTarget.current = element;
+  };
+}