@opentrons/components 0.1.6-alpha.9 → 0.1.7-alpha.0

package/src/hardware-sim/ProtocolDeck/index.tsx

@@ -0,0 +1,85 @@
+import {
+  FLEX_ROBOT_TYPE,
+  getSimplestDeckConfigForProtocol,
+} from '@opentrons/shared-data'
+
+import { BaseDeck } from '../BaseDeck'
+import { getStandardDeckViewLayerBlockList } from './utils'
+import { getLabwareInfoByLiquidId } from './utils/getLabwareInfoByLiquidId'
+import { getTopMostLabwareInSlots } from './utils/getLabwareInSlots'
+import { getModulesInSlots } from './utils/getModulesInSlots'
+import { getWellFillFromLabwareId } from './utils/getWellFillFromLabwareId'
+
+import type { ComponentProps } from 'react'
+import type {
+  CompletedProtocolAnalysis,
+  ProtocolAnalysisOutput,
+} from '@opentrons/shared-data'
+
+export * from './utils/getStandardDeckViewLayerBlockList'
+export * from './types'
+interface ProtocolDeckProps {
+  protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput | null
+  /** extra props to pass through to BaseDeck component */
+  baseDeckProps?: Partial<ComponentProps<typeof BaseDeck>>
+}
+
+export function ProtocolDeck(props: ProtocolDeckProps): JSX.Element | null {
+  const { protocolAnalysis, baseDeckProps } = props
+
+  if (protocolAnalysis == null || (protocolAnalysis?.errors ?? []).length > 0)
+    return null
+
+  const robotType = protocolAnalysis.robotType ?? FLEX_ROBOT_TYPE
+  const deckConfig = getSimplestDeckConfigForProtocol(protocolAnalysis)
+  const labwareByLiquidId = getLabwareInfoByLiquidId(protocolAnalysis.commands)
+
+  const modulesInSlots = getModulesInSlots(protocolAnalysis)
+  const modulesOnDeck = modulesInSlots.map(
+    ({ moduleModel, moduleLocation, nestedLabwareId, nestedLabwareDef }) => {
+      return {
+        moduleModel,
+        moduleLocation,
+        nestedLabwareDef,
+        nestedLabwareWellFill: getWellFillFromLabwareId(
+          nestedLabwareId ?? '',
+          protocolAnalysis.liquids,
+          labwareByLiquidId
+        ),
+      }
+    }
+  )
+
+  // this function gets the top most labware
+  const topMostLabwareInSlots = getTopMostLabwareInSlots(protocolAnalysis)
+  const labwareOnDeck = topMostLabwareInSlots.map(
+    ({ labwareId, labwareDef, location }) => {
+      return {
+        definition: labwareDef,
+        labwareLocation: location,
+        wellFill: getWellFillFromLabwareId(
+          labwareId,
+          protocolAnalysis.liquids,
+          labwareByLiquidId
+        ),
+      }
+    }
+  )
+
+  return (
+    <BaseDeck
+      deckConfig={deckConfig}
+      deckLayerBlocklist={getStandardDeckViewLayerBlockList(robotType)}
+      robotType={robotType}
+      labwareOnDeck={labwareOnDeck}
+      modulesOnDeck={modulesOnDeck}
+      {...{
+        svgProps: {
+          'aria-label': 'protocol deck map',
+          ...(baseDeckProps?.svgProps ?? {}),
+        },
+        ...baseDeckProps,
+      }}
+    />
+  )
+}

package/src/hardware-sim/ProtocolDeck/types.ts

@@ -0,0 +1,6 @@
+export interface LabwareByLiquidId {
+  [liquidId: string]: Array<{
+    labwareId: string
+    volumeByWell: { [well: string]: number }
+  }>
+}

