Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

WV-4212 Modernize timeline-coverage components

Victor Gonzalez Leon8713067b4bad
diff --git a/web/js/components/timeline/timeline-coverage/coverage-item-container.js b/web/js/components/timeline/timeline-coverage/coverage-item-container.js
index fecf6efdb..f3b3c5a98 100644
--- a/web/js/components/timeline/timeline-coverage/coverage-item-container.js
+++ b/web/js/components/timeline/timeline-coverage/coverage-item-container.js
@@ -1,66 +1,36 @@
-import React, { Component } from 'react';
+import React, { useEffect, useState } from 'react';
import PropTypes from 'prop-types';
import CoverageLine from './coverage-line';
/*
* Coverage Item Container for individual layer temporal coverage.
*
- * @class CoverageItemContainer
+ * @function CoverageItemContainer
*/
-class CoverageItemContainer extends Component {
- constructor(props) {
- super(props);
- this.state = {
- layerDateRanges: [],
- };
- }
-
- componentDidMount() {
- const {
- layer,
- needDateRangeBuilt,
- } = this.props;
- const { dateRanges } = layer;
- // handle date range query/array building
- if (needDateRangeBuilt) {
- this.callDateRangeHelper(dateRanges);
- }
- }
-
- componentDidUpdate(prevProps) {
- const {
- layer,
- frontDate,
- backDate,
- needDateRangeBuilt,
- } = this.props;
- const { dateRanges } = layer;
-
- const frontDateChanged = prevProps.frontDate !== frontDate;
- const backDateChanged = prevProps.backDate !== backDate;
-
- if (frontDateChanged || backDateChanged) {
- if (needDateRangeBuilt) {
- this.callDateRangeHelper(dateRanges);
- }
- }
- }
-
- async callDateRangeHelper(dateRanges) {
- const dateRangesToDisplay = await this.getDateRangeToDisplay(dateRanges);
- this.updateDateRangeState(dateRangesToDisplay);
- }
+const CoverageItemContainer = ({
+ axisWidth,
+ backDate,
+ frontDate,
+ getDatesInDateRange,
+ getLayerItemStyles,
+ getMatchingCoverageLineDimensions,
+ getMaxEndDate,
+ getRangeDateEndWithAddedInterval,
+ layer,
+ layerPeriod,
+ needDateRangeBuilt,
+ positionTransformX,
+}) => {
+ const [layerDateRanges, setlayerDateRanges] = useState([]);
/**
* @desc getDateRangeToDisplay
* @param {Array} dateRanges
* @returns {Promise() <ArrayBuffer>} multiDateToDisplay
*/
- getDateRangeToDisplay = async (dateRanges) => {
- const { getMaxEndDate, getDatesInDateRange, layer } = this.props;
-
- const multiDateToDisplay = await dateRanges.reduce(async (dates, range, innerIndex) => {
+ const getDateRangeToDisplay = async (dateRanges) => {
+ const multiDateToDisplay = dateRanges.reduce((dates, range, innerIndex) => {
const multiCoverageDates = { ...dates };
const { dateInterval, startDate, endDate } = range;
const isLastInRange = innerIndex === dateRanges.length - 1;
@@ -70,7 +40,7 @@ class CoverageItemContainer extends Component {
// get dates based on date ranges
const startDateTime = new Date(startDate).getTime();
const endDateTime = new Date(endDate).getTime();
- const dateIntervalStartDates = await getDatesInDateRange(
+ const dateIntervalStartDates = getDatesInDateRange(
layer, range, endDateLimit, isLastInRange);
// add date intervals to multiCoverageDates object to catch repeats
@@ -91,115 +61,102 @@ class CoverageItemContainer extends Component {
return Object.values(multiDateToDisplay);
};
- /**
- * @desc updateDateRangeState
- * @param {Array} dateRange
- * @returns {Void}
- */
- updateDateRangeState = (dateRange) => {
- this.setState({
- layerDateRanges: dateRange,
- });
- };
-
- render() {
- const {
- axisWidth,
- getLayerItemStyles,
- getMatchingCoverageLineDimensions,
- getRangeDateEndWithAddedInterval,
- layer,
- layerPeriod,
- positionTransformX,
- needDateRangeBuilt,
- } = this.props;
- const {
- layerDateRanges,
- } = this.state;
+ useEffect(() => {
+ if (!needDateRangeBuilt) return;
- // layer options
- const {
- endDate,
- id,
- startDate,
- visible,
- } = layer;
+ let cancelled = false;
- // conditional styling for line/background colors
- const {
- lineBackgroundColor,
- } = getLayerItemStyles(visible, id);
+ getDateRangeToDisplay(layer.dateRanges).then((dateRangesToDisplay) => {
+ if (!cancelled) setlayerDateRanges(dateRangesToDisplay);
+ });
- // get line container dimensions
- const containerLineDimensions = getMatchingCoverageLineDimensions(layer)
- .filter(({ visible: isVisible }) => isVisible);
- return (
- <div
- className="layer-coverage-line"
- style={{
- width: `${axisWidth}px`,
- }}
+ return () => {
+ cancelled = true;
+ };
+ }, [frontDate, backDate]);
+
+ // layer options
+ const {
+ endDate,
+ id,
+ startDate,
+ visible,
+ } = layer;
+
+ // conditional styling for line/background colors
+ const {
+ lineBackgroundColor,
+ } = getLayerItemStyles(visible, id);
+
+ // get line container dimensions
+ const containerLineDimensions = getMatchingCoverageLineDimensions(layer)
+ .filter(({ visible: isVisible }) => isVisible);
+ return (
+ <div
+ className="layer-coverage-line"
+ style={{
+ width: `${axisWidth}px`,
+ }}
+ >
+ <svg
+ className="layer-coverage-line-svg"
+ width={`${axisWidth}px`}
>
- <svg
- className="layer-coverage-line-svg"
- width={`${axisWidth}px`}
- >
- {needDateRangeBuilt
- ? layerDateRanges.map((itemRange, multiIndex, array) => {
- const { date, interval } = itemRange;
- const dateObj = new Date(date);
- const nextDate = array[multiIndex + 1];
- const rangeDateEnd = getRangeDateEndWithAddedInterval(
- layer,
- dateObj,
- layerPeriod,
- interval,
- nextDate,
- );
- // get range line dimensions
- const multiLineRangeOptions = getMatchingCoverageLineDimensions(
- layer,
- dateObj,
- rangeDateEnd,
- ).filter(({ visible: isVisible }) => isVisible);
- // create DOM line element
- const key = `${id}-${multiIndex}`;
- return (
- <React.Fragment key={key}>
- <CoverageLine
- axisWidth={axisWidth}
- positionTransformX={positionTransformX}
- id={id}
- options={multiLineRangeOptions}
- lineType="MULTI"
- startDate={date}
- endDate={rangeDateEnd}
- color={lineBackgroundColor}
- layerPeriod={layerPeriod}
- index={key}
- />
- </React.Fragment>
- );
- })
- : (
- <CoverageLine
- axisWidth={axisWidth}
- positionTransformX={positionTransformX}
- id={id}
- options={containerLineDimensions}
- lineType="SINGLE"
- startDate={startDate}
- endDate={endDate}
- color={lineBackgroundColor}
- layerPeriod={layerPeriod}
- index={`${id}-0`}
- />
- )}
- </svg>
- </div>
- );
- }
-}
+ {needDateRangeBuilt
+ ? layerDateRanges.map((itemRange, multiIndex, array) => {
+ const { date, interval } = itemRange;
+ const dateObj = new Date(date);
+ const nextDate = array[multiIndex + 1];
+ const rangeDateEnd = getRangeDateEndWithAddedInterval(
+ layer,
+ dateObj,
+ layerPeriod,
+ interval,
+ nextDate,
+ );
+ // get range line dimensions
+ const multiLineRangeOptions = getMatchingCoverageLineDimensions(
+ layer,
+ dateObj,
+ rangeDateEnd,
+ ).filter(({ visible: isVisible }) => isVisible);
+ // create DOM line element
+ const key = `${id}-${multiIndex}`;
+ return (
+ <React.Fragment key={key}>
+ <CoverageLine
+ axisWidth={axisWidth}
+ positionTransformX={positionTransformX}
+ id={id}
+ options={multiLineRangeOptions}
+ lineType="MULTI"
+ startDate={date}
+ endDate={rangeDateEnd}
+ color={lineBackgroundColor}
+ layerPeriod={layerPeriod}
+ index={key}
+ />
+ </React.Fragment>
+ );
+ })
+ : (
+ <CoverageLine
+ axisWidth={axisWidth}
+ positionTransformX={positionTransformX}
+ id={id}
+ options={containerLineDimensions}
+ lineType="SINGLE"
+ startDate={startDate}
+ endDate={endDate}
+ color={lineBackgroundColor}
+ layerPeriod={layerPeriod}
+ index={`${id}-0`}
+ />
+ )}
+ </svg>
+ </div>
+ );
+};
CoverageItemContainer.propTypes = {
axisWidth: PropTypes.number,
diff --git a/web/js/components/timeline/timeline-coverage/coverage-item-list.js b/web/js/components/timeline/timeline-coverage/coverage-item-list.js
index f078ecb05..033d88034 100644
--- a/web/js/components/timeline/timeline-coverage/coverage-item-list.js
+++ b/web/js/components/timeline/timeline-coverage/coverage-item-list.js
@@ -1,4 +1,4 @@
-import { Component } from 'react';
+import { useEffect, useRef, useState } from 'react';
import PropTypes from 'prop-types';
import moment from 'moment';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
@@ -20,122 +20,124 @@ const ignoredLayer = {
GRACE_Tellus_Liquid_Water_Equivalent_Thickness_Mascon_CRI: true,
};
-/*
- * Layer Coverage Container item list.
- *
- * @class CoverageItemList
- */
-class CoverageItemList extends Component {
- /**
- * @desc get layer header with title, subtitle, and full date range
- * @param {Object} layer
- * @param {Boolean} visible
- * @param {String} dateRange
- * @param {String} background color
- * @returns {DOM Element} header
- */
- static getHeaderDOMEl(layer, visible, layerItemBackground, inactiveLayers) {
- const titleColor = visible ? '#000' : '#999';
- const textColor = visible ? '#222' : '#999';
- const {
- subtitle, title, startDate, endDate,
- } = layer;
- const formattedStartDate = startDate && formatDisplayDate(new Date(startDate));
- const formattedEndDate = endDate && formatDisplayDate(new Date(endDate));
- const baseStyle = { width: '110px', display: 'inline-block' };
- const getStyle = (date) => (
- date
- ? { ...baseStyle, textAlign: 'center' }
- : { ...baseStyle, paddingLeft: '2px' }
- );
-
- return (
- <div className="layer-coverage-item-header">
- <div
- className="layer-coverage-item-title"
+/**
+* @desc get layer header with title, subtitle, and full date range
+* @param {Object} layer
+* @param {Boolean} visible
+* @param {String} dateRange
+* @param {String} background color
+* @returns {DOM Element} header
+*/
+const getHeaderDOMEl = (layer, visible, layerItemBackground, inactiveLayers) => {
+ const titleColor = visible ? '#000' : '#999';
+ const textColor = visible ? '#222' : '#999';
+ const {
+ subtitle, title, startDate, endDate,
+ } = layer;
+ const formattedStartDate = startDate && formatDisplayDate(new Date(startDate));
+ const formattedEndDate = endDate && formatDisplayDate(new Date(endDate));
+ const baseStyle = { width: '110px', display: 'inline-block' };
+ const getStyle = (date) => (
+ date
+ ? { ...baseStyle, textAlign: 'center' }
+ : { ...baseStyle, paddingLeft: '2px' }
+ );
+
+ return (
+ <div className="layer-coverage-item-header">
+ <div
+ className="layer-coverage-item-title"
+ style={{
+ color: titleColor,
+ }}
+ >
+ {title}
+ {' '}
+ <span
+ className="layer-coverage-item-subtitle"
style={{
- color: titleColor,
- }}
- >
- {title}
- {' '}
- <span
- className="layer-coverage-item-subtitle"
- style={{
- color: textColor,
- }}
- >
- {subtitle}
- </span>
- </div>
- <div
- className="layer-coverage-item-date-range"
- style={{
- background: layerItemBackground,
color: textColor,
- float: 'left',
- width: inactiveLayers || formattedEndDate ? '205px' : '175px',
}}
>
- <MonospaceDate style={getStyle(formattedStartDate)} date={formattedStartDate || ' Start '} />
- {' - '}
- <MonospaceDate style={getStyle(formattedEndDate)} date={formattedEndDate || ' Present '} />
- </div>
+ {subtitle}
+ </span>
</div>
- );
- }
-
- /**
- * @desc get empty layers message DOM element
- * @returns {DOM Element} div contained message
- */
- static createEmptyLayersDOMEl() {
- return (
- <div className="layer-coverage-list-empty">
- <div className="layer-coverage-item-empty">
- <FontAwesomeIcon icon="exclamation-triangle" className="error-icon" widthAuto />
- <p>
- No visible layers with defined coverage. Add layers or toggle
- &quot;Include Hidden Layers&quot; if current layers are hidden.
- </p>
- </div>
+ <div
+ className="layer-coverage-item-date-range"
+ style={{
+ background: layerItemBackground,
+ color: textColor,
+ float: 'left',
+ width: inactiveLayers || formattedEndDate ? '205px' : '175px',
+ }}
+ >
+ <MonospaceDate style={getStyle(formattedStartDate)} date={formattedStartDate || ' Start '} />
+ {' - '}
+ <MonospaceDate style={getStyle(formattedEndDate)} date={formattedEndDate || ' Present '} />
</div>
- );
- }
-
- /**
- * @desc get formatted time period name
- * @param {String} period
- * @returns {String} formatted period
- */
- static getFormattedTimePeriod (period) {
- if (period === 'daily') return 'day';
- if (period === 'monthly') return 'monthly';
- if (period === 'yearly') return 'year';
- return 'minute';
- }
-
- constructor(props) {
- super(props);
- this.state = {
- hoveredLayer: undefined,
- };
-
- // cache for queried date arrays
- this.layerDateArrayCache = {};
- }
+ </div>
+ );
+};
- componentDidMount() {
- events.on(SIDEBAR_LAYER_HOVER, this.layerHoverCallback);
- }
+/**
+* @desc get empty layers message DOM element
+* @returns {DOM Element} div contained message
+*/
+const createEmptyLayersDOMEl = () => {
+ return (
+ <div className="layer-coverage-list-empty">
+ <div className="layer-coverage-item-empty">
+ <FontAwesomeIcon icon="exclamation-triangle" className="error-icon" widthAuto />
+ <p>
+ No visible layers with defined coverage. Add layers or toggle
+ &quot;Include Hidden Layers&quot; if current layers are hidden.
+ </p>
+ </div>
+ </div>
+ );
+};
- componentWillUnmount() {
- events.off(SIDEBAR_LAYER_HOVER, this.layerHoverCallback);
- }
+/**
+* @desc get formatted time period name
+* @param {String} period
+* @returns {String} formatted period
+*/
+const getFormattedTimePeriod = (period) => {
+ if (period === 'daily') return 'day';
+ if (period === 'monthly') return 'monthly';
+ if (period === 'yearly') return 'year';
+ return 'minute';
+};
- layerHoverCallback = (id, active) => {
- this.setState({ hoveredLayer: active ? id : undefined });
- };
+/*
+ * Layer Coverage Container item list.
+ *
+ * @function CoverageItemList
+ */
+const CoverageItemList = ({
+ activeLayers,
+ appNow,
+ axisWidth,
+ backDate,
+ frontDate,
+ getMatchingCoverageLineDimensions,
+ positionTransformX,
+ timeScale,
+}) => {
+ const [hoveredLayer, setHoveredLayer] = useState(undefined);
+
+ // cache for queried date arrays
+ const layerDateArrayCache = useRef({});
+
+ useEffect(() => {
+ const layerHoverCallback = (id, active) => {
+ setHoveredLayer(active ? id : undefined);
+ };
+ events.on(SIDEBAR_LAYER_HOVER, layerHoverCallback);
+ return () => {
+ events.off(SIDEBAR_LAYER_HOVER, layerHoverCallback);
+ };
+ }, []);
/**
* @desc get range date end with added interval based on period
@@ -146,14 +148,13 @@ class CoverageItemList extends Component {
* @param {Object} nextDate range object with date
* @returns {String} rangeDateEnd date ISO string
*/
- getRangeDateEndWithAddedInterval = (
+ const getRangeDateEndWithAddedInterval = (
layer,
rangeDate,
layerPeriod,
itemRangeInterval,
nextDate,
) => {
- const { appNow } = this.props;
const { endDate, futureTime } = layer;
const {
minYear,
@@ -205,11 +206,7 @@ class CoverageItemList extends Component {
* @param {Boolean} isLastInRange
* @returns {Object} endDateLimit date object
*/
- getMaxEndDate = (layer, isLastInRange) => {
- const {
- appNow,
- backDate,
- } = this.props;
+ const getMaxEndDate = (layer, isLastInRange) => {
const { endDate, futureTime, ongoing } = layer;
let endDateLimit = new Date(backDate);
@@ -241,18 +238,13 @@ class CoverageItemList extends Component {
* @param {Boolean} isLastInRange
* @returns {Array} dateIntervalStartDates
*/
- getDatesInDateRange = async (def, range, endDateLimit, isLastInRange) => {
- const {
- appNow,
- backDate,
- frontDate,
- } = this.props;
+ const getDatesInDateRange = (def, range, endDateLimit, isLastInRange) => {
const {
futureTime, period, id, ongoing,
} = def;
const { dateInterval, startDate, endDate } = range;
- const layerPeriod = CoverageItemList.getFormattedTimePeriod(period);
+ const layerPeriod = getFormattedTimePeriod(period);
const rangeInterval = Number(dateInterval);
let rangeEnd;
@@ -286,20 +278,21 @@ class CoverageItemList extends Component {
.getTime() >= startDateLimit.getTime();
if (startLessThanOrEqualToEndDateLimit && endGreaterThanOrEqualToStartDateLimit) {
// check layer date array cache and use caches date array if available, if not add date array
- this.layerDateArrayCache[id] ??= {};
+ const cache = layerDateArrayCache.current;
+ cache[id] ??= {};
const layerIdDates = `${appNow.toISOString()}-${frontDate}-${backDate}`;
- if (this.layerDateArrayCache[id][layerIdDates] === undefined) {
- dateIntervalStartDates = await datesInDateRanges(
+ if (cache[id][layerIdDates] === undefined) {
+ dateIntervalStartDates = datesInDateRanges(
def,
startDateLimit,
startDateLimit,
endDateLimit,
appNow,
);
- this.layerDateArrayCache[id][layerIdDates] = dateIntervalStartDates;
+ cache[id][layerIdDates] = dateIntervalStartDates;
} else {
- dateIntervalStartDates = this.layerDateArrayCache[id][layerIdDates];
+ dateIntervalStartDates = cache[id][layerIdDates];
}
}
return dateIntervalStartDates;
@@ -314,8 +307,7 @@ class CoverageItemList extends Component {
* @param {String} layerItemBackground
* @param {String} layerItemOutline
*/
- getLayerItemStyles = (visible, id) => {
- const { hoveredLayer } = this.state;
+ const getLayerItemStyles = (visible, id) => {
// conditional styling for line/background colors
const containerBackgroundColor = visible
? 'rgb(204, 204, 204)'
@@ -344,119 +336,110 @@ class CoverageItemList extends Component {
};
};
- render() {
- const {
- activeLayers,
- axisWidth,
- backDate,
- frontDate,
- getMatchingCoverageLineDimensions,
- timeScale,
- positionTransformX,
- } = this.props;
- const emptyLayers = activeLayers.length === 0;
- const inactiveLayers = activeLayers.some(({ ongoing }) => !ongoing);
- return (
- <div className="layer-coverage-layer-list">
- {/* Empty layer coverage message */
- emptyLayers && CoverageItemList.createEmptyLayersDOMEl()
- }
+ const emptyLayers = activeLayers.length === 0;
+ const inactiveLayers = activeLayers.some(({ ongoing }) => !ongoing);
+ return (
+ <div className="layer-coverage-layer-list">
+ {/* Empty layer coverage message */
+ emptyLayers && createEmptyLayersDOMEl()
+ }
- {/* Build individual layer coverage components */
- activeLayers.map((layer, index) => {
- const {
- dateRanges,
- id,
- period,
- startDate,
- visible,
- } = layer;
- if (!dateRanges && !startDate) {
- return null;
- }
- // check for multiple date ranges
- let multipleCoverageRanges = false;
- const isValidLayer = !ignoredLayer[id] && dateRanges;
- if (isValidLayer) {
- multipleCoverageRanges = dateRanges.length > 1;
- }
- let layerPeriod = CoverageItemList.getFormattedTimePeriod(period);
-
- // get layer scale number to determine relation to current axis zoom level
- const timeScaleNumber = TIME_SCALE_TO_NUMBER[timeScale];
- const layerScaleNumber = TIME_SCALE_TO_NUMBER[layerPeriod];
- const isLayerGreaterIncrementThanZoom = layerScaleNumber < timeScaleNumber;
- const isLayerEqualIncrementThanZoom = layerScaleNumber === timeScaleNumber;
-
- // concat (ex: day to days) for moment manipulation below
- layerPeriod += 's';
-
- // conditional styling for line/background colors
- const {
- layerItemBackground,
- layerItemOutline,
- } = this.getLayerItemStyles(visible, id);
-
- // get date range
- const dateRangeIntervalZeroIndex = dateRanges
- ? Number(dateRanges[0].dateInterval)
- : 1;
-
- // conditional check to determine how layer coverage line
- // will be built in child component
- const isLayerGreaterZoomWithMultipleCoverage = isLayerGreaterIncrementThanZoom &&
- (multipleCoverageRanges || dateRangeIntervalZeroIndex);
- const isLayerEqualZoomWithMultipleCoverage = isLayerEqualIncrementThanZoom &&
- dateRangeIntervalZeroIndex > 1;
- // determine date range building vs using startDate to endDate single coverage
- const needDateRangeBuilt = !!(isValidLayer && (isLayerGreaterZoomWithMultipleCoverage ||
- isLayerEqualZoomWithMultipleCoverage));
- const encodedId = util.encodeId(id);
- const key = `layer-coverage-item-${encodedId}-${index}`;
-
- return (
+ {/* Build individual layer coverage components */
+ activeLayers.map((layer, index) => {
+ const {
+ dateRanges,
+ id,
+ period,
+ startDate,
+ visible,
+ } = layer;
+ if (!dateRanges && !startDate) {
+ return null;
+ }
+ // check for multiple date ranges
+ let multipleCoverageRanges = false;
+ const isValidLayer = !ignoredLayer[id] && dateRanges;
+ if (isValidLayer) {
+ multipleCoverageRanges = dateRanges.length > 1;
+ }
+ let layerPeriod = getFormattedTimePeriod(period);
+
+ // get layer scale number to determine relation to current axis zoom level
+ const timeScaleNumber = TIME_SCALE_TO_NUMBER[timeScale];
+ const layerScaleNumber = TIME_SCALE_TO_NUMBER[layerPeriod];
+ const isLayerGreaterIncrementThanZoom = layerScaleNumber < timeScaleNumber;
+ const isLayerEqualIncrementThanZoom = layerScaleNumber === timeScaleNumber;
+
+ // concat (ex: day to days) for moment manipulation below
+ layerPeriod += 's';
+
+ // conditional styling for line/background colors
+ const {
+ layerItemBackground,
+ layerItemOutline,
+ } = getLayerItemStyles(visible, id);
+
+ // get date range
+ const dateRangeIntervalZeroIndex = dateRanges
+ ? Number(dateRanges[0].dateInterval)
+ : 1;
+
+ // conditional check to determine how layer coverage line
+ // will be built in child component
+ const isLayerGreaterZoomWithMultipleCoverage = isLayerGreaterIncrementThanZoom &&
+ (multipleCoverageRanges || dateRangeIntervalZeroIndex);
+ const isLayerEqualZoomWithMultipleCoverage = isLayerEqualIncrementThanZoom &&
+ dateRangeIntervalZeroIndex > 1;
+ // determine date range building vs using startDate to endDate single coverage
+ const needDateRangeBuilt = !!(isValidLayer && (isLayerGreaterZoomWithMultipleCoverage ||
+ isLayerEqualZoomWithMultipleCoverage));
+ const encodedId = util.encodeId(id);
+ const key = `layer-coverage-item-${encodedId}-${index}`;
+
+ return (
+ <div
+ key={key}
+ className="layer-coverage-layer-list-item"
+ style={{
+ background: layerItemBackground,
+ outline: layerItemOutline,
+ }}
+ >
+ {/* Layer Header DOM El */
+ getHeaderDOMEl(
+ layer, visible, layerItemBackground, inactiveLayers,
+ )
+ }
<div
- key={key}
- className="layer-coverage-layer-list-item"
+ className="layer-coverage-line-container"
style={{
- background: layerItemBackground,
- outline: layerItemOutline,
+ maxWidth: `${axisWidth}px`,
}}
>
- {/* Layer Header DOM El */
- CoverageItemList.getHeaderDOMEl(
- layer, visible, layerItemBackground, inactiveLayers,
- )
- }
- <div
- className="layer-coverage-line-container"
- style={{
- maxWidth: `${axisWidth}px`,
- }}
- >
- <CoverageItemContainer
- frontDate={frontDate}
- backDate={backDate}
- getLayerItemStyles={this.getLayerItemStyles}
- getMaxEndDate={this.getMaxEndDate}
- getDatesInDateRange={this.getDatesInDateRange}
- axisWidth={axisWidth}
- positionTransformX={positionTransformX}
- layer={layer}
- layerPeriod={layerPeriod}
- getMatchingCoverageLineDimensions={getMatchingCoverageLineDimensions}
- getRangeDateEndWithAddedInterval={this.getRangeDateEndWithAddedInterval}
- needDateRangeBuilt={needDateRangeBuilt}
- />
- </div>
+ <CoverageItemContainer
+ frontDate={frontDate}
+ backDate={backDate}
+ getLayerItemStyles={getLayerItemStyles}
+ getMaxEndDate={getMaxEndDate}
+ getDatesInDateRange={getDatesInDateRange}
+ axisWidth={axisWidth}
+ positionTransformX={positionTransformX}
+ layer={layer}
+ layerPeriod={layerPeriod}
+ getMatchingCoverageLineDimensions={getMatchingCoverageLineDimensions}
+ getRangeDateEndWithAddedInterval={getRangeDateEndWithAddedInterval}
+ needDateRangeBuilt={needDateRangeBuilt}
+ />
</div>
- );
- })
- }
- </div>
- );
- }
-}
+ </div>
+ );
+ })
+ }
+ </div>
+ );
+};
+
+CoverageItemList.getFormattedTimePeriod = getFormattedTimePeriod;
CoverageItemList.propTypes = {
activeLayers: PropTypes.oneOfType([PropTypes.array, PropTypes.oneOf(['null'])]),
diff --git a/web/js/components/timeline/timeline-coverage/coverage-line.js b/web/js/components/timeline/timeline-coverage/coverage-line.js
index 6448a2400..a0a340db4 100644
--- a/web/js/components/timeline/timeline-coverage/coverage-line.js
+++ b/web/js/components/timeline/timeline-coverage/coverage-line.js
@@ -1,175 +1,160 @@
-import { PureComponent } from 'react';
+import { memo } from 'react';
import PropTypes from 'prop-types';
import { formatDisplayDate } from '../../../modules/date/util';
-/*
- * Coverage Line for DOM Element layer coverage.
- *
- * @class CoverageLine PureComponent
- */
+/**
+* @desc get formatted display dates for line tooltips and selectors
+* @param {String} lineType
+* @param {String} startDate date ISO string
+* @param {String} endDate date ISO string
+* @param {String} layerPeriod
+* @returns {Object}
+* @param {String} dateRangeStart
+* @param {String} dateRangeEnd
+* @param {String} toolTipText
+*/
+const getFormattedDisplayDates = (lineType, startDate, endDate, layerPeriod) => {
+ let dateRangeStart;
+ let dateRangeEnd;
+ let toolTipText;
-class CoverageLine extends PureComponent {
- /**
- * @desc get formatted display dates for line tooltips and selectors
- * @param {String} lineType
- * @param {String} startDate date ISO string
- * @param {String} endDate date ISO string
- * @param {String} layerPeriod
- * @returns {Object}
- * @param {String} dateRangeStart
- * @param {String} dateRangeEnd
- * @param {String} toolTipText
- */
- static getFormattedDisplayDates(lineType, startDate, endDate, layerPeriod) {
- let dateRangeStart;
- let dateRangeEnd;
- let toolTipText;
-
- switch (lineType) {
- case 'SINGLE':
- dateRangeStart = (startDate && formatDisplayDate(new Date(startDate))) || 'Start';
- dateRangeEnd = (endDate && formatDisplayDate(new Date(endDate))) || 'Present';
+ switch (lineType) {
+ case 'SINGLE':
+ dateRangeStart = (startDate && formatDisplayDate(new Date(startDate))) || 'Start';
+ dateRangeEnd = (endDate && formatDisplayDate(new Date(endDate))) || 'Present';
+ toolTipText = `${dateRangeStart} to ${dateRangeEnd}`;
+ break;
+ case 'MULTI':
+ // handle minutes range display text (ex: '14:50 to 15:00')
+ if (layerPeriod === 'minutes') {
+ dateRangeStart = startDate.split('T')[1];
+ dateRangeEnd = endDate.split('T')[1];
+ toolTipText = `${dateRangeStart.split(':', 2).join(':')} to ${dateRangeEnd.split(':', 2).join(':')}`;
+ dateRangeStart = dateRangeStart.replace(/[.:]/g, '_');
+ dateRangeEnd = dateRangeEnd.replace(/[.:]/g, '_');
+ } else {
+ dateRangeStart = formatDisplayDate(new Date(startDate));
+ dateRangeEnd = formatDisplayDate(new Date(endDate));
toolTipText = `${dateRangeStart} to ${dateRangeEnd}`;
- break;
- case 'MULTI':
- // handle minutes range display text (ex: '14:50 to 15:00')
- if (layerPeriod === 'minutes') {
- dateRangeStart = startDate.split('T')[1];
- dateRangeEnd = endDate.split('T')[1];
- toolTipText = `${dateRangeStart.split(':', 2).join(':')} to ${dateRangeEnd.split(':', 2).join(':')}`;
- dateRangeStart = dateRangeStart.replace(/[.:]/g, '_');
- dateRangeEnd = dateRangeEnd.replace(/[.:]/g, '_');
- } else {
- dateRangeStart = formatDisplayDate(new Date(startDate));
- dateRangeEnd = formatDisplayDate(new Date(endDate));
- toolTipText = `${dateRangeStart} to ${dateRangeEnd}`;
- }
- break;
- }
-
- return {
- dateRangeStart,
- dateRangeEnd,
- toolTipText,
- };
+ }
+ break;
}
- /**
- * @desc get line DOM element from full/partial (interval) date range with tooltip
- * @param {String} id
- * @param {Object} options
- * @param {String} lineType
- * @param {String} dateRangeStart
- * @param {String} dateRangeEnd
- * @param {String} color
- * @param {String} layerPeriod
- * @param {Number/String} index
- * @returns {DOM Element} line
- */
- createMatchingCoverageLineDOMEl = (
- id,
- options,
- lineType,
- startDate,
- endDate,
- color,
- layerPeriod,
- index,
- ) => {
- const {
- positionTransformX,
- } = this.props;
- const {
- leftOffset,
- isWidthGreaterThanRendered,
- width,
- layerStartBeforeAxisFront,
- layerEndBeforeAxisBack,
- } = options;
- let lineWidth = Math.max(width, 0);
+ return {
+ dateRangeStart,
+ dateRangeEnd,
+ toolTipText,
+ };
+};
+
+/**
+* @desc get line DOM element from full/partial (interval) date range with tooltip
+* @param {String} id
+* @param {Object} options
+* @param {String} lineType
+* @param {String} dateRangeStart
+* @param {String} dateRangeEnd
+* @param {String} color
+* @param {String} layerPeriod
+* @param {Number/String} index
+* @returns {DOM Element} line
+*/
+const createMatchingCoverageLineDOMEl = (options, line, positionTransformX) => {
+ const {
+ id, lineType, startDate, endDate, color, layerPeriod, index,
+ } = line;
+ const {
+ leftOffset,
+ isWidthGreaterThanRendered,
+ width,
+ layerStartBeforeAxisFront,
+ layerEndBeforeAxisBack,
+ } = options;
+ let lineWidth = Math.max(width, 0);
- // get formatted dates based on line type
- const {
- dateRangeStart,
- dateRangeEnd,
- toolTipText,
- } = CoverageLine.getFormattedDisplayDates(lineType, startDate, endDate, layerPeriod);
- const dateRangeStartEnd = `${id}-${dateRangeStart}-${dateRangeEnd}`;
+ // get formatted dates based on line type
+ const {
+ dateRangeStart,
+ dateRangeEnd,
+ toolTipText,
+ } = CoverageLine.getFormattedDisplayDates(lineType, startDate, endDate, layerPeriod);
+ const dateRangeStartEnd = `${id}-${dateRangeStart}-${dateRangeEnd}`;
- // candy stripe color
- const patternType = color === 'rgb(0, 69, 123)'
- ? 'url(#coverage-line-pattern)'
- : 'url(#coverage-line-pattern-hidden)';
+ // candy stripe color
+ const patternType = color === 'rgb(0, 69, 123)'
+ ? 'url(#coverage-line-pattern)'
+ : 'url(#coverage-line-pattern-hidden)';
- // allow moving striped background for large width lines
- let rectTransform = leftOffset === 0 && isWidthGreaterThanRendered && !layerEndBeforeAxisBack
- ? positionTransformX
- : leftOffset;
+ // allow moving striped background for large width lines
+ let rectTransform = leftOffset === 0 && isWidthGreaterThanRendered && !layerEndBeforeAxisBack
+ ? positionTransformX
+ : leftOffset;
- // determine line radius for line start/end vs. partial large width lines
- let lineRadius = !isWidthGreaterThanRendered ||
- (leftOffset !== 0 && isWidthGreaterThanRendered)
- ? '6'
- : '0';
+ // determine line radius for line start/end vs. partial large width lines
+ let lineRadius = !isWidthGreaterThanRendered ||
+ (leftOffset !== 0 && isWidthGreaterThanRendered)
+ ? '6'
+ : '0';
- // handle "false transform" line edge to simulate line movement for striped background
- if (leftOffset === 0 &&
- ((isWidthGreaterThanRendered && layerEndBeforeAxisBack) ||
- (!isWidthGreaterThanRendered && layerStartBeforeAxisFront))) {
- lineWidth -= positionTransformX;
- rectTransform += positionTransformX;
- lineRadius = '6';
- }
+ // handle "false transform" line edge to simulate line movement for striped background
+ if (leftOffset === 0 &&
+ ((isWidthGreaterThanRendered && layerEndBeforeAxisBack) ||
+ (!isWidthGreaterThanRendered && layerStartBeforeAxisFront))) {
+ lineWidth -= positionTransformX;
+ rectTransform += positionTransformX;
+ lineRadius = '6';
+ }
- return (
- <g
- key={index}
- className="layer-coverage-line-group"
+ return (
+ <g
+ key={index}
+ className="layer-coverage-line-group"
+ >
+ <rect
+ id={`layer-coverage-line-${dateRangeStartEnd}`}
+ className="layer-coverage-line"
+ width={`${lineWidth}px`}
+ height="12px"
+ x="0"
+ y="0"
+ fill={patternType}
+ rx={lineRadius}
+ transform={`translate(${rectTransform})`}
>
- <rect
- id={`layer-coverage-line-${dateRangeStartEnd}`}
- className="layer-coverage-line"
- width={`${lineWidth}px`}
- height="12px"
- x="0"
- y="0"
- fill={patternType}
- rx={lineRadius}
- transform={`translate(${rectTransform})`}
- >
- <title>{toolTipText}</title>
- </rect>
- </g>
- );
+ <title>{toolTipText}</title>
+ </rect>
+ </g>
+ );
+};
+
+/*
+ * Coverage Line for DOM Element layer coverage.
+ *
+ * @class CoverageLine PureComponent
+ */
+
+const CoverageLine = memo(({
+ color,
+ endDate,
+ id,
+ index,
+ layerPeriod,
+ lineType,
+ options,
+ positionTransformX,
+ startDate,
+}) => {
+ const line = {
+ id, lineType, startDate, endDate, color, layerPeriod, index,
};
+ return options.map((option, i) => (
+ <g clipPath="url(#coverageLineBoundary)" key={`${id}-${i}`}>
+ {createMatchingCoverageLineDOMEl(option, line, positionTransformX)}
+ </g>
+ ));
+});
- render() {
- const {
- id,
- options,
- lineType,
- startDate,
- endDate,
- color,
- layerPeriod,
- index,
- } = this.props;
- return options.map((option, i) => (
- <g clipPath="url(#coverageLineBoundary)" key={`${id}-${i}`}>
- {this.createMatchingCoverageLineDOMEl(
- id,
- option,
- lineType,
- startDate,
- endDate,
- color,
- layerPeriod,
- index,
- )}
- </g>
- ));
- }
-}
+CoverageLine.getFormattedDisplayDates = getFormattedDisplayDates;
CoverageLine.propTypes = {
color: PropTypes.string,
diff --git a/web/js/components/timeline/timeline-coverage/timeline-coverage.js b/web/js/components/timeline/timeline-coverage/timeline-coverage.js
index 7da2e72a8..41be918a3 100644
--- a/web/js/components/timeline/timeline-coverage/timeline-coverage.js
+++ b/web/js/components/timeline/timeline-coverage/timeline-coverage.js
@@ -1,4 +1,4 @@
-import { Component } from 'react';
+import { memo, useEffect, useRef, useState } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
@@ -19,104 +19,47 @@ import Switch from '../../util/switch';
import LayerCoverageInfoModal from './info-modal';
import CoverageItemList from './coverage-item-list';
-/*
- * Timeline Layer Coverage Panel for temporal coverage.
- *
- * @class TimelineLayerCoveragePanel
+/**
+ * @desc stop event from bubling to the timeline
+ * @param {*} e - event
+ * @returns {void}
*/
+const stopPropagation = (e) => {
+ e.nativeEvent.stopImmediatePropagation();
+ e.stopPropagation();
+ e.preventDefault();
+};
-class TimelineLayerCoveragePanel extends Component {
- static stopPropagation(e) {
- e.nativeEvent.stopImmediatePropagation();
- e.stopPropagation();
- e.preventDefault();
- }
-
- constructor(props) {
- super(props);
- this.state = {
- activeLayers: [],
- shouldIncludeHiddenLayers: false,
- };
- }
-
- componentDidMount() {
- const { activeLayers } = this.props;
- const { shouldIncludeHiddenLayers } = this.state;
-
- const layers = this.getActiveLayers(activeLayers);
- this.setActiveLayers(layers);
- // prevent bubbling to parent which the wheel event
- // is blocked for timeline zoom in/out wheel event
- document.querySelector('.timeline-layer-coverage-container').addEventListener('wheel', (e) => e.stopPropagation(), { passive: false });
- // init populate of activeLayers
- this.addMatchingCoverageToTimeline(shouldIncludeHiddenLayers, layers);
- }
-
- shouldComponentUpdate(nextProps) {
- const {
- timeScale,
- frontDate,
- backDate,
- } = this.props;
-
- // prevent repeated rendering on timescale change updates
- if (nextProps.timeScale !== timeScale) {
- const isFrontDateSame = nextProps.frontDate === frontDate;
- const isBackDateSame = nextProps.backDate === backDate;
- if (isFrontDateSame && isBackDateSame) {
- return false;
- }
- }
- return true;
- }
-
- componentDidUpdate(prevProps, prevState) {
- const {
- appNow,
- activeLayers,
- isProductPickerOpen,
- isTimelineLayerCoveragePanelOpen,
- projection,
- } = this.props;
- const { shouldIncludeHiddenLayers } = this.state;
-
- if (!prevProps.isProductPickerOpen && isProductPickerOpen && isTimelineLayerCoveragePanelOpen) {
- this.togglePanelOpenClose();
- return;
- }
-
- const updatedActiveLayers = this.getActiveLayers(activeLayers);
-
- const layersChange = !lodashIsEqual(updatedActiveLayers, this.state.activeLayers);
- const projectionChange = prevProps.projection !== projection;
- const toggleHiddenChange = prevState.shouldIncludeHiddenLayers !== shouldIncludeHiddenLayers;
- const appNowUpdated = prevProps.appNow !== appNow;
- if (projectionChange || toggleHiddenChange || layersChange || appNowUpdated) {
- // update coverage including layer added/removed and option changes (active/inactive)
- this.setActiveLayers(updatedActiveLayers);
- this.addMatchingCoverageToTimeline(shouldIncludeHiddenLayers, updatedActiveLayers);
- }
- }
-
- /**
- * @desc set active layers
- * @param {Array} layers
- * @returns {void}
- */
- setActiveLayers = (layers) => {
- this.setState({
- activeLayers: layers,
- });
- };
+const TimelineLayerCoveragePanel = ({
+ activeLayers: allActiveLayers,
+ appNow,
+ axisWidth,
+ backDate,
+ frontDate,
+ isProductPickerOpen,
+ isTimelineLayerCoveragePanelOpen,
+ onInfoClick,
+ parentOffset,
+ positionTransformX,
+ projection,
+ setMatchingTimelineCoverage,
+ timelineStartDateLimit,
+ timeScale,
+ toggleLayerCoveragePanel,
+}) => {
+ const [activeLayers, setActiveLayers] = useState([]);
+ const [shouldIncludeHiddenLayers, setShouldIncludeHiddenLayers] = useState(false);
+ const containerRef = useRef(null);
+ const prevRef = useRef(null);
/**
* @desc get active layers
* @param {Array} layers
* @returns {Array}
+ *
+ * renamed from getActiveLayers to filterVisibleLayers so it does not conflict
*/
- getActiveLayers = (layers) => {
- const { shouldIncludeHiddenLayers } = this.state;
+ const filterVisibleLayers = (layers) => {
return layers.filter((layer) => (shouldIncludeHiddenLayers ? true : layer.visible));
};
@@ -127,22 +70,13 @@ class TimelineLayerCoveragePanel extends Component {
* @param {String} rangeEnd
* @returns {Array} visible, leftOffset, width, isWidthGreaterThanRendered
*/
- getMatchingCoverageLineDimensions = (layer, rangeStart, rangeEnd) => {
- const {
- appNow,
- axisWidth,
- backDate,
- frontDate,
- positionTransformX,
- timeScale,
- timelineStartDateLimit,
- } = this.props;
+ const getMatchingCoverageLineDimensions = (layer, rangeStart, rangeEnd) => {
const {
- futureTime, ongoing,
+ futureTime, granuleDateRanges, ongoing, startDate, endDate,
} = layer;
- if (layer.granuleDateRanges?.length) {
- return layer.granuleDateRanges.map(([startDate, endDate]) => {
+ if (granuleDateRanges?.length) {
+ return granuleDateRanges.map(([startDate, endDate]) => {
const { gridWidth } = timeScaleOptions[timeScale].timeAxis;
const axisFrontDate = new Date(frontDate).getTime();
const axisBackDate = new Date(backDate).getTime();
@@ -193,7 +127,6 @@ class TimelineLayerCoveragePanel extends Component {
};
});
}
- const { startDate, endDate } = layer;
const { gridWidth } = timeScaleOptions[timeScale].timeAxis;
const axisFrontDate = new Date(frontDate).getTime();
const axisBackDate = new Date(backDate).getTime();
@@ -255,31 +188,10 @@ class TimelineLayerCoveragePanel extends Component {
* @desc handle open/close modal from clicking handle
* @returns {void}
*/
- togglePanelOpenClose = () => {
- const {
- isTimelineLayerCoveragePanelOpen,
- toggleLayerCoveragePanel,
- } = this.props;
+ const togglePanelOpenClose = () => {
toggleLayerCoveragePanel(!isTimelineLayerCoveragePanelOpen);
};
- /**
- * @desc add matching coverage to timeline
- * @param {Boolean} isChecked
- * @param {Array} layers
- * @returns {void}
- */
-
- addMatchingCoverageToTimeline = async (isChecked, layers) => {
- const { setMatchingTimelineCoverage } = this.props;
- const dateRange = this.getNewMatchingDatesRange(layers);
- setMatchingTimelineCoverage(dateRange, isChecked);
- this.setState({
- activeLayers: layers,
- shouldIncludeHiddenLayers: isChecked,
- });
- };
-
/**
* @desc get startDate and endDate based on layers currently selected for matching coverage
* @param {Array} layers
@@ -287,10 +199,7 @@ class TimelineLayerCoveragePanel extends Component {
* @param {String} startDate
* @param {String} endDate
*/
- getNewMatchingDatesRange = (layers) => {
- const {
- appNow,
- } = this.props;
+ const getNewMatchingDatesRange = (layers) => {
if (layers.length > 0) {
return layers.flatMap(({ granuleDateRanges, startDate, endDate }) => {
if (!granuleDateRanges?.length) {
@@ -304,167 +213,179 @@ class TimelineLayerCoveragePanel extends Component {
};
/**
- * @desc render info button for layer coverage panel coverage info modal
- * @returns {DOM Object}
+ * @desc add matching coverage to timeline
+ * @param {Boolean} isChecked
+ * @param {Array} layers
+ * @returns {void}
*/
- renderInfoButton = () => {
- const { onInfoClick } = this.props;
- const layerInfoBtnId = 'layer-coverage-info-button';
- const layerInfoBtnTitle = 'Timeline Layer Coverage Information';
- return (
- <button
- type="button"
- id={layerInfoBtnId}
- aria-label={layerInfoBtnTitle}
- className={layerInfoBtnId}
- onMouseDown={TimelineLayerCoveragePanel.stopPropagation}
- onClick={() => onInfoClick()}
- >
- <FontAwesomeIcon icon="question-circle" className="layer-coverage-info-button-icon" widthAuto />
- </button>
- );
+ const addMatchingCoverageToTimeline = async (isChecked, layers) => {
+ const dateRange = getNewMatchingDatesRange(layers);
+ setMatchingTimelineCoverage(dateRange, isChecked);
+ setActiveLayers(layers);
+ setShouldIncludeHiddenLayers(isChecked);
};
- /**
- * @desc handle dynamic conditional container styling, className, and text label generation
- * @returns {Object}
- */
- getConditionalStyles = () => {
- const {
- axisWidth,
- isTimelineLayerCoveragePanelOpen,
- parentOffset,
- } = this.props;
- const {
- activeLayers,
- } = this.state;
-
- // conditional style properties
- const maxHeightScrollBar = '203px';
- const layerListItemHeightConstant = Math.max(1, activeLayers.length) * 41;
- const layerCoveragePanelHandleTopOffset = `${Math.max(-54 - layerListItemHeightConstant, -259)}px`;
-
- const mainContainerWidth = `${axisWidth + 1}px`;
- const mainContainerHeight = `${Math.min(35 + layerListItemHeightConstant, 240)}px`;
- const mainContainerLeftOffset = `${parentOffset - 10}px`;
-
- // conditional classNames and label text
- const isPanelOpenClassName = `timeline-layer-coverage-${isTimelineLayerCoveragePanelOpen ? 'open' : 'closed'}`;
- const panelChevronClassName = `timeline-layer-coverage-panel-handle-chevron-${isTimelineLayerCoveragePanelOpen ? 'open' : 'closed'}`;
- const panelToggleLabelText = isTimelineLayerCoveragePanelOpen ? 'Collapse layer coverage panel' : 'Show layer coverage panel';
-
- // conditional style objects
- const panelHandleStyle = {
- right: Math.floor((axisWidth + 75) / 2),
- top: isTimelineLayerCoveragePanelOpen ? layerCoveragePanelHandleTopOffset : '-19px',
- };
- const panelContainerStyle = {
- width: mainContainerWidth,
- height: isTimelineLayerCoveragePanelOpen ? mainContainerHeight : 0,
- left: mainContainerLeftOffset,
- display: isTimelineLayerCoveragePanelOpen ? 'block' : 'none',
- };
- const layerCoverageStyle = { width: mainContainerWidth };
- const scrollbarStyle = { maxHeight: maxHeightScrollBar };
-
- return {
- panelHandleStyle,
- panelContainerStyle,
- layerCoverageStyle,
- scrollbarStyle,
- panelToggleLabelText,
- panelChevronClassName,
- isPanelOpenClassName,
+ // componentDidMount
+ useEffect(() => {
+ const container = containerRef.current;
+ const onWheel = (e) => e.stopPropagation();
+ container.addEventListener('wheel', onWheel, {passive: false});
+
+ addMatchingCoverageToTimeline(shouldIncludeHiddenLayers, filterVisibleLayers(allActiveLayers));
+
+ return () => {
+ container.removeEventListener('wheel', onWheel);
};
- };
+ }, []);
- render() {
- const {
+ // componentDidUpdate
+ useEffect(() => {
+ const prev = prevRef.current;
+ prevRef.current = {
appNow,
- axisWidth,
- backDate,
- frontDate,
- isTimelineLayerCoveragePanelOpen,
- positionTransformX,
- timeScale,
- } = this.props;
- const {
- activeLayers,
+ isProductPickerOpen,
+ projection,
shouldIncludeHiddenLayers,
- } = this.state;
+ };
- const {
- panelHandleStyle,
- panelContainerStyle,
- layerCoverageStyle,
- scrollbarStyle,
- panelToggleLabelText,
- panelChevronClassName,
- isPanelOpenClassName,
- } = this.getConditionalStyles();
-
- return (
- <>
- {/* Timeline Layer Coverage Panel open/close handle */}
- <button
- type="button"
- id="timeline-layer-coverage-panel-handle"
- aria-label={panelToggleLabelText}
- onClick={this.togglePanelOpenClose}
- style={panelHandleStyle}
- >
- <UncontrolledTooltip id="center-align-tooltip" placement="top" target="timeline-layer-coverage-panel-handle">
- {panelToggleLabelText}
- </UncontrolledTooltip>
- <div className={`timeline-layer-coverage-panel-handle-chevron ${panelChevronClassName}`} />
- </button>
- <div
- className={`timeline-layer-coverage-container ${isPanelOpenClassName}`}
- style={panelContainerStyle}
- >
- {/* Timeline Layer Coverage Panel */}
- {isTimelineLayerCoveragePanelOpen &&
- (
- <div
- className="timeline-layer-coverage"
- style={layerCoverageStyle}
- >
- <header className="timeline-layer-coverage-header">
- <h3 className="timeline-layer-coverage-header-title">LAYER COVERAGE</h3>
- {this.renderInfoButton()}
- <Switch
- active={shouldIncludeHiddenLayers}
- border
- color="00457b"
- id="toggle-layer-coverage-include-hidden"
- containerClassAddition="toggle-layer-coverage-include-hidden"
- label="Include Hidden Layers"
- toggle={() => this.addMatchingCoverageToTimeline(
- !shouldIncludeHiddenLayers,
- activeLayers,
- )}
- />
- </header>
- <Scrollbars style={scrollbarStyle}>
- <CoverageItemList
- activeLayers={activeLayers}
- appNow={appNow}
- axisWidth={axisWidth}
- backDate={backDate}
- frontDate={frontDate}
- getMatchingCoverageLineDimensions={this.getMatchingCoverageLineDimensions}
- timeScale={timeScale}
- positionTransformX={positionTransformX}
- />
- </Scrollbars>
- </div>
- )}
- </div>
- </>
- );
- }
-}
+ // skip the first render
+ if (!prev) return;
+
+ if (!prev.isProductPickerOpen && isProductPickerOpen && isTimelineLayerCoveragePanelOpen) {
+ togglePanelOpenClose();
+ return;
+ }
+
+ const updatedActiveLayers = filterVisibleLayers(allActiveLayers);
+
+ const layersChange = !lodashIsEqual(updatedActiveLayers, activeLayers);
+ const projectionChange = prev.projection !== projection;
+ const toggleHiddenChange = prev.shouldIncludeHiddenLayers !== shouldIncludeHiddenLayers;
+ const appNowUpdated = prev.appNow !== appNow;
+ if (projectionChange || toggleHiddenChange || layersChange || appNowUpdated) {
+ // update coverage including layer added/removed and option changes (active/inactive)
+ addMatchingCoverageToTimeline(shouldIncludeHiddenLayers, updatedActiveLayers);
+ }
+ });
+
+ // conditional style properties
+ const maxHeightScrollBar = '203px';
+ const layerListItemHeightConstant = Math.max(1, activeLayers.length) * 41;
+ const layerCoveragePanelHandleTopOffset = `${Math.max(-54 - layerListItemHeightConstant, -259)}px`;
+
+ const mainContainerWidth = `${axisWidth + 1}px`;
+ const mainContainerHeight = `${Math.min(35 + layerListItemHeightConstant, 240)}px`;
+ const mainContainerLeftOffset = `${parentOffset - 10}px`;
+
+ // conditional classNames and label text
+ const isPanelOpenClassName = `timeline-layer-coverage-${isTimelineLayerCoveragePanelOpen ? 'open' : 'closed'}`;
+ const panelChevronClassName = `timeline-layer-coverage-panel-handle-chevron-${isTimelineLayerCoveragePanelOpen ? 'open' : 'closed'}`;
+ const panelToggleLabelText = isTimelineLayerCoveragePanelOpen ? 'Collapse layer coverage panel' : 'Show layer coverage panel';
+
+ // conditional style objects
+ const panelHandleStyle = {
+ right: Math.floor((axisWidth + 75) / 2),
+ top: isTimelineLayerCoveragePanelOpen ? layerCoveragePanelHandleTopOffset : '-19px',
+ };
+ const panelContainerStyle = {
+ width: mainContainerWidth,
+ height: isTimelineLayerCoveragePanelOpen ? mainContainerHeight : 0,
+ left: mainContainerLeftOffset,
+ display: isTimelineLayerCoveragePanelOpen ? 'block' : 'none',
+ };
+ const layerCoverageStyle = { width: mainContainerWidth };
+ const scrollbarStyle = { maxHeight: maxHeightScrollBar };
+
+ const layerInfoBtnId = 'layer-coverage-info-button';
+ const layerInfoBtnTitle = 'Timeline Layer Coverage Information';
+
+ return (
+ <>
+ {/* Timeline Layer Coverage Panel open/close handle */}
+ <button
+ type="button"
+ id="timeline-layer-coverage-panel-handle"
+ aria-label={panelToggleLabelText}
+ onClick={togglePanelOpenClose}
+ style={panelHandleStyle}
+ >
+ <UncontrolledTooltip id="center-align-tooltip" placement="top" target="timeline-layer-coverage-panel-handle">
+ {panelToggleLabelText}
+ </UncontrolledTooltip>
+ <div className={`timeline-layer-coverage-panel-handle-chevron ${panelChevronClassName}`} />
+ </button>
+ <div
+ ref={containerRef}
+ className={`timeline-layer-coverage-container ${isPanelOpenClassName}`}
+ style={panelContainerStyle}
+ >
+ {/* Timeline Layer Coverage Panel */}
+ {isTimelineLayerCoveragePanelOpen &&
+ (
+ <div
+ className="timeline-layer-coverage"
+ style={layerCoverageStyle}
+ >
+ <header className="timeline-layer-coverage-header">
+ <h3 className="timeline-layer-coverage-header-title">LAYER COVERAGE</h3>
+ <button
+ type="button"
+ id={layerInfoBtnId}
+ aria-label={layerInfoBtnTitle}
+ className={layerInfoBtnId}
+ onMouseDown={stopPropagation}
+ onClick={() => onInfoClick()}
+ >
+ <FontAwesomeIcon icon="question-circle" className="layer-coverage-info-button-icon" widthAuto />
+ </button>
+ <Switch
+ active={shouldIncludeHiddenLayers}
+ border
+ color="00457b"
+ id="toggle-layer-coverage-include-hidden"
+ containerClassAddition="toggle-layer-coverage-include-hidden"
+ label="Include Hidden Layers"
+ toggle={() => addMatchingCoverageToTimeline(
+ !shouldIncludeHiddenLayers,
+ activeLayers,
+ )}
+ />
+ </header>
+ <Scrollbars style={scrollbarStyle}>
+ <CoverageItemList
+ activeLayers={activeLayers}
+ appNow={appNow}
+ axisWidth={axisWidth}
+ backDate={backDate}
+ frontDate={frontDate}
+ getMatchingCoverageLineDimensions={getMatchingCoverageLineDimensions}
+ timeScale={timeScale}
+ positionTransformX={positionTransformX}
+ />
+ </Scrollbars>
+ </div>
+ )}
+ </div>
+ </>
+ );
+};
+
+/**
+* @desc memo comparator replacing shouldComponentUpdate - returns true to SKIP a render.
+* Prevents repeated rendering on timescale change updates when the axis dates are unchanged.
+* @param {Object} prevProps
+* @param {Object} nextProps
+* @returns {Boolean}
+*/
+const areEqual = (prevProps, nextProps) => nextProps.timeScale !== prevProps.timeScale &&
+ nextProps.frontDate === prevProps.frontDate &&
+ nextProps.backDate === prevProps.backDate;
+
+const MemoizedTimelineLayerCoveragePanel = memo(TimelineLayerCoveragePanel, areEqual);
+
+// exposed as a static for callers/tests that used the class static method
+MemoizedTimelineLayerCoveragePanel.stopPropagation = stopPropagation;
function mapStateToProps(state) {
const {
@@ -531,4 +452,4 @@ TimelineLayerCoveragePanel.propTypes = {
export default connect(
mapStateToProps,
mapDispatchToProps,
-)(TimelineLayerCoveragePanel);
+)(MemoizedTimelineLayerCoveragePanel);