gab-social/app/javascript/gabsocial/components/scrollable_list.js

285 lines
8.1 KiB
JavaScript
Raw Normal View History

import React from 'react'
import PropTypes from 'prop-types'
2020-04-08 02:06:59 +01:00
import throttle from 'lodash.throttle'
2020-03-04 03:45:16 +00:00
import { List as ImmutableList } from 'immutable'
import IntersectionObserverArticle from './intersection_observer_article'
import IntersectionObserverWrapper from '../features/ui/util/intersection_observer_wrapper'
2020-05-03 06:22:49 +01:00
import Block from './block'
2020-03-04 03:45:16 +00:00
import ColumnIndicator from './column_indicator'
import LoadMore from './load_more'
2020-03-04 03:45:16 +00:00
const MOUSE_IDLE_DELAY = 300
class ScrollableList extends React.PureComponent {
static contextTypes = {
router: PropTypes.object,
2020-03-04 03:45:16 +00:00
}
state = {
pullToRefreshTriggered: false,
cachedMediaWidth: 250, // Default media/card width using default Gab Social theme
2020-03-04 03:45:16 +00:00
}
intersectionObserverWrapper = new IntersectionObserverWrapper();
mouseIdleTimer = null;
mouseMovedRecently = false;
lastScrollWasSynthetic = false;
scrollToTopOnMouseIdle = false;
setScrollTop = newScrollTop => {
if (this.documentElement.scrollTop !== newScrollTop) {
this.lastScrollWasSynthetic = true;
this.documentElement.scrollTop = newScrollTop;
}
};
clearMouseIdleTimer = () => {
if (this.mouseIdleTimer === null) return;
clearTimeout(this.mouseIdleTimer);
this.mouseIdleTimer = null;
};
handleMouseMove = throttle(() => {
// As long as the mouse keeps moving, clear and restart the idle timer.
this.clearMouseIdleTimer();
this.mouseIdleTimer = setTimeout(this.handleMouseIdle, MOUSE_IDLE_DELAY);
// Only set if we just started moving and are scrolled to the top.
if (!this.mouseMovedRecently && this.documentElement.scrollTop === 0) {
this.scrollToTopOnMouseIdle = true;
}
// Save setting this flag for last, so we can do the comparison above.
this.mouseMovedRecently = true;
}, MOUSE_IDLE_DELAY / 2);
handleMouseIdle = () => {
if (this.scrollToTopOnMouseIdle) {
this.setScrollTop(0);
}
this.mouseMovedRecently = false;
this.scrollToTopOnMouseIdle = false;
}
2020-03-04 22:26:01 +00:00
componentDidMount() {
this.window = window;
this.documentElement = document.scrollingElement || document.documentElement;
this.attachScrollListener();
this.attachIntersectionObserver();
// Handle initial scroll posiiton
this.handleScroll();
}
2020-03-04 22:26:01 +00:00
componentDidUpdate(prevProps, prevState, snapshot) {
// Reset the scroll position when a new child comes in in order not to
// jerk the scrollbar around if you're already scrolled down the page.
if (snapshot !== null) {
this.setScrollTop(this.documentElement.scrollHeight - snapshot);
}
}
2020-03-04 22:26:01 +00:00
attachScrollListener() {
this.window.addEventListener('scroll', this.handleScroll);
this.window.addEventListener('wheel', this.handleWheel);
}
2020-03-04 22:26:01 +00:00
detachScrollListener() {
this.window.removeEventListener('scroll', this.handleScroll);
this.window.removeEventListener('wheel', this.handleWheel);
}
handleScroll = throttle(() => {
if (this.window) {
const { scrollTop, scrollHeight } = this.documentElement;
const { innerHeight } = this.window;
const offset = scrollHeight - scrollTop - innerHeight;
if (scrollTop < -80 && this.props.onReload && !this.state.pullToRefreshTriggered) {
this.setState({ pullToRefreshTriggered: true })
} else if (scrollTop > -10 && this.props.onReload && this.state.pullToRefreshTriggered) {
this.props.onReload()
this.setState({ pullToRefreshTriggered: false })
2020-05-07 06:55:24 +01:00
}
if (600 > offset && this.props.onLoadMore && this.props.hasMore && !this.props.isLoading) {
this.props.onLoadMore();
}
if (scrollTop < 100 && this.props.onScrollToTop) {
this.props.onScrollToTop();
} else if (this.props.onScroll) {
this.props.onScroll();
}
if (!this.lastScrollWasSynthetic) {
// If the last scroll wasn't caused by setScrollTop(), assume it was
// intentional and cancel any pending scroll reset on mouse idle
this.scrollToTopOnMouseIdle = false;
}
this.lastScrollWasSynthetic = false;
}
}, 150, {
2020-04-08 02:06:59 +01:00
trailing: true,
});
handleWheel = throttle(() => {
this.scrollToTopOnMouseIdle = false;
}, 150, {
2020-04-08 02:06:59 +01:00
trailing: true,
});
2020-03-04 22:26:01 +00:00
getSnapshotBeforeUpdate(prevProps) {
const someItemInserted = React.Children.count(prevProps.children) > 0 &&
React.Children.count(prevProps.children) < React.Children.count(this.props.children) &&
this.getFirstChildKey(prevProps) !== this.getFirstChildKey(this.props);
if (someItemInserted && (this.documentElement.scrollTop > 0 || this.mouseMovedRecently)) {
return this.documentElement.scrollHeight - this.documentElement.scrollTop;
}
return null;
}
cacheMediaWidth = (width) => {
if (width && this.state.cachedMediaWidth !== width) {
this.setState({ cachedMediaWidth: width });
}
}
2020-03-04 22:26:01 +00:00
componentWillUnmount() {
this.clearMouseIdleTimer();
this.detachScrollListener();
this.detachIntersectionObserver();
}
2020-03-04 22:26:01 +00:00
attachIntersectionObserver() {
this.intersectionObserverWrapper.connect();
}
2020-03-04 22:26:01 +00:00
detachIntersectionObserver() {
this.intersectionObserverWrapper.disconnect();
}
2020-03-04 22:26:01 +00:00
getFirstChildKey(props) {
const { children } = props;
let firstChild = children;
if (children instanceof ImmutableList) {
firstChild = children.get(0);
} else if (Array.isArray(children)) {
firstChild = children[0];
}
return firstChild && firstChild.key;
}
2020-04-28 06:33:58 +01:00
handleLoadMore = (e) => {
2020-05-02 07:25:55 +01:00
e.preventDefault()
this.props.onLoadMore();
}
2020-03-04 22:26:01 +00:00
render() {
2020-04-08 02:06:59 +01:00
const {
children,
scrollKey,
showLoading,
isLoading,
hasMore,
emptyMessage,
onLoadMore,
placeholderComponent: Placeholder,
placeholderCount,
2020-04-08 02:06:59 +01:00
} = this.props
const childrenCount = React.Children.count(children);
if (showLoading) {
if (Placeholder) {
return (
<React.Fragment>
{
Array.apply(null, {
length: placeholderCount
}).map((_, i) => (
<Placeholder
key={`${scrollKey}-placeholder-${i}`}
isLast={i === placeholderCount - 1}
/>
))
}
</React.Fragment>
)
}
return <ColumnIndicator type='loading' />
} else if (isLoading || childrenCount > 0 || hasMore || !emptyMessage) {
return (
2020-03-04 22:26:01 +00:00
<div onMouseMove={this.handleMouseMove}>
<div role='feed'>
2020-03-04 22:26:01 +00:00
{
!!this.props.children &&
React.Children.map(this.props.children, (child, index) => (
<IntersectionObserverArticle
key={child.key}
id={child.key}
index={index}
listLength={childrenCount}
intersectionObserverWrapper={this.intersectionObserverWrapper}
2020-04-28 06:33:58 +01:00
saveHeightKey={`${this.context.router.route.location.key}:${scrollKey}`}
2020-03-04 22:26:01 +00:00
>
{
React.cloneElement(child, {
cachedMediaWidth: this.state.cachedMediaWidth,
cacheMediaWidth: this.cacheMediaWidth,
})
}
</IntersectionObserverArticle>
))
}
{
(hasMore && onLoadMore && !isLoading) &&
<LoadMore onClick={this.handleLoadMore} />
}
{
isLoading &&
<ColumnIndicator type='loading' />
}
</div>
</div>
)
}
2020-05-03 06:22:49 +01:00
return (
<Block>
<ColumnIndicator type='error' message={emptyMessage} />
</Block>
)
}
}
2020-05-07 05:03:34 +01:00
ScrollableList.propTypes = {
scrollKey: PropTypes.string.isRequired,
onLoadMore: PropTypes.func,
onReload: PropTypes.func,
isLoading: PropTypes.bool,
showLoading: PropTypes.bool,
hasMore: PropTypes.bool,
emptyMessage: PropTypes.oneOfType([
PropTypes.string,
PropTypes.object,
]),
children: PropTypes.node,
onScrollToTop: PropTypes.func,
onScroll: PropTypes.func,
placeholderComponent: PropTypes.node,
placeholderCount: PropTypes.node,
}
export default ScrollableList