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

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

@@ -0,0 +1,87 @@
+import { EXTENSION, LEFT, RIGHT } from '@opentrons/shared-data'
+
+import type { TFunction } from 'i18next'
+import type {
+  MotorAxis,
+  RobotCloseGripperJawRunTimeCommand,
+  RobotMotorAxisMap,
+  RobotMoveAxesRelativeRunTimeCommand,
+  RobotMoveAxesToRunTimeCommand,
+  RobotMoveToRunTimeCommand,
+  RobotOpenGripperJawRunTimeCommand,
+} from '@opentrons/shared-data'
+import type { HandlesCommands } from '../../'
+
+const formatAxisMap = (axisMap: RobotMotorAxisMap, t: TFunction): string => {
+  const sortedAxes = [
+    'x',
+    'y',
+    'leftZ',
+    'rightZ',
+    'extensionZ',
+    'leftPlunger',
+    'rightPlunger',
+    'extensionJaw',
+  ] as const
+  const names: Record<MotorAxis, string> = {
+    x: 'X',
+    y: 'Y',
+    leftZ: t('left_z'),
+    rightZ: t('right_z'),
+    leftPlunger: t('left_plunger'),
+    rightPlunger: t('right_plunger'),
+    extensionZ: t('extension_z'),
+    extensionJaw: t('extension_jaw'),
+  }
+  const coordinateStr = sortedAxes
+    .map(axis => {
+      if (Object.hasOwn(axisMap, axis)) {
+        return `${names[axis]}: ${axisMap[axis]}`
+      }
+      return undefined
+    })
+    .filter(x => x != null)
+    .join(', ')
+  return `(${coordinateStr})`
+}
+
+export type SupportedCommands =
+  | RobotMoveToRunTimeCommand
+  | RobotMoveAxesToRunTimeCommand
+  | RobotMoveAxesRelativeRunTimeCommand
+  | RobotOpenGripperJawRunTimeCommand
+  | RobotCloseGripperJawRunTimeCommand
+
+export const getRobotCommandText = ({
+  command,
+  t,
+}: HandlesCommands<SupportedCommands>): string => {
+  switch (command?.commandType) {
+    case 'robot/moveTo': {
+      const { destination, mount } = command.params
+      const gantryMountName = (): string => {
+        switch (mount) {
+          case LEFT:
+            return t('left_mount')
+          case RIGHT:
+            return t('right_mount')
+          case EXTENSION:
+            return t('extension_mount')
+        }
+      }
+      return t('robot_move_to', { ...destination, mount: gantryMountName() })
+    }
+    case 'robot/moveAxesTo':
+      return t('robot_move_axes_to', {
+        position: formatAxisMap(command.params.axis_map, t),
+      })
+    case 'robot/moveAxesRelative':
+      return t('robot_move_axes_relative', {
+        displacement: formatAxisMap(command.params.axis_map, t),
+      })
+    case 'robot/openGripperJaw':
+      return t('robot_open_gripper_jaw')
+    case 'robot/closeGripperJaw':
+      return t('robot_close_gripper_jaw')
+  }
+}

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

