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

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

@@ -0,0 +1,118 @@
+import { useTranslation } from 'react-i18next'
+import { screen } from '@testing-library/react'
+import { describe, it } from 'vitest'
+
+import { i18n } from '../../../../../../i18n'
+import { renderWithProviders } from '../../../../../../testing/utils'
+import { getRobotCommandText } from '../getRobotCommandText'
+
+import type { HandlesCommands } from '../../types'
+import type { SupportedCommands } from '../getRobotCommandText'
+
+function TestWrapper({ command }: { command: SupportedCommands }): JSX.Element {
+  const { t } = useTranslation('protocol_command_text')
+  const text = getRobotCommandText({
+    command,
+    t,
+  } as HandlesCommands<SupportedCommands>)
+  return <div>{text}</div>
+}
+
+const render = (command: any) => {
+  return renderWithProviders(<TestWrapper command={command} />, {
+    i18nInstance: i18n,
+  })
+}
+
+describe('getRobotCommandText', () => {
+  it('should render openGripperJaw', () => {
+    render({ commandType: 'robot/openGripperJaw' } as SupportedCommands)
+    screen.getByText(/Opening robot gripper jaw/)
+  })
+  it('should render closeGripperJaw', () => {
+    render({ commandType: 'robot/closeGripperJaw' } as SupportedCommands)
+    screen.getByText(/Closing robot gripper jaw/)
+  })
+  ;(['left', 'right', 'extension'] as const).forEach(mountName =>
+    it(`should render moveAxes {mountName}`, () => {
+      render({
+        commandType: 'robot/moveTo',
+        params: { destination: { x: 1, y: 2, z: 3 }, mount: mountName },
+      })
+      screen.getByText(`Moving ${mountName} mount to (X: 1, Y: 2, Z: 3)`)
+    })
+  )
+
+  it('should render moveAxesTo with all axes', () => {
+    render({
+      commandType: 'robot/moveAxesTo',
+      params: {
+        axis_map: {
+          x: 1,
+          y: 2,
+          leftZ: 3,
+          rightZ: 4,
+          extensionZ: 5,
+          leftPlunger: 6,
+          rightPlunger: 7,
+          extensionJaw: 8,
+        },
+      },
+    })
+    screen.getByText(
+      'Moving robot to (X: 1, Y: 2, left Z: 3, right Z: 4, extension Z: 5, left plunger: 6, right plunger: 7, extension jaw: 8)'
+    )
+  })
+  it('should render moveAxesTo with not all axes', () => {
+    render({
+      commandType: 'robot/moveAxesTo',
+      params: {
+        axis_map: {
+          x: 1,
+          rightZ: 4,
+          extensionZ: 5,
+          rightPlunger: 7,
+        },
+      },
+    })
+    screen.getByText(
+      'Moving robot to (X: 1, right Z: 4, extension Z: 5, right plunger: 7)'
+    )
+  })
+  it('should render moveAxesRelative with all axes', () => {
+    render({
+      commandType: 'robot/moveAxesRelative',
+      params: {
+        axis_map: {
+          x: 1,
+          y: 2,
+          leftZ: 3,
+          rightZ: 4,
+          extensionZ: 5,
+          leftPlunger: 6,
+          rightPlunger: 7,
+          extensionJaw: 8,
+        },
+      },
+    })
+    screen.getByText(
+      'Moving robot by (X: 1, Y: 2, left Z: 3, right Z: 4, extension Z: 5, left plunger: 6, right plunger: 7, extension jaw: 8)'
+    )
+  })
+  it('should render moveAxesRelative with not all axes', () => {
+    render({
+      commandType: 'robot/moveAxesRelative',
+      params: {
+        axis_map: {
+          x: 1,
+          rightZ: 4,
+          extensionZ: 5,
+          rightPlunger: 7,
+        },
+      },
+    })
+    screen.getByText(
+      'Moving robot by (X: 1, right Z: 4, extension Z: 5, right plunger: 7)'
+    )
+  })
+})

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

@@ -0,0 +1,53 @@
+import type {
+  AbsorbanceReaderCloseLidRunTimeCommand,
+  AbsorbanceReaderInitializeRunTimeCommand,
+  AbsorbanceReaderOpenLidRunTimeCommand,
+  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,
+    })
+  }
+}

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