package/src/hardware-sim/ProtocolDeck/utils/__tests__/getLabwareInforByLiquidId.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from 'vitest'
+import { getLabwareInfoByLiquidId } from '../getLabwareInfoByLiquidId'
+import type { RunTimeCommand } from '@opentrons/shared-data'
+
+const mockLoadLiquidRunTimeCommands = [
+  {
+    id: '97ba49a5-04f6-4f91-986a-04a0eb632882',
+    createdAt: '2022-09-07T19:47:42.781065+00:00',
+    commandType: 'loadPipette',
+    key: '0feeecaf-3895-46d7-ab71-564601265e35',
+    status: 'succeeded',
+    params: {
+      pipetteName: 'p20_single_gen2',
+      mount: 'left',
+      pipetteId: '90183a18-a1df-4fd6-9636-be3bcec63fe4',
+    },
+    result: {
+      pipetteId: '90183a18-a1df-4fd6-9636-be3bcec63fe4',
+    },
+    startedAt: '2022-09-07T19:47:42.782665+00:00',
+    completedAt: '2022-09-07T19:47:42.785061+00:00',
+  },
+  {
+    id: '846e0b7b-1e54-4f42-9ab1-964ebda45da5',
+    createdAt: '2022-09-07T19:47:42.781281+00:00',
+    commandType: 'loadLiquid',
+    key: '1870d1a2-8dcd-46f2-9e27-16578365913b',
+    status: 'succeeded',
+    params: {
+      liquidId: '1',
+      labwareId: 'mockLabwareId1',
+      volumeByWell: {
+        A2: 20,
+        B2: 20,
+        C2: 20,
+        D2: 20,
+        E2: 20,
+        F2: 20,
+        G2: 20,
+        H2: 20,
+      },
+    },
+    result: {},
+    startedAt: '2022-09-07T19:47:42.785987+00:00',
+    completedAt: '2022-09-07T19:47:42.786087+00:00',
+  },
+  {
+    id: '1e03ae10-7e9b-465c-bc72-21ab5706bfb0',
+    createdAt: '2022-09-07T19:47:42.781323+00:00',
+    commandType: 'loadLiquid',
+    key: '48df9766-04ff-4927-9f2d-4efdcf0b3df8',
+    status: 'succeeded',
+    params: {
+      liquidId: '1',
+      labwareId: 'mockLabwareId2',
+      volumeByWell: {
+        D3: 40,
+      },
+    },
+    result: {},
+    startedAt: '2022-09-07T19:47:42.786212+00:00',
+    completedAt: '2022-09-07T19:47:42.786285+00:00',
+  },
+  {
+    id: '1e03ae10-7e9b-465c-bc72-21ab5706bfb0',
+    createdAt: '2022-09-07T19:47:42.781323+00:00',
+    commandType: 'loadLiquid',
+    key: '48df9766-04ff-4927-9f2d-4efdcf0b3df8',
+    status: 'succeeded',
+    params: {
+      liquidId: '1',
+      labwareId: 'mockLabwareId2',
+      volumeByWell: {
+        A3: 33,
+        B3: 33,
+        C3: 33,
+      },
+    },
+    result: {},
+    startedAt: '2022-09-07T19:47:42.786212+00:00',
+    completedAt: '2022-09-07T19:47:42.786285+00:00',
+  },
+  {
+    id: 'e8596bb3-b650-4d62-9bb5-dfc6e9e63249',
+    createdAt: '2022-09-07T19:47:42.781363+00:00',
+    commandType: 'loadLiquid',
+    key: '69d19b03-fdcc-4964-a2f8-3cbb30f4ddf3',
+    status: 'succeeded',
+    params: {
+      liquidId: '0',
+      labwareId: 'mockLabwareId1',
+      volumeByWell: {
+        A1: 33,
+        B1: 33,
+        C1: 33,
+        D1: 33,
+        E1: 33,
+        F1: 33,
+        G1: 33,
+        H1: 33,
+      },
+    },
+    result: {},
+    startedAt: '2022-09-07T19:47:42.786347+00:00',
+    completedAt: '2022-09-07T19:47:42.786412+00:00',
+  },
+]
+
+describe('getLabwareInfoByLiquidId', () => {
+  it('returns labware info by liquid id', () => {
+    const expected = {
+      '0': [
+        {
+          labwareId: 'mockLabwareId1',
+          volumeByWell: {
+            A1: 33,
+            B1: 33,
+            C1: 33,
+            D1: 33,
+            E1: 33,
+            F1: 33,
+            G1: 33,
+            H1: 33,
+          },
+        },
+      ],
+      '1': [
+        {
+          labwareId: 'mockLabwareId1',
+          volumeByWell: {
+            A2: 20,
+            B2: 20,
+            C2: 20,
+            D2: 20,
+            E2: 20,
+            F2: 20,
+            G2: 20,
+            H2: 20,
+          },
+        },
+        {
+          labwareId: 'mockLabwareId2',
+          volumeByWell: {
+            A3: 33,
+            B3: 33,
+            C3: 33,
+            D3: 40,
+          },
+        },
+      ],
+    }
+    expect(
+      getLabwareInfoByLiquidId(
+        mockLoadLiquidRunTimeCommands as RunTimeCommand[]
+      )
+    ).toEqual(expected)
+  })
+})

