fix(app): fix labware well color and liquid volume (#20814)

Closes [RABR-856](https://opentrons.atlassian.net/browse/RABR-856)

Author: mjhuff

shared-data/js/helpers/getLabwareInfoByLiquidId.ts

@@ -3,16 +3,25 @@ import reduce from 'lodash/reduce'
 import type { LoadLiquidRunTimeCommand, RunTimeCommand } from '../../command'
 
 export interface LabwareByLiquidId {
-  [liquidId: string]: Array<{
-    labwareId: string
-    volumeByWell: { [well: string]: number }
-  }>
+  [liquidId: string]: LabwareVolumeEntry[]
 }
+
+interface WellVolumeMap {
+  [well: string]: number
+}
+
+interface LabwareVolumeEntry {
+  labwareId: string
+  volumeByWell: WellVolumeMap
+}
+
 interface WellVolumeEntry {
   labwareId: string
   volume: number
   liquidId: string
 }
+
+// Filter for loadLiquid commands with non-empty liquids, then build and consolidate them
 export function getLabwareInfoByLiquidId(
   commands: RunTimeCommand[]
 ): LabwareByLiquidId {
@@ -25,19 +34,29 @@ export function getLabwareInfoByLiquidId(
         )
       : []
 
-  const initialLabwareByLiquidId = reduce<
-    LoadLiquidRunTimeCommand,
-    LabwareByLiquidId
-  >(
-    loadLiquidCommands,
+  const initialLabwareByLiquidId =
+    buildInitialLabwareByLiquidId(loadLiquidCommands)
+
+  return consolidateSharedWells(initialLabwareByLiquidId)
+}
+
+// Group labware by liquidId, merging volumeByWell entries when the same labware
+// appears multiple times for the same liquid
+function buildInitialLabwareByLiquidId(
+  commands: LoadLiquidRunTimeCommand[]
+): LabwareByLiquidId {
+  return reduce<LoadLiquidRunTimeCommand, LabwareByLiquidId>(
+    commands,
     (acc, command) => {
       const { liquidId, labwareId, volumeByWell } = command.params
       if (!(liquidId in acc)) acc[liquidId] = []
 
       const labwareIndex = acc[liquidId].findIndex(
         i => i.labwareId === labwareId
       )
+
       if (labwareIndex >= 0) {
+        // Merge wells into existing labware entry
         acc[liquidId][labwareIndex].volumeByWell = {
           ...acc[liquidId][labwareIndex].volumeByWell,
           ...volumeByWell,
@@ -49,72 +68,75 @@ export function getLabwareInfoByLiquidId(
     },
     {}
   )
+}
+
+// Build a reverse mapping of wells to all liquids that occupy them
+function consolidateSharedWells(
+  liquidsByIdForLabware: LabwareByLiquidId
+): LabwareByLiquidId {
+  const wellToLabwareVolumes: Record<string, WellVolumeEntry[]> = {}
 
-  const consolidateSharedWells = (
-    liquidsByIdForLabware: LabwareByLiquidId
-  ): LabwareByLiquidId => {
-    const wellToLabwareVolumes: Record<string, WellVolumeEntry[]> = {}
-
-    // Track all wells with their labware, volume, and source liquid
-    Object.entries(liquidsByIdForLabware).forEach(
-      ([liquidId, labwareArray]) => {
-        labwareArray.forEach(labware => {
-          Object.entries(labware.volumeByWell).forEach(([well, volume]) => {
-            wellToLabwareVolumes[well] ??= []
-            wellToLabwareVolumes[well].push({
-              labwareId: labware.labwareId,
-              volume,
-              liquidId,
-            })
-          })
+  Object.entries(liquidsByIdForLabware).forEach(([liquidId, labwareArray]) => {
+    labwareArray.forEach(labware => {
+      Object.entries(labware.volumeByWell).forEach(([well, volume]) => {
+        const compositeKey = `${labware.labwareId}:${well}`
+        wellToLabwareVolumes[compositeKey] ??= []
+        wellToLabwareVolumes[compositeKey].push({
+          labwareId: labware.labwareId,
+          volume,
+          liquidId,
         })
-      }
-    )
-
-    // Identify overlapping wells
-    const overlappingWells = Object.entries(wellToLabwareVolumes).filter(
-      ([, entries]) => entries.length > 1
-    )
-    const consolidatedWells: LabwareByLiquidId = {}
-
-    overlappingWells.forEach(([well, entries]) => {
-      const totalVolume = entries.reduce((sum, entry) => sum + entry.volume, 0)
-      const labwareIdName = entries[0].labwareId
-      const liquidIds = entries.map(e => e.liquidId).sort()
-      const mixedLiquidId = `mixed-${liquidIds.join('-')}`
-
-      consolidatedWells[mixedLiquidId] ??= [
-        { labwareId: labwareIdName, volumeByWell: {} },
-      ]
-      consolidatedWells[mixedLiquidId][0].volumeByWell[well] = totalVolume
+      })
     })
-    // Remove consolidated wells from the original liquids
-    const cleanedOriginal: LabwareByLiquidId = {}
-    const overlappingWellSet = new Set(overlappingWells.map(([well]) => well))
-
-    Object.entries(liquidsByIdForLabware).forEach(
-      ([liquidId, labwareArray]) => {
-        labwareArray.forEach(labware => {
-          const remainingWells = Object.fromEntries(
-            Object.entries(labware.volumeByWell).filter(
-              ([well]) => !overlappingWellSet.has(well)
-            )
-          )
-
-          if (Object.keys(remainingWells).length > 0) {
-            cleanedOriginal[liquidId] ??= []
-            cleanedOriginal[liquidId].push({
-              labwareId: labware.labwareId,
-              volumeByWell: remainingWells,
-            })
-          }
+  })
+
+  // Find wells that have been loaded with multiple different liquids
+  const overlappingWells = Object.entries(wellToLabwareVolumes).filter(
+    ([, entries]) => entries.length > 1
+  )
+
+  // Create consolidated entries for wells with mixed liquids
+  const consolidatedWells: LabwareByLiquidId = {}
+
+  overlappingWells.forEach(([compositeKey, entries]) => {
+    const totalVolume = entries.reduce((sum, entry) => sum + entry.volume, 0)
+    const labwareIdName = entries[0].labwareId
+    const liquidIds = entries.map(e => e.liquidId).sort()
+    const mixedLiquidId = `mixed-${liquidIds.join('-')}`
+
+    consolidatedWells[mixedLiquidId] ??= [
+      { labwareId: labwareIdName, volumeByWell: {} },
+    ]
+    const wellName = compositeKey.split(':')[1]
+    consolidatedWells[mixedLiquidId][0].volumeByWell[wellName] = totalVolume
+  })
+
+  // Remove overlapping wells from original liquid entries, keeping only non-overlapping wells
+  const cleanedOriginal: LabwareByLiquidId = {}
+  const overlappingWellSet = new Set(
+    overlappingWells.map(([compositeKey]) => compositeKey)
+  )
+
+  Object.entries(liquidsByIdForLabware).forEach(([liquidId, labwareArray]) => {
+    labwareArray.forEach(labware => {
+      const remainingWells = Object.fromEntries(
+        Object.entries(labware.volumeByWell).filter(
+          ([well]) => !overlappingWellSet.has(`${labware.labwareId}:${well}`)
+        )
+      )
+
+      if (Object.keys(remainingWells).length > 0) {
+        cleanedOriginal[liquidId] ??= []
+        cleanedOriginal[liquidId].push({
+          labwareId: labware.labwareId,
+          volumeByWell: remainingWells,
         })
       }
-    )
-    return {
-      ...cleanedOriginal,
-      ...consolidatedWells,
-    }
+    })
+  })
+
+  return {
+    ...cleanedOriginal,
+    ...consolidatedWells,
   }
-  return consolidateSharedWells(initialLabwareByLiquidId)
 }