# All files / utils getBandHoverIndices.ts

7.14% Statements 3/42
0% Branches 0/20
0% Functions 0/7
7.14% Lines 3/42

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    1x

    1x

    1x

     import {NumericColumnData, BandIndexMap, LineData} from '../types'
    import {isDefined} from './isDefined'

    interface LineLengths {
      [index: string]: {
        length: number
        startIndex: number
      }
    }

    export interface BandHoverIndices {
      rowIndices: number[]
      lowerIndices: number[]
      upperIndices: number[]
    }

    export const getLineLengths = (lineData: LineData): LineLengths => {
      const keys = Object.keys(lineData)

      const lineLengths = {}
      let total = 0
      if (Array.isArray(keys)) {
        keys.forEach(lineIndex => {
          const length = Math.min(
            lineData[lineIndex].xs.length,
            lineData[lineIndex].ys.length
          )
          if (!lineLengths[lineIndex]) {
            lineLengths[lineIndex] = {}
          }
          lineLengths[lineIndex].length = length
          lineLengths[lineIndex].startIndex = total
          total += length
        })
      }
      return lineLengths
    }

    export const getBandHoverIndices = (
      lineLengths: LineLengths,
      hoverRowIndices: number[],
      hoverGroupData: NumericColumnData,
      bandLineIndexMap: object
    ): BandIndexMap => {
      const bandHoverIndices = {
        rowIndices: [],
        lowerIndices: [],
        upperIndices: [],
      }
      const hoverGroupBoundaries = {}

      if (Array.isArray(hoverGroupData)) {
        hoverGroupData.forEach((lineIndex, position) => {
          if (!hoverGroupBoundaries[lineIndex]) {
            hoverGroupBoundaries[lineIndex] = {
              length: lineLengths[lineIndex].length,
              startIndex: position,
            }
          }
        })
      }

      const bands = bandLineIndexMap ? Object.values(bandLineIndexMap) : []
      bands.forEach(band => {
        if (hoverGroupBoundaries[band.row]) {
          hoverGroupBoundaries[band.row].upper = band.upper
          hoverGroupBoundaries[band.row].lower = band.lower
        }
      })

      if (Array.isArray(hoverRowIndices)) {
        hoverRowIndices.forEach(index => {
          const columnId = hoverGroupData[index]
          const hoveredBandId = Object.keys(hoverGroupBoundaries).find(
            bandId => Number(bandId) === Number(columnId)
          )

          if (hoverGroupBoundaries[hoveredBandId]) {
            const rowBase = lineLengths[hoveredBandId].startIndex
            const offset = index - hoverGroupBoundaries[hoveredBandId].startIndex

            bandHoverIndices.rowIndices.push(rowBase + offset)

            if (isDefined(hoverGroupBoundaries[hoveredBandId].upper)) {
              const upperBase =
                lineLengths[hoverGroupBoundaries[hoveredBandId].upper].startIndex
              bandHoverIndices.upperIndices.push(upperBase + offset)
            }

            if (isDefined(hoverGroupBoundaries[hoveredBandId].lower)) {
              const lowerBase =
                lineLengths[hoverGroupBoundaries[hoveredBandId].lower].startIndex
              bandHoverIndices.lowerIndices.push(lowerBase + offset)
            }
          }
        })
      }

      return bandHoverIndices
    }