@enact/ui 4.5.2 → 4.5.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (167) hide show
  1. package/AnnounceDecorator/Announce.js +1 -40
  2. package/AnnounceDecorator/AnnounceDecorator.js +3 -21
  3. package/AnnounceDecorator/tests/Announce-specs.js +2 -7
  4. package/AnnounceDecorator/tests/AnnounceDecorator-specs.js +2 -6
  5. package/AnnounceDecorator/tests/useAnnounce-specs.js +8 -19
  6. package/AnnounceDecorator/useAnnounce.js +0 -6
  7. package/BodyText/BodyText.js +6 -26
  8. package/BodyText/tests/BodyText-specs.js +0 -19
  9. package/Button/Button.js +26 -56
  10. package/Button/tests/Button-specs.js +0 -26
  11. package/CHANGELOG.md +4 -0
  12. package/Cancelable/Cancelable.js +8 -47
  13. package/Cancelable/cancelHandler.js +5 -12
  14. package/Cancelable/modalHandler.js +3 -11
  15. package/Cancelable/tests/Cancelable-specs.js +3 -57
  16. package/Changeable/Changeable.js +2 -34
  17. package/Changeable/tests/Changeable-specs.js +20 -66
  18. package/ComponentOverride/ComponentOverride.js +1 -13
  19. package/FloatingLayer/FloatingLayer.js +17 -73
  20. package/FloatingLayer/FloatingLayerContainer.js +0 -15
  21. package/FloatingLayer/FloatingLayerDecorator.js +4 -17
  22. package/FloatingLayer/Scrim.js +9 -53
  23. package/FloatingLayer/index.js +0 -4
  24. package/FloatingLayer/tests/FloatingLayer-specs.js +8 -22
  25. package/FloatingLayer/tests/Scrim-specs.js +0 -9
  26. package/FloatingLayer/tests/useFloatingLayerDecorator-specs.js +0 -13
  27. package/FloatingLayer/useFloatingLayer.js +3 -14
  28. package/FloatingLayer/useFloatingLayerDecorator.js +3 -11
  29. package/ForwardRef/ForwardRef.js +1 -10
  30. package/GridListImageItem/GridListImageItem.js +17 -50
  31. package/Group/Group.js +4 -35
  32. package/Group/GroupItem.js +15 -32
  33. package/Group/tests/Group-specs.js +0 -32
  34. package/Heading/Heading.js +7 -35
  35. package/Heading/tests/Heading-specs.js +81 -14
  36. package/Icon/Icon.js +14 -48
  37. package/Icon/tests/Icon-specs.js +0 -22
  38. package/IconButton/IconButton.js +12 -50
  39. package/IconButton/tests/IconButton-specs.js +0 -7
  40. package/Image/Image.js +16 -45
  41. package/Image/tests/Image-specs.js +0 -14
  42. package/ImageItem/ImageItem.js +17 -46
  43. package/ImageItem/tests/ImageItem-specs.js +0 -25
  44. package/Item/Item.js +8 -32
  45. package/Item/tests/Item-specs.js +0 -24
  46. package/LabeledIcon/LabeledIcon.js +19 -50
  47. package/LabeledIcon/tests/LabeledIcon-specs.js +0 -14
  48. package/Layout/Cell.js +11 -37
  49. package/Layout/Layout.js +14 -37
  50. package/Layout/tests/Layout-specs.js +10 -39
  51. package/Marquee/MarqueeBase.js +29 -63
  52. package/Marquee/MarqueeController.js +11 -72
  53. package/Marquee/MarqueeDecorator.js +62 -196
  54. package/Marquee/index.js +1 -5
  55. package/Marquee/tests/Marquee-specs.js +258 -87
  56. package/Measurable/Measurable.js +12 -34
  57. package/Measurable/tests/Measurable-specs.js +115 -0
  58. package/Media/Media.js +15 -65
  59. package/Media/tests/Media-specs.js +168 -0
  60. package/Placeholder/PlaceholderControllerDecorator.js +7 -43
  61. package/Placeholder/PlaceholderDecorator.js +7 -38
  62. package/Placeholder/index.js +0 -4
  63. package/Placeholder/tests/PlaceholderControllerDecorator-specs.js +25 -0
  64. package/Placeholder/tests/PlaceholderDecorator-specs.js +28 -0
  65. package/ProgressBar/ProgressBar.js +13 -44
  66. package/ProgressBar/tests/ProgressBar-specs.js +0 -17
  67. package/RadioDecorator/RadioControllerDecorator.js +1 -29
  68. package/RadioDecorator/RadioDecorator.js +4 -42
  69. package/RadioDecorator/tests/RadioDecorator-specs.js +12 -49
  70. package/Repeater/Repeater.js +9 -33
  71. package/Repeater/tests/Repeater-specs.js +0 -38
  72. package/Resizable/Resizable.js +7 -35
  73. package/Resizable/tests/Resizable-specs.js +34 -0
  74. package/Routable/Link.js +8 -44
  75. package/Routable/Routable.js +10 -33
  76. package/Routable/Route.js +0 -6
  77. package/Routable/Router.js +13 -56
  78. package/Routable/tests/Routable-specs.js +7 -33
  79. package/Routable/tests/Router-specs.js +18 -44
  80. package/Routable/useLink.js +4 -8
  81. package/Routable/util.js +18 -24
  82. package/Scrollable/ScrollAnimator.js +49 -65
  83. package/Scrollable/ScrollThumb.js +2 -13
  84. package/Scrollable/Scrollable.js +179 -386
  85. package/Scrollable/ScrollableNative.js +188 -391
  86. package/Scrollable/Scrollbar.js +28 -100
  87. package/Scroller/Scroller.js +15 -39
  88. package/Scroller/ScrollerBasic.js +34 -89
  89. package/Scroller/UiScrollerBase.js +31 -84
  90. package/Skinnable/Skinnable.js +11 -38
  91. package/Skinnable/tests/Skinnable-specs.js +3 -74
  92. package/Skinnable/tests/useSkins-specs.js +1 -13
  93. package/Skinnable/tests/util-specs.js +0 -14
  94. package/Skinnable/useSkins.js +8 -15
  95. package/Skinnable/util.js +9 -20
  96. package/Slider/Knob.js +5 -24
  97. package/Slider/PositionDecorator.js +16 -54
  98. package/Slider/Slider.js +26 -64
  99. package/Slider/tests/Slider-specs.js +94 -7
  100. package/Slider/utils.js +0 -2
  101. package/SlotItem/SlotItem.js +15 -41
  102. package/SlotItem/tests/SlotItem-specs.js +0 -5
  103. package/Slottable/Slottable.js +4 -12
  104. package/Slottable/tests/Slottable-specs.js +19 -46
  105. package/Slottable/tests/useSlots-specs.js +27 -65
  106. package/Slottable/useSlots.js +8 -33
  107. package/Spinner/Spinner.js +15 -42
  108. package/Spinner/tests/Spinner-specs.js +0 -15
  109. package/ToggleIcon/ToggleIcon.js +10 -36
  110. package/ToggleIcon/tests/ToggleIcon-specs.js +0 -16
  111. package/ToggleItem/ToggleItem.js +15 -52
  112. package/ToggleItem/tests/ToggleItem-specs.js +0 -30
  113. package/Toggleable/Toggle.js +1 -15
  114. package/Toggleable/Toggleable.js +12 -45
  115. package/Toggleable/tests/Toggleable-specs.js +28 -96
  116. package/Toggleable/useToggle.js +3 -19
  117. package/Touchable/ClickAllow.js +5 -14
  118. package/Touchable/Drag.js +16 -54
  119. package/Touchable/Flick.js +11 -42
  120. package/Touchable/Hold.js +21 -68
  121. package/Touchable/Touch.js +37 -65
  122. package/Touchable/Touchable.js +32 -71
  123. package/Touchable/config.js +8 -22
  124. package/Touchable/tests/Touchable-specs.js +270 -119
  125. package/Touchable/tests/useTouch-specs.js +6 -80
  126. package/Touchable/useTouch.js +17 -34
  127. package/Transition/Transition.js +37 -118
  128. package/Transition/tests/Transition-specs.js +20 -60
  129. package/ViewManager/Arranger.js +10 -22
  130. package/ViewManager/TransitionGroup.js +31 -106
  131. package/ViewManager/View.js +35 -91
  132. package/ViewManager/ViewManager.js +19 -83
  133. package/ViewManager/tests/View-specs.js +0 -17
  134. package/ViewManager/tests/ViewManager-specs.js +236 -305
  135. package/ViewManager/tests/test-utils.js +0 -8
  136. package/VirtualList/UiVirtualListBase.js +256 -406
  137. package/VirtualList/VirtualList.js +29 -69
  138. package/VirtualList/VirtualListBase.js +0 -3
  139. package/VirtualList/VirtualListBasic.js +270 -428
  140. package/VirtualList/tests/VirtualList-specs.js +9 -37
  141. package/internal/IdProvider/IdProvider.js +7 -21
  142. package/internal/IdProvider/Provider.js +4 -17
  143. package/internal/IdProvider/tests/IdProvider-specs.js +44 -0
  144. package/internal/IdProvider/tests/useId-specs.js +7 -22
  145. package/internal/IdProvider/useId.js +0 -6
  146. package/internal/Pure/Pure.js +3 -30
  147. package/internal/Pure/tests/Pure-specs.js +88 -0
  148. package/internal/localized-fonts/localized-fonts.js +33 -62
  149. package/internal/localized-fonts/tests/localized-fonts-specs.js +33 -0
  150. package/internal/selection/selection.js +1 -6
  151. package/internal/selection/tests/selection-specs.js +6 -4
  152. package/internal/validators/tests/validators-specs.js +80 -0
  153. package/internal/validators/validators.js +14 -34
  154. package/package.json +8 -2
  155. package/resolution/ResolutionDecorator.js +4 -40
  156. package/resolution/index.js +0 -7
  157. package/resolution/resolution.js +42 -80
  158. package/resolution/tests/ResolutionDecorator-specs.js +4 -11
  159. package/resolution/tests/resolution-specs.js +2 -2
  160. package/useControlledState/tests/useControlledState-specs.js +15 -46
  161. package/useControlledState/useControlledState.js +11 -22
  162. package/useScroll/ScrollAnimator.js +49 -65
  163. package/useScroll/Scrollbar.js +22 -58
  164. package/useScroll/ScrollbarTrack.js +3 -19
  165. package/useScroll/useScroll.js +267 -454
  166. package/useScroll/utilDOM.js +8 -14
  167. package/useScroll/utilEvent.js +0 -4
@@ -4,122 +4,88 @@ Object.defineProperty(exports, "__esModule", {
4
4
  value: true
5
5
  });
6
6
  exports.useScrollBase = exports.useScroll = exports["default"] = exports.constants = exports.assignPropertiesOf = void 0;
7
-
8
7
  var _classnames = _interopRequireDefault(require("classnames"));
9
-
10
8
  var _handle = require("@enact/core/handle");
11
-
12
9
  var _keymap = require("@enact/core/keymap");
13
-
14
10
  var _platform = require("@enact/core/platform");
15
-
16
11
  var _Registry = _interopRequireDefault(require("@enact/core/internal/Registry"));
17
-
18
12
  var _util = require("@enact/core/util");
19
-
20
13
  var _clamp = _interopRequireDefault(require("ramda/src/clamp"));
21
-
22
14
  var _react = require("react");
23
-
24
15
  var _warning = _interopRequireDefault(require("warning"));
25
-
26
16
  var _ForwardRef = _interopRequireDefault(require("../ForwardRef"));
27
-
28
17
  var _Resizable = require("../Resizable");
29
-
30
18
  var _resolution = _interopRequireDefault(require("../resolution"));
31
-
32
19
  var _Touchable = _interopRequireDefault(require("../Touchable"));
33
-
34
20
  var _ScrollAnimator = _interopRequireDefault(require("./ScrollAnimator"));
35
-
36
21
  var _utilDOM = _interopRequireDefault(require("./utilDOM"));
37
-
38
22
  var _utilEvent = _interopRequireDefault(require("./utilEvent"));
39
-
40
23
  var _useScrollModule = _interopRequireDefault(require("./useScroll.module.css"));
