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

package/src/organisms/CommandText/useCommandTextString/utils/__tests__/getFinalLabwareLocation.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest'
+import { fixtureTiprack10ul } from '@opentrons/shared-data'
+import { getFinalLabwareLocation } from '../getFinalLabwareLocation'
+import type { LabwareDefinition2 } from '@opentrons/shared-data'
+
+describe('getFinalLabwareLocation', () => {
+  it('calculates labware location after only load_labware', () => {
+    const labwareId = 'fakeLabwareId'
+    const location = { slotName: 'C3' }
+    expect(
+      getFinalLabwareLocation(labwareId, [
+        {
+          id: 'fakeId1',
+          commandType: 'loadLabware',
+          params: {
+            location,
+            loadName: 'fakeLoadname',
+            namespace: 'opentrons',
+            version: 1,
+          },
+          result: {
+            labwareId,
+            definition: fixtureTiprack10ul as LabwareDefinition2,
+            offset: { x: 1, y: 2, z: 3 },
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+      ]).location
+    ).toBe(location)
+  })
+  it('calculates labware location after only load_labware and move_labware', () => {
+    const labwareId = 'fakeLabwareId'
+    const initialLocation = { slotName: 'C3' }
+    const finalLocation = { slotName: 'D1' }
+    expect(
+      getFinalLabwareLocation(labwareId, [
+        {
+          id: 'fakeId1',
+          commandType: 'loadLabware',
+          params: {
+            location: initialLocation,
+            loadName: 'fakeLoadname',
+            namespace: 'opentrons',
+            version: 1,
+          },
+          result: {
+            labwareId,
+            definition: fixtureTiprack10ul as LabwareDefinition2,
+            offset: { x: 1, y: 2, z: 3 },
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+        {
+          id: 'fakeId2',
+          commandType: 'moveLabware',
+          params: {
+            labwareId,
+            newLocation: finalLocation,
+            strategy: 'usingGripper',
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+      ]).location
+    ).toBe(finalLocation)
+  })
+  it('calculates labware location after multiple moves', () => {
+    const labwareId = 'fakeLabwareId'
+    const initialLocation = { slotName: 'C3' }
+    const secondLocation = { slotName: 'D1' }
+    const finalLocation = { slotName: 'A2' }
+    expect(
+      getFinalLabwareLocation(labwareId, [
+        {
+          id: 'fakeId1',
+          commandType: 'loadLabware',
+          params: {
+            location: initialLocation,
+            loadName: 'fakeLoadname',
+            namespace: 'opentrons',
+            version: 1,
+          },
+          result: {
+            labwareId,
+            definition: fixtureTiprack10ul as LabwareDefinition2,
+            offset: { x: 1, y: 2, z: 3 },
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+        {
+          id: 'fakeId2',
+          commandType: 'moveLabware',
+          params: {
+            labwareId,
+            newLocation: secondLocation,
+            strategy: 'usingGripper',
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+        {
+          id: 'fakeId3',
+          commandType: 'moveLabware',
+          params: {
+            labwareId,
+            newLocation: finalLocation,
+            strategy: 'usingGripper',
+          },
+          status: 'succeeded',
+          createdAt: 'fake_timestamp',
+          startedAt: 'fake_timestamp',
+          completedAt: 'fake_timestamp',
+        },
+      ]).location
+    ).toBe(finalLocation)
+  })
+})

package/src/organisms/CommandText/useCommandTextString/utils/__tests__/getLabwareDisplayLocation.test.tsx

@@ -0,0 +1,185 @@
+import { describe, it, expect, vi } from 'vitest'
+import { screen } from '@testing-library/react'
+import { useTranslation } from 'react-i18next'
+
+import {
+  FLEX_ROBOT_TYPE,
+  getModuleDisplayName,
+  getModuleType,
+  getOccludedSlotCountForModule,
+  getLabwareDefURI,
+  getLabwareDisplayName,
+} from '@opentrons/shared-data'
+import { renderWithProviders } from '../../../../../testing/utils'
+import { i18n } from '../../../../../i18n'
+import { getLabwareDisplayLocation } from '../getLabwareDisplayLocation'
+import { getModuleDisplayLocation } from '../getModuleDisplayLocation'
+import { getModuleModel } from '../getModuleModel'
+
+import type { ComponentProps } from 'react'
+import type { LabwareLocation } from '@opentrons/shared-data'
+
+vi.mock('../getModuleModel')
+vi.mock('../getModuleDisplayLocation')
+vi.mock('@opentrons/shared-data', async () => {
+  const actual = await vi.importActual('@opentrons/shared-data')
+  return {
+    ...actual,
+    getModuleDisplayName: vi.fn(),
+    getModuleType: vi.fn(),
+    getOccludedSlotCountForModule: vi.fn(),
+    getLabwareDefURI: vi.fn(),
+    getLabwareDisplayName: vi.fn(),
+  }
+})
+
+const TestWrapper = ({
+  location,
+  params,
+}: {
+  location: LabwareLocation | null
+  params: any
+}) => {
+  const { t } = useTranslation('protocol_command_text')
+  const displayLocation = getLabwareDisplayLocation({ ...params, location, t })
+  return <div>{displayLocation}</div>
+}
+
+const render = (props: ComponentProps<typeof TestWrapper>) => {
+  return renderWithProviders(<TestWrapper {...props} />, {
+    i18nInstance: i18n,
+  })[0]
+}
+
+describe('getLabwareDisplayLocation with translations', () => {
+  const defaultParams = {
+    loadedLabwares: [],
+    loadedModules: [],
+    robotType: FLEX_ROBOT_TYPE,
+    allRunDefs: [],
+  }
+
+  it('should return an empty string for null location', () => {
+    render({ location: null, params: defaultParams })
+    expect(screen.queryByText(/.+/)).toBeNull()
+  })
+
+  it('should return "off deck" for offDeck location', () => {
+    render({ location: 'offDeck', params: defaultParams })
+
+    screen.getByText('off deck')
+  })
+
+  it('should return a slot name for slot location', () => {
+    render({ location: { slotName: 'A1' }, params: defaultParams })
+
+    screen.getByText('Slot A1')
+  })
+
+  it('should return an addressable area name for an addressable area location', () => {
+    render({ location: { addressableAreaName: 'B2' }, params: defaultParams })
+
+    screen.getByText('Slot B2')
+  })
+
+  it('should return a module location for a module location', () => {
+    const mockModuleModel = 'temperatureModuleV2'
+    vi.mocked(getModuleModel).mockReturnValue(mockModuleModel)
+    vi.mocked(getModuleDisplayLocation).mockReturnValue('3')
+    vi.mocked(getModuleDisplayName).mockReturnValue('Temperature Module')
+    vi.mocked(getModuleType).mockReturnValue('temperatureModuleType')
+    vi.mocked(getOccludedSlotCountForModule).mockReturnValue(1)
+
+    render({ location: { moduleId: 'temp123' }, params: defaultParams })
+
+    screen.getByText('Temperature Module in Slot 3')
+  })
+
+  it('should return an adapter location for an adapter location', () => {
+    const mockLoadedLabwares = [
+      {
+        id: 'adapter123',
+        definitionUri: 'adapter-uri',
+        location: { slotName: 'D1' },
+      },
+    ]
+    const mockAllRunDefs = [
+      { uri: 'adapter-uri', metadata: { displayName: 'Mock Adapter' } },
+    ]
+    vi.mocked(getLabwareDefURI).mockReturnValue('adapter-uri')
+    vi.mocked(getLabwareDisplayName).mockReturnValue('Mock Adapter')
+
+    render({
+      location: { labwareId: 'adapter123' },
+      params: {
+        ...defaultParams,
+        loadedLabwares: mockLoadedLabwares,
+        allRunDefs: mockAllRunDefs,
+        detailLevel: 'full',
+      },
+    })
+
+    screen.getByText('Mock Adapter in Slot D1')
+  })
+
+  it('should return a slot-only location when detailLevel is "slot-only"', () => {
+    render({
+      location: { slotName: 'C1' },
+      params: { ...defaultParams, detailLevel: 'slot-only' },
+    })
+
+    screen.getByText('Slot C1')
+  })
+
+  it('should special case the slotName if it contains "waste chute"', () => {
+    render({
+      location: { slotName: 'gripperWasteChute' },
+      params: { ...defaultParams, detailLevel: 'slot-only' },
+    })
+
+    screen.getByText('Waste Chute')
+  })
+
+  it('should special case the slotName if it contains "trash bin"', () => {
+    render({
+      location: { slotName: 'trashBin' },
+      params: { ...defaultParams, detailLevel: 'slot-only' },
+    })
+
+    screen.getByText('Trash Bin')
+  })
+
+  it('should handle an adapter on module location when the detail level is full', () => {
+    const mockLoadedLabwares = [
+      {
+        id: 'adapter123',
+        definitionUri: 'adapter-uri',
+        location: { moduleId: 'temp123' },
+      },
+    ]
+    const mockLoadedModules = [{ id: 'temp123', model: 'temperatureModuleV2' }]
+    const mockAllRunDefs = [
+      { uri: 'adapter-uri', metadata: { displayName: 'Mock Adapter' } },
+    ]
+
+    vi.mocked(getLabwareDefURI).mockReturnValue('adapter-uri')
+    vi.mocked(getLabwareDisplayName).mockReturnValue('Mock Adapter')
+    vi.mocked(getModuleDisplayLocation).mockReturnValue('2')
+    vi.mocked(getModuleDisplayName).mockReturnValue('Temperature Module')
+    vi.mocked(getModuleType).mockReturnValue('temperatureModuleType')
+    vi.mocked(getOccludedSlotCountForModule).mockReturnValue(1)
+
+    render({
+      location: { labwareId: 'adapter123' },
+      params: {
+        ...defaultParams,
+        loadedLabwares: mockLoadedLabwares,
+        loadedModules: mockLoadedModules,
+        allRunDefs: mockAllRunDefs,
+        detailLevel: 'full',
+      },
+    })
+
+    screen.getByText('Mock Adapter on Temperature Module in Slot 2')
+  })
+})

package/src/organisms/CommandText/useCommandTextString/utils/commandText/__tests__/getPipettingCommandText.test.tsx

@@ -0,0 +1,187 @@
+import { screen } from '@testing-library/react'
+import { vi, describe, it, beforeEach } from 'vitest'
+import { useTranslation } from 'react-i18next'
+
+import { renderWithProviders } from '../../../../../../testing/utils'
+import { i18n } from '../../../../../../i18n'
+import { getPipettingCommandText } from '../getPipettingCommandText'
+import { getLabwareDefURI } from '@opentrons/shared-data'
+import { getFinalLabwareLocation } from '../../getFinalLabwareLocation'
+import { getWellRange } from '../../getWellRange'
+import { getLabwareDefinitionsFromCommands } from '../../getLabwareDefinitionsFromCommands'
+import { getLabwareName } from '../../getLabwareName'
+import { getLoadedLabware } from '../../getLoadedLabware'
+import { getLabwareDisplayLocation } from '../../getLabwareDisplayLocation'
+import { getFinalMoveToAddressableAreaCmd } from '../../getFinalAddressableAreaCmd'
+import { getAddressableAreaDisplayName } from '../../getAddressableAreaDisplayName'
+
+vi.mock('@opentrons/shared-data')
+vi.mock('../../getFinalLabwareLocation')
+vi.mock('../../getWellRange')
+vi.mock('../../getLabwareDefinitionsFromCommands')
+vi.mock('../../getFinalAddressableAreaCmd')
+vi.mock('../../getAddressableAreaDisplayName')
+vi.mock('../../getLabwareName')
+vi.mock('../../getLabwareDisplayLocation')
+vi.mock('../../getLoadedLabware')
+
+const baseCommandData = {
+  allRunDefs: {},
+  robotType: 'OT-2',
+  commandTextData: {
+    commands: [],
+    labware: [],
+    modules: [],
+    pipettes: [{ id: 'pipette-1', pipetteName: 'p300_single' }],
+  },
+} as any
+
+function TestWrapper({ command }: { command: any }): JSX.Element {
+  const { t } = useTranslation('protocol_command_text')
+  const text = getPipettingCommandText({
+    command,
+    ...baseCommandData,
+    t,
+  })
+
+  return <div>{text}</div>
+}
+
+const render = (command: any) => {
+  return renderWithProviders(<TestWrapper command={command} />, {
+    i18nInstance: i18n,
+  })
+}
+
+describe('getPipettingCommandText', () => {
+  beforeEach(() => {
+    vi.mocked(getLabwareDefURI).mockImplementation((def: any) => def.uri)
+    vi.mocked(getFinalLabwareLocation).mockReturnValue('slot-1' as any)
+    vi.mocked(getWellRange).mockReturnValue('A1')
+    vi.mocked(getLabwareDefinitionsFromCommands).mockReturnValue([
+      { uri: 'tiprack-uri', parameters: { isTiprack: true } },
+      { uri: 'plate-uri', parameters: { isTiprack: false } },
+    ] as any)
+    vi.mocked(getLabwareName).mockReturnValue('Test Labware')
+    vi.mocked(getLoadedLabware).mockImplementation(
+      (labware, id) =>
+        ({
+          definitionUri: id === 'tiprack-id' ? 'tiprack-uri' : 'plate-uri',
+        } as any)
+    )
+    vi.mocked(getLabwareDisplayLocation).mockReturnValue('Slot 1')
+    vi.mocked(getFinalMoveToAddressableAreaCmd).mockReturnValue({
+      id: 'cmd-1',
+      commandType: 'moveToAddressableArea',
+    } as any)
+    vi.mocked(getAddressableAreaDisplayName).mockReturnValue('Fixed Trash')
+  })
+
+  it('should render aspirate command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'aspirate',
+      params: {
+        labwareId: 'labware-1',
+        wellName: 'A1',
+        volume: 100,
+        flowRate: 150,
+      },
+    }
+
+    render(command)
+    screen.getByText(
+      /Aspirating 100 µL from well A1 of Test Labware in Slot 1 at 150 µL\/sec/
+    )
+  })
+
+  it('should render dispense command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dispense',
+      params: {
+        labwareId: 'labware-1',
+        wellName: 'A1',
+        volume: 100,
+        flowRate: 150,
+      },
+    }
+
+    render(command)
+    screen.getByText(
+      /Dispensing 100 µL into well A1 of Test Labware in Slot 1 at 150 µL\/sec/
+    )
+  })
+
+  it('should render dispense with push out command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dispense',
+      params: {
+        labwareId: 'labware-1',
+        wellName: 'A1',
+        volume: 100,
+        flowRate: 150,
+        pushOut: 10,
+      },
+    }
+
+    render(command)
+    screen.getByText(
+      /Dispensing 100 µL into well A1 of Test Labware in Slot 1 at 150 µL\/sec and pushing out 10 µL/
+    )
+  })
+
+  it('should render pickup tip command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'pickUpTip',
+      params: {
+        labwareId: 'tiprack-id',
+        wellName: 'A1',
+        pipetteId: 'pipette-1',
+      },
+    }
+
+    render(command)
+    screen.getByText(/Picking up tip\(s\) from A1 of Test Labware in Slot 1/)
+  })
+
+  it('should render drop tip in tiprack command text correctly', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dropTip',
+      params: {
+        labwareId: 'tiprack-id',
+        wellName: 'A1',
+      },
+    }
+
+    render(command)
+    screen.getByText(/Returning tip to A1 of Test Labware in Slot 1/)
+  })
+
+  it('should render drop tip in place command text correctly if there is an addressable area name', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dropTipInPlace',
+      params: {},
+    }
+
+    render(command)
+    screen.getByText('Dropping tip in Fixed Trash')
+  })
+
+  it('should render drop tip in place command text correctly if there is not an addressable area name', () => {
+    const command = {
+      id: 'cmd-1',
+      commandType: 'dropTipInPlace',
+      params: {},
+    }
+
+    vi.mocked(getFinalMoveToAddressableAreaCmd).mockReturnValue(null)
+
+    render(command)
+    screen.getByText('Dropping tip in place')
+  })
+})

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getAbsorbanceReaderCommandText.ts

