@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.
- package/AnnounceDecorator/Announce.js +1 -40
- package/AnnounceDecorator/AnnounceDecorator.js +3 -21
- package/AnnounceDecorator/tests/Announce-specs.js +2 -7
- package/AnnounceDecorator/tests/AnnounceDecorator-specs.js +2 -6
- package/AnnounceDecorator/tests/useAnnounce-specs.js +8 -19
- package/AnnounceDecorator/useAnnounce.js +0 -6
- package/BodyText/BodyText.js +6 -26
- package/BodyText/tests/BodyText-specs.js +0 -19
- package/Button/Button.js +26 -56
- package/Button/tests/Button-specs.js +0 -26
- package/CHANGELOG.md +4 -0
- package/Cancelable/Cancelable.js +8 -47
- package/Cancelable/cancelHandler.js +5 -12
- package/Cancelable/modalHandler.js +3 -11
- package/Cancelable/tests/Cancelable-specs.js +3 -57
- package/Changeable/Changeable.js +2 -34
- package/Changeable/tests/Changeable-specs.js +20 -66
- package/ComponentOverride/ComponentOverride.js +1 -13
- package/FloatingLayer/FloatingLayer.js +17 -73
- package/FloatingLayer/FloatingLayerContainer.js +0 -15
- package/FloatingLayer/FloatingLayerDecorator.js +4 -17
- package/FloatingLayer/Scrim.js +9 -53
- package/FloatingLayer/index.js +0 -4
- package/FloatingLayer/tests/FloatingLayer-specs.js +8 -22
- package/FloatingLayer/tests/Scrim-specs.js +0 -9
- package/FloatingLayer/tests/useFloatingLayerDecorator-specs.js +0 -13
- package/FloatingLayer/useFloatingLayer.js +3 -14
- package/FloatingLayer/useFloatingLayerDecorator.js +3 -11
- package/ForwardRef/ForwardRef.js +1 -10
- package/GridListImageItem/GridListImageItem.js +17 -50
- package/Group/Group.js +4 -35
- package/Group/GroupItem.js +15 -32
- package/Group/tests/Group-specs.js +0 -32
- package/Heading/Heading.js +7 -35
- package/Heading/tests/Heading-specs.js +81 -14
- package/Icon/Icon.js +14 -48
- package/Icon/tests/Icon-specs.js +0 -22
- package/IconButton/IconButton.js +12 -50
- package/IconButton/tests/IconButton-specs.js +0 -7
- package/Image/Image.js +16 -45
- package/Image/tests/Image-specs.js +0 -14
- package/ImageItem/ImageItem.js +17 -46
- package/ImageItem/tests/ImageItem-specs.js +0 -25
- package/Item/Item.js +8 -32
- package/Item/tests/Item-specs.js +0 -24
- package/LabeledIcon/LabeledIcon.js +19 -50
- package/LabeledIcon/tests/LabeledIcon-specs.js +0 -14
- package/Layout/Cell.js +11 -37
- package/Layout/Layout.js +14 -37
- package/Layout/tests/Layout-specs.js +10 -39
- package/Marquee/MarqueeBase.js +29 -63
- package/Marquee/MarqueeController.js +11 -72
- package/Marquee/MarqueeDecorator.js +62 -196
- package/Marquee/index.js +1 -5
- package/Marquee/tests/Marquee-specs.js +258 -87
- package/Measurable/Measurable.js +12 -34
- package/Measurable/tests/Measurable-specs.js +115 -0
- package/Media/Media.js +15 -65
- package/Media/tests/Media-specs.js +168 -0
- package/Placeholder/PlaceholderControllerDecorator.js +7 -43
- package/Placeholder/PlaceholderDecorator.js +7 -38
- package/Placeholder/index.js +0 -4
- package/Placeholder/tests/PlaceholderControllerDecorator-specs.js +25 -0
- package/Placeholder/tests/PlaceholderDecorator-specs.js +28 -0
- package/ProgressBar/ProgressBar.js +13 -44
- package/ProgressBar/tests/ProgressBar-specs.js +0 -17
- package/RadioDecorator/RadioControllerDecorator.js +1 -29
- package/RadioDecorator/RadioDecorator.js +4 -42
- package/RadioDecorator/tests/RadioDecorator-specs.js +12 -49
- package/Repeater/Repeater.js +9 -33
- package/Repeater/tests/Repeater-specs.js +0 -38
- package/Resizable/Resizable.js +7 -35
- package/Resizable/tests/Resizable-specs.js +34 -0
- package/Routable/Link.js +8 -44
- package/Routable/Routable.js +10 -33
- package/Routable/Route.js +0 -6
- package/Routable/Router.js +13 -56
- package/Routable/tests/Routable-specs.js +7 -33
- package/Routable/tests/Router-specs.js +18 -44
- package/Routable/useLink.js +4 -8
- package/Routable/util.js +18 -24
- package/Scrollable/ScrollAnimator.js +49 -65
- package/Scrollable/ScrollThumb.js +2 -13
- package/Scrollable/Scrollable.js +179 -386
- package/Scrollable/ScrollableNative.js +188 -391
- package/Scrollable/Scrollbar.js +28 -100
- package/Scroller/Scroller.js +15 -39
- package/Scroller/ScrollerBasic.js +34 -89
- package/Scroller/UiScrollerBase.js +31 -84
- package/Skinnable/Skinnable.js +11 -38
- package/Skinnable/tests/Skinnable-specs.js +3 -74
- package/Skinnable/tests/useSkins-specs.js +1 -13
- package/Skinnable/tests/util-specs.js +0 -14
- package/Skinnable/useSkins.js +8 -15
- package/Skinnable/util.js +9 -20
- package/Slider/Knob.js +5 -24
- package/Slider/PositionDecorator.js +16 -54
- package/Slider/Slider.js +26 -64
- package/Slider/tests/Slider-specs.js +94 -7
- package/Slider/utils.js +0 -2
- package/SlotItem/SlotItem.js +15 -41
- package/SlotItem/tests/SlotItem-specs.js +0 -5
- package/Slottable/Slottable.js +4 -12
- package/Slottable/tests/Slottable-specs.js +19 -46
- package/Slottable/tests/useSlots-specs.js +27 -65
- package/Slottable/useSlots.js +8 -33
- package/Spinner/Spinner.js +15 -42
- package/Spinner/tests/Spinner-specs.js +0 -15
- package/ToggleIcon/ToggleIcon.js +10 -36
- package/ToggleIcon/tests/ToggleIcon-specs.js +0 -16
- package/ToggleItem/ToggleItem.js +15 -52
- package/ToggleItem/tests/ToggleItem-specs.js +0 -30
- package/Toggleable/Toggle.js +1 -15
- package/Toggleable/Toggleable.js +12 -45
- package/Toggleable/tests/Toggleable-specs.js +28 -96
- package/Toggleable/useToggle.js +3 -19
- package/Touchable/ClickAllow.js +5 -14
- package/Touchable/Drag.js +16 -54
- package/Touchable/Flick.js +11 -42
- package/Touchable/Hold.js +21 -68
- package/Touchable/Touch.js +37 -65
- package/Touchable/Touchable.js +32 -71
- package/Touchable/config.js +8 -22
- package/Touchable/tests/Touchable-specs.js +270 -119
- package/Touchable/tests/useTouch-specs.js +6 -80
- package/Touchable/useTouch.js +17 -34
- package/Transition/Transition.js +37 -118
- package/Transition/tests/Transition-specs.js +20 -60
- package/ViewManager/Arranger.js +10 -22
- package/ViewManager/TransitionGroup.js +31 -106
- package/ViewManager/View.js +35 -91
- package/ViewManager/ViewManager.js +19 -83
- package/ViewManager/tests/View-specs.js +0 -17
- package/ViewManager/tests/ViewManager-specs.js +236 -305
- package/ViewManager/tests/test-utils.js +0 -8
- package/VirtualList/UiVirtualListBase.js +256 -406
- package/VirtualList/VirtualList.js +29 -69
- package/VirtualList/VirtualListBase.js +0 -3
- package/VirtualList/VirtualListBasic.js +270 -428
- package/VirtualList/tests/VirtualList-specs.js +9 -37
- package/internal/IdProvider/IdProvider.js +7 -21
- package/internal/IdProvider/Provider.js +4 -17
- package/internal/IdProvider/tests/IdProvider-specs.js +44 -0
- package/internal/IdProvider/tests/useId-specs.js +7 -22
- package/internal/IdProvider/useId.js +0 -6
- package/internal/Pure/Pure.js +3 -30
- package/internal/Pure/tests/Pure-specs.js +88 -0
- package/internal/localized-fonts/localized-fonts.js +33 -62
- package/internal/localized-fonts/tests/localized-fonts-specs.js +33 -0
- package/internal/selection/selection.js +1 -6
- package/internal/selection/tests/selection-specs.js +6 -4
- package/internal/validators/tests/validators-specs.js +80 -0
- package/internal/validators/validators.js +14 -34
- package/package.json +8 -2
- package/resolution/ResolutionDecorator.js +4 -40
- package/resolution/index.js +0 -7
- package/resolution/resolution.js +42 -80
- package/resolution/tests/ResolutionDecorator-specs.js +4 -11
- package/resolution/tests/resolution-specs.js +2 -2
- package/useControlledState/tests/useControlledState-specs.js +15 -46
- package/useControlledState/useControlledState.js +11 -22
- package/useScroll/ScrollAnimator.js +49 -65
- package/useScroll/Scrollbar.js +22 -58
- package/useScroll/ScrollbarTrack.js +3 -19
- package/useScroll/useScroll.js +267 -454
- package/useScroll/utilDOM.js +8 -14
- package/useScroll/utilEvent.js +0 -4
package/useScroll/useScroll.js
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
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
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
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
|
-
|
|
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
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
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
|
-
|
|
193
|
-
|
|
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
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
159
|
+
_useState2 = _slicedToArray(_useState, 2),
|
|
160
|
+
isHorizontalScrollbarVisible = _useState2[0],
|
|
161
|
+
setIsHorizontalScrollbarVisible = _useState2[1];
|
|
202
162
|
var _useState3 = (0, _react.useState)(verticalScrollbar === 'visible'),
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
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;
|
|
336
|
+
mutableRef.current.resizeRegistry.parent = context;
|
|
398
337
|
|
|
338
|
+
// componentWillUnmount
|
|
399
339
|
return function () {
|
|
400
340
|
var _mutableRef$current = mutableRef.current,
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
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;
|
|
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
|
-
|
|
413
|
-
|
|
354
|
+
// scrollMode 'translate' [
|
|
414
355
|
if (animator.isAnimating()) {
|
|
415
356
|
animator.stop();
|
|
416
|
-
}
|
|
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
|
-
});
|
|
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]);
|
|
375
|
+
}, [forceUpdate, scrollContentHandle]);
|
|
376
|
+
// scrollMode 'translate' ]]
|
|
434
377
|
|
|
435
378
|
function handleResizeWindow() {
|
|
436
|
-
var propsHandleResizeWindow = props.handleResizeWindow;
|
|
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
|
-
}
|
|
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]);
|
|
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
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
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
|
-
}
|
|
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
|
-
});
|
|
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
|
-
}
|
|
538
|
-
//
|
|
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
|
-
}
|
|
554
|
-
|
|
488
|
+
}
|
|
555
489
|
|
|
490
|
+
// scrollMode 'native' [[
|
|
556
491
|
function onTouchStart() {
|
|
557
492
|
mutableRef.current.isTouching = true;
|
|
558
|
-
}
|
|
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
|
-
}
|
|
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
|
-
|
|
600
|
-
|
|
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
|
-
|
|
629
|
-
|
|
630
|
-
|
|
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
|
-
|
|
656
|
-
|
|
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
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
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
|
-
|
|
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);
|
|
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
|
-
}
|
|
844
|
-
|
|
745
|
+
}
|
|
845
746
|
|
|
747
|
+
// scrollMode 'translate' [[
|
|
846
748
|
function scrollByPage(keyCode) {
|
|
847
749
|
var bounds = getScrollBounds(),
|
|
848
|
-
|
|
849
|
-
|
|
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
|
-
}
|
|
853
|
-
// scrollMode '
|
|
854
|
-
|
|
754
|
+
}
|
|
755
|
+
// scrollMode 'translate' ]]
|
|
855
756
|
|
|
757
|
+
// scrollMode 'native' [[
|
|
856
758
|
function onScroll(ev) {
|
|
857
759
|
var _ev$target = ev.target,
|
|
858
|
-
|
|
859
|
-
|
|
760
|
+
scrollLeft = _ev$target.scrollLeft,
|
|
761
|
+
scrollTop = _ev$target.scrollTop;
|
|
860
762
|
var bounds = getScrollBounds(),
|
|
861
|
-
|
|
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
|
-
}
|
|
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
|
-
}
|
|
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
|
-
|
|
944
|
-
|
|
945
|
-
|
|
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
|
-
|
|
969
|
-
|
|
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
|
-
|
|
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
|
-
}
|
|
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
|
-
}
|
|
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
|
-
|
|
1027
|
-
|
|
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
|
-
}
|
|
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
|
-
}
|
|
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
|
-
}
|
|
1100
|
-
//
|
|
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
|
-
|
|
1132
|
-
|
|
1133
|
-
|
|
1134
|
-
|
|
1135
|
-
|
|
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
|
-
}
|
|
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
|
-
}
|
|
1170
|
-
|
|
1034
|
+
}
|
|
1035
|
+
// scrollMode 'translate' ]]
|
|
1171
1036
|
|
|
1172
1037
|
function start(_ref2) {
|
|
1173
1038
|
var targetX = _ref2.targetX,
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
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
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
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
|
-
};
|
|
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
|
-
}
|
|
1259
|
-
|
|
1112
|
+
}
|
|
1260
1113
|
|
|
1114
|
+
// scrollMode 'translate' [[
|
|
1261
1115
|
function scrollAnimation(animationInfo) {
|
|
1262
1116
|
return function (curTime) {
|
|
1263
1117
|
var sourceX = animationInfo.sourceX,
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
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
|
-
|
|
1273
|
-
|
|
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
|
-
}
|
|
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
|
-
}
|
|
1190
|
+
}
|
|
1352
1191
|
|
|
1192
|
+
// scrollTo API
|
|
1353
1193
|
|
|
1354
1194
|
function getPositionForScrollTo(opt) {
|
|
1355
1195
|
var bounds = getScrollBounds(),
|
|
1356
|
-
|
|
1357
|
-
|
|
1196
|
+
canScrollH = canScrollHorizontally(bounds),
|
|
1197
|
+
canScrollV = canScrollVertically(bounds);
|
|
1358
1198
|
var itemPos,
|
|
1359
|
-
|
|
1360
|
-
|
|
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
|
-
|
|
1424
|
-
|
|
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
|
-
}
|
|
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
|
-
|
|
1488
|
-
|
|
1489
|
-
|
|
1490
|
-
|
|
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
|
-
|
|
1507
|
-
|
|
1508
|
-
|
|
1509
|
-
|
|
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
|
-
}
|
|
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
|
-
}
|
|
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);
|
|
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
|
-
}
|
|
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
|
-
}
|
|
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);
|
|
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
|
-
});
|
|
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
|
-
}
|
|
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
|
-
}
|
|
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
|
-
|
|
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;
|
|
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)({});
|
|
1530
|
+
var verticalScrollbarHandle = (0, _react.useRef)({});
|
|
1719
1531
|
|
|
1720
|
-
|
|
1721
|
-
assignProperties = assignPropertiesOf(collectionOfProperties);
|
|
1532
|
+
// Hooks
|
|
1722
1533
|
|
|
1534
|
+
var collectionOfProperties = {},
|
|
1535
|
+
assignProperties = assignPropertiesOf(collectionOfProperties);
|
|
1723
1536
|
var _useScrollBase = useScrollBase(_objectSpread(_objectSpread({}, props), {}, {
|
|
1724
|
-
|
|
1725
|
-
|
|
1726
|
-
|
|
1727
|
-
|
|
1728
|
-
|
|
1729
|
-
|
|
1730
|
-
|
|
1731
|
-
|
|
1732
|
-
|
|
1733
|
-
|
|
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
|
-
});
|
|
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;
|