41
-
42
24
  var _jsxRuntime = require("react/jsx-runtime");
43
-
44
25
  var _excluded = ["componentRef"],
45
- _excluded2 = ["childProps", "children", "className", "clientSize", "assignProperties", "dataSize", "direction", "horizontalScrollbar", "horizontalScrollbarHandle", "itemRenderer", "itemSize", "itemSizes", "noScrollByDrag", "noScrollByWheel", "overhang", "overscrollEffectOn", "pageScroll", "role", "rtl", "scrollContainerRef", "scrollContentHandle", "scrollContentRef", "scrollMode", "setScrollContainerHandle", "snapToCenter", "spacing", "spotlightContainerDisabled", "verticalScrollbar", "verticalScrollbarHandle", "wrap"];
46
-
26
+ _excluded2 = ["childProps", "children", "className", "clientSize", "assignProperties", "dataSize", "direction", "horizontalScrollbar", "horizontalScrollbarHandle", "itemRenderer", "itemSize", "itemSizes", "noScrollByDrag", "noScrollByWheel", "overhang", "overscrollEffectOn", "pageScroll", "role", "rtl", "scrollContainerRef", "scrollContentHandle", "scrollContentRef", "scrollMode", "setScrollContainerHandle", "snapToCenter", "spacing", "spotlightContainerDisabled", "verticalScrollbar", "verticalScrollbarHandle", "wrap"];
47
27
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
48
-
49
28
  function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
50
-
51
29
  function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
52
-
53
30
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
54
-
55
31
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
56
-
57
32
  function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
58
-
59
33
  function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
60
-
61
34
  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; }
62
-
63
35
  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(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; }
64
-
65
36
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
66
-
67
37
  function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
68
-
69
38
  function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
70
-
71
39
  var constants = {
72
- animationDuration: 1000,
73
- epsilon: 1,
74
- flickConfig: {
75
- maxDuration: null
40
+ animationDuration: 1000,
41
+ epsilon: 1,
42
+ flickConfig: {
43
+ maxDuration: null
44
+ },
45
+ isPageDown: (0, _keymap.is)('pageDown'),
46
+ isPageUp: (0, _keymap.is)('pageUp'),
47
+ nop: function nop() {},
48
+ overscrollDefaultRatio: 0.5,
49
+ overscrollTypeNone: 0,
50
+ overscrollTypeHold: 1,
51
+ overscrollTypeOnce: 2,
52
+ overscrollTypeDone: 9,
53
+ overscrollVelocityFactor: 300,
54
+ // scrollMode 'native'
55
+ paginationPageMultiplier: 0.66,
56
+ scrollStopWaiting: 200,
57
+ scrollWheelPageMultiplierForMaxPixel: 0.2 // The ratio of the maximum distance scrolled by wheel to the size of the viewport.
76
58
  },
77
- isPageDown: (0, _keymap.is)('pageDown'),
78
- isPageUp: (0, _keymap.is)('pageUp'),
79
- nop: function nop() {},
80
- overscrollDefaultRatio: 0.5,
81
- overscrollTypeNone: 0,
82
- overscrollTypeHold: 1,
83
- overscrollTypeOnce: 2,
84
- overscrollTypeDone: 9,
85
- overscrollVelocityFactor: 300,
86
- // scrollMode 'native'
87
- paginationPageMultiplier: 0.66,
88
- scrollStopWaiting: 200,
89
- scrollWheelPageMultiplierForMaxPixel: 0.2 // The ratio of the maximum distance scrolled by wheel to the size of the viewport.
90
-
91
- },
92
- animationDuration = constants.animationDuration,
93
- epsilon = constants.epsilon,
94
- flickConfig = constants.flickConfig,
95
- isPageDown = constants.isPageDown,
96
- isPageUp = constants.isPageUp,
97
- overscrollDefaultRatio = constants.overscrollDefaultRatio,
98
- overscrollTypeDone = constants.overscrollTypeDone,
99
- overscrollTypeHold = constants.overscrollTypeHold,
100
- overscrollTypeNone = constants.overscrollTypeNone,
101
- overscrollTypeOnce = constants.overscrollTypeOnce,
102
- overscrollVelocityFactor = constants.overscrollVelocityFactor,
103
- paginationPageMultiplier = constants.paginationPageMultiplier,
104
- scrollStopWaiting = constants.scrollStopWaiting,
105
- scrollWheelPageMultiplierForMaxPixel = constants.scrollWheelPageMultiplierForMaxPixel;
59
+ animationDuration = constants.animationDuration,
60
+ epsilon = constants.epsilon,
61
+ flickConfig = constants.flickConfig,
62
+ isPageDown = constants.isPageDown,
63
+ isPageUp = constants.isPageUp,
64
+ overscrollDefaultRatio = constants.overscrollDefaultRatio,
65
+ overscrollTypeDone = constants.overscrollTypeDone,
66
+ overscrollTypeHold = constants.overscrollTypeHold,
67
+ overscrollTypeNone = constants.overscrollTypeNone,
68
+ overscrollTypeOnce = constants.overscrollTypeOnce,
69
+ overscrollVelocityFactor = constants.overscrollVelocityFactor,
70
+ paginationPageMultiplier = constants.paginationPageMultiplier,
71
+ scrollStopWaiting = constants.scrollStopWaiting,
72
+ scrollWheelPageMultiplierForMaxPixel = constants.scrollWheelPageMultiplierForMaxPixel;
106
73
  exports.constants = constants;
107
74
  var TouchableDiv = (0, _ForwardRef["default"])({
108
75
  prop: 'componentRef'
109
76
  }, (0, _Touchable["default"])(function (_ref) {
110
77
  var componentRef = _ref.componentRef,
111
- rest = _objectWithoutProperties(_ref, _excluded);
112
-
78
+ rest = _objectWithoutProperties(_ref, _excluded);
113
79
  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", _objectSpread(_objectSpread({}, rest), {}, {
114
80
  ref: componentRef
115
81
  }));
116
82
  }));
117
-
118
83
  var useForceUpdate = function useForceUpdate() {
119
84
  return (0, _react.useReducer)(function (x) {
120
85
  return x + 1;
121
86
  }, 0);
122
87
  };
88
+
123
89
  /**
124
90
  * A custom hook that passes scrollable behavior information as its render prop.
125
91
  *
@@ -128,45 +94,43 @@ var useForceUpdate = function useForceUpdate() {
128
94
  * @ui
129
95
  * @private
130
96
  */