@@ -0,0 +1,53 @@
+import type {
+  AbsorbanceReaderOpenLidRunTimeCommand,
+  AbsorbanceReaderCloseLidRunTimeCommand,
+  AbsorbanceReaderInitializeRunTimeCommand,
+  AbsorbanceReaderReadRunTimeCommand,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+import type { HandlesCommands } from '../types'
+
+export type AbsorbanceCreateCommand =
+  | AbsorbanceReaderOpenLidRunTimeCommand
+  | AbsorbanceReaderCloseLidRunTimeCommand
+  | AbsorbanceReaderInitializeRunTimeCommand
+  | AbsorbanceReaderReadRunTimeCommand
+
+const KEYS_BY_COMMAND_TYPE: {
+  [commandType in AbsorbanceCreateCommand['commandType']]: string
+} = {
+  'absorbanceReader/openLid': 'absorbance_reader_open_lid',
+  'absorbanceReader/closeLid': 'absorbance_reader_close_lid',
+  'absorbanceReader/initialize': 'absorbance_reader_initialize',
+  'absorbanceReader/read': 'absorbance_reader_read',
+}
+
+type HandledCommands = Extract<
+  RunTimeCommand,
+  { commandType: keyof typeof KEYS_BY_COMMAND_TYPE }
+>
+
+type GetAbsorbanceReaderCommandText = HandlesCommands<HandledCommands>
+
+export const getAbsorbanceReaderCommandText = ({
+  command,
+  t,
+}: GetAbsorbanceReaderCommandText): string => {
+  if (command.commandType === 'absorbanceReader/initialize') {
+    const wavelengths = command.params.sampleWavelengths.join(' nm, ') + ` nm`
+    const mode =
+      command.params.measureMode === 'multi' ? t('multiple') : t('single')
+
+    return `${t('absorbance_reader_initialize', {
+      mode,
+      wavelengths,
+    })} ${
+      command.params.referenceWavelength != null
+        ? t('with_reference_of', {
+            wavelength: command.params.referenceWavelength,
+          })
+        : ''
+    }`
+  }
+  return t(KEYS_BY_COMMAND_TYPE[command.commandType])
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getCommentCommandText.ts

@@ -0,0 +1,10 @@
+import type { CommentRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getCommentCommandText({
+  command,
+}: HandlesCommands<CommentRunTimeCommand>): string {
+  const { message } = command.params
+
+  return message
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getConfigureForVolumeCommandText.ts

@@ -0,0 +1,21 @@
+import { getPipetteSpecsV2 } from '@opentrons/shared-data'
+
+import type { ConfigureForVolumeRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getConfigureForVolumeCommandText({
+  command,
+  commandTextData,
+  t,
+}: HandlesCommands<ConfigureForVolumeRunTimeCommand>): string {
+  const { volume, pipetteId } = command.params
+  const pipetteName = commandTextData?.pipettes.find(
+    pip => pip.id === pipetteId
+  )?.pipetteName
+
+  return t('configure_for_volume', {
+    volume,
+    pipette:
+      pipetteName != null ? getPipetteSpecsV2(pipetteName)?.displayName : '',
+  })
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getConfigureNozzleLayoutCommandText.ts

@@ -0,0 +1,29 @@
+import { getPipetteSpecsV2 } from '@opentrons/shared-data'
+
+import type { ConfigureNozzleLayoutRunTimeCommand } from '@opentrons/shared-data'
+import type { HandlesCommands } from '../types'
+
+export function getConfigureNozzleLayoutCommandText({
+  command,
+  commandTextData,
+  t,
+}: HandlesCommands<ConfigureNozzleLayoutRunTimeCommand>): string {
+  const { configurationParams, pipetteId } = command.params
+  const pipetteName = commandTextData?.pipettes.find(
+    pip => pip.id === pipetteId
+  )?.pipetteName
+
+  const ConfigAmount = {
+    SINGLE: t('single_nozzle_layout'),
+    COLUMN: t('column_layout'),
+    ROW: t('row_layout'),
+    QUADRANT: t('partial_layout'),
+    ALL: t('all_nozzles'),
+  }
+
+  return t('configure_nozzle_layout', {
+    layout: ConfigAmount[configurationParams.style],
+    pipette:
+      pipetteName != null ? getPipetteSpecsV2(pipetteName)?.displayName : '',
+  })
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getCustomCommandText.ts

@@ -0,0 +1,16 @@
+import type { CustomRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getCustomCommandText({
+  command,
+}: HandlesCommands<CustomRunTimeCommand>): string {
+  const { legacyCommandText } = command.params ?? {}
+  const sanitizedCommandText =
+    typeof legacyCommandText === 'object'
+      ? JSON.stringify(legacyCommandText)
+      : String(legacyCommandText)
+
+  return legacyCommandText != null
+    ? sanitizedCommandText
+    : `${command.commandType}: ${JSON.stringify(command.params)}`
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getDelayCommandText.ts

@@ -0,0 +1,20 @@
+import type { DeprecatedDelayRunTimeCommand } from '@opentrons/shared-data'
+import type { HandlesCommands } from '../types'
+
+export function getDelayCommandText({
+  command,
+  t,
+}: HandlesCommands<DeprecatedDelayRunTimeCommand>): string {
+  const { message = '' } = command.params
+
+  if ('waitForResume' in command.params) {
+    return command.params?.message != null && command.params.message !== ''
+      ? command.params.message
+      : t('wait_for_resume')
+  } else {
+    return t('wait_for_duration', {
+      seconds: command.params.seconds,
+      message,
+    })
+  }
+}