Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

15.2 KB
Raw Blame
import { memo, useEffect, useRef, useState } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { UncontrolledTooltip } from 'reactstrap';
import moment from 'moment';
import {
  isEqual as lodashIsEqual,
} from 'lodash';
import googleTagManager from 'googleTagManager';
import { timeScaleOptions } from '../../../modules/date/constants';
import {
  filterProjLayersWithStartDate,
} from '../../../modules/date/util';
import { getActiveLayers } from '../../../modules/layers/selectors';
import { toggleCustomContent } from '../../../modules/modal/actions';
import Scrollbars from '../../util/scrollbar';
import Switch from '../../util/switch';
import LayerCoverageInfoModal from './info-modal';
import CoverageItemList from './coverage-item-list';

/**
 * @desc stop event from bubling to the timeline
 * @param {*} e - event
 * @returns {void}
 */
const stopPropagation = (e) => {
  e.nativeEvent.stopImmediatePropagation();
  e.stopPropagation();
  e.preventDefault();
};

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
  */
  const filterVisibleLayers = (layers) => {
    return layers.filter((layer) => (shouldIncludeHiddenLayers ? true : layer.visible));
  };

  /**
  * @desc get line dimensions for given date range
  * @param {Object} layer
  * @param {String} rangeStart
  * @param {String} rangeEnd
  * @returns {Array} visible, leftOffset, width, isWidthGreaterThanRendered
  */
  const getMatchingCoverageLineDimensions = (layer, rangeStart, rangeEnd) => {
    const {
      futureTime, granuleDateRanges, ongoing, startDate, endDate,
    } = layer;

    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();
        let layerStart;
        const layerEnd = new Date(endDate).getTime();

        if (rangeStart || startDate) {
          layerStart = new Date(startDate).getTime();
        } else {
          layerStart = new Date(timelineStartDateLimit).getTime();
        }

        let visible = true;
        if (layerStart >= axisBackDate || layerEnd <= axisFrontDate) {
          visible = false;
        }

        let leftOffset = 0;
        const isWidthGreaterThanRendered = layerStart < axisFrontDate || layerEnd > axisBackDate;
        const layerStartBeforeAxisFront = layerStart <= axisFrontDate;
        const layerEndBeforeAxisBack = layerEnd <= axisBackDate;
        // oversized width allows axis drag buffer
        let width = axisWidth * 5;
        if (visible) {
          if (layerStartBeforeAxisFront) {
            leftOffset = 0;
          } else {
            // positive diff means layerStart more recent than axisFrontDate
            const diff = moment.utc(layerStart).diff(axisFrontDate, timeScale, true);
            const gridDiff = gridWidth * diff;
            leftOffset = gridDiff + positionTransformX;
          }
          if (layerEndBeforeAxisBack) {
            // positive diff means layerEnd earlier than back date
            const diff = moment.utc(layerEnd).diff(axisFrontDate, timeScale, true);
            const gridDiff = gridWidth * diff;
            width = gridDiff + positionTransformX - leftOffset;
          }
        }

        return {
          visible,
          leftOffset,
          width,
          isWidthGreaterThanRendered,
          layerStartBeforeAxisFront,
          layerEndBeforeAxisBack,
        };
      });
    }
    const { gridWidth } = timeScaleOptions[timeScale].timeAxis;
    const axisFrontDate = new Date(frontDate).getTime();
    const axisBackDate = new Date(backDate).getTime();
    let layerStart;
    let layerEnd;

    if (rangeStart || startDate) {
      layerStart = new Date(rangeStart || startDate).getTime();
    } else {
      layerStart = new Date(timelineStartDateLimit).getTime();
    }
    if (rangeEnd || !ongoing) {
      layerEnd = new Date(rangeEnd || endDate).getTime();
    } else if (futureTime && endDate) {
      layerEnd = new Date(endDate).getTime();
    } else {
      layerEnd = new Date(appNow).getTime();
    }

    let visible = true;
    if (layerStart >= axisBackDate || layerEnd <= axisFrontDate) {
      visible = false;
    }

    let leftOffset = 0;
    const isWidthGreaterThanRendered = layerStart < axisFrontDate || layerEnd > axisBackDate;
    const layerStartBeforeAxisFront = layerStart <= axisFrontDate;
    const layerEndBeforeAxisBack = layerEnd <= axisBackDate;
    // oversized width allows axis drag buffer
    let width = axisWidth * 5;
    if (visible) {
      if (layerStartBeforeAxisFront) {
        leftOffset = 0;
      } else {
        // positive diff means layerStart more recent than axisFrontDate
        const diff = moment.utc(layerStart).diff(axisFrontDate, timeScale, true);
        const gridDiff = gridWidth * diff;
        leftOffset = gridDiff + positionTransformX;
      }
      if (layerEndBeforeAxisBack) {
        // positive diff means layerEnd earlier than back date
        const diff = moment.utc(layerEnd).diff(axisFrontDate, timeScale, true);
        const gridDiff = gridWidth * diff;
        width = gridDiff + positionTransformX - leftOffset;
      }
    }

    return [{
      visible,
      leftOffset,
      width,
      isWidthGreaterThanRendered,
      layerStartBeforeAxisFront,
      layerEndBeforeAxisBack,
    }];
  };

  /**
  * @desc handle open/close modal from clicking handle
  * @returns {void}
  */
  const togglePanelOpenClose = () => {
    toggleLayerCoveragePanel(!isTimelineLayerCoveragePanelOpen);
  };

  /**
  * @desc get startDate and endDate based on layers currently selected for matching coverage
  * @param {Array} layers
  * @returns {Object}
    * @param {String} startDate
    * @param {String} endDate
  */
  const getNewMatchingDatesRange = (layers) => {
    if (layers.length > 0) {
      return layers.flatMap(({ granuleDateRanges, startDate, endDate }) => {
        if (!granuleDateRanges?.length) {
          return [{ startDate, endDate: endDate || appNow }];
        }

        return granuleDateRanges.map(([start, end]) => ({ startDate: start, endDate: end }));
      });
    }
    return undefined;
  };

  /**
  * @desc add matching coverage to timeline
  * @param {Boolean} isChecked
  * @param {Array} layers
  * @returns {void}
  */

  const addMatchingCoverageToTimeline = async (isChecked, layers) => {
    const dateRange = getNewMatchingDatesRange(layers);
    setMatchingTimelineCoverage(dateRange, isChecked);
    setActiveLayers(layers);
    setShouldIncludeHiddenLayers(isChecked);
  };

  // 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);
    };
  }, []);

  // componentDidUpdate
  useEffect(() => {
    const prev = prevRef.current;
    prevRef.current = {
      appNow,
      isProductPickerOpen,
      projection,
      shouldIncludeHiddenLayers,
    };

    // 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 {
    date,
    modal,
    proj,
  } = state;
  const {
    appNow,
  } = date;

  // handle active layer filtering
  const activeLayers = getActiveLayers(state);
  const projection = proj.id;
  const activeLayersFiltered = filterProjLayersWithStartDate(activeLayers, projection);
  const isProductPickerOpen = modal.isOpen && modal.id === 'LAYER_PICKER_COMPONENT';

  return {
    activeLayers: activeLayersFiltered,
    appNow,
    isProductPickerOpen,
    projection,
  };
}

