@cdc/map 4.26.3 → 4.26.5

package/src/helpers/countyTerritories.ts

@@ -0,0 +1,38 @@
+export const US_TERRITORY_STATE_FIPS_PREFIXES = new Set(['60', '66', '69', '72', '78'])
+
+export type CountyTerritoryVisibility = {
+  showTerritories: boolean
+  statePrefixes: Set<string>
+  countyIds: Set<string>
+  key: string
+}
+
+export const getCountyTerritoryVisibility = (
+  territoriesAlwaysShow: boolean | undefined,
+  runtimeData?: Record<string, any>
+): CountyTerritoryVisibility => {
+  const countyIds = new Set<string>()
+  const statePrefixes = new Set<string>()
+
+  if (runtimeData) {
+    Object.keys(runtimeData).forEach(key => {
+      if (key.length <= 2) return
+
+      const statePrefix = key.slice(0, 2)
+      if (!US_TERRITORY_STATE_FIPS_PREFIXES.has(statePrefix)) return
+
+      countyIds.add(key)
+      statePrefixes.add(statePrefix)
+    })
+  }
+
+  const showTerritories = territoriesAlwaysShow !== false && countyIds.size > 0
+  const key = `${showTerritories}:${showTerritories ? Array.from(countyIds).sort().join(',') : ''}`
+
+  return {
+    showTerritories,
+    statePrefixes,
+    countyIds,
+    key
+  }
+}

package/src/helpers/dataTableHelpers.ts