@@ -0,0 +1,44 @@
+import type { RunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+const SIMPLE_TRANSLATION_KEY_BY_COMMAND_TYPE: {
+  [commandType in RunTimeCommand['commandType']]?: string
+} = {
+  home: 'home_gantry',
+  savePosition: 'save_position',
+  touchTip: 'touch_tip',
+  'magneticModule/engage': 'engaging_magnetic_module',
+  'magneticModule/disengage': 'disengaging_magnetic_module',
+  'temperatureModule/deactivate': 'deactivate_temperature_module',
+  'thermocycler/waitForBlockTemperature': 'waiting_for_tc_block_to_reach',
+  'thermocycler/waitForLidTemperature': 'waiting_for_tc_lid_to_reach',
+  'thermocycler/openLid': 'opening_tc_lid',
+  'thermocycler/closeLid': 'closing_tc_lid',
+  'thermocycler/deactivateBlock': 'deactivating_tc_block',
+  'thermocycler/deactivateLid': 'deactivating_tc_lid',
+  'thermocycler/awaitProfileComplete': 'tc_awaiting_for_duration',
+  'heaterShaker/deactivateHeater': 'deactivating_hs_heater',
+  'heaterShaker/openLabwareLatch': 'unlatching_hs_latch',
+  'heaterShaker/closeLabwareLatch': 'latching_hs_latch',
+  'heaterShaker/deactivateShaker': 'deactivate_hs_shake',
+  'heaterShaker/waitForTemperature': 'waiting_for_hs_to_reach',
+}
+
+type HandledCommands = Extract<
+  RunTimeCommand,
+  { commandType: keyof typeof SIMPLE_TRANSLATION_KEY_BY_COMMAND_TYPE }
+>
+
+export type GetDirectTranslationCommandText = HandlesCommands<HandledCommands>
+
+export function getDirectTranslationCommandText({
+  command,
+  t,
+}: GetDirectTranslationCommandText): string {
+  const simpleTKey =
+    command != null
+      ? SIMPLE_TRANSLATION_KEY_BY_COMMAND_TYPE[command.commandType]
+      : null
+
+  return simpleTKey != null ? t(simpleTKey) : ''
+}

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

@@ -0,0 +1,168 @@
+import { getLabwareDefURI } from '@opentrons/shared-data'
+
+import { getLabwareDisplayLocation } from '../../utils/getLabwareDisplayLocation'
+
+import type {
+  FlexStackerEmptyRunTimeCommand,
+  FlexStackerFillRunTimeCommand,
+  FlexStackerRetrieveRunTimeCommand,
+  FlexStackerSetStoredLabwareRunTimeCommand,
+  FlexStackerStoreRunTimeCommand,
+  LabwareDefinition2,
+  LabwareDefinition3,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+import type { HandlesCommands } from '../types'
+
+export type FlexStackerCommand =
+  | FlexStackerSetStoredLabwareRunTimeCommand
+  | FlexStackerStoreRunTimeCommand
+  | FlexStackerRetrieveRunTimeCommand
+  | FlexStackerFillRunTimeCommand
+  | FlexStackerEmptyRunTimeCommand
+
+export const KEYS_BY_COMMAND_TYPE: {
+  [commandType in FlexStackerCommand['commandType']]: string
+} = {
+  'flexStacker/retrieve': 'flex_stacker_retrieve',
+  'flexStacker/store': 'flex_stacker_store',
+  'flexStacker/setStoredLabware': 'flex_stacker_set_stored_labware',
+  'flexStacker/empty': 'flex_stacker_empty',
+  'flexStacker/fill': 'flex_stacker_fill',
+}
+
+type HandledCommands = Extract<
+  RunTimeCommand,
+  { commandType: keyof typeof KEYS_BY_COMMAND_TYPE }
+>
+
+type GetFlexStackerCommandText = HandlesCommands<HandledCommands>
+
+const getLabwareDisplayName = (labwareUri: string, allRunDefs: any): string => {
+  const currentLabwareDef = allRunDefs.find(
+    (def: LabwareDefinition2 | LabwareDefinition3) =>
+      getLabwareDefURI(def) === labwareUri
+  )
+  return currentLabwareDef?.metadata.displayName ?? null
+}
+
+export const getFlexStackerCommandText = ({
+  command,
+  allRunDefs,
+  commandTextData,
+  t,
+  robotType,
+}: // stackerCommand,
+GetFlexStackerCommandText): string => {
+  const primaryDefinitionDisplayName =
+    command.result !== undefined && 'primaryLabwareURI' in command?.result
+      ? getLabwareDisplayName(
+          command?.result.primaryLabwareURI,
+          allRunDefs ?? []
+        )
+      : null
+  if (command.commandType === 'flexStacker/retrieve') {
+    const slotName = getLabwareDisplayLocation({
+      loadedLabwares: commandTextData?.labware ?? [],
+      location: command.result?.primaryLocationSequence,
+      robotType,
+      allRunDefs,
+      loadedModules: commandTextData?.modules ?? [],
+      t,
+    })
+    if (primaryDefinitionDisplayName != null && slotName != null) {
+      return t('branded:retrieve_labware_from_stacker_to', {
+        primaryDefinitionDisplayName,
+        slotName,
+      })
+    }
+  } else if (command.commandType === 'flexStacker/store') {
+    const slotName = getLabwareDisplayLocation({
+      loadedLabwares: commandTextData?.labware ?? [],
+      location: command.result?.primaryOriginLocationSequence ?? null,
+      robotType,
+      allRunDefs,
+      loadedModules: commandTextData?.modules ?? [],
+      t,
+    })
+    if (primaryDefinitionDisplayName != null && slotName != null) {
+      return t('branded:store_labware_from_slot_to_stacker', {
+        primaryDefinitionDisplayName,
+        slotName,
+      })
+    }
+  } else if (command.commandType === 'flexStacker/setStoredLabware') {
+    const slotName = getLabwareDisplayLocation({
+      loadedLabwares: commandTextData?.labware ?? [],
+      location: { moduleId: command.params?.moduleId },
+      robotType,
+      allRunDefs,
+      loadedModules: commandTextData?.modules ?? [],
+      t,
+    })
+    if (
+      command.result !== undefined &&
+      'primaryLabwareDefinition' in command.result &&
+      slotName != null
+    ) {
+      return (
+        t(
+          'branded:flex_stacker_set_stored_labware_with_quantity_and_location',
+          {
+            quantity: command.params.initialCount,
+            stackerColumn: slotName,
+            labwareAndLidDisplayNames:
+              command.result?.primaryLabwareDefinition.metadata.displayName,
+          }
+        ) +
+        (command.result?.lidLabwareDefinition != null
+          ? t('with_lid_name', {
+              lidDisplayName:
+                command.result?.lidLabwareDefinition.metadata.displayName,
+            })
+          : '')
+      )
+    }
+  } else if (command.commandType === 'flexStacker/fill') {
+    const slotName = getLabwareDisplayLocation({
+      loadedLabwares: commandTextData?.labware ?? [],
+      location: { moduleId: command.params?.moduleId },
+      robotType,
+      allRunDefs,
+      loadedModules: commandTextData?.modules ?? [],
+      t,
+    })
+    if (primaryDefinitionDisplayName != null) {
+      return (
+        t('branded:flex_stacker_fill_with_quantity_and_labware', {
+          quantity: command.params.count,
+          stackerColumn: slotName,
+          labwareAndLidDisplayNames: primaryDefinitionDisplayName,
+        }) +
+        (command.result?.lidLabwareURI != null
+          ? t('with_lid_name', {
+              lidDisplayName: getLabwareDisplayName(
+                command.result?.lidLabwareURI,
+                allRunDefs ?? []
+              ),
+            })
+          : '')
+      )
+    }
+  } else if (command.commandType === 'flexStacker/empty') {
+    const slotName = getLabwareDisplayLocation({
+      loadedLabwares: commandTextData?.labware ?? [],
+      location: { moduleId: command.params?.moduleId },
+      robotType,
+      allRunDefs,
+      loadedModules: commandTextData?.modules ?? [],
+      t,
+    })
+    if (primaryDefinitionDisplayName != null && slotName != null) {
+      return t('branded:flex_stacker_empty_from_location', {
+        stackerColumn: slotName,
+      })
+    }
+  }
+  return t('branded:' + KEYS_BY_COMMAND_TYPE[command.commandType])
+}

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

@@ -0,0 +1,11 @@
+import type { HeaterShakerSetAndWaitForShakeSpeedRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getHSShakeSpeedCommandText({
+  command,
+  t,
+}: HandlesCommands<HeaterShakerSetAndWaitForShakeSpeedRunTimeCommand>): string {
+  const { rpm } = command.params
+
+  return t('set_and_await_hs_shake', { rpm })
+}

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

@@ -0,0 +1,61 @@
+import { getFinalLabwareLocation } from '../getFinalLabwareLocation'
+import { getLabwareDisplayLocation } from '../getLabwareDisplayLocation'
+import { getLabwareName } from '../getLabwareName'
+
+import type {
+  LiquidProbeRunTimeCommand,
+  RunTimeCommand,
+  TryLiquidProbeRunTimeCommand,
+} from '@opentrons/shared-data'
+import type { HandlesCommands } from '../types'
+
+type LiquidProbeRunTimeCommands =
+  | LiquidProbeRunTimeCommand
+  | TryLiquidProbeRunTimeCommand
+
+export function getLiquidProbeCommandText({
+  command,
+  allRunDefs,
+  commandTextData,
+  t,
+  robotType,
+}: HandlesCommands<LiquidProbeRunTimeCommands>): string {
+  const { wellName, labwareId } = command.params
+
+  const allPreviousCommands = commandTextData?.commands.slice(
+    0,
+    commandTextData.commands.findIndex(c => c.id === command?.id)
+  )
+
+  const labwareLocation =
+    allPreviousCommands != null
+      ? getFinalLabwareLocation(
+          labwareId as string,
+          allPreviousCommands as RunTimeCommand[]
+        )
+      : null
+
+  const displayLocation = getLabwareDisplayLocation({
+    loadedLabwares: commandTextData?.labware ?? [],
+    location: labwareLocation?.locationSequence ?? labwareLocation?.location,
+    robotType,
+    allRunDefs,
+    loadedModules: commandTextData?.modules ?? [],
+    t,
+  })
+
+  const labware =
+    commandTextData != null
+      ? getLabwareName({
+          loadedLabwares: commandTextData?.labware ?? [],
+          labwareId,
+          allRunDefs,
+        })
+      : null
+
+  return t('detect_liquid_presence', {
+    labware,
+    labware_location: displayLocation,
+    well_name: wellName,
+  })
+}