131
-
132
-
133
97
  var useScrollBase = function useScrollBase(props) {
134
98
  var childProps = props.childProps,
135
- children = props.children,
136
- className = props.className,
137
- clientSize = props.clientSize,
138
- assignProperties = props.assignProperties,
139
- dataSize = props.dataSize,
140
- direction = props.direction,
141
- horizontalScrollbar = props.horizontalScrollbar,
142
- horizontalScrollbarHandle = props.horizontalScrollbarHandle,
143
- itemRenderer = props.itemRenderer,
144
- itemSize = props.itemSize,
145
- itemSizes = props.itemSizes,
146
- noScrollByDrag = props.noScrollByDrag,
147
- noScrollByWheel = props.noScrollByWheel,
148
- overhang = props.overhang,
149
- overscrollEffectOn = props.overscrollEffectOn,
150
- pageScroll = props.pageScroll,
151
- role = props.role,
152
- rtl = props.rtl,
153
- scrollContainerRef = props.scrollContainerRef,
154
- scrollContentHandle = props.scrollContentHandle,
155
- scrollContentRef = props.scrollContentRef,
156
- scrollMode = props.scrollMode,
157
- setScrollContainerHandle = props.setScrollContainerHandle,
158
- snapToCenter = props.snapToCenter,
159
- spacing = props.spacing,
160
- spotlightContainerDisabled = props.spotlightContainerDisabled,
161
- verticalScrollbar = props.verticalScrollbar,
162
- verticalScrollbarHandle = props.verticalScrollbarHandle,
163
- wrap = props.wrap,
164
- rest = _objectWithoutProperties(props, _excluded2),
165
- scrollClasses = (0, _classnames["default"])(_useScrollModule["default"].scroll, className); // The following props are the one having the same naming function in this scope.
99
+ children = props.children,
100
+ className = props.className,
101
+ clientSize = props.clientSize,
102
+ assignProperties = props.assignProperties,
103
+ dataSize = props.dataSize,
104
+ direction = props.direction,
105
+ horizontalScrollbar = props.horizontalScrollbar,
106
+ horizontalScrollbarHandle = props.horizontalScrollbarHandle,
107
+ itemRenderer = props.itemRenderer,
108
+ itemSize = props.itemSize,
109
+ itemSizes = props.itemSizes,
110
+ noScrollByDrag = props.noScrollByDrag,
111
+ noScrollByWheel = props.noScrollByWheel,
112
+ overhang = props.overhang,
113
+ overscrollEffectOn = props.overscrollEffectOn,
114
+ pageScroll = props.pageScroll,
115
+ role = props.role,
116
+ rtl = props.rtl,
117
+ scrollContainerRef = props.scrollContainerRef,
118
+ scrollContentHandle = props.scrollContentHandle,
119
+ scrollContentRef = props.scrollContentRef,
120
+ scrollMode = props.scrollMode,
121
+ setScrollContainerHandle = props.setScrollContainerHandle,
122
+ snapToCenter = props.snapToCenter,
123
+ spacing = props.spacing,
124
+ spotlightContainerDisabled = props.spotlightContainerDisabled,
125
+ verticalScrollbar = props.verticalScrollbar,
126
+ verticalScrollbarHandle = props.verticalScrollbarHandle,
127
+ wrap = props.wrap,
128
+ rest = _objectWithoutProperties(props, _excluded2),
129
+ scrollClasses = (0, _classnames["default"])(_useScrollModule["default"].scroll, className);
130
+
131
+ // The following props are the one having the same naming function in this scope.
166
132
  // So it is better to use props[propName]
167
133
  // instead of extracting it from the `props` and renaming it
168
-
169
-
170
134
  delete rest.addEventListeners;
171
135
  delete rest.applyOverscrollEffect;
172
136
  delete rest.cbScrollTo;
@@ -181,29 +145,24 @@ var useScrollBase = function useScrollBase(props) {
181
145
  delete rest.onWheel;
182
146
  delete rest.removeEventListeners;
183
147
  delete rest.scrollStopOnScroll; // scrollMode 'native'
184
-
185
148
  delete rest.scrollTo;
186
149
  delete rest.start; // scrollMode 'native'
187
-
188
150
  delete rest.stop; // scrollMode 'translate'
151
+
189
152
  // Mutable value and Hooks
190
153
 
191
154
  var _useForceUpdate = useForceUpdate(),
192
- _useForceUpdate2 = _slicedToArray(_useForceUpdate, 2),
193
- forceUpdate = _useForceUpdate2[1];
194
-
155
+ _useForceUpdate2 = _slicedToArray(_useForceUpdate, 2),
156
+ forceUpdate = _useForceUpdate2[1];
195
157
  var context = (0, _react.useContext)(_Resizable.ResizeContext);
196
-
197
158
  var _useState = (0, _react.useState)(horizontalScrollbar === 'visible'),
198
- _useState2 = _slicedToArray(_useState, 2),
199
- isHorizontalScrollbarVisible = _useState2[0],
200
- setIsHorizontalScrollbarVisible = _useState2[1];
201
-
159
+ _useState2 = _slicedToArray(_useState, 2),
160
+ isHorizontalScrollbarVisible = _useState2[0],
161
+ setIsHorizontalScrollbarVisible = _useState2[1];
202
162
  var _useState3 = (0, _react.useState)(verticalScrollbar === 'visible'),
203
- _useState4 = _slicedToArray(_useState3, 2),
204
- isVerticalScrollbarVisible = _useState4[0],
205
- setIsVerticalScrollbarVisible = _useState4[1];
206
-
163
+ _useState4 = _slicedToArray(_useState3, 2),
164
+ isVerticalScrollbarVisible = _useState4[0],
165
+ setIsVerticalScrollbarVisible = _useState4[1];
207
166
  var mutableRef = (0, _react.useRef)({
208
167
  overscrollEnabled: !!props.applyOverscrollEffect,
209
168
  // Enable the early bail out of repeated scrolling to the same position
@@ -213,6 +172,7 @@ var useScrollBase = function useScrollBase(props) {
213
172
  pixelPerLine: 39,
214
173
  scrollWheelMultiplierForDeltaPixel: 1.5,
215
174
  // The ratio of wheel 'delta' units to pixels scrolled.
175
+
216
176
  // status
217
177
  deferScrollTo: true,
218
178
  isScrollAnimationTargetAccumulated: false,
@@ -254,6 +214,7 @@ var useScrollBase = function useScrollBase(props) {
254
214
  isDragging: false,
255
215
  isTouching: false,
256
216
  // scrollMode 'native'
217
+
257
218
  // scroll info
258
219
  scrolling: false,
259
220
  scrollLeft: 0,
@@ -275,11 +236,9 @@ var useScrollBase = function useScrollBase(props) {
275
236
  isVerticalScrollbarVisible: isVerticalScrollbarVisible
276
237
  }
277
238
  });
278
-
279
239
  if (mutableRef.current.animator == null) {
280
240
  mutableRef.current.animator = new _ScrollAnimator["default"]();
281
241
  }
282
-
283
242
  (0, _react.useLayoutEffect)(function () {
284
243
  if (setScrollContainerHandle) {
285
244
  setScrollContainerHandle({
@@ -291,76 +250,58 @@ var useScrollBase = function useScrollBase(props) {
291
250
  canScrollVertically: canScrollVertically,
292
251
  checkAndApplyOverscrollEffect: checkAndApplyOverscrollEffect,
293
252
  getScrollBounds: getScrollBounds,
294
-
295
253
  get isDragging() {
296
254
  return mutableRef.current.isDragging;
297
255
  },
298
-
299
256
  set isDragging(val) {
300
257
  mutableRef.current.isDragging = val;
301
258
  },
302
-
303
259
  get isScrollAnimationTargetAccumulated() {
304
260
  return mutableRef.current.isScrollAnimationTargetAccumulated;
305
261
  },
306
-
307
262
  set isScrollAnimationTargetAccumulated(val) {
308
263
  mutableRef.current.isScrollAnimationTargetAccumulated = val;
309
264
  },
310
-
311
265
  get lastInputType() {
312
266
  return mutableRef.current.lastInputType;
313
267
  },
314
-
315
268
  set lastInputType(val) {
316
269
  mutableRef.current.lastInputType = val;
317
270
  },
318
-
319
271
  get rtl() {
320
272
  return rtl;
321
273
  },
322
-
323
274
  get scrollBounds() {
324
275
  return getScrollBounds();
325
276
  },
326
-
327
277
  get scrollHeight() {
328
278
  return mutableRef.current.bounds.scrollHeight;
329
279
  },
330
-
331
280
  get scrolling() {
332
281
  return mutableRef.current.scrolling;
333
282
  },
334
-
335
283
  get scrollLeft() {
336
284
  return mutableRef.current.scrollLeft;
337
285
  },
338
-
339
286
  scrollTo: scrollTo,
340
287
  scrollToAccumulatedTarget: scrollToAccumulatedTarget,
341
-
342
288
  get scrollToInfo() {
343
289
  return mutableRef.current.scrollToInfo;
344
290
  },
345
-
346
291
  get scrollTop() {
347
292
  return mutableRef.current.scrollTop;
348
293
  },
349
-
350
294
  setOverscrollStatus: setOverscrollStatus,
351
295
  showScrollbarTrack: showScrollbarTrack,
352
296
  start: start,
353
297
  startHidingScrollbarTrack: startHidingScrollbarTrack,
354
298
  stop: stop,
355
-
356
299
  get wheelDirection() {
357
300
  return mutableRef.current.wheelDirection;
358
301
  },
359
-
360
302
  set wheelDirection(val) {
361
303
  mutableRef.current.wheelDirection = val;
362
304
  }
363
-
364
305
  });
365
306
  }
366
307
  });
@@ -372,11 +313,9 @@ var useScrollBase = function useScrollBase(props) {
372
313
 
373
314
  (0, _react.useLayoutEffect)(function () {
374
315
  var containerRef = scrollContainerRef.current;
375
-
376
316
  if (!containerRef) {
377
317
  return;
378
318
  }
379
-
380
319
  if (typeof ResizeObserver === 'function') {
381
320
  var resizeObserver = new ResizeObserver(function () {
382
321
  if (scrollContentHandle.current && scrollContentHandle.current.syncClientSize) {
@@ -394,27 +333,29 @@ var useScrollBase = function useScrollBase(props) {
394
333
  }, []); // eslint-disable-line react-hooks/exhaustive-deps
395
334
 
396
335
  (0, _react.useLayoutEffect)(function () {
397
- mutableRef.current.resizeRegistry.parent = context; // componentWillUnmount
336
+ mutableRef.current.resizeRegistry.parent = context;
398
337
 
338
+ // componentWillUnmount
399
339
  return function () {
400
340
  var _mutableRef$current = mutableRef.current,
401
- animator = _mutableRef$current.animator,
402
- resizeRegistry = _mutableRef$current.resizeRegistry,
403
- scrolling = _mutableRef$current.scrolling,
404
- scrollStopJob = _mutableRef$current.scrollStopJob; // eslint-disable-line react-hooks/exhaustive-deps
341
+ animator = _mutableRef$current.animator,
342
+ resizeRegistry = _mutableRef$current.resizeRegistry,
343
+ scrolling = _mutableRef$current.scrolling,
344
+ scrollStopJob = _mutableRef$current.scrollStopJob; // eslint-disable-line react-hooks/exhaustive-deps
405
345
 
406
- resizeRegistry.parent = null; // Before call cancelAnimationFrame, you must send scrollStop Event.
346
+ resizeRegistry.parent = null;
407
347
 
348
+ // Before call cancelAnimationFrame, you must send scrollStop Event.
408
349
  if (scrolling) {
409
350
  forwardScrollEvent('onScrollStop', getReachedEdgeInfo());
410
351
  }
352
+ scrollStopJob.stop();
411
353
 
412
- scrollStopJob.stop(); // scrollMode 'translate' [
413
-
354
+ // scrollMode 'translate' [
414
355
  if (animator.isAnimating()) {
415
356
  animator.stop();
416
- } // scrollMode 'translate' ]
417
-
357
+ }
358
+ // scrollMode 'translate' ]
418
359
  };
419
360
  }, []); // eslint-disable-line react-hooks/exhaustive-deps
420
361
 
@@ -423,21 +364,23 @@ var useScrollBase = function useScrollBase(props) {
423
364
  return function () {
424
365
  removeEventListeners();
425
366
  };
426
- }); // scrollMode 'translate' [[
367
+ });
368
+
369
+ // scrollMode 'translate' [[
427
370
  // TODO: consider replacing forceUpdate() by storing bounds in state rather than a non-
428
371
  // state member.
429
-
430
372
  var enqueueForceUpdate = (0, _react.useCallback)(function () {
431
373
  scrollContentHandle.current.calculateMetrics(scrollContentHandle.current.props);
432
374
  forceUpdate();
433
- }, [forceUpdate, scrollContentHandle]); // scrollMode 'translate' ]]
375
+ }, [forceUpdate, scrollContentHandle]);
376
+ // scrollMode 'translate' ]]
434
377
 
435
378
  function handleResizeWindow() {
436
- var propsHandleResizeWindow = props.handleResizeWindow; // `handleSize` in `ui/resolution.ResolutionDecorator` should be executed first.
379
+ var propsHandleResizeWindow = props.handleResizeWindow;
437
380
 
381
+ // `handleSize` in `ui/resolution.ResolutionDecorator` should be executed first.
438
382
  setTimeout(function () {
439
383
  var handleResizeResult = propsHandleResizeWindow === null || propsHandleResizeWindow === void 0 ? void 0 : propsHandleResizeWindow();
440
-
441
384
  if (handleResizeResult) {
442
385
  if (scrollMode === 'translate') {
443
386
  scrollTo({
@@ -451,47 +394,44 @@ var useScrollBase = function useScrollBase(props) {
451
394
  scrollContentHandle.current.scrollToPosition(0, 0, 'instant');
452
395
  }
453
396
  }
454
-
455
397
  enqueueForceUpdate();
456
398
  });
457
- } // scrollMode 'translate' [[
458
-
399
+ }
459
400
 
401
+ // scrollMode 'translate' [[
460
402
  var handleResize = (0, _react.useCallback)(function (ev) {
461
403
  if (ev.action === 'invalidateBounds') {
462
404
  enqueueForceUpdate();
463
405
  }
464
- }, [enqueueForceUpdate]); // scrollMode 'translate' ]]
406
+ }, [enqueueForceUpdate]);
407
+ // scrollMode 'translate' ]]
465
408
 
466
409
  if (mutableRef.current.resizeRegistry == null) {
467
410
  mutableRef.current.resizeRegistry = _Registry["default"].create(handleResize);
468
411
  }
469
-
470
412
  (0, _react.useLayoutEffect)(function () {
471
413
  var ref = mutableRef.current;
472
-
473
414
  if (scrollMode === 'translate') {
474
415
  ref.scrollStopJob = new _util.Job(doScrollStop, scrollStopWaiting);
475
416
  } else {
476
417
  ref.scrollStopJob = new _util.Job(scrollStopOnScroll, scrollStopWaiting);
477
418
  }
478
-
479
419
  return function () {
480
420
  if (ref.scrolling) {
481
421
  ref.scrollStopJob.run();
482
422
  }
483
-
484
423
  ref.scrollStopJob.stop();
485
424
  };
486
425
  }, [direction, isHorizontalScrollbarVisible, isVerticalScrollbarVisible, rtl, scrollMode, spotlightContainerDisabled]); // eslint-disable-line react-hooks/exhaustive-deps
487
426
 
488
427
  (0, _react.useLayoutEffect)(function () {
489
428
  var hasDataSizeChanged = scrollContentHandle.current.hasDataSizeChanged,
490
- _mutableRef$current2 = mutableRef.current,
491
- prevState = _mutableRef$current2.prevState,
492
- resizeRegistry = _mutableRef$current2.resizeRegistry,
493
- scrollToInfo = _mutableRef$current2.scrollToInfo; // Need to sync calculated client size if it is different from the real size
429
+ _mutableRef$current2 = mutableRef.current,
430
+ prevState = _mutableRef$current2.prevState,
431
+ resizeRegistry = _mutableRef$current2.resizeRegistry,
432
+ scrollToInfo = _mutableRef$current2.scrollToInfo;
494
433
 
434
+ // Need to sync calculated client size if it is different from the real size
495
435
  if (scrollContentHandle.current.syncClientSize) {
496
436
  // If we actually synced, we need to reset scroll position.
497
437
  if (scrollContentHandle.current.syncClientSize()) {
@@ -499,7 +439,6 @@ var useScrollBase = function useScrollBase(props) {
499
439
  setScrollTop(0);
500
440
  }
501
441
  }
502
-
503
442
  clampScrollPosition(); // scrollMode 'translate'
504
443
 
505
444
  if (hasDataSizeChanged === false && (isHorizontalScrollbarVisible && !prevState.isHorizontalScrollbarVisible || isVerticalScrollbarVisible && !prevState.isVerticalScrollbarVisible)) {
@@ -508,55 +447,51 @@ var useScrollBase = function useScrollBase(props) {
508
447
  } else {
509
448
  updateScrollbars();
510
449
  }
511
-
512
450
  if (scrollToInfo !== null) {
513
451
  if (!mutableRef.current.deferScrollTo) {
514
452
  scrollTo(scrollToInfo);
515
453
  }
516
- } // publish container resize changes
517
-
454
+ }
518
455
 
456
+ // publish container resize changes
519
457
  var horizontal = isHorizontalScrollbarVisible !== prevState.isHorizontalScrollbarVisible;
520
458
  var vertical = isVerticalScrollbarVisible !== prevState.isVerticalScrollbarVisible;
521
-
522
459
  if (horizontal || vertical) {
523
460
  resizeRegistry.notify({});
524
461
  }
525
- }); // scrollMode 'translate' [[
462
+ });
526
463
 
464
+ // scrollMode 'translate' [[
527
465
  function clampScrollPosition() {
528
466
  var bounds = getScrollBounds();
529
-
530
467
  if (mutableRef.current.scrollTop > bounds.maxTop) {
531
468
  mutableRef.current.scrollTop = bounds.maxTop;
532
469
  }
533
-
534
470
  if (mutableRef.current.scrollLeft > bounds.maxLeft) {
535
471
  mutableRef.current.scrollLeft = bounds.maxLeft;
536
472
  }
537
- } // scrollMode 'translate' ]]
538
- // drag/flick event handlers
473
+ }
474
+ // scrollMode 'translate' ]]
539
475
 
476
+ // drag/flick event handlers
540
477
 
541
478
  function getRtlX(x) {
542
479
  return rtl ? -x : x;
543
480
  }
544
-
545
481
  function onMouseDown(ev) {
546
482
  if (snapToCenter) {
547
483
  ev.preventDefault();
548
484
  }
549
-
550
485
  if ((0, _handle.forwardWithPrevent)('onMouseDown', ev, props) && !snapToCenter) {
551
486
  stop();
552
487
  }
553
- } // scrollMode 'native' [[
554
-
488
+ }
555
489
 
490
+ // scrollMode 'native' [[
556
491
  function onTouchStart() {
557
492
  mutableRef.current.isTouching = true;
558
- } // scrollMode 'native' ]]
559
-
493
+ }
494
+ // scrollMode 'native' ]]
560
495
 
561
496
  function onDragStart(ev) {
562
497
  if (scrollMode === 'translate') {
@@ -570,20 +505,18 @@ var useScrollBase = function useScrollBase(props) {
570
505
  if (!mutableRef.current.isTouching) {
571
506
  stop();
572
507
  mutableRef.current.isDragging = true;
573
- } // these values are used also for touch inputs
574
-
508
+ }
575
509
 
510
+ // these values are used also for touch inputs
576
511
  mutableRef.current.dragStartX = mutableRef.current.scrollLeft + getRtlX(ev.x);
577
512
  mutableRef.current.dragStartY = mutableRef.current.scrollTop + ev.y;
578
513
  }
579
514
  }
580
-
581
515
  function onDrag(ev) {
582
516
  if (scrollMode === 'translate') {
583
517
  if (ev.type === 'drag') {
584
518
  return;
585
519
  }
586
-
587
520
  mutableRef.current.lastInputType = 'drag';
588
521
  (0, _handle.forward)('onDrag', ev, props);
589
522
  start({
@@ -596,11 +529,10 @@ var useScrollBase = function useScrollBase(props) {
596
529
  });
597
530
  } else {
598
531
  var targetX = direction === 'vertical' ? 0 : mutableRef.current.dragStartX - getRtlX(ev.x),
599
- // 'horizontal' or 'both'
600
- targetY = direction === 'horizontal' ? 0 : mutableRef.current.dragStartY - ev.y; // 'vertical' or 'both'
532
+ // 'horizontal' or 'both'
533
+ targetY = direction === 'horizontal' ? 0 : mutableRef.current.dragStartY - ev.y; // 'vertical' or 'both'
601
534
 
602
535
  mutableRef.current.lastInputType = 'drag';
603
-
604
536
  if (!mutableRef.current.isTouching) {
605
537
  start({
606
538
  targetX: targetX,
@@ -613,21 +545,18 @@ var useScrollBase = function useScrollBase(props) {
613
545
  }
614
546
  }
615
547
  }
616
-
617
548
  function onDragEnd(ev) {
618
549
  if (scrollMode === 'translate') {
619
550
  if (ev.type === 'dragend') {
620
551
  return;
621
552
  }
622
-
623
553
  mutableRef.current.isDragging = false;
624
554
  (0, _handle.forward)('onDragEnd', ev, props);
625
-
626
555
  if (mutableRef.current.flickTarget) {
627
556
  var _mutableRef$current$f = mutableRef.current.flickTarget,
628
- targetX = _mutableRef$current$f.targetX,
629
- targetY = _mutableRef$current$f.targetY,
630
- duration = _mutableRef$current$f.duration;
557
+ targetX = _mutableRef$current$f.targetX,
558
+ targetY = _mutableRef$current$f.targetY,
559
+ duration = _mutableRef$current$f.duration;
631
560
  mutableRef.current.lastInputType = 'drag';
632
561
  mutableRef.current.isScrollAnimationTargetAccumulated = false;
633
562
  start({
@@ -639,22 +568,18 @@ var useScrollBase = function useScrollBase(props) {
639
568
  } else {
640
569
  stop();
641
570
  }
642
-
643
571
  if (mutableRef.current.overscrollEnabled) {
644
572
  // not check overscrollEffectOn && overscrollEffectOn.drag for safety
645
573
  clearAllOverscrollEffects();
646
574
  }
647
-
648
575
  mutableRef.current.flickTarget = null;
649
576
  } else {
650
577
  mutableRef.current.isDragging = false;
651
578
  mutableRef.current.lastInputType = 'drag';
652
-
653
579
  if (mutableRef.current.flickTarget) {
654
580
  var _mutableRef$current$f2 = mutableRef.current.flickTarget,
655
- _targetX = _mutableRef$current$f2.targetX,
656
- _targetY = _mutableRef$current$f2.targetY;
657
-
581
+ _targetX = _mutableRef$current$f2.targetX,
582
+ _targetY = _mutableRef$current$f2.targetY;
658
583
  if (!mutableRef.current.isTouching) {
659
584
  mutableRef.current.isScrollAnimationTargetAccumulated = false;
660
585
  start({
@@ -668,20 +593,16 @@ var useScrollBase = function useScrollBase(props) {
668
593
  } else if (!mutableRef.current.isTouching) {
669
594
  stop();
670
595
  }
671
-
672
596
  if (mutableRef.current.overscrollEnabled) {
673
597
  // not check overscrollEffectOn && overscrollEffectOn.drag for safety
674
598
  clearAllOverscrollEffects();
675
599
  }
676
-
677
600
  mutableRef.current.isTouching = false;
678
601
  mutableRef.current.flickTarget = null;
679
602
  }
680
603
  }
681
-
682
604
  function onFlick(ev) {
683
605
  var isVerticalFlick = ev.direction === 'vertical';
684
-
685
606
  if (scrollMode === 'translate' || !mutableRef.current.isTouching) {
686
607
  // except touch input in 'native' mode
687
608
  mutableRef.current.flickTarget = mutableRef.current.animator.simulate(mutableRef.current.scrollLeft, mutableRef.current.scrollTop, direction !== 'vertical' && !isVerticalFlick ? getRtlX(-ev.velocityX) : 0, direction !== 'horizontal' && isVerticalFlick ? -ev.velocityY : 0);
@@ -691,7 +612,6 @@ var useScrollBase = function useScrollBase(props) {
691
612
  targetX: mutableRef.current.scrollLeft + (!isVerticalFlick ? getRtlX(-ev.velocityX) : 0) * overscrollVelocityFactor,
692
613
  // 'horizontal' or 'both'
693
614
  targetY: mutableRef.current.scrollTop + (isVerticalFlick ? -ev.velocityY : 0) * overscrollVelocityFactor // 'vertical' or 'both'
694
-
695
615
  };
696
616
  }
697
617
 
@@ -699,7 +619,6 @@ var useScrollBase = function useScrollBase(props) {
699
619
  (0, _handle.forward)('onFlick', ev, props);
700
620
  }
701
621
  }
702
-
703
622
  function calculateDistanceByWheel(deltaMode, delta, maxPixel) {
704
623
  if (deltaMode === 0) {
705
624
  delta = (0, _clamp["default"])(-maxPixel, maxPixel, _resolution["default"].scale(delta * mutableRef.current.scrollWheelMultiplierForDeltaPixel));
@@ -710,37 +629,32 @@ var useScrollBase = function useScrollBase(props) {
710
629
  // page
711
630
  delta = delta < 0 ? -maxPixel : maxPixel;
712
631
  }
713
-
714
632
  return delta;
715
633
  }
634
+
716
635
  /*
717
636
  * wheel event handler;
718
637
  * - for horizontal scroll, supports wheel action on any children nodes since web engine cannot support this
719
638
  * - for vertical scroll, supports wheel action on scrollbars only
720
639
  */
721
-
722
-
723
640
  function onWheel(ev) {
724
641
  if (mutableRef.current.isDragging) {
725
642
  ev.preventDefault();
726
643
  ev.stopPropagation();
727
644
  } else {
728
645
  var bounds = getScrollBounds(),
729
- canScrollH = canScrollHorizontally(bounds),
730
- canScrollV = canScrollVertically(bounds),
731
- eventDeltaMode = ev.deltaMode,
732
- eventDelta = -ev.wheelDeltaY || ev.deltaY;
646
+ canScrollH = canScrollHorizontally(bounds),
647
+ canScrollV = canScrollVertically(bounds),
648
+ eventDeltaMode = ev.deltaMode,
649
+ eventDelta = -ev.wheelDeltaY || ev.deltaY;
733
650
  var delta = 0;
734
651
  mutableRef.current.lastInputType = 'wheel';
735
-
736
652
  if (noScrollByWheel) {
737
653
  if (scrollMode === 'native' && canScrollV) {
738
654
  ev.preventDefault();
739
655
  }
740
-
741
656
  return;
742
657
  }
743
-
744
658
  if (snapToCenter) {
745
659
  if (scrollMode === 'native' && (canScrollV || canScrollH)) {
746
660
  ev.preventDefault();
@@ -748,27 +662,22 @@ var useScrollBase = function useScrollBase(props) {
748
662
  return;
749
663
  }
750
664
  }
751
-
752
665
  if (scrollMode === 'translate') {
753
666
  if (canScrollV) {
754
667
  delta = calculateDistanceByWheel(eventDeltaMode, eventDelta, bounds.clientHeight * scrollWheelPageMultiplierForMaxPixel);
755
668
  } else if (canScrollH) {
756
669
  delta = calculateDistanceByWheel(eventDeltaMode, eventDelta, bounds.clientWidth * scrollWheelPageMultiplierForMaxPixel);
757
670
  }
758
-
759
671
  var dir = Math.sign(delta);
760
-
761
672
  if (dir !== mutableRef.current.wheelDirection) {
762
673
  mutableRef.current.isScrollAnimationTargetAccumulated = false;
763
674
  mutableRef.current.wheelDirection = dir;
764
675
  }
765
-
766
676
  (0, _handle.forward)('onWheel', {
767
677
  delta: delta,
768
678
  horizontalScrollbarHandle: horizontalScrollbarHandle,
769
679
  verticalScrollbarHandle: verticalScrollbarHandle
770
680
  }, props);
771
-
772
681
  if (delta !== 0) {
773
682
  scrollToAccumulatedTarget(delta, canScrollV, overscrollEffectOn && overscrollEffectOn.wheel);
774
683
  ev.preventDefault();
@@ -778,15 +687,14 @@ var useScrollBase = function useScrollBase(props) {
778
687
  // scrollMode 'native'
779
688
  var overscrollEffectRequired = mutableRef.current.overscrollEnabled && overscrollEffectOn && overscrollEffectOn.wheel;
780
689
  var needToHideScrollbarTrack = false;
781
-
782
690
  if (props.onWheel) {
783
691
  (0, _handle.forward)('onWheel', ev, props);
784
692
  return;
785
693
  }
694
+ showScrollbarTrack(bounds);
786
695
 
787
- showScrollbarTrack(bounds); // FIXME This routine is a temporary support for horizontal wheel scroll.
696
+ // FIXME This routine is a temporary support for horizontal wheel scroll.
788
697
  // FIXME If web engine supports horizontal wheel, this routine should be refined or removed.
789
-
790
698
  if (canScrollV) {
791
699
  // This routine handles wheel events on scrollbars for vertical scroll.
792
700
  if (eventDelta < 0 && mutableRef.current.scrollTop > 0 || eventDelta > 0 && mutableRef.current.scrollTop < bounds.maxTop) {
@@ -798,13 +706,11 @@ var useScrollBase = function useScrollBase(props) {
798
706
  } else if (overscrollEffectRequired) {
799
707
  checkAndApplyOverscrollEffect('vertical', eventDelta > 0 ? 'after' : 'before', overscrollTypeOnce);
800
708
  }
801
-
802
709
  ev.stopPropagation();
803
710
  } else {
804
711
  if (overscrollEffectRequired && (eventDelta < 0 && mutableRef.current.scrollTop <= 0 || eventDelta > 0 && mutableRef.current.scrollTop >= bounds.maxTop)) {
805
712
  applyOverscrollEffect('vertical', eventDelta > 0 ? 'after' : 'before', overscrollTypeOnce);
806
713
  }
807
-
808
714
  needToHideScrollbarTrack = true;
809
715
  }
810
716
  } else if (canScrollH) {
@@ -818,72 +724,62 @@ var useScrollBase = function useScrollBase(props) {
818
724
  if (overscrollEffectRequired && (eventDelta < 0 && mutableRef.current.scrollLeft <= 0 || eventDelta > 0 && mutableRef.current.scrollLeft >= bounds.maxLeft)) {
819
725
  applyOverscrollEffect('horizontal', eventDelta > 0 ? 'after' : 'before', overscrollTypeOnce);
820
726
  }
821
-
822
727
  needToHideScrollbarTrack = true;
823
728
  }
824
729
  }
825
-
826
730
  if (delta !== 0) {
827
- var _dir = Math.sign(delta); // Not to accumulate scroll position if wheel direction is different from hold direction
828
-
731
+ var _dir = Math.sign(delta);
829
732
 
733
+ // Not to accumulate scroll position if wheel direction is different from hold direction
830
734
  if (_dir !== mutableRef.current.wheelDirection) {
831
735
  mutableRef.current.isScrollAnimationTargetAccumulated = false;
832
736
  mutableRef.current.wheelDirection = _dir;
833
737
  }
834
-
835
738
  scrollToAccumulatedTarget(delta, canScrollV, overscrollEffectOn && overscrollEffectOn.wheel);
836
739
  }
837
-
838
740
  if (needToHideScrollbarTrack) {
839
741
  startHidingScrollbarTrack();
840
742
  }
841
743
  }
842
744
  }
843
- } // scrollMode 'translate' [[
844
-
745
+ }
845
746
 
747
+ // scrollMode 'translate' [[
846
748
  function scrollByPage(keyCode) {
847
749
  var bounds = getScrollBounds(),
848
- canScrollV = canScrollVertically(bounds),
849
- pageDistance = (isPageUp(keyCode) ? -1 : 1) * (canScrollV ? bounds.clientHeight : bounds.clientWidth) * paginationPageMultiplier;
750
+ canScrollV = canScrollVertically(bounds),
751
+ pageDistance = (isPageUp(keyCode) ? -1 : 1) * (canScrollV ? bounds.clientHeight : bounds.clientWidth) * paginationPageMultiplier;
850
752
  mutableRef.current.lastInputType = 'pageKey';
851
753
  scrollToAccumulatedTarget(pageDistance, canScrollV, overscrollEffectOn && overscrollEffectOn.pageKey);
852
- } // scrollMode 'translate' ]]
853
- // scrollMode 'native' [[
854
-
754
+ }
755
+ // scrollMode 'translate' ]]
855
756
 
757
+ // scrollMode 'native' [[
856
758
  function onScroll(ev) {
857
759
  var _ev$target = ev.target,
858
- scrollLeft = _ev$target.scrollLeft,
859
- scrollTop = _ev$target.scrollTop;
760
+ scrollLeft = _ev$target.scrollLeft,
761
+ scrollTop = _ev$target.scrollTop;
860
762
  var bounds = getScrollBounds(),
861
- canScrollH = canScrollHorizontally(bounds);
862
-
763
+ canScrollH = canScrollHorizontally(bounds);
863
764
  if (!mutableRef.current.scrolling) {
864
765
  scrollStartOnScroll();
865
766
  }
866
-
867
767
  if (rtl && canScrollH) {
868
768
  scrollLeft = _platform.platform.ios || _platform.platform.safari || _platform.platform.chrome >= 85 || _platform.platform.androidChrome >= 85 ? -scrollLeft : bounds.maxLeft - scrollLeft;
869
769
  }
870
-
871
770
  if (scrollLeft !== mutableRef.current.scrollLeft) {
872
771
  setScrollLeft(scrollLeft);
873
772
  }
874
-
875
773
  if (scrollTop !== mutableRef.current.scrollTop) {
876
774
  setScrollTop(scrollTop);
877
775
  }
878
-
879
776
  if (scrollContentHandle.current.didScroll) {
880
777
  scrollContentHandle.current.didScroll(mutableRef.current.scrollLeft, mutableRef.current.scrollTop);
881
778
  }
882
-
883
779
  forwardScrollEvent('onScroll');
884
780
  mutableRef.current.scrollStopJob.start();
885
- } // scrollMode 'native' ]]
886
-
781
+ }
782
+ // scrollMode 'native' ]]
887
783
 
888
784
  function onKeyDown(ev) {
889
785
  if (scrollMode === 'translate') {
@@ -896,27 +792,25 @@ var useScrollBase = function useScrollBase(props) {
896
792
  (0, _handle.forward)('onKeyDown', ev, props);
897
793
  }
898
794
  }
899
-
900
795
  function scrollToAccumulatedTarget(delta, vertical, overscrollEffect) {
901
796
  if (!mutableRef.current.isScrollAnimationTargetAccumulated) {
902
797
  mutableRef.current.accumulatedTargetX = mutableRef.current.scrollLeft;
903
798
  mutableRef.current.accumulatedTargetY = mutableRef.current.scrollTop;
904
799
  mutableRef.current.isScrollAnimationTargetAccumulated = true;
905
800
  }
906
-
907
801
  if (vertical) {
908
802
  mutableRef.current.accumulatedTargetY += delta;
909
803
  } else {
910
804
  mutableRef.current.accumulatedTargetX += delta;
911
805
  }
912
-
913
806
  start({
914
807
  targetX: mutableRef.current.accumulatedTargetX,
915
808
  targetY: mutableRef.current.accumulatedTargetY,
916
809
  overscrollEffect: overscrollEffect
917
810
  });
918
- } // overscroll effect
811
+ }
919
812
 
813
+ // overscroll effect
920
814
 
921
815
  function getEdgeFromPosition(position, maxPosition) {
922
816
  if (position <= 0) {
@@ -927,24 +821,20 @@ var useScrollBase = function useScrollBase(props) {
927
821
  return null;
928
822
  }
929
823
  }
930
-
931
824
  function setOverscrollStatus(orientation, edge, overscrollEffectType, ratio) {
932
825
  var status = mutableRef.current.overscrollStatus[orientation][edge];
933
826
  status.type = overscrollEffectType;
934
827
  status.ratio = ratio;
935
828
  }
936
-
937
829
  function getOverscrollStatus(orientation, edge) {
938
830
  return mutableRef.current.overscrollStatus[orientation][edge];
939
831
  }
940
-
941
832
  function calculateOverscrollRatio(orientation, position) {
942
833
  var bounds = getScrollBounds(),
943
- isVertical = orientation === 'vertical',
944
- baseSize = isVertical ? bounds.clientHeight : bounds.clientWidth,
945
- maxPos = bounds[isVertical ? 'maxTop' : 'maxLeft'];
834
+ isVertical = orientation === 'vertical',
835
+ baseSize = isVertical ? bounds.clientHeight : bounds.clientWidth,
836
+ maxPos = bounds[isVertical ? 'maxTop' : 'maxLeft'];
946
837
  var overDistance = 0;
947
-
948
838
  if (position < 0) {
949
839
  overDistance = -position;
950
840
  } else if (position > maxPos) {
@@ -952,22 +842,18 @@ var useScrollBase = function useScrollBase(props) {
952
842
  } else {
953
843
  return 0;
954
844
  }
955
-
956
845
  return Math.min(1, 2 * overDistance / baseSize);
957
846
  }
958
-
959
847
  function applyOverscrollEffect(orientation, edge, overscrollEffectType) {
960
848
  var ratio = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : overscrollDefaultRatio;
961
849
  props.applyOverscrollEffect(orientation, edge, overscrollEffectType, ratio);
962
850
  setOverscrollStatus(orientation, edge, overscrollEffectType === overscrollTypeOnce ? overscrollTypeDone : overscrollEffectType, ratio);
963
851
  }
964
-
965
852
  function checkAndApplyOverscrollEffect(orientation, edge, overscrollEffectType) {
966
853
  var ratio = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : overscrollDefaultRatio;
967
854
  var isVertical = orientation === 'vertical',
968
- curPos = isVertical ? mutableRef.current.scrollTop : mutableRef.current.scrollLeft,
969
- maxPos = getScrollBounds()[isVertical ? 'maxTop' : 'maxLeft'];
970
-
855
+ curPos = isVertical ? mutableRef.current.scrollTop : mutableRef.current.scrollLeft,
856
+ maxPos = getScrollBounds()[isVertical ? 'maxTop' : 'maxLeft'];
971
857
  if (edge === 'before' && curPos <= 0 || edge === 'after' && curPos >= maxPos - epsilon) {
972
858
  // Already on the edge
973
859
  applyOverscrollEffect(orientation, edge, overscrollEffectType, ratio);
@@ -975,7 +861,6 @@ var useScrollBase = function useScrollBase(props) {
975
861
  setOverscrollStatus(orientation, edge, overscrollEffectType, ratio);
976
862
  }
977
863
  }
978
-
979
864
  function clearOverscrollEffect(orientation, edge) {
980
865
  if (getOverscrollStatus(orientation, edge).type !== overscrollTypeNone) {
981
866
  if (props.clearOverscrollEffect) {
@@ -985,7 +870,6 @@ var useScrollBase = function useScrollBase(props) {
985
870
  }
986
871
  }
987
872
  }
988
-
989
873
  function clearAllOverscrollEffects() {
990
874
  ['horizontal', 'vertical'].forEach(function (orientation) {
991
875
  ['before', 'after'].forEach(function (edge) {
@@ -993,57 +877,52 @@ var useScrollBase = function useScrollBase(props) {
993
877
  });
994
878
  });
995
879
  }
996
-
997
880
  function applyOverscrollEffectOnDrag(orientation, edge, targetPosition, overscrollEffectType) {
998
881
  if (edge) {
999
882
  var oppositeEdge = edge === 'before' ? 'after' : 'before',
1000
- ratio = calculateOverscrollRatio(orientation, targetPosition);
883
+ ratio = calculateOverscrollRatio(orientation, targetPosition);
1001
884
  applyOverscrollEffect(orientation, edge, overscrollEffectType, ratio);
1002
885
  clearOverscrollEffect(orientation, oppositeEdge);
1003
886
  } else {
1004
887
  clearOverscrollEffect(orientation, 'before');
1005
888
  clearOverscrollEffect(orientation, 'after');
1006
889
  }
1007
- } // scrollMode 'native' [[
1008
-
890
+ }
1009
891
 
892
+ // scrollMode 'native' [[
1010
893
  function checkAndApplyOverscrollEffectOnDrag(targetX, targetY, overscrollEffectType) {
1011
894
  var bounds = getScrollBounds();
1012
-
1013
895
  if (canScrollHorizontally(bounds)) {
1014
896
  applyOverscrollEffectOnDrag('horizontal', getEdgeFromPosition(targetX, bounds.maxLeft), targetX, overscrollEffectType);
1015
897
  }
1016
-
1017
898
  if (canScrollVertically(bounds)) {
1018
899
  applyOverscrollEffectOnDrag('vertical', getEdgeFromPosition(targetY, bounds.maxTop), targetY, overscrollEffectType);
1019
900
  }
1020
- } // scrollMode 'native' ]]
1021
-
901
+ }
902
+ // scrollMode 'native' ]]
1022
903
 
1023
904
  function checkAndApplyOverscrollEffectOnScroll(orientation) {
1024
905
  ['before', 'after'].forEach(function (edge) {
1025
906
  var _getOverscrollStatus = getOverscrollStatus(orientation, edge),
1026
- ratio = _getOverscrollStatus.ratio,
1027
- overscrollEffectType = _getOverscrollStatus.type;
1028
-
907
+ ratio = _getOverscrollStatus.ratio,
908
+ overscrollEffectType = _getOverscrollStatus.type;
1029
909
  if (overscrollEffectType === overscrollTypeOnce) {
1030
910
  checkAndApplyOverscrollEffect(orientation, edge, overscrollEffectType, ratio);
1031
911
  }
1032
912
  });
1033
913
  }
1034
-
1035
914
  function checkAndApplyOverscrollEffectOnStart(orientation, edge, targetPosition) {
1036
915
  if (mutableRef.current.isDragging) {
1037
916
  applyOverscrollEffectOnDrag(orientation, edge, targetPosition, overscrollTypeHold);
1038
917
  } else if (edge) {
1039
918
  checkAndApplyOverscrollEffect(orientation, edge, overscrollTypeOnce);
1040
919
  }
1041
- } // call scroll callbacks
920
+ }
1042
921
 
922
+ // call scroll callbacks
1043
923
 
1044
924
  var addObserverOnScroll = (0, _react.useCallback)(function (fn) {
1045
925
  var observerOnScroll = mutableRef.current.observerOnScroll;
1046
-
1047
926
  if (typeof fn === 'function' && !observerOnScroll.includes(fn)) {
1048
927
  observerOnScroll.push(fn);
1049
928
  }
@@ -1051,12 +930,10 @@ var useScrollBase = function useScrollBase(props) {
1051
930
  var removeObserverOnScroll = (0, _react.useCallback)(function (fn) {
1052
931
  var observerOnScroll = mutableRef.current.observerOnScroll;
1053
932
  var index = observerOnScroll.indexOf(fn);
1054
-
1055
933
  if (index !== -1) {
1056
934
  observerOnScroll.splice(index, 1);
1057
935
  }
1058
936
  }, []);
1059
-
1060
937
  function forwardScrollEvent(type, reachedEdgeInfo) {
1061
938
  var data = {
1062
939
  scrollLeft: mutableRef.current.scrollLeft,
@@ -1065,79 +942,69 @@ var useScrollBase = function useScrollBase(props) {
1065
942
  reachedEdgeInfo: reachedEdgeInfo
1066
943
  };
1067
944
  (0, _handle.forward)(type, data, props);
1068
-
1069
945
  if (type === 'onScroll') {
1070
946
  mutableRef.current.observerOnScroll.forEach(function (fn) {
1071
947
  return fn(data);
1072
948
  });
1073
949
  }
1074
- } // scrollMode 'native' [[
1075
- // call scroll callbacks and update scrollbars for native scroll
950
+ }
1076
951
 
952
+ // scrollMode 'native' [[
953
+ // call scroll callbacks and update scrollbars for native scroll
1077
954
 
1078
955
  function scrollStartOnScroll() {
1079
956
  mutableRef.current.scrolling = true;
1080
957
  showScrollbarTrack(getScrollBounds());
1081
958
  forwardScrollEvent('onScrollStart');
1082
959
  }
1083
-
1084
960
  function scrollStopOnScroll() {
1085
961
  if (props.scrollStopOnScroll) {
1086
962
  props.scrollStopOnScroll();
1087
963
  }
1088
-
1089
964
  if (mutableRef.current.overscrollEnabled && !mutableRef.current.isDragging) {
1090
965
  // not check overscrollEffectOn && overscrollEffectOn for safety
1091
966
  clearAllOverscrollEffects();
1092
967
  }
1093
-
1094
968
  mutableRef.current.lastInputType = null;
1095
969
  mutableRef.current.isScrollAnimationTargetAccumulated = false;
1096
970
  mutableRef.current.scrolling = false;
1097
971
  forwardScrollEvent('onScrollStop', getReachedEdgeInfo());
1098
972
  startHidingScrollbarTrack();
1099
- } // scrollMode 'native' ]]
1100
- // update scroll position
973
+ }
974
+ // scrollMode 'native' ]]
1101
975
 
976
+ // update scroll position
1102
977
 
1103
978
  function setScrollLeft(value) {
1104
979
  var bounds = getScrollBounds();
1105
980
  mutableRef.current.scrollLeft = (0, _clamp["default"])(0, bounds.maxLeft, value);
1106
-
1107
981
  if (mutableRef.current.overscrollEnabled && overscrollEffectOn && overscrollEffectOn[mutableRef.current.lastInputType]) {
1108
982
  checkAndApplyOverscrollEffectOnScroll('horizontal');
1109
983
  }
1110
-
1111
984
  if (isHorizontalScrollbarVisible) {
1112
985
  updateScrollbarTrack(horizontalScrollbarHandle, bounds);
1113
986
  }
1114
987
  }
1115
-
1116
988
  function setScrollTop(value) {
1117
989
  var bounds = getScrollBounds();
1118
990
  mutableRef.current.scrollTop = (0, _clamp["default"])(0, bounds.maxTop, value);
1119
-
1120
991
  if (mutableRef.current.overscrollEnabled && overscrollEffectOn && overscrollEffectOn[mutableRef.current.lastInputType]) {
1121
992
  checkAndApplyOverscrollEffectOnScroll('vertical');
1122
993
  }
1123
-
1124
994
  if (isVerticalScrollbarVisible) {
1125
995
  updateScrollbarTrack(verticalScrollbarHandle, bounds);
1126
996
  }
1127
997
  }
1128
-
1129
998
  function getReachedEdgeInfo() {
1130
999
  var bounds = getScrollBounds(),
1131
- reachedEdgeInfo = {
1132
- bottom: false,
1133
- left: false,
1134
- right: false,
1135
- top: false
1136
- };
1137
-
1000
+ reachedEdgeInfo = {
1001
+ bottom: false,
1002
+ left: false,
1003
+ right: false,
1004
+ top: false
1005
+ };
1138
1006
  if (canScrollHorizontally(bounds)) {
1139
1007
  var edge = getEdgeFromPosition(mutableRef.current.scrollLeft, bounds.maxLeft);
1140
-
1141
1008
  if (edge) {
1142
1009
  // if edge is null, no need to check which edge is reached.
1143
1010
  if (edge === 'before' && !rtl || edge === 'after' && rtl) {
@@ -1147,43 +1014,41 @@ var useScrollBase = function useScrollBase(props) {
1147
1014
  }
1148
1015
  }
1149
1016
  }
1150
-
1151
1017
  if (canScrollVertically(bounds)) {
1152
1018
  var _edge = getEdgeFromPosition(mutableRef.current.scrollTop, bounds.maxTop);
1153
-
1154
1019
  if (_edge === 'before') {
1155
1020
  reachedEdgeInfo.top = true;
1156
1021
  } else if (_edge === 'after') {
1157
1022
  reachedEdgeInfo.bottom = true;
1158
1023
  }
1159
1024
  }
1160
-
1161
1025
  return reachedEdgeInfo;
1162
- } // scroll start/stop
1163
- // scrollMode 'translate' [[
1026
+ }
1164
1027
 
1028
+ // scroll start/stop
1165
1029
 
1030
+ // scrollMode 'translate' [[
1166
1031
  function doScrollStop() {
1167
1032
  mutableRef.current.scrolling = false;
1168
1033
  forwardScrollEvent('onScrollStop', getReachedEdgeInfo());
1169
- } // scrollMode 'translate' ]]
1170
-
1034
+ }
1035
+ // scrollMode 'translate' ]]
1171
1036
 
1172
1037
  function start(_ref2) {
1173
1038
  var targetX = _ref2.targetX,
1174
- targetY = _ref2.targetY,
1175
- _ref2$animate = _ref2.animate,
1176
- animate = _ref2$animate === void 0 ? true : _ref2$animate,
1177
- _ref2$duration = _ref2.duration,
1178
- duration = _ref2$duration === void 0 ? animationDuration : _ref2$duration,
1179
- _ref2$overscrollEffec = _ref2.overscrollEffect,
1180
- overscrollEffect = _ref2$overscrollEffec === void 0 ? false : _ref2$overscrollEffec;
1039
+ targetY = _ref2.targetY,
1040
+ _ref2$animate = _ref2.animate,
1041
+ animate = _ref2$animate === void 0 ? true : _ref2$animate,
1042
+ _ref2$duration = _ref2.duration,
1043
+ duration = _ref2$duration === void 0 ? animationDuration : _ref2$duration,
1044
+ _ref2$overscrollEffec = _ref2.overscrollEffect,
1045
+ overscrollEffect = _ref2$overscrollEffec === void 0 ? false : _ref2$overscrollEffec;
1181
1046
  var _mutableRef$current3 = mutableRef.current,
1182
- scrollLeft = _mutableRef$current3.scrollLeft,
1183
- scrollTop = _mutableRef$current3.scrollTop,
1184
- bounds = getScrollBounds(),
1185
- maxLeft = bounds.maxLeft,
1186
- maxTop = bounds.maxTop;
1047
+ scrollLeft = _mutableRef$current3.scrollLeft,
1048
+ scrollTop = _mutableRef$current3.scrollTop,
1049
+ bounds = getScrollBounds(),
1050
+ maxLeft = bounds.maxLeft,
1051
+ maxTop = bounds.maxTop;
1187
1052
  var updatedAnimationInfo = scrollMode === 'translate' ? {
1188
1053
  sourceX: scrollLeft,
1189
1054
  sourceY: scrollTop,
@@ -1193,50 +1058,40 @@ var useScrollBase = function useScrollBase(props) {
1193
1058
  } : {
1194
1059
  targetX: targetX,
1195
1060
  targetY: targetY
1196
- }; // bail early when scrolling to the same position
1061
+ };
1197
1062
 
1063
+ // bail early when scrolling to the same position
1198
1064
  if ((scrollMode === 'translate' && mutableRef.current.animator.isAnimating() || scrollMode === 'native' && mutableRef.current.scrolling) && mutableRef.current.animationInfo && mutableRef.current.animationInfo.targetX === targetX && mutableRef.current.animationInfo.targetY === targetY) {
1199
1065
  return;
1200
1066
  }
1201
-
1202
1067
  mutableRef.current.animationInfo = updatedAnimationInfo;
1203
-
1204
1068
  if (scrollMode === 'translate') {
1205
1069
  mutableRef.current.animator.stop();
1206
-
1207
1070
  if (!mutableRef.current.scrolling) {
1208
1071
  mutableRef.current.scrolling = true;
1209
1072
  forwardScrollEvent('onScrollStart');
1210
1073
  }
1211
-
1212
1074
  mutableRef.current.scrollStopJob.stop();
1213
1075
  }
1214
-
1215
1076
  if (Math.abs(maxLeft - targetX) < epsilon) {
1216
1077
  targetX = maxLeft;
1217
1078
  }
1218
-
1219
1079
  if (Math.abs(maxTop - targetY) < epsilon) {
1220
1080
  targetY = maxTop;
1221
1081
  }
1222
-
1223
1082
  if (mutableRef.current.overscrollEnabled && overscrollEffect) {
1224
1083
  if (scrollLeft !== targetX && canScrollHorizontally(bounds)) {
1225
1084
  checkAndApplyOverscrollEffectOnStart('horizontal', getEdgeFromPosition(targetX, maxLeft), targetX);
1226
1085
  }
1227
-
1228
1086
  if (scrollTop !== targetY && canScrollVertically(bounds)) {
1229
1087
  checkAndApplyOverscrollEffectOnStart('vertical', getEdgeFromPosition(targetY, maxTop), targetY);
1230
1088
  }
1231
1089
  }
1232
-
1233
1090
  if (scrollMode === 'translate') {
1234
1091
  showScrollbarTrack(bounds);
1235
-
1236
1092
  if (scrollContentHandle.current && scrollContentHandle.current.setScrollPositionTarget) {
1237
1093
  scrollContentHandle.current.setScrollPositionTarget(targetX, targetY);
1238
1094
  }
1239
-
1240
1095
  if (animate) {
1241
1096
  mutableRef.current.animator.animate(scrollAnimation(mutableRef.current.animationInfo));
1242
1097
  } else {
@@ -1250,50 +1105,42 @@ var useScrollBase = function useScrollBase(props) {
1250
1105
  } else {
1251
1106
  scrollContentHandle.current.scrollToPosition(targetX, targetY, 'instant');
1252
1107
  }
1253
-
1254
1108
  if (props.start) {
1255
1109
  props.start(animate);
1256
1110
  }
1257
1111
  }
1258
- } // scrollMode 'translate' [[
1259
-
1112
+ }
1260
1113
 
1114
+ // scrollMode 'translate' [[
1261
1115
  function scrollAnimation(animationInfo) {
1262
1116
  return function (curTime) {
1263
1117
  var sourceX = animationInfo.sourceX,
1264
- sourceY = animationInfo.sourceY,
1265
- targetX = animationInfo.targetX,
1266
- targetY = animationInfo.targetY,
1267
- duration = animationInfo.duration,
1268
- bounds = getScrollBounds();
1269
-
1118
+ sourceY = animationInfo.sourceY,
1119
+ targetX = animationInfo.targetX,
1120
+ targetY = animationInfo.targetY,
1121
+ duration = animationInfo.duration,
1122
+ bounds = getScrollBounds();
1270
1123
  if (curTime < duration) {
1271
1124
  var toBeContinued = false,
1272
- curTargetX = sourceX,
1273
- curTargetY = sourceY;
1274
-
1125
+ curTargetX = sourceX,
1126
+ curTargetY = sourceY;
1275
1127
  if (canScrollHorizontally(bounds)) {
1276
1128
  curTargetX = mutableRef.current.animator.timingFunction(sourceX, targetX, duration, curTime);
1277
-
1278
1129
  if (Math.abs(curTargetX - targetX) < epsilon) {
1279
1130
  curTargetX = targetX;
1280
1131
  } else {
1281
1132
  toBeContinued = true;
1282
1133
  }
1283
1134
  }
1284
-
1285
1135
  if (canScrollVertically(bounds)) {
1286
1136
  curTargetY = mutableRef.current.animator.timingFunction(sourceY, targetY, duration, curTime);
1287
-
1288
1137
  if (Math.abs(curTargetY - targetY) < epsilon) {
1289
1138
  curTargetY = targetY;
1290
1139
  } else {
1291
1140
  toBeContinued = true;
1292
1141
  }
1293
1142
  }
1294
-
1295
1143
  scroll(curTargetX, curTargetY);
1296
-
1297
1144
  if (!toBeContinued) {
1298
1145
  stop();
1299
1146
  }
@@ -1303,62 +1150,54 @@ var useScrollBase = function useScrollBase(props) {
1303
1150
  }
1304
1151
  };
1305
1152
  }
1306
-
1307
1153
  function scroll(left, top) {
1308
1154
  if (left !== mutableRef.current.scrollLeft) {
1309
1155
  setScrollLeft(left);
1310
1156
  }
1311
-
1312
1157
  if (top !== mutableRef.current.scrollTop) {
1313
1158
  setScrollTop(top);
1314
1159
  }
1315
-
1316
1160
  scrollContentHandle.current.setScrollPosition(mutableRef.current.scrollLeft, mutableRef.current.scrollTop);
1317
1161
  forwardScrollEvent('onScroll');
1318
- } // scrollMode 'translate' ]]
1319
-
1162
+ }
1163
+ // scrollMode 'translate' ]]
1320
1164
 
1321
1165
  function stopForTranslate() {
1322
1166
  mutableRef.current.animator.stop();
1323
1167
  mutableRef.current.lastInputType = null;
1324
1168
  mutableRef.current.isScrollAnimationTargetAccumulated = false;
1325
1169
  startHidingScrollbarTrack();
1326
-
1327
1170
  if (mutableRef.current.overscrollEnabled && !mutableRef.current.isDragging) {
1328
1171
  // not check overscrollEffectOn && overscrollEffectOn for safety
1329
1172
  clearAllOverscrollEffects();
1330
1173
  }
1331
-
1332
1174
  if (props.stop) {
1333
1175
  props.stop();
1334
1176
  }
1335
-
1336
1177
  if (mutableRef.current.scrolling) {
1337
1178
  mutableRef.current.scrollStopJob.start();
1338
1179
  }
1339
1180
  }
1340
-
1341
1181
  function stopForNative() {
1342
1182
  scrollContentHandle.current.scrollToPosition(mutableRef.current.scrollLeft + (rtl ? -0.1 : 0.1), mutableRef.current.scrollTop + 0.1, 'instant');
1343
1183
  }
1344
-
1345
1184
  function stop() {
1346
1185
  if (scrollMode === 'translate') {
1347
1186
  stopForTranslate();
1348
1187
  } else {
1349
1188
  stopForNative();
1350
1189
  }
1351
- } // scrollTo API
1190
+ }
1352
1191
 
1192
+ // scrollTo API
1353
1193
 
1354
1194
  function getPositionForScrollTo(opt) {
1355
1195
  var bounds = getScrollBounds(),
1356
- canScrollH = canScrollHorizontally(bounds),
1357
- canScrollV = canScrollVertically(bounds);
1196
+ canScrollH = canScrollHorizontally(bounds),
1197
+ canScrollV = canScrollVertically(bounds);
1358
1198
  var itemPos,
1359
- left = null,
1360
- top = null;
1361
-
1199
+ left = null,
1200
+ top = null;
1362
1201
  if (opt instanceof Object) {
1363
1202
  if (opt.position instanceof Object) {
1364
1203
  if (canScrollH) {
@@ -1367,7 +1206,6 @@ var useScrollBase = function useScrollBase(props) {
1367
1206
  } else {
1368
1207
  left = 0;
1369
1208
  }
1370
-
1371
1209
  if (canScrollV) {
1372
1210
  // We need '!=' to check if opt.position.y is null or undefined
1373
1211
  top = opt.position.y != null ? opt.position.y : mutableRef.current.scrollTop;
@@ -1382,7 +1220,6 @@ var useScrollBase = function useScrollBase(props) {
1382
1220
  left = bounds.maxLeft;
1383
1221
  }
1384
1222
  }
1385
-
1386
1223
  if (canScrollV) {
1387
1224
  if (opt.align.includes('top')) {
1388
1225
  top = 0;
@@ -1398,44 +1235,35 @@ var useScrollBase = function useScrollBase(props) {
1398
1235
  itemPos = scrollContentHandle.current.getNodePosition(opt.node);
1399
1236
  }
1400
1237
  }
1401
-
1402
1238
  if (itemPos) {
1403
1239
  if (canScrollH) {
1404
1240
  left = itemPos.left;
1405
1241
  }
1406
-
1407
1242
  if (canScrollV) {
1408
1243
  top = itemPos.top;
1409
1244
  }
1410
1245
  }
1411
1246
  }
1412
1247
  }
1413
-
1414
1248
  return {
1415
1249
  left: left,
1416
1250
  top: top
1417
1251
  };
1418
1252
  }
1419
-
1420
1253
  function scrollTo(opt) {
1421
1254
  if (!mutableRef.current.deferScrollTo) {
1422
1255
  var _getPositionForScroll = getPositionForScrollTo(opt),
1423
- left = _getPositionForScroll.left,
1424
- top = _getPositionForScroll.top;
1425
-
1256
+ left = _getPositionForScroll.left,
1257
+ top = _getPositionForScroll.top;
1426
1258
  var targetX = left !== null ? left : mutableRef.current.scrollLeft;
1427
1259
  var targetY = top !== null ? top : mutableRef.current.scrollTop;
1428
-
1429
1260
  if (props.scrollTo) {
1430
1261
  props.scrollTo(opt);
1431
1262
  }
1432
-
1433
1263
  mutableRef.current.scrollToInfo = null;
1434
-
1435
1264
  if (scrollMode === 'native' && scrollContentHandle.current && scrollContentHandle.current.setScrollToPositionTarget) {
1436
1265
  scrollContentHandle.current.setScrollToPositionTarget(targetX, targetY);
1437
1266
  }
1438
-
1439
1267
  start({
1440
1268
  targetX: targetX,
1441
1269
  targetY: targetY,
@@ -1445,52 +1273,46 @@ var useScrollBase = function useScrollBase(props) {
1445
1273
  mutableRef.current.scrollToInfo = opt;
1446
1274
  }
1447
1275
  }
1448
-
1449
1276
  function canScrollHorizontally(bounds) {
1450
1277
  return (direction === 'horizontal' || direction === 'both') && bounds.scrollWidth > bounds.clientWidth && !isNaN(bounds.scrollWidth);
1451
1278
  }
1452
-
1453
1279
  function canScrollVertically(bounds) {
1454
1280
  return (direction === 'vertical' || direction === 'both') && bounds.scrollHeight > bounds.clientHeight && !isNaN(bounds.scrollHeight);
1455
- } // scroll bar
1281
+ }
1456
1282
 
1283
+ // scroll bar
1457
1284
 
1458
1285
  function showScrollbarTrack(bounds) {
1459
1286
  if (isHorizontalScrollbarVisible && canScrollHorizontally(bounds) && horizontalScrollbarHandle.current) {
1460
1287
  horizontalScrollbarHandle.current.showScrollbarTrack();
1461
1288
  }
1462
-
1463
1289
  if (isVerticalScrollbarVisible && canScrollVertically(bounds) && verticalScrollbarHandle.current) {
1464
1290
  verticalScrollbarHandle.current.showScrollbarTrack();
1465
1291
  }
1466
1292
  }
1467
-
1468
1293
  function updateScrollbarTrack(scrollbarRef, bounds) {
1469
1294
  scrollbarRef.current.update(_objectSpread(_objectSpread({}, bounds), {}, {
1470
1295
  scrollLeft: mutableRef.current.scrollLeft,
1471
1296
  scrollTop: mutableRef.current.scrollTop
1472
1297
  }));
1473
1298
  }
1474
-
1475
1299
  function startHidingScrollbarTrack() {
1476
1300
  if (isHorizontalScrollbarVisible && horizontalScrollbarHandle.current) {
1477
1301
  horizontalScrollbarHandle.current.startHidingScrollbarTrack();
1478
1302
  }
1479
-
1480
1303
  if (isVerticalScrollbarVisible && verticalScrollbarHandle.current) {
1481
1304
  verticalScrollbarHandle.current.startHidingScrollbarTrack();
1482
1305
  }
1483
1306
  }
1484
-
1485
1307
  function updateScrollbars() {
1486
1308
  var bounds = getScrollBounds(),
1487
- canScrollH = canScrollHorizontally(bounds),
1488
- canScrollV = canScrollVertically(bounds),
1489
- curHorizontalScrollbarVisible = horizontalScrollbar === 'auto' ? canScrollH : horizontalScrollbar === 'visible',
1490
- curVerticalScrollbarVisible = verticalScrollbar === 'auto' ? canScrollV : verticalScrollbar === 'visible'; // determine if we should hide or show any scrollbars
1309
+ canScrollH = canScrollHorizontally(bounds),
1310
+ canScrollV = canScrollVertically(bounds),
1311
+ curHorizontalScrollbarVisible = horizontalScrollbar === 'auto' ? canScrollH : horizontalScrollbar === 'visible',
1312
+ curVerticalScrollbarVisible = verticalScrollbar === 'auto' ? canScrollV : verticalScrollbar === 'visible';
1491
1313
 
1314
+ // determine if we should hide or show any scrollbars
1492
1315
  var isVisibilityChanged = isHorizontalScrollbarVisible !== curHorizontalScrollbarVisible || isVerticalScrollbarVisible !== curVerticalScrollbarVisible;
1493
-
1494
1316
  if (isVisibilityChanged) {
1495
1317
  // one or both scrollbars have changed visibility
1496
1318
  setIsHorizontalScrollbarVisible(curHorizontalScrollbarVisible);
@@ -1500,14 +1322,12 @@ var useScrollBase = function useScrollBase(props) {
1500
1322
  updateScrollbarTrackSize();
1501
1323
  }
1502
1324
  }
1503
-
1504
1325
  function updateScrollbarTrackSize() {
1505
1326
  var bounds = getScrollBounds(),
1506
- canScrollH = canScrollHorizontally(bounds),
1507
- canScrollV = canScrollVertically(bounds),
1508
- curHorizontalScrollbarVisible = horizontalScrollbar === 'auto' ? canScrollH : horizontalScrollbar === 'visible',
1509
- curVerticalScrollbarVisible = verticalScrollbar === 'auto' ? canScrollV : verticalScrollbar === 'visible';
1510
-
1327
+ canScrollH = canScrollHorizontally(bounds),
1328
+ canScrollV = canScrollVertically(bounds),
1329
+ curHorizontalScrollbarVisible = horizontalScrollbar === 'auto' ? canScrollH : horizontalScrollbar === 'visible',
1330
+ curVerticalScrollbarVisible = verticalScrollbar === 'auto' ? canScrollV : verticalScrollbar === 'visible';
1511
1331
  if (curHorizontalScrollbarVisible || curVerticalScrollbarVisible) {
1512
1332
  // no visibility change but need to notify whichever scrollbars are visible of the
1513
1333
  // updated bounds and scroll position
@@ -1515,75 +1335,73 @@ var useScrollBase = function useScrollBase(props) {
1515
1335
  scrollLeft: mutableRef.current.scrollLeft,
1516
1336
  scrollTop: mutableRef.current.scrollTop
1517
1337
  });
1518
-
1519
1338
  if (curHorizontalScrollbarVisible && horizontalScrollbarHandle.current) {
1520
1339
  horizontalScrollbarHandle.current.update(updatedBounds);
1521
1340
  }
1522
-
1523
1341
  if (curVerticalScrollbarVisible && verticalScrollbarHandle.current) {
1524
1342
  verticalScrollbarHandle.current.update(updatedBounds);
1525
1343
  }
1526
-
1527
1344
  return true;
1528
1345
  }
1529
-
1530
1346
  return false;
1531
- } // ref
1347
+ }
1532
1348
 
1349
+ // ref
1533
1350
 
1534
1351
  function getScrollBounds() {
1535
1352
  if (scrollContentHandle.current && typeof scrollContentHandle.current.getScrollBounds === 'function') {
1536
1353
  return scrollContentHandle.current.getScrollBounds();
1537
1354
  }
1538
1355
  }
1539
-
1540
1356
  function getMoreInfo() {
1541
1357
  if (scrollContentHandle.current && typeof scrollContentHandle.current.getMoreInfo === 'function') {
1542
1358
  return scrollContentHandle.current.getMoreInfo();
1543
1359
  }
1544
- } // FIXME setting event handlers directly to work on the V8 snapshot.
1545
-
1360
+ }
1546
1361
 
1362
+ // FIXME setting event handlers directly to work on the V8 snapshot.
1547
1363
  function addEventListeners() {
1548
1364
  (0, _utilEvent["default"])('wheel').addEventListener(scrollContainerRef, onWheel);
1549
1365
  (0, _utilEvent["default"])('keydown').addEventListener(scrollContainerRef, onKeyDown);
1550
- (0, _utilEvent["default"])('mousedown').addEventListener(scrollContainerRef, onMouseDown); // scrollMode 'native' [[
1366
+ (0, _utilEvent["default"])('mousedown').addEventListener(scrollContainerRef, onMouseDown);
1551
1367
 
1368
+ // scrollMode 'native' [[
1552
1369
  if (scrollMode === 'native' && scrollContentRef.current) {
1553
1370
  (0, _utilEvent["default"])('scroll').addEventListener(scrollContentRef, onScroll, {
1554
1371
  passive: true
1555
1372
  });
1556
- } // scrollMode 'native' ]]
1557
-
1373
+ }
1374
+ // scrollMode 'native' ]]
1558
1375
 
1559
1376
  if (props.addEventListeners) {
1560
1377
  props.addEventListeners(scrollContentRef);
1561
1378
  }
1562
-
1563
1379
  if (window) {
1564
1380
  (0, _utilEvent["default"])('resize').addEventListener(window, handleResizeWindow);
1565
1381
  }
1566
- } // FIXME setting event handlers directly to work on the V8 snapshot.
1567
-
1382
+ }
1568
1383
 
1384
+ // FIXME setting event handlers directly to work on the V8 snapshot.
1569
1385
  function removeEventListeners() {
1570
1386
  (0, _utilEvent["default"])('wheel').removeEventListener(scrollContainerRef, onWheel);
1571
1387
  (0, _utilEvent["default"])('keydown').removeEventListener(scrollContainerRef, onKeyDown);
1572
- (0, _utilEvent["default"])('mousedown').removeEventListener(scrollContainerRef, onMouseDown); // scrollMode 'native' [[
1388
+ (0, _utilEvent["default"])('mousedown').removeEventListener(scrollContainerRef, onMouseDown);
1573
1389
 
1390
+ // scrollMode 'native' [[
1574
1391
  (0, _utilEvent["default"])('scroll').removeEventListener(scrollContentRef, onScroll, {
1575
1392
  passive: true
1576
- }); // scrollMode 'native' ]]
1393
+ });
1394
+ // scrollMode 'native' ]]
1577
1395
 
1578
1396
  if (props.removeEventListeners) {
1579
1397
  props.removeEventListeners(scrollContentRef);
1580
1398
  }
1581
-
1582
1399
  (0, _utilEvent["default"])('resize').removeEventListener(window, handleResizeWindow);
1583
- } // render
1584
- // scrollMode 'translate' [[
1400
+ }
1585
1401
 
1402
+ // render
1586
1403
 
1404
+ // scrollMode 'translate' [[
1587
1405
  function handleScroll() {
1588
1406
  // Prevent scroll by focus.
1589
1407
  // VirtualList and VirtualGridList DO NOT receive `onscroll` event.
@@ -1593,13 +1411,12 @@ var useScrollBase = function useScrollBase(props) {
1593
1411
  scrollContentRef.current.scrollTop = mutableRef.current.scrollTop;
1594
1412
  scrollContentRef.current.scrollLeft = scrollContentHandle.current.getRtlPositionX(mutableRef.current.scrollLeft);
1595
1413
  }
1596
- } // scrollMode 'translate' ]]
1597
-
1414
+ }
1415
+ // scrollMode 'translate' ]]
1598
1416
 
1599
1417
  function scrollContainerContainsDangerously(target) {
1600
1418
  return _utilDOM["default"].containsDangerously(scrollContainerRef, target);
1601
1419
  }
1602
-
1603
1420
  assignProperties('scrollContainerProps', _objectSpread(_objectSpread({}, rest), {}, {
1604
1421
  className: [scrollClasses]
1605
1422
  }));
@@ -1615,9 +1432,10 @@ var useScrollBase = function useScrollBase(props) {
1615
1432
  onDragStart: onDragStart,
1616
1433
  onFlick: onFlick,
1617
1434
  onTouchStart: scrollMode === 'native' ? onTouchStart : null // scrollMode 'native'
1618
-
1619
1435
  }));
1620
- var scrollContentProps = props.itemRenderer ? // If the child component is a VirtualList
1436
+
1437
+ var scrollContentProps = props.itemRenderer ?
1438
+ // If the child component is a VirtualList
1621
1439
  {
1622
1440
  childProps: childProps,
1623
1441
  clientSize: clientSize,
@@ -1636,15 +1454,12 @@ var useScrollBase = function useScrollBase(props) {
1636
1454
  cbScrollTo: scrollTo,
1637
1455
  className: [_useScrollModule["default"].scrollFill],
1638
1456
  direction: direction,
1639
-
1640
1457
  get isHorizontalScrollbarVisible() {
1641
1458
  return isHorizontalScrollbarVisible;
1642
1459
  },
1643
-
1644
1460
  get isVerticalScrollbarVisible() {
1645
1461
  return isVerticalScrollbarVisible;
1646
1462
  },
1647
-
1648
1463
  onScroll: scrollMode === 'translate' ? handleScroll : null,
1649
1464
  role: role,
1650
1465
  rtl: rtl,
@@ -1682,56 +1497,53 @@ var useScrollBase = function useScrollBase(props) {
1682
1497
  }
1683
1498
  };
1684
1499
  };
1685
-
1686
1500
  exports.useScrollBase = useScrollBase;
1687
-
1688
1501
  var assignPropertiesOf = function assignPropertiesOf(instance) {
1689
1502
  return function (name, properties) {
1690
1503
  if (!instance[name]) {
1691
1504
  instance[name] = {};
1692
1505
  }
1693
-
1694
1506
  if (typeof properties === 'object') {
1695
1507
  for (var property in properties) {
1696
1508
  if (property === 'className') {
1697
1509
  process.env.NODE_ENV !== "production" ? (0, _warning["default"])(Array.isArray(properties.className), 'Unsupported other types for `className` prop except Array') : void 0;
1698
1510
  instance[name].className = (0, _classnames["default"])(instance[name].className, properties.className);
1699
1511
  } else {
1700
- process.env.NODE_ENV !== "production" ? (0, _warning["default"])(!instance[name][property], 'Unsupported to push value in the same ' + property + ' prop.') : void 0; // Override the previous value.
1512
+ process.env.NODE_ENV !== "production" ? (0, _warning["default"])(!instance[name][property], 'Unsupported to push value in the same ' + property + ' prop.') : void 0;
1701
1513
 
1514
+ // Override the previous value.
1702
1515
  instance[name][property] = properties[property];
1703
1516
  }
1704
1517
  }
1705
1518
  }
1706
1519
  };
1707
1520
  };
1708
-
1709
1521
  exports.assignPropertiesOf = assignPropertiesOf;
1710
-
1711
1522
  var useScroll = function useScroll(props) {
1712
1523
  // Mutable value
1524
+
1713
1525
  var scrollContainerRef = (0, _react.useRef)({});
1714
1526
  var scrollContentHandle = (0, _react.useRef)({});
1715
1527
  var scrollContentRef = (0, _react.useRef)({});
1716
1528
  var itemRefs = (0, _react.useRef)([]);
1717
1529
  var horizontalScrollbarHandle = (0, _react.useRef)({});
1718
- var verticalScrollbarHandle = (0, _react.useRef)({}); // Hooks
1530
+ var verticalScrollbarHandle = (0, _react.useRef)({});
1719
1531
 
1720
- var collectionOfProperties = {},
1721
- assignProperties = assignPropertiesOf(collectionOfProperties);
1532
+ // Hooks
1722
1533
 
1534
+ var collectionOfProperties = {},
1535
+ assignProperties = assignPropertiesOf(collectionOfProperties);
1723
1536
  var _useScrollBase = useScrollBase(_objectSpread(_objectSpread({}, props), {}, {
1724
- assignProperties: assignProperties,
1725
- horizontalScrollbarHandle: horizontalScrollbarHandle,
1726
- scrollContainerRef: scrollContainerRef,
1727
- scrollContentHandle: scrollContentHandle,
1728
- scrollContentRef: scrollContentRef,
1729
- verticalScrollbarHandle: verticalScrollbarHandle
1730
- })),
1731
- scrollContentWrapper = _useScrollBase.scrollContentWrapper,
1732
- isHorizontalScrollbarVisible = _useScrollBase.isHorizontalScrollbarVisible,
1733
- isVerticalScrollbarVisible = _useScrollBase.isVerticalScrollbarVisible;
1734
-
1537
+ assignProperties: assignProperties,
1538
+ horizontalScrollbarHandle: horizontalScrollbarHandle,
1539
+ scrollContainerRef: scrollContainerRef,
1540
+ scrollContentHandle: scrollContentHandle,
1541
+ scrollContentRef: scrollContentRef,
1542
+ verticalScrollbarHandle: verticalScrollbarHandle
1543
+ })),
1544
+ scrollContentWrapper = _useScrollBase.scrollContentWrapper,
1545
+ isHorizontalScrollbarVisible = _useScrollBase.isHorizontalScrollbarVisible,
1546
+ isVerticalScrollbarVisible = _useScrollBase.isVerticalScrollbarVisible;
1735
1547
  assignProperties('scrollContainerProps', {
1736
1548
  ref: scrollContainerRef
1737
1549
  });
@@ -1745,7 +1557,9 @@ var useScroll = function useScroll(props) {
1745
1557
  });
1746
1558
  assignProperties('horizontalScrollbarProps', {
1747
1559
  scrollbarHandle: horizontalScrollbarHandle
1748
- }); // Return
1560
+ });
1561
+
1562
+ // Return
1749
1563
 
1750
1564
  return _objectSpread(_objectSpread({}, collectionOfProperties), {}, {
1751
1565
  scrollContentWrapper: scrollContentWrapper,
@@ -1754,7 +1568,6 @@ var useScroll = function useScroll(props) {
1754
1568
  isVerticalScrollbarVisible: isVerticalScrollbarVisible
1755
1569
  });
1756
1570
  };
1757
-
1758
1571
  exports.useScroll = useScroll;
1759
1572
  var _default = useScroll;
1760
1573
  exports["default"] = _default;