@@ -1,6 +1,6 @@
 import {
   stateFipsToTwoDigit as stateFipsToAbbreviation,
-  supportedStatesFipsCodes as supportedStateCodes
+  supportedStatesFipsCodes as supportedStateFipsCodes
 } from '../data/supported-geos'
 
 /**
@@ -13,18 +13,46 @@ export const shouldShowDataTable = (config: any, table: any, general: any, loadi
 /**
  * Filters county runtime data to a selected state code for data table display.
  * Keeps the original non-enumerable fromHash metadata when present.
+ * Fail-safe: if no recognizable state columns exist in the data, returns original
+ * data unfiltered (avoids breaking misconfigured datasets). If valid state columns
+ * exist but a state has no data, returns empty result as expected.
  */
 export const filterCountyTableRuntimeDataByStateCode = (runtimeData: any, stateCode: string, config?: any) => {
   if (!runtimeData || runtimeData.init || !stateCode) return runtimeData
 
-  const filtered = {}
-  const stateName = supportedStateCodes[stateCode]
-  const stateAbbreviation = stateFipsToAbbreviation[stateCode]
+  const runtimeKeys = Object.keys(runtimeData)
+  if (runtimeKeys.length === 0) return runtimeData
+
+  const stateName = supportedStateFipsCodes?.[stateCode]
+  const stateAbbreviation = stateFipsToAbbreviation?.[stateCode]
   const normalizedSelectedStateCode = String(stateCode).replace(/^0+/, '')
   const paddedSelectedStateCode = normalizedSelectedStateCode.padStart(2, '0')
   const stateColumnNames = Object.values(config?.columns || {})
     .map((column: any) => column?.name)
-    .filter((name: string) => !!name && /(state|territory|fips)/i.test(name))
+    .filter((name: string) => !!name && /(state|territory|fips|jurisdiction)/i.test(name))
+
+  // Also check common state field names directly in the data rows
+  const commonStateFieldNames = [
+    'jurisdiction',
+    'state',
+    'State',
+    'state_name',
+    'stateName',
+    'State/Territory',
+    'state_territory_name'
+  ]
+  const allStateColumns = [...new Set([...stateColumnNames, ...commonStateFieldNames])]
+
+  // Fail-safe: check if UIDs look like county FIPS codes (5 digits) OR if any state column exists in the data
+  const hasCountyFipsUids = runtimeKeys.some(uid => /^\d{5}$/.test(String(uid)))
+  const hasStateColumn = runtimeKeys.some(uid => allStateColumns.some(col => runtimeData[uid]?.[col] !== undefined))
+
+  // If data has neither county FIPS UIDs nor any recognizable state columns, don't filter
+  if (!hasCountyFipsUids && !hasStateColumn) {
+    return runtimeData
+  }
+
+  const filtered = {}
 
   if (runtimeData.fromHash !== undefined) {
     Object.defineProperty(filtered, 'fromHash', {
@@ -38,7 +66,8 @@ export const filterCountyTableRuntimeDataByStateCode = (runtimeData: any, stateC
     const normalizedUidPrefix = uidPrefix.startsWith('0') ? uidPrefix.slice(1) : uidPrefix
     const matchesUidPrefix =
       uidPrefix === paddedSelectedStateCode || normalizedUidPrefix === normalizedSelectedStateCode
-    const matchesStateColumn = stateColumnNames.some((columnName: string) => {
+
+    const matchesStateColumn = allStateColumns.some((columnName: string) => {
       const rawValue = row?.[columnName]
       if (rawValue === undefined || rawValue === null) return false
 

package/src/helpers/generateRuntimeFilters.ts

@@ -13,6 +13,7 @@ export const generateRuntimeFilters = (state, hash, runtimeFilters) => {
         queryParameter,
         orderedValues,
         active,
+        defaultValue,
         values,
         type,
         showDropdown,
@@ -50,7 +51,7 @@ export const generateRuntimeFilters = (state, hash, runtimeFilters) => {
       newFilter.values = values
       newFilter.setByQueryParameter = setByQueryParameter
       handleSorting(newFilter)
-      newFilter.active = active ?? values[0] // Default to first found value
+      newFilter.active = active ?? defaultValue ?? values[0] // Default to configured defaultValue, then first found value
       newFilter.filterStyle = state.filters[idx].filterStyle ? state.filters[idx].filterStyle : 'dropdown'
       newFilter.showDropdown = showDropdown
       newFilter.subGrouping = state.filters[idx].subGrouping

package/src/helpers/handleMapAriaLabels.ts

@@ -1,36 +1,51 @@
-export const handleMapAriaLabels = (state: MapConfig = '') => {
+import type { AltTextConfig } from '@cdc/core/types/AltText'
+import { resolveAltTextDescription } from '@cdc/core/helpers/resolveAltTextDescription'
+
+const getAutoLabel = (state): string => {
+  const {
+    general: { title, geoType, statesPicked }
+  } = state
+  let ariaLabel = ''
+  switch (geoType) {
+    case 'world':
+      ariaLabel += 'World map'
+      break
+    case 'us':
+      ariaLabel += 'United States map'
+      break
+    case 'us-county':
+      ariaLabel += `United States county map`
+      break
+    case 'single-state':
+      ariaLabel += `${statesPicked.map(sp => sp.stateName).join(', ')} county map`
+      break
+    case 'us-region':
+      ariaLabel += `United States HHS Region map`
+      break
+    default:
+      ariaLabel = 'Data visualization container'
+      break
+  }
+
+  if (title) {
+    ariaLabel += ` with the title: ${title}`
+  }
+
+  return ariaLabel
+}
+
+export const handleMapAriaLabels = (state: {
+  general?: { geoType?: string; title?: string; statesPicked?: { stateName: string }[] }
+  altText?: AltTextConfig
+  dataMetadata?: Record<string, string>
+}): string => {
   try {
-    if (!state.general.geoType) throw Error('handleMapAriaLabels: no geoType found in state')
-    const {
-      general: { title, geoType, statesPicked }
-    } = state
-    let ariaLabel = ''
-    switch (geoType) {
-      case 'world':
-        ariaLabel += 'World map'
-        break
-      case 'us':
-        ariaLabel += 'United States map'
-        break
-      case 'us-county':
-        ariaLabel += `United States county map`
-        break
-      case 'single-state':
-        ariaLabel += `${statesPicked.map(sp => sp.stateName).join(', ')} county map`
-        break
-      case 'us-region':
-        ariaLabel += `United States HHS Region map`
-        break
-      default:
-        ariaLabel = 'Data visualization container'
-        break
-    }
+    if (!state.general?.geoType) throw Error('handleMapAriaLabels: no geoType found in state')
 
-    if (title) {
-      ariaLabel += ` with the title: ${title}`
-    }
+    const title = getAutoLabel(state)
+    const description = resolveAltTextDescription(state.altText, state.dataMetadata)
 
-    return ariaLabel
+    return description ? `${title}. ${description}` : title
   } catch (e) {
     console.error('COVE: ', e.message) // eslint-disable-line
     return 'Data visualization container'

package/src/helpers/shouldAutoResetSingleStateZoom.ts

@@ -0,0 +1,22 @@
+type AutoResetArgs = {
+  isDashboard: boolean
+  previousRuntimeDataHash: number | null
+  nextRuntimeDataHash?: number
+  hasDashboardFilters?: boolean
+  allowMapZoom?: boolean
+}
+
+export const shouldAutoResetSingleStateZoom = ({
+  isDashboard,
+  previousRuntimeDataHash,
+  nextRuntimeDataHash,
+  hasDashboardFilters = false,
+  allowMapZoom = true
+}: AutoResetArgs): boolean => {
+  if (!isDashboard || !allowMapZoom) return false
+  if (!hasDashboardFilters) return false
+  if (previousRuntimeDataHash === null) return false
+  if (nextRuntimeDataHash === undefined) return false
+
+  return previousRuntimeDataHash !== nextRuntimeDataHash
+}

package/src/helpers/tests/countyTerritories.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest'
+import { getCountyTerritoryVisibility } from '../countyTerritories'
+
+describe('countyTerritories', () => {
+  it('collects visible territory prefixes and county ids from runtime data', () => {
+    const runtimeData = {
+      '06001': { uid: '06001', value: 1 },
+      '72001': { uid: '72001', value: 2 }
+    }
+
+    const visibility = getCountyTerritoryVisibility(true, runtimeData)
+
+    expect(visibility.showTerritories).toBe(true)
+    expect(Array.from(visibility.statePrefixes).sort()).toEqual(['72'])
+    expect(Array.from(visibility.countyIds).sort()).toEqual(['72001'])
+    expect(visibility.key).toBe('true:72001')
+  })
+
+  it('collects multiple territory prefixes and ignores non-territory counties', () => {
+    const runtimeData = {
+      '72001': { uid: '72001', value: 1 },
+      '72003': { uid: '72003', value: 2 },
+      '78010': { uid: '78010', value: 3 },
+      '06001': { uid: '06001', value: 4 }
+    }
+
+    const visibility = getCountyTerritoryVisibility(true, runtimeData)
+
+    expect(Array.from(visibility.statePrefixes).sort()).toEqual(['72', '78'])
+    expect(Array.from(visibility.countyIds).sort()).toEqual(['72001', '72003', '78010'])
+    expect(visibility.key).toBe('true:72001,72003,78010')
+  })
+
+  it('hides county territories when the config flag is disabled even if territory data exists', () => {
+    const runtimeData = {
+      '72001': { uid: '72001', value: 1 }
+    }
+
+    const visibility = getCountyTerritoryVisibility(false, runtimeData)
+
+    expect(visibility.showTerritories).toBe(false)
+    expect(Array.from(visibility.statePrefixes).sort()).toEqual(['72'])
+    expect(Array.from(visibility.countyIds).sort()).toEqual(['72001'])
+    expect(visibility.key).toBe('false:')
+  })
+
+  it('hides county territories when the config flag is enabled but no territory data exists', () => {
+    const runtimeData = {
+      '06001': { uid: '06001', value: 1 }
+    }
+
+    const visibility = getCountyTerritoryVisibility(true, runtimeData)
+
+    expect(visibility.showTerritories).toBe(false)
+    expect(Array.from(visibility.statePrefixes).sort()).toEqual([])
+    expect(Array.from(visibility.countyIds).sort()).toEqual([])
+    expect(visibility.key).toBe('false:')
+  })
+
+  it('treats an omitted config flag as enabled by default but still hides territories when no territory data exists', () => {
+    const runtimeData = {
+      '06001': { uid: '06001', value: 1 }
+    }
+
+    const visibility = getCountyTerritoryVisibility(undefined, runtimeData)
+
+    expect(visibility.showTerritories).toBe(false)
+    expect(Array.from(visibility.statePrefixes)).toEqual([])
+    expect(Array.from(visibility.countyIds)).toEqual([])
+    expect(visibility.key).toBe('false:')
+  })
+
+  it('changes the key when visible territory county ids change within the same territory prefix', () => {
+    const firstVisibility = getCountyTerritoryVisibility(true, {
+      '72001': { uid: '72001', value: 1 }
+    })
+    const secondVisibility = getCountyTerritoryVisibility(true, {
+      '72003': { uid: '72003', value: 1 }
+    })
+
+    expect(Array.from(firstVisibility.statePrefixes)).toEqual(['72'])
+    expect(Array.from(secondVisibility.statePrefixes)).toEqual(['72'])
+    expect(firstVisibility.key).toBe('true:72001')
+    expect(secondVisibility.key).toBe('true:72003')
+    expect(firstVisibility.key).not.toBe(secondVisibility.key)
+  })
+})

package/src/helpers/tests/handleMapAriaLabels.test.ts

@@ -0,0 +1,71 @@
+import { handleMapAriaLabels } from '../handleMapAriaLabels'
+
+const baseState = {
+  general: {
+    geoType: 'us',
+    title: 'COVID-19 Cases by State',
+    statesPicked: []
+  }
+}
+
+describe('handleMapAriaLabels', () => {
+  it('returns auto-generated title for US map', () => {
+    const result = handleMapAriaLabels(baseState)
+    expect(result).toBe('United States map with the title: COVID-19 Cases by State')
+  })
+
+  it('returns auto-generated title for world map', () => {
+    const result = handleMapAriaLabels({
+      general: { geoType: 'world', title: 'Global Data', statesPicked: [] }
+    })
+    expect(result).toBe('World map with the title: Global Data')
+  })
+
+  it('returns fallback when geoType is missing', () => {
+    const result = handleMapAriaLabels({ general: {} })
+    expect(result).toBe('Data visualization container')
+  })
+
+  describe('description', () => {
+    it('concatenates static description after title', () => {
+      const result = handleMapAriaLabels({
+        ...baseState,
+        altText: { type: 'static', value: 'Rates highest in the Southeast.' }
+      })
+      expect(result).toBe('United States map with the title: COVID-19 Cases by State. Rates highest in the Southeast.')
+    })
+
+    it('concatenates description from metadata after title', () => {
+      const result = handleMapAriaLabels({
+        ...baseState,
+        altText: { type: 'metadata', metadataKey: 'altDescription' },
+        dataMetadata: { altDescription: 'Map shows elevated rates in southern states.' }
+      })
+      expect(result).toBe(
+        'United States map with the title: COVID-19 Cases by State. Map shows elevated rates in southern states.'
+      )
+    })
+
+    it('returns title only when metadata key is missing', () => {
+      const result = handleMapAriaLabels({
+        ...baseState,
+        altText: { type: 'metadata', metadataKey: 'missing' },
+        dataMetadata: { other: 'value' }
+      })
+      expect(result).toBe('United States map with the title: COVID-19 Cases by State')
+    })
+
+    it('returns title only when not configured', () => {
+      const result = handleMapAriaLabels(baseState)
+      expect(result).toBe('United States map with the title: COVID-19 Cases by State')
+    })
+
+    it('returns title only when altText is empty object', () => {
+      const result = handleMapAriaLabels({
+        ...baseState,
+        altText: {}
+      })
+      expect(result).toBe('United States map with the title: COVID-19 Cases by State')
+    })
+  })
+})

package/src/helpers/tests/shouldAutoResetSingleStateZoom.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+import { shouldAutoResetSingleStateZoom } from '../shouldAutoResetSingleStateZoom'
+
+describe('shouldAutoResetSingleStateZoom', () => {
+  it('returns false on the first runtime data load', () => {
+    expect(
+      shouldAutoResetSingleStateZoom({
+        isDashboard: true,
+        previousRuntimeDataHash: null,
+        nextRuntimeDataHash: 123,
+        hasDashboardFilters: true
+      })
+    ).toBe(false)
+  })
+
+  it('returns true when filtered dashboard runtime data changes after initial load', () => {
+    expect(
+      shouldAutoResetSingleStateZoom({
+        isDashboard: true,
+        previousRuntimeDataHash: 123,
+        nextRuntimeDataHash: 456,
+        hasDashboardFilters: true
+      })
+    ).toBe(true)
+  })
+
+  it('returns false when the runtime data hash is unchanged', () => {
+    expect(
+      shouldAutoResetSingleStateZoom({
+        isDashboard: true,
+        previousRuntimeDataHash: 123,
+        nextRuntimeDataHash: 123,
+        hasDashboardFilters: true
+      })
+    ).toBe(false)
+  })
+
+  it('returns false outside dashboards', () => {
+    expect(
+      shouldAutoResetSingleStateZoom({
+        isDashboard: false,
+        previousRuntimeDataHash: 123,
+        nextRuntimeDataHash: 456,
+        hasDashboardFilters: true
+      })
+    ).toBe(false)
+  })
+
+  it('returns false when map zoom is disabled', () => {
+    expect(
+      shouldAutoResetSingleStateZoom({
+        isDashboard: true,
+        previousRuntimeDataHash: 123,
+        nextRuntimeDataHash: 456,
+        hasDashboardFilters: true,
+        allowMapZoom: false
+      })
+    ).toBe(false)
+  })
+
+  it('returns false when dashboard filters are not present on the visualization', () => {
+    expect(
+      shouldAutoResetSingleStateZoom({
+        isDashboard: true,
+        previousRuntimeDataHash: 123,
+        nextRuntimeDataHash: 456,
+        hasDashboardFilters: false
+      })
+    ).toBe(false)
+  })
+})

package/src/hooks/useApplyTooltipsToGeo.tsx

@@ -1,8 +1,7 @@
 import { type ReactNode, useContext } from 'react'
-import { displayGeoName, navigationHandler } from '../helpers'
+import { navigationHandler } from '../helpers'
 import ConfigContext from '../context'
 import useTooltip from './useTooltip'
-import { supportedStatesFipsCodes } from './../data/supported-geos'
 import parse from 'html-react-parser'
 import isDomainExternal from '@cdc/core/helpers/isDomainExternal'
 import ExternalIcon from './../images/external-link.svg'
@@ -10,7 +9,7 @@ import ExternalIcon from './../images/external-link.svg'
 const useApplyTooltipsToGeo = () => {
   const { config, customNavigationHandler } = useContext(ConfigContext)
   const navigationColumnName = config.columns.navigate.name
-  const { buildTooltip } = useTooltip({ config, displayGeoName, supportedStatesFipsCodes })
+  const { buildTooltip } = useTooltip(config)
 
   const applyTooltipsToGeo = (geoName: string, row: Object, returnType = 'string') => {
     let toolTipText: string | ReactNode = buildTooltip(row, geoName, '')
@@ -18,7 +17,11 @@ const useApplyTooltipsToGeo = () => {
     // We convert the markup into JSX and add a navigation link if it's going into a modal.
     if ('jsx' === returnType) {
       if (typeof toolTipText === 'string') {
-        toolTipText = [<div key='modal-content'>{parse(toolTipText)}</div>]
+        toolTipText = [
+          <div key='modal-content' className='cove-prose'>
+            {parse(toolTipText)}
+          </div>
+        ]
       }
 
       if (config.columns.hasOwnProperty('navigate') && row[navigationColumnName]) {

package/src/hooks/useGeoClickHandler.ts

@@ -9,6 +9,9 @@ const useGeoClickHandler = () => {
     config: state,
     setConfig,
     setSharedFilter,
+    clearSharedFilter,
+    hasActiveSharedFilter,
+    setSharedFilterValue,
     customNavigationHandler,
     interactionLabel
   } = useContext(ConfigContext)
@@ -16,7 +19,16 @@ const useGeoClickHandler = () => {
 
   const geoClickHandler = (geoDisplayName: string, geoData: object): void => {
     if (setSharedFilter) {
-      setSharedFilter(state.uid, geoData)
+      // Get the column name for the filter (from dashboardFilters config)
+      const filterColumnName = state.dashboardFilters?.[0]?.columnName || state.columns?.geo?.name
+      const clickedValue = filterColumnName ? geoData[filterColumnName] : geoDisplayName
+
+      // Toggle behavior: if the clicked value matches the current filter value, clear it
+      if (hasActiveSharedFilter && setSharedFilterValue === clickedValue && clearSharedFilter) {
+        clearSharedFilter(state.uid)
+      } else {
+        setSharedFilter(state.uid, geoData)
+      }
     }
 
     // If world-geocode map zoom to geo point

package/src/hooks/useMapLayers.tsx

@@ -53,7 +53,7 @@ export default function useMapLayers(config: MapConfig, setConfig, pathGenerator
     setConfig(newConfig)
   }
 
-  const handleAddLayer = (e: Event) => {
+  const handleAddLayer = (e: MouseEvent<HTMLButtonElement>) => {
     e.preventDefault()
     const placeHolderLayer = {
       name: 'New Custom Layer',

package/src/hooks/useStateZoom.tsx

@@ -19,7 +19,7 @@ interface StateData {
 }
 
 const useSetScaleAndTranslate = (topoData: { states: StateData[] }) => {
-  const { config, runtimeData, position, interactionLabel } = useContext<MapContext>(ConfigContext)
+  const { config, runtimeData, position, scale, translate, interactionLabel } = useContext<MapContext>(ConfigContext)
   const dispatch = useContext(MapDispatchContext)
 
   // Get statesPicked with memoization
@@ -72,8 +72,42 @@ const useSetScaleAndTranslate = (topoData: { states: StateData[] }) => {
     return { projection, newProjection, stateCenter, bounds }
   }, [topoData, statesPicked])
 
+  const resetZoomState = useCallback(
+    ({ publishEvent = true }: { publishEvent?: boolean } = {}) => {
+      const nextCoordinates = projectionData.stateCenter
+      const alreadyAtDefaultPosition =
+        position.zoom === 1 &&
+        position.coordinates[0] === nextCoordinates[0] &&
+        position.coordinates[1] === nextCoordinates[1]
+      const alreadyAtDefaultTransform = scale === 1 && translate[0] === 0 && translate[1] === 0
+
+      if (alreadyAtDefaultPosition && alreadyAtDefaultTransform) return
+
+      dispatch({ type: 'SET_POSITION', payload: { coordinates: nextCoordinates, zoom: 1 } })
+      dispatch({ type: 'SET_TRANSLATE', payload: [0, 0] })
+      dispatch({ type: 'SET_SCALE', payload: 1 })
+
+      if (publishEvent) {
+        publishAnalyticsEvent({
+          vizType: 'map',
+          vizSubType: getVizSubType(config),
+          eventType: 'map_reset_zoom_level',
+          eventAction: 'click',
+          eventLabel: interactionLabel,
+          vizTitle: getVizTitle(config)
+        })
+      }
+    },
+    [config, dispatch, interactionLabel, position, projectionData.stateCenter, scale, translate]
+  )
+
   const setScaleAndTranslate = useCallback(
     (zoomFunction: string = '') => {
+      if (zoomFunction === 'reset') {
+        resetZoomState()
+        return
+      }
+
       const _prevPosition = position
       let newZoom = _prevPosition.zoom
       let newCoordinates = _prevPosition.coordinates
@@ -98,27 +132,11 @@ const useSetScaleAndTranslate = (topoData: { states: StateData[] }) => {
           _prevPosition.coordinates[0] !== 0 && _prevPosition.coordinates[1] !== 0
             ? _prevPosition.coordinates
             : projectionData.stateCenter
-      } else if (zoomFunction === 'reset') {
-        newZoom = 1
-        newCoordinates = projectionData.stateCenter
       }
 
       dispatch({ type: 'SET_POSITION', payload: { coordinates: newCoordinates, zoom: newZoom } })
-
-      if (zoomFunction === 'reset') {
-        dispatch({ type: 'SET_TRANSLATE', payload: [0, 0] }) // needed for state switcher
-        dispatch({ type: 'SET_SCALE', payload: 1 }) // needed for state switcher
-        publishAnalyticsEvent({
-          vizType: 'map',
-          vizSubType: getVizSubType(config),
-          eventType: 'map_reset_zoom_level',
-          eventAction: 'click',
-          eventLabel: interactionLabel,
-          vizTitle: getVizTitle(config)
-        })
-      }
     },
-    [position, projectionData.stateCenter, interactionLabel, dispatch]
+    [config, dispatch, interactionLabel, position, projectionData.stateCenter, resetZoomState]
   )
 
   // Essential fix: Remove config from dependencies to prevent infinite loops
@@ -165,9 +183,9 @@ const useSetScaleAndTranslate = (topoData: { states: StateData[] }) => {
 
   const handleZoomReset = useCallback(
     _setRuntimeData => {
-      setScaleAndTranslate('reset')
+      resetZoomState()
     },
-    [setScaleAndTranslate]
+    [resetZoomState]
   )
 
   return {
@@ -178,6 +196,7 @@ const useSetScaleAndTranslate = (topoData: { states: StateData[] }) => {
     handleZoomOut,
     handleMoveEnd,
     handleZoomReset,
+    resetZoomState,
     projection: projectionData.projection,
     bounds: projectionData.bounds
   }

package/src/hooks/useTooltip.test.tsx

@@ -1,10 +1,6 @@
 import { renderHook } from '@testing-library/react'
 import useTooltip from './useTooltip'
 
-const supportedStatesFipsCodes = {
-  '01': 'Alabama'
-}
-
 const createConfig = (hideGeoColumnInTooltip: boolean) => ({
   general: {
     geoType: 'world',
@@ -41,18 +37,8 @@ describe('useTooltip', () => {
   it('hides the geography column label in the tooltip body when configured', () => {
     const row = { Country: 'ssd', Value: 10 }
 
-    const { result: visibleResult } = renderHook(() =>
-      useTooltip({
-        config: createConfig(false),
-        supportedStatesFipsCodes
-      })
-    )
-    const { result: hiddenResult } = renderHook(() =>
-      useTooltip({
-        config: createConfig(true),
-        supportedStatesFipsCodes
-      })
-    )
+    const { result: visibleResult } = renderHook(() => useTooltip(createConfig(false) as any))
+    const { result: hiddenResult } = renderHook(() => useTooltip(createConfig(true) as any))
 
     const visibleTooltip = visibleResult.current.buildTooltip(row, 'South Sudan')
     const hiddenTooltip = hiddenResult.current.buildTooltip(row, 'South Sudan')