const mapDispatchToProps = (dispatch) => ({
  onInfoClick: () => {
    const key = 'TIMELINE_LAYER_COVERAGE_INFO_MODAL';
    googleTagManager.pushEvent({
      event: 'layer_coverage_panel_info',
    });
    dispatch(
      toggleCustomContent(key, {
        headerText: 'Timeline Layer Coverage',
        backdrop: false,
        size: 'lg',
        bodyComponent: LayerCoverageInfoModal,
        modalClassName: ' timeline-layer-coverage-info-modal',
        wrapClassName: 'clickable-behind-modal',
        desktopOnly: true,
      }),
    );
  },
});

TimelineLayerCoveragePanel.propTypes = {
  activeLayers: PropTypes.oneOfType([PropTypes.array, PropTypes.oneOf(['null'])]),
  appNow: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
  axisWidth: PropTypes.number,
  backDate: PropTypes.string,
  frontDate: PropTypes.string,
  isTimelineLayerCoveragePanelOpen: PropTypes.bool,
  isProductPickerOpen: PropTypes.bool,
  onInfoClick: PropTypes.func,
  parentOffset: PropTypes.number,
  positionTransformX: PropTypes.number,
  projection: PropTypes.string,
  setMatchingTimelineCoverage: PropTypes.func,
  timelineStartDateLimit: PropTypes.string,
  timeScale: PropTypes.string,
  toggleLayerCoveragePanel: PropTypes.func,
};

export default connect(
  mapStateToProps,
  mapDispatchToProps,
)(MemoizedTimelineLayerCoveragePanel);