package/src/hardware-sim/ProtocolDeck/utils/getInitiallyLoadedLabwareByAdapter.ts

@@ -0,0 +1,33 @@
+import reduce from 'lodash/reduce'
+import type {
+  LoadLabwareRunTimeCommand,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+
+export interface LoadedLabwareByAdapter {
+  [labwareId: string]: LoadLabwareRunTimeCommand
+}
+export function getInitialLoadedLabwareByAdapter(
+  commands: RunTimeCommand[]
+): LoadedLabwareByAdapter {
+  const loadLabwareCommandsReversed = commands
+    .filter(
+      (command): command is LoadLabwareRunTimeCommand =>
+        command.commandType === 'loadLabware'
+    )
+    .reverse()
+  return reduce<LoadLabwareRunTimeCommand, LoadedLabwareByAdapter>(
+    loadLabwareCommandsReversed,
+    (acc, command) => {
+      if (
+        typeof command.params.location === 'object' &&
+        'labwareId' in command.params.location
+      ) {
+        return { ...acc, [command.params.location.labwareId]: command }
+      } else {
+        return acc
+      }
+    },
+    {}
+  )
+}

package/src/hardware-sim/ProtocolDeck/utils/getLabwareInSlots.ts

@@ -0,0 +1,321 @@
+import { getInitialLoadedLabwareByAdapter } from './getInitiallyLoadedLabwareByAdapter'
+import type {
+  CompletedProtocolAnalysis,
+  LoadLabwareRunTimeCommand,
+  MoveLabwareRunTimeCommand,
+  ProtocolAnalysisOutput,
+  LabwareDefinition2,
+  LoadLidRunTimeCommand,
+  LoadLidStackRunTimeCommand,
+} from '@opentrons/shared-data'
+
+interface LabwareInSlot {
+  labwareId: string
+  labwareDef: LabwareDefinition2
+  labwareNickName: string | null
+  location: { slotName: string }
+}
+
+interface LabwareWithDef {
+  labwareId: string
+  labwareDef: LabwareDefinition2
+  labwareNickName: string | null
+}
+
+export const getInitialAndMovedLabwareInSlots = (
+  protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput
+): LabwareInSlot[] => {
+  const { commands } = protocolAnalysis
+  const initialLoadedLabwareByAdapter = getInitialLoadedLabwareByAdapter(
+    commands
+  )
+  const topMostLabwareInSlots = getTopMostLabwareInSlots(protocolAnalysis)
+  const allLabwareDefs = getAllLabwareDefinitions(protocolAnalysis)
+
+  return commands
+    .filter(
+      (command): command is MoveLabwareRunTimeCommand =>
+        command.commandType === 'moveLabware'
+    )
+    .reduce<LabwareInSlot[]>((acc, command) => {
+      const labwareId = command.params.labwareId
+      const location = command.params.newLocation
+
+      const originalLabware = allLabwareDefs.find(
+        labware => labware.labwareId === labwareId
+      )
+      const labwareDef = originalLabware?.labwareDef
+
+      if (
+        location === 'offDeck' ||
+        location === 'systemLocation' ||
+        'moduleId' in location ||
+        'labwareId' in location
+      )
+        return acc
+      if (labwareId == null) {
+        console.warn(
+          `expected to find labware id from command id ${String(
+            command.id
+          )} but could not`
+        )
+        return acc
+      }
+      if (labwareDef == null) {
+        console.warn(
+          `expected to find labware def for labware id ${String(
+            labwareId
+          )} in command id ${String(command.id)} but could not`
+        )
+        return acc
+      }
+
+      const slotName =
+        'addressableAreaName' in location
+          ? location.addressableAreaName
+          : location.slotName
+
+      // if list of labware already includes slotName, return acc
+      if (acc.find(labware => labware.location.slotName === slotName) != null) {
+        return acc
+      }
+
+      const labwareInAdapter = initialLoadedLabwareByAdapter[labwareId]
+
+      //  NOTE: only grabbing the labware on top most layer so
+      //  either the adapter or the labware but not both
+      const topLabwareDefinition =
+        labwareInAdapter?.result?.definition ?? labwareDef
+      const topLabwareId = labwareInAdapter?.result?.labwareId ?? labwareId
+      const topLabwareNickName =
+        labwareInAdapter?.params?.displayName ??
+        originalLabware?.labwareNickName ??
+        null
+
+      return [
+        ...acc,
+        {
+          labwareId: topLabwareId,
+          labwareDef: topLabwareDefinition,
+          labwareNickName: topLabwareNickName,
+          location: { slotName },
+        },
+      ]
+    }, topMostLabwareInSlots)
+}
+
+export const getTopMostLabwareInSlots = (
+  protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput
+): LabwareInSlot[] => {
+  const { commands } = protocolAnalysis
+  const initialLoadedLabwareByAdapter = getInitialLoadedLabwareByAdapter(
+    commands
+  )
+  const lidStackObjects: LabwareInSlot[] = commands
+    .filter(
+      (command): command is LoadLidStackRunTimeCommand =>
+        command.commandType === 'loadLidStack'
+    )
+    .reduce<LabwareInSlot[]>((acc, command) => {
+      const labwareId = command.result?.labwareIds.at(-1)
+      if (labwareId == null) {
+        console.warn(
+          `expected to find labware id from command id ${String(
+            command.id
+          )} but could not`
+        )
+        return acc
+      }
+      const labwareDef = command.result?.definition
+      if (labwareDef == null) {
+        console.warn(
+          `expected to find labware def for labware id ${String(
+            labwareId
+          )} in command id ${String(command.id)}but could not`
+        )
+        return acc
+      }
+      let location = command.params.location
+      if (
+        location !== 'offDeck' &&
+        location !== 'systemLocation' &&
+        'labwareId' in location
+      ) {
+        const locationLabwareId = location.labwareId
+        const adapterCommand = commands.find(
+          (command): command is LoadLabwareRunTimeCommand =>
+            command.commandType === 'loadLabware' &&
+            command.result?.labwareId === locationLabwareId
+        )
+        if (adapterCommand != null) {
+          location = adapterCommand.params.location
+        } else {
+          return acc
+        }
+      }
+      if (
+        location === 'offDeck' ||
+        location === 'systemLocation' ||
+        'moduleId' in location ||
+        'labwareId' in location
+      ) {
+        return acc
+      }
+
+      const slotName =
+        'addressableAreaName' in location
+          ? location.addressableAreaName
+          : location.slotName
+
+      return [
+        ...acc,
+        {
+          labwareId,
+          labwareDef,
+          labwareNickName: null,
+          location: { slotName },
+        },
+      ]
+    }, [])
+  const labwareObjects: LabwareInSlot[] = commands
+    .filter(
+      (command): command is LoadLabwareRunTimeCommand =>
+        command.commandType === 'loadLabware'
+    )
+    .reduce<LabwareInSlot[]>((acc, command) => {
+      const labwareId = command.result?.labwareId
+      const location = command.params.location
+      const labwareDef = command.result?.definition
+      if (
+        location === 'offDeck' ||
+        location === 'systemLocation' ||
+        'moduleId' in location ||
+        'labwareId' in location
+      )
+        return acc
+      const slotName =
+        'addressableAreaName' in location
+          ? location.addressableAreaName
+          : location.slotName
+      // if there is a lid stack in this slot, don't add the adapter below it
+      if (
+        lidStackObjects.some(
+          lidStackObject => lidStackObject.location.slotName === slotName
+        )
+      ) {
+        return acc
+      }
+      if (labwareId == null) {
+        console.warn(
+          `expected to find labware id from command id ${String(
+            command.id
+          )} but could not`
+        )
+        return acc
+      }
+      if (labwareDef == null) {
+        console.warn(
+          `expected to find labware def for labware id ${String(
+            labwareId
+          )} in command id ${String(command.id)}but could not`
+        )
+        return acc
+      }
+
+      const labwareInAdapter = initialLoadedLabwareByAdapter[labwareId]
+
+      //  NOTE: only grabbing the labware on top most layer so
+      //  either the adapter or the labware but not both
+      const topLabwareDefinition =
+        labwareInAdapter?.result?.definition ?? labwareDef
+      const topLabwareId = labwareInAdapter?.result?.labwareId ?? labwareId
+      const topLabwareNickName =
+        labwareInAdapter?.params?.displayName ??
+        command.params.displayName ??
+        null
+
+      return [
+        ...acc,
+        {
+          labwareId: topLabwareId,
+          labwareDef: topLabwareDefinition,
+          labwareNickName: topLabwareNickName,
+          location: { slotName },
+        },
+      ]
+    }, [])
+
+  return labwareObjects.concat(lidStackObjects)
+}
+
+const getAllLabwareDefinitions = (
+  protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput
+): LabwareWithDef[] => {
+  const { commands } = protocolAnalysis
+  const lidAndLabware: LabwareWithDef[] = commands
+    .filter((command): command is
+      | LoadLabwareRunTimeCommand
+      | LoadLidRunTimeCommand =>
+      ['loadLabware', 'loadLid'].includes(command.commandType)
+    )
+    .reduce<LabwareWithDef[]>((acc, command) => {
+      const labwareId = command.result?.labwareId
+      const labwareDef = command.result?.definition
+      if (labwareId == null) {
+        console.warn(
+          `expected to find labware id from command id ${String(
+            command.id
+          )} but could not`
+        )
+        return acc
+      }
+      if (labwareDef == null) {
+        console.warn(
+          `expected to find labware def for labware id ${String(
+            labwareId
+          )} fromm command id ${String(command.id)} but could not`
+        )
+        return acc
+      }
+      const displayName =
+        command.commandType === 'loadLabware'
+          ? command.params?.displayName ?? null
+          : null
+      return [
+        ...acc,
+        {
+          labwareId: labwareId,
+          labwareDef: labwareDef,
+          labwareNickName: displayName,
+        },
+      ]
+    }, [])
+
+  const lidStacks: LabwareWithDef[] = commands
+    .filter(
+      (command): command is LoadLidStackRunTimeCommand =>
+        command.commandType === 'loadLidStack'
+    )
+    .reduce<LabwareWithDef[]>((acc, command) => {
+      const lidStackObjects: LabwareWithDef[] = []
+      const labwareDef = command.result?.definition
+      if (labwareDef == null) {
+        console.warn(
+          `expected to find labware def for lid stack ${String(
+            command.result?.stackLabwareId
+          )} fromm command id ${String(command.id)} but could not`
+        )
+        return acc
+      }
+      command.result?.labwareIds.forEach(labwareId => {
+        lidStackObjects.push({
+          labwareId: labwareId,
+          labwareDef: labwareDef,
+          labwareNickName: null,
+        })
+      })
+      return [...acc, ...lidStackObjects]
+    }, [])
+
+  return lidAndLabware.concat(lidStacks)
+}

package/src/hardware-sim/ProtocolDeck/utils/getLabwareInfoByLiquidId.ts

@@ -0,0 +1,43 @@
+import type {
+  LoadLiquidRunTimeCommand,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+import reduce from 'lodash/reduce'
+import type { LabwareByLiquidId } from '../types'
+
+export function getLabwareInfoByLiquidId(
+  commands: RunTimeCommand[]
+): LabwareByLiquidId {
+  const loadLiquidCommands =
+    commands.length !== 0
+      ? commands.filter(
+          (command): command is LoadLiquidRunTimeCommand =>
+            command.commandType === 'loadLiquid' &&
+            command.params.liquidId !== 'EMPTY'
+        )
+      : []
+
+  return reduce<LoadLiquidRunTimeCommand, LabwareByLiquidId>(
+    loadLiquidCommands,
+    (acc, command) => {
+      if (!(command.params.liquidId in acc)) {
+        acc[command.params.liquidId] = []
+      }
+      const labwareId = command.params.labwareId
+      const volumeByWell = command.params.volumeByWell
+      const labwareIndex = acc[command.params.liquidId].findIndex(
+        i => i.labwareId === labwareId
+      )
+      if (labwareIndex >= 0) {
+        acc[command.params.liquidId][labwareIndex].volumeByWell = {
+          ...acc[command.params.liquidId][labwareIndex].volumeByWell,
+          ...volumeByWell,
+        }
+      } else {
+        acc[command.params.liquidId].push({ labwareId, volumeByWell })
+      }
+      return acc
+    },
+    {}
+  )
+}