@@ -0,0 +1,68 @@
+import { formatDurationLabeled } from '../formatDuration'
+
+import type {
+  AtomicProfileStep,
+  TCProfileCycle,
+  TCRunExtendedProfileRunTimeCommand,
+} from '@opentrons/shared-data/command'
+import type { GetTCRunExtendedProfileCommandTextResult } from '../..'
+import type { HandlesCommands } from '../types'
+
+export interface TCProfileStepText {
+  kind: 'step'
+  stepText: string
+}
+
+export interface TCProfileCycleText {
+  kind: 'cycle'
+  cycleText: string
+  stepTexts: TCProfileStepText[]
+}
+
+export function getTCRunExtendedProfileCommandText({
+  command,
+  t,
+}: HandlesCommands<TCRunExtendedProfileRunTimeCommand>): GetTCRunExtendedProfileCommandTextResult {
+  const { profileElements } = command.params
+
+  const stepText = ({
+    celsius,
+    holdSeconds,
+  }: AtomicProfileStep): TCProfileStepText => ({
+    kind: 'step',
+    stepText: t('tc_run_profile_steps', {
+      celsius,
+      duration: formatDurationLabeled({ seconds: holdSeconds }),
+    }).trim(),
+  })
+
+  const stepTexts = (cycle: AtomicProfileStep[]): TCProfileStepText[] =>
+    cycle.map(stepText)
+
+  const startingCycleText = (cycle: TCProfileCycle): string =>
+    t('tc_starting_extended_profile_cycle', {
+      repetitions: cycle.repetitions,
+    })
+
+  const cycleText = (cycle: TCProfileCycle): TCProfileCycleText => ({
+    kind: 'cycle',
+    cycleText: startingCycleText(cycle),
+    stepTexts: stepTexts(cycle.steps),
+  })
+  const profileElementTexts = (
+    profile: Array<TCProfileCycle | AtomicProfileStep>
+  ): Array<TCProfileStepText | TCProfileCycleText> =>
+    profile.map(element =>
+      Object.hasOwn(element, 'repetitions')
+        ? cycleText(element as TCProfileCycle)
+        : stepText(element as AtomicProfileStep)
+    )
+
+  return {
+    kind: 'thermocycler/runExtendedProfile',
+    commandText: t('tc_starting_extended_profile', {
+      elementCount: profileElements.length,
+    }),
+    profileElementTexts: profileElementTexts(profileElements),
+  }
+}

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

@@ -0,0 +1,30 @@
+import { formatDurationLabeled } from '../formatDuration'
+
+import type { TCRunProfileRunTimeCommand } from '@opentrons/shared-data/command'
+import type { GetTCRunProfileCommandTextResult } from '../..'
+import type { HandlesCommands } from '../types'
+
+export function getTCRunProfileCommandText({
+  command,
+  t,
+}: HandlesCommands<TCRunProfileRunTimeCommand>): GetTCRunProfileCommandTextResult {
+  const { profile } = command.params
+
+  const stepTexts = profile.map(
+    ({ holdSeconds, celsius }: { holdSeconds: number; celsius: number }) =>
+      t('tc_run_profile_steps', {
+        celsius,
+        duration: formatDurationLabeled({ seconds: holdSeconds }),
+      }).trim()
+  )
+
+  const startingProfileText = t('tc_starting_profile', {
+    stepCount: Object.keys(stepTexts).length,
+  })
+
+  return {
+    kind: 'thermocycler/runProfile',
+    commandText: startingProfileText,
+    stepTexts,
+  }
+}

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

@@ -0,0 +1,49 @@
+import type {
+  HeaterShakerSetTargetTemperatureCreateCommand,
+  RunTimeCommand,
+  TCSetTargetBlockTemperatureCreateCommand,
+  TCSetTargetLidTemperatureCreateCommand,
+  TemperatureModuleAwaitTemperatureCreateCommand,
+  TemperatureModuleSetTargetTemperatureCreateCommand,
+} from '@opentrons/shared-data'
+import type { HandlesCommands } from '../types'
+
+export type TemperatureCreateCommand =
+  | TemperatureModuleSetTargetTemperatureCreateCommand
+  | TemperatureModuleAwaitTemperatureCreateCommand
+  | TCSetTargetBlockTemperatureCreateCommand
+  | TCSetTargetLidTemperatureCreateCommand
+  | HeaterShakerSetTargetTemperatureCreateCommand
+
+const T_KEYS_BY_COMMAND_TYPE: {
+  [commandType in TemperatureCreateCommand['commandType']]: string
+} = {
+  'temperatureModule/setTargetTemperature': 'setting_temperature_module_temp',
+  'temperatureModule/waitForTemperature': 'waiting_to_reach_temp_module',
+  'thermocycler/setTargetBlockTemperature': 'setting_thermocycler_block_temp',
+  'thermocycler/setTargetLidTemperature': 'setting_thermocycler_lid_temp',
+  'heaterShaker/setTargetTemperature': 'setting_hs_temp',
+}
+
+type HandledCommands = Extract<
+  RunTimeCommand,
+  { commandType: keyof typeof T_KEYS_BY_COMMAND_TYPE }
+>
+
+type GetTemperatureCommandText = HandlesCommands<HandledCommands>
+
+export const getTemperatureCommandText = ({
+  command,
+  t,
+}: GetTemperatureCommandText): string => {
+  return t(T_KEYS_BY_COMMAND_TYPE[command.commandType], {
+    temp:
+      command.params?.celsius != null
+        ? t('degrees_c', { temp: command.params.celsius })
+        : t('target_temperature'),
+    hold_time_seconds:
+      'holdTimeSeconds' in command.params
+        ? command.params.holdTimeSeconds ?? '0'
+        : '0',
+  })
+}

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

