import PropTypes from 'prop-types';
import IntersectionObserverArticleContainer from '../containers/intersection_observer_article_container';
import LoadMore from './load_more';
+import LoadPending from './load_pending';
import IntersectionObserverWrapper from '../features/ui/util/intersection_observer_wrapper';
import { throttle } from 'lodash';
import { List as ImmutableList } from 'immutable';
import classNames from 'classnames';
import { attachFullscreenListener, detachFullscreenListener, isFullscreen } from '../features/ui/util/fullscreen';
+import LoadingIndicator from './loading_indicator';
const MOUSE_IDLE_DELAY = 300;
static propTypes = {
scrollKey: PropTypes.string.isRequired,
onLoadMore: PropTypes.func,
+ onLoadPending: PropTypes.func,
onScrollToTop: PropTypes.func,
onScroll: PropTypes.func,
trackScroll: PropTypes.bool,
shouldUpdateScroll: PropTypes.func,
isLoading: PropTypes.bool,
+ showLoading: PropTypes.bool,
hasMore: PropTypes.bool,
+ numPending: PropTypes.number,
prepend: PropTypes.node,
alwaysPrepend: PropTypes.bool,
- alwaysShowScrollbar: PropTypes.bool,
emptyMessage: PropTypes.node,
children: PropTypes.node,
+ bindToDocument: PropTypes.bool,
};
static defaultProps = {
state = {
fullscreen: null,
+ cachedMediaWidth: 250, // Default media/card width using default Mastodon theme
};
intersectionObserverWrapper = new IntersectionObserverWrapper();
handleScroll = throttle(() => {
if (this.node) {
- const { scrollTop, scrollHeight, clientHeight } = this.node;
+ const scrollTop = this.getScrollTop();
+ const scrollHeight = this.getScrollHeight();
+ const clientHeight = this.getClientHeight();
const offset = scrollHeight - scrollTop - clientHeight;
- if (400 > offset && this.props.onLoadMore && !this.props.isLoading) {
+ if (400 > offset && this.props.onLoadMore && this.props.hasMore && !this.props.isLoading) {
this.props.onLoadMore();
}
} 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, {
trailing: true,
mouseIdleTimer = null;
mouseMovedRecently = false;
+ lastScrollWasSynthetic = false;
scrollToTopOnMouseIdle = false;
+ setScrollTop = newScrollTop => {
+ if (this.getScrollTop() !== newScrollTop) {
+ this.lastScrollWasSynthetic = true;
+
+ if (this.props.bindToDocument) {
+ document.scrollingElement.scrollTop = newScrollTop;
+ } else {
+ this.node.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);
+ this.mouseIdleTimer = setTimeout(this.handleMouseIdle, MOUSE_IDLE_DELAY);
- if (!this.mouseMovedRecently && this.node.scrollTop === 0) {
+ if (!this.mouseMovedRecently && this.getScrollTop() === 0) {
// Only set if we just started moving and are scrolled to the top.
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.node.scrollTop = 0;
+ this.setScrollTop(0);
}
+
this.mouseMovedRecently = false;
this.scrollToTopOnMouseIdle = false;
}
componentDidMount () {
this.attachScrollListener();
this.attachIntersectionObserver();
+
attachFullscreenListener(this.onFullScreenChange);
// Handle initial scroll posiiton
this.handleScroll();
}
+ getScrollPosition = () => {
+ if (this.node && (this.getScrollTop() > 0 || this.mouseMovedRecently)) {
+ return { height: this.getScrollHeight(), top: this.getScrollTop() };
+ } else {
+ return null;
+ }
+ }
+
+ getScrollTop = () => {
+ return this.props.bindToDocument ? document.scrollingElement.scrollTop : this.node.scrollTop;
+ }
+
+ getScrollHeight = () => {
+ return this.props.bindToDocument ? document.scrollingElement.scrollHeight : this.node.scrollHeight;
+ }
+
+ getClientHeight = () => {
+ return this.props.bindToDocument ? document.scrollingElement.clientHeight : this.node.clientHeight;
+ }
+
+ updateScrollBottom = (snapshot) => {
+ const newScrollTop = this.getScrollHeight() - snapshot;
+
+ this.setScrollTop(newScrollTop);
+ }
+
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.node.scrollTop > 0) || this.mouseMovedRecently) {
- return this.node.scrollHeight - this.node.scrollTop;
+ const pendingChanged = (prevProps.numPending > 0) !== (this.props.numPending > 0);
+
+ if (pendingChanged || someItemInserted && (this.getScrollTop() > 0 || this.mouseMovedRecently)) {
+ return this.getScrollHeight() - this.getScrollTop();
} else {
return null;
}
// 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) {
- const newScrollTop = this.node.scrollHeight - snapshot;
+ this.setScrollTop(this.getScrollHeight() - snapshot);
+ }
+ }
- if (this.node.scrollTop !== newScrollTop) {
- this.node.scrollTop = newScrollTop;
- }
+ cacheMediaWidth = (width) => {
+ if (width && this.state.cachedMediaWidth !== width) {
+ this.setState({ cachedMediaWidth: width });
}
}
this.clearMouseIdleTimer();
this.detachScrollListener();
this.detachIntersectionObserver();
+
detachFullscreenListener(this.onFullScreenChange);
}
}
attachIntersectionObserver () {
- this.intersectionObserverWrapper.connect({
+ let nodeOptions = {
root: this.node,
rootMargin: '300% 0px',
- });
+ };
+
+ this.intersectionObserverWrapper
+ .connect(this.props.bindToDocument ? {} : nodeOptions);
}
detachIntersectionObserver () {
}
attachScrollListener () {
- this.node.addEventListener('scroll', this.handleScroll);
- this.node.addEventListener('wheel', this.handleWheel);
+ if (this.props.bindToDocument) {
+ document.addEventListener('scroll', this.handleScroll);
+ document.addEventListener('wheel', this.handleWheel);
+ } else {
+ this.node.addEventListener('scroll', this.handleScroll);
+ this.node.addEventListener('wheel', this.handleWheel);
+ }
}
detachScrollListener () {
- this.node.removeEventListener('scroll', this.handleScroll);
- this.node.removeEventListener('wheel', this.handleWheel);
+ if (this.props.bindToDocument) {
+ document.removeEventListener('scroll', this.handleScroll);
+ document.removeEventListener('wheel', this.handleWheel);
+ } else {
+ this.node.removeEventListener('scroll', this.handleScroll);
+ this.node.removeEventListener('wheel', this.handleWheel);
+ }
}
getFirstChildKey (props) {
const { children } = props;
- let firstChild = children;
+ let firstChild = children;
+
if (children instanceof ImmutableList) {
firstChild = children.get(0);
} else if (Array.isArray(children)) {
firstChild = children[0];
}
+
return firstChild && firstChild.key;
}
this.node = c;
}
- handleLoadMore = (e) => {
+ handleLoadMore = e => {
e.preventDefault();
this.props.onLoadMore();
}
+ handleLoadPending = e => {
+ e.preventDefault();
+ this.props.onLoadPending();
+ // Prevent the weird scroll-jumping behavior, as we explicitly don't want to
+ // scroll to top, and we know the scroll height is going to change
+ this.scrollToTopOnMouseIdle = false;
+ this.lastScrollWasSynthetic = false;
+ this.clearMouseIdleTimer();
+ this.mouseIdleTimer = setTimeout(this.handleMouseIdle, MOUSE_IDLE_DELAY);
+ this.mouseMovedRecently = true;
+ }
+
render () {
- const { children, scrollKey, trackScroll, shouldUpdateScroll, isLoading, hasMore, prepend, alwaysPrepend, alwaysShowScrollbar, emptyMessage, onLoadMore } = this.props;
+ const { children, scrollKey, trackScroll, shouldUpdateScroll, showLoading, isLoading, hasMore, numPending, prepend, alwaysPrepend, emptyMessage, onLoadMore } = this.props;
const { fullscreen } = this.state;
const childrenCount = React.Children.count(children);
- const loadMore = (hasMore && childrenCount > 0 && onLoadMore) ? <LoadMore visible={!isLoading} onClick={this.handleLoadMore} /> : null;
+ const loadMore = (hasMore && onLoadMore) ? <LoadMore visible={!isLoading} onClick={this.handleLoadMore} /> : null;
+ const loadPending = (numPending > 0) ? <LoadPending count={numPending} onClick={this.handleLoadPending} /> : null;
let scrollableArea = null;
- if (isLoading || childrenCount > 0 || !emptyMessage) {
+ if (showLoading) {
+ scrollableArea = (
+ <div className='scrollable scrollable--flex' ref={this.setRef}>
+ <div role='feed' className='item-list'>
+ {prepend}
+ </div>
+
+ <div className='scrollable__append'>
+ <LoadingIndicator />
+ </div>
+ </div>
+ );
+ } else if (isLoading || childrenCount > 0 || hasMore || !emptyMessage) {
scrollableArea = (
<div className={classNames('scrollable', { fullscreen })} ref={this.setRef} onMouseMove={this.handleMouseMove}>
<div role='feed' className='item-list'>
{prepend}
+ {loadPending}
+
{React.Children.map(this.props.children, (child, index) => (
<IntersectionObserverArticleContainer
key={child.key}
intersectionObserverWrapper={this.intersectionObserverWrapper}
saveHeightKey={trackScroll ? `${this.context.router.route.location.key}:${scrollKey}` : null}
>
- {child}
+ {React.cloneElement(child, {
+ getScrollPosition: this.getScrollPosition,
+ updateScrollBottom: this.updateScrollBottom,
+ cachedMediaWidth: this.state.cachedMediaWidth,
+ cacheMediaWidth: this.cacheMediaWidth,
+ })}
</IntersectionObserverArticleContainer>
))}
</div>
);
} else {
- const scrollable = alwaysShowScrollbar;
-
scrollableArea = (
- <div className={classNames({ scrollable, fullscreen })} ref={this.setRef} style={{ flex: '1 1 auto', display: 'flex', flexDirection: 'column' }}>
+ <div className={classNames('scrollable scrollable--flex', { fullscreen })} ref={this.setRef}>
{alwaysPrepend && prepend}
<div className='empty-column-indicator'>
git-æsc / mastodon.git / blobdiff