@@ -0,0 +1,5 @@
+import type { GetCommandText } from '../..'
+
+export function getUnknownCommandText({ command }: GetCommandText): string {
+  return JSON.stringify(command)
+}

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

@@ -0,0 +1,11 @@
+import type { WaitForDurationRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getWaitForDurationCommandText({
+  command,
+  t,
+}: HandlesCommands<WaitForDurationRunTimeCommand>): string {
+  const { seconds, message } = command.params
+
+  return t('wait_for_duration', { seconds, message: message ?? '' })
+}

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

@@ -0,0 +1,11 @@
+import type { WaitForResumeRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getWaitForResumeCommandText({
+  command,
+  t,
+}: HandlesCommands<WaitForResumeRunTimeCommand>): string {
+  return command.params?.message != null && command.params.message !== ''
+    ? command.params.message
+    : t('wait_for_resume')
+}

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

@@ -0,0 +1,28 @@
+export * from './getLoadCommandText'
+export * from './getTemperatureCommandText'
+export * from './getTCRunProfileCommandText'
+export * from './getTCRunExtendedProfileCommandText'
+export * from './getHSShakeSpeedCommandText'
+export * from './getMoveToSlotCommandText'
+export * from './getMoveRelativeCommandText'
+export * from './getMoveToCoordinatesCommandText'
+export * from './getMoveToWellCommandText'
+export * from './getMoveLabwareCommandText'
+export * from './getConfigureForVolumeCommandText'
+export * from './getConfigureNozzleLayoutCommandText'
+export * from './getPrepareToAspirateCommandText'
+export * from './getMoveToAddressableAreaCommandText'
+export * from './getMoveToAddressableAreaForDropTipCommandText'
+export * from './getDirectTranslationCommandText'
+export * from './getWaitForDurationCommandText'
+export * from './getWaitForResumeCommandText'
+export * from './getDelayCommandText'
+export * from './getCommentCommandText'
+export * from './getCustomCommandText'
+export * from './getUnknownCommandText'
+export * from './getPipettingCommandText'
+export * from './getLiquidProbeCommandText'
+export * from './getRailLightsCommandText'
+export * from './getAbsorbanceReaderCommandText'
+export * from './getFlexStackerCommandText'
+export * from './getRobotCommandText'

package/src/organisms/CommandText/useCommandTextString/utils/formatDuration.ts

@@ -0,0 +1,46 @@
+import padStart from 'lodash/padStart'
+
+import type { Duration } from 'date-fns'
+
+/**
+ * utility to format a date-fns duration object to hh:mm:ss
+ * @param duration date-fns duration object
+ * @returns string in format hh:mm:ss, e.g. 03:15:45
+ */
+export function formatDuration(duration: Duration): string {
+  const { hours, minutes, seconds } = timestampDetails(duration)
+
+  return `${hours}:${minutes}:${seconds}`
+}
+
+export function formatDurationLabeled(duration: Duration): string {
+  const { hours, minutes, seconds } = timestampDetails(duration, 1)
+
+  return `${hours}h ${minutes}m ${seconds}s`
+}
+
+function timestampDetails(
+  duration: Duration,
+  padHoursTo?: number
+): { hours: string; minutes: string; seconds: string } {
+  const paddingWithDefault = padHoursTo ?? 2
+  const days = duration?.days ?? 0
+  const hours = duration?.hours ?? 0
+  const minutes = duration?.minutes ?? 0
+  const seconds = duration?.seconds ?? 0
+
+  const totalSeconds = seconds + minutes * 60 + hours * 3600 + days * 24 * 3600
+
+  const normalizedHours = Math.floor(totalSeconds / 3600)
+  const normalizedMinutes = Math.floor((totalSeconds % 3600) / 60)
+  const normalizedSeconds = totalSeconds % 60
+
+  const paddedHours = padStart(
+    normalizedHours.toString(),
+    paddingWithDefault,
+    '0'
+  )
+  const paddedMinutes = padStart(normalizedMinutes.toString(), 2, '0')
+  const paddedSeconds = padStart(normalizedSeconds.toString(), 2, '0')
+  return { hours: paddedHours, minutes: paddedMinutes, seconds: paddedSeconds }
+}

package/src/organisms/CommandText/useCommandTextString/utils/getAddressableAreaDisplayName.ts

@@ -0,0 +1,62 @@
+import type { TFunction } from 'i18next'
+import type {
+  AddressableAreaName,
+  MoveToAddressableAreaParams,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+
+export function getAddressableAreaDisplayName(
+  commands: RunTimeCommand[] | undefined,
+  commandId: string,
+  t: TFunction
+): string {
+  const addressableAreaCommand = (commands ?? []).find(
+    command => command.id === commandId
+  )
+
+  if (
+    addressableAreaCommand == null ||
+    !('addressableAreaName' in addressableAreaCommand.params)
+  ) {
+    return ''
+  }
+
+  const addressableAreaName: MoveToAddressableAreaParams['addressableAreaName'] =
+    addressableAreaCommand.params.addressableAreaName
+
+  if (addressableAreaName.includes('movableTrash')) {
+    const slotName = getMovableTrashSlot(addressableAreaName)
+    return t('trash_bin_in_slot', { slot_name: slotName })
+  } else if (addressableAreaName.includes('WasteChute')) {
+    return t('waste_chute')
+  } else if (addressableAreaName === 'fixedTrash') {
+    return t('fixed_trash')
+  } else {
+    return addressableAreaName
+  }
+}
+
+const getMovableTrashSlot = (
+  addressableAreaName: AddressableAreaName
+): string => {
+  switch (addressableAreaName) {
+    case 'movableTrashA1':
+      return 'A1'
+    case 'movableTrashA3':
+      return 'A3'
+    case 'movableTrashB1':
+      return 'B1'
+    case 'movableTrashB3':
+      return 'B3'
+    case 'movableTrashC1':
+      return 'C1'
+    case 'movableTrashC3':
+      return 'C3'
+    case 'movableTrashD1':
+      return 'D1'
+    case 'movableTrashD3':
+      return 'D3'
+    default:
+      return ''
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/getFinalAddressableAreaCmd.ts

@@ -0,0 +1,22 @@
+import { findLastAt } from './helpers'
+
+import type { RunTimeCommand } from '@opentrons/shared-data'
+
+/**
+ * given a list of commands and a labwareId, calculate the resulting location
+ * of the corresponding labware after all given commands are executed
+ * @param commands list of commands to search within
+ * @returns The last command related to addressable areas.
+ */
+export function getFinalMoveToAddressableAreaCmd(
+  commands: RunTimeCommand[]
+): RunTimeCommand | null {
+  const [cmd] = findLastAt(
+    commands,
+    (c: RunTimeCommand) =>
+      c.commandType === 'moveToAddressableArea' ||
+      c.commandType === 'moveToAddressableAreaForDropTip'
+  )
+
+  return cmd ?? null
+}

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

@@ -0,0 +1,46 @@
+import { findLastAt } from './helpers'
+
+import type {
+  LabwareLocation,
+  LabwareLocationSequence,
+  LoadLabwareRunTimeCommand,
+  MoveLabwareRunTimeCommand,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+
+/**
+ * given a list of commands and a labwareId, calculate the resulting location
+ * of the corresponding labware after all given commands are executed
+ * @param labwareId target labware
+ * @param commands list of commands to search within
+ * @returns LabwareLocation object of the resulting location of the target labware after all commands execute
+ */
+export function getFinalLabwareLocation(
+  labwareId: string,
+  commands: RunTimeCommand[]
+): { location?: LabwareLocation; locationSequence?: LabwareLocationSequence } {
+  const [lastMove, lastMoveIndex] = findLastAt(
+    commands,
+    (c: RunTimeCommand): c is MoveLabwareRunTimeCommand =>
+      c.commandType === 'moveLabware' && c.params.labwareId === labwareId
+  )
+
+  const [lastLoad, lastLoadIndex] = findLastAt(
+    commands,
+    (c: RunTimeCommand): c is LoadLabwareRunTimeCommand =>
+      c.commandType === 'loadLabware' && c.result?.labwareId === labwareId
+  )
+  if (lastMoveIndex > lastLoadIndex) {
+    return {
+      location: lastMove?.params?.newLocation,
+      locationSequence: lastMove?.result?.immediateDestinationLocationSequence,
+    }
+  } else if (lastLoadIndex > lastMoveIndex) {
+    return {
+      location: lastLoad?.params?.location,
+      locationSequence: lastLoad?.result?.locationSequence,
+    }
+  } else {
+    return {}
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/getLabwareDefinitionsFromCommands.ts

@@ -0,0 +1,59 @@
+import { getLabwareDefURI } from '@opentrons/shared-data'
+
+import type {
+  LabwareDefinition2,
+  LoadLabwareRunTimeCommand,
+  LoadLidRunTimeCommand,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+
+// Note: This is an O(n) operation.
+export function getLabwareDefinitionsFromCommands(
+  commands: RunTimeCommand[]
+): LabwareDefinition2[] {
+  return commands.reduce<LabwareDefinition2[]>(
+    (acc, command) => [
+      ...getLabwareDefinitionFromCommand(command, acc),
+      ...acc,
+    ],
+    []
+  )
+}
+
+function getNewLabwareDefinitions(
+  newDefinitions: Array<LabwareDefinition2 | null | undefined>,
+  knownDefinitions: LabwareDefinition2[]
+): LabwareDefinition2[] {
+  return newDefinitions.filter(
+    (maybeNewDef): maybeNewDef is LabwareDefinition2 =>
+      maybeNewDef != null &&
+      !knownDefinitions.some(
+        knownDef => getLabwareDefURI(knownDef) === getLabwareDefURI(maybeNewDef)
+      )
+  )
+}
+
+const isLoadCommand = (
+  command: RunTimeCommand
+): command is LoadLabwareRunTimeCommand | LoadLidRunTimeCommand =>
+  ['loadLabware', 'loadLid', 'loadLidStack'].includes(command.commandType)
+
+function getLabwareDefinitionFromCommand(
+  command: RunTimeCommand,
+  known: LabwareDefinition2[]
+): LabwareDefinition2[] {
+  if (isLoadCommand(command)) {
+    return getNewLabwareDefinitions([command.result?.definition], known)
+  }
+  if (command.commandType === 'flexStacker/setStoredLabware') {
+    return getNewLabwareDefinitions(
+      [
+        command.result?.primaryLabwareDefinition,
+        command.result?.adapterLabwareDefinition,
+        command.result?.lidLabwareDefinition,
+      ],
+      known
+    )
+  }
+  return []
+}