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

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

@@ -0,0 +1,163 @@
+import {
+  FLEX_STACKER_MODULE_V1,
+  getModuleDisplayName,
+  getModuleType,
+  getOccludedSlotCountForModule,
+  MOVABLE_TRASH_ADDRESSABLE_AREAS,
+  THERMOCYCLER_MODULE_V1,
+  THERMOCYCLER_MODULE_V2,
+  TRASH_BIN_FIXTURE,
+  WASTE_CHUTE_ADDRESSABLE_AREAS,
+} from '@opentrons/shared-data'
+
+import {
+  getLabwareLocation,
+  getLabwareLocationFromSequence,
+} from './getLabwareLocation'
+
+import type { TFunction } from 'i18next'
+import type {
+  AddressableAreaName,
+  LabwareLocation,
+  LabwareLocationSequence,
+} from '@opentrons/shared-data'
+import type {
+  LocationFullParams,
+  LocationSlotOnlyParams,
+} from './getLabwareLocation'
+
+export interface DisplayLocationSlotOnlyParams
+  extends Omit<LocationSlotOnlyParams, 'location'> {
+  t: TFunction
+  isOnDevice?: boolean
+  location?: LabwareLocation | LabwareLocationSequence | null
+}
+export interface DisplayLocationFullParams
+  extends Omit<LocationFullParams, 'location'> {
+  t: TFunction
+  isOnDevice?: boolean
+  location?: LabwareLocation | LabwareLocationSequence | null
+}
+export type DisplayLocationParams =
+  | DisplayLocationSlotOnlyParams
+  | DisplayLocationFullParams
+
+// detailLevel applies to nested labware. If 'full', return copy that includes the actual peripheral that nests the
+// labware, ex, "in module XYZ in slot C1".
+// If 'slot-only', return only the slot name, ex "in slot C1".
+export function getLabwareDisplayLocation(
+  params: DisplayLocationParams
+): string {
+  const { t, isOnDevice = false, location } = params
+  const locationResult = Array.isArray(location)
+    ? getLabwareLocationFromSequence({
+        ...params,
+        locationSequence: location,
+      })
+    : getLabwareLocation({
+        ...params,
+        location: location ?? null,
+      })
+  if (locationResult == null) {
+    return ''
+  }
+
+  const { slotName: initialSlotName, moduleModel, adapterName } = locationResult
+  const slotName =
+    moduleModel === THERMOCYCLER_MODULE_V1 ||
+    moduleModel === THERMOCYCLER_MODULE_V2
+      ? 'A1+B1'
+      : initialSlotName
+
+  if (slotName === 'offDeck' || slotName === 'systemLocation') {
+    return t('off_deck')
+  } else if (slotName === 'systemLocation') {
+    // returning system location for slot name which we'll use to swap out
+    // run log copy, this should never reach the user
+    return slotName
+  }
+  // Simple slot location
+  else if (moduleModel == null && adapterName == null) {
+    const validatedSlotCopy = handleSpecialSlotNames(slotName, t)
+    return isOnDevice ? validatedSlotCopy.odd : validatedSlotCopy.desktop
+  }
+  // Module location without adapter
+  else if (moduleModel != null && adapterName == null) {
+    if (params.detailLevel === 'slot-only') {
+      switch (moduleModel) {
+        case THERMOCYCLER_MODULE_V1:
+        case THERMOCYCLER_MODULE_V2:
+          return t('slot', { slot_name: 'A1+B1' })
+        case FLEX_STACKER_MODULE_V1:
+          return t('stacker_display_name', {
+            stacker_slot: getSlotColumn(slotName),
+          })
+        default:
+          return t('slot', { slot_name: slotName })
+      }
+    } else {
+      switch (moduleModel) {
+        case FLEX_STACKER_MODULE_V1:
+          return t('stacker_column_display_name', {
+            stacker_slot: getSlotColumn(slotName),
+          })
+        default:
+          return isOnDevice
+            ? `${getModuleDisplayName(moduleModel)}, ${slotName}`
+            : t('module_in_slot', {
+                count: getOccludedSlotCountForModule(
+                  getModuleType(moduleModel),
+                  params.robotType
+                ),
+                module: getModuleDisplayName(moduleModel),
+                slot_name: slotName,
+              })
+      }
+    }
+  }
+  // Adapter locations
+  else if (adapterName != null) {
+    if (moduleModel == null) {
+      return t('adapter_in_slot', {
+        adapter: adapterName,
+        slot: slotName,
+      })
+    } else {
+      return t('adapter_in_mod_in_slot', {
+        count: getOccludedSlotCountForModule(
+          getModuleType(moduleModel),
+          params.robotType
+        ),
+        module: getModuleDisplayName(moduleModel),
+        adapter: adapterName,
+        slot: slotName,
+      })
+    }
+  } else {
+    return ''
+  }
+}
+
+function getSlotColumn(slotName: string): string {
+  return slotName.charAt(0)
+}
+
+// Sometimes we don't want to show the actual slotName, so we special case the text here.
+function handleSpecialSlotNames(
+  slotName: string,
+  t: TFunction
+): { odd: string; desktop: string } {
+  if (WASTE_CHUTE_ADDRESSABLE_AREAS.includes(slotName as AddressableAreaName)) {
+    return { odd: t('waste_chute'), desktop: t('waste_chute') }
+  } else if (
+    slotName === TRASH_BIN_FIXTURE ||
+    MOVABLE_TRASH_ADDRESSABLE_AREAS.includes(slotName as AddressableAreaName)
+  ) {
+    return { odd: t('trash_bin'), desktop: t('trash_bin') }
+  } else {
+    return {
+      odd: slotName,
+      desktop: t('slot', { slot_name: slotName }),
+    }
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/getLabwareLocation.tsx

@@ -0,0 +1,280 @@
+import {
+  FLEX_STACKER_MODULE_V1,
+  getCutoutDisplayName,
+  getLabwareDefURI,
+  getLabwareDisplayName,
+  getModuleModelFromAddressableArea,
+  getSlotFromAddressableAreaName,
+  MOVABLE_TRASH_ADDRESSABLE_AREAS,
+  WASTE_CHUTE_ADDRESSABLE_AREAS,
+} from '@opentrons/shared-data'
+
+import { getModuleDisplayLocation } from './getModuleDisplayLocation'
+import { getModuleModel } from './getModuleModel'
+
+import type {
+  AddressableAreaName,
+  CutoutId,
+  LabwareDefinition2,
+  LabwareLocation,
+  LabwareLocationSequence,
+  ModuleModel,
+  RobotType,
+} from '@opentrons/shared-data'
+import type { LoadedLabwares, LoadedModules } from './types'
+
+export interface LocationResult {
+  slotName: string
+  moduleModel?: ModuleModel
+  adapterName?: string
+}
+
+interface BaseParams {
+  location: LabwareLocation | null
+  loadedModules: LoadedModules
+  loadedLabwares: LoadedLabwares
+  robotType: RobotType
+}
+interface SequenceBaseParams {
+  locationSequence: LabwareLocationSequence
+  loadedModules: LoadedModules
+  loadedLabwares: LoadedLabwares
+}
+
+export interface LocationSlotOnlyParams extends BaseParams {
+  detailLevel: 'slot-only'
+}
+
+export interface SequenceSlotOnlyParams extends SequenceBaseParams {
+  detailLevel: 'slot-only'
+}
+export interface LocationFullParams extends BaseParams {
+  allRunDefs: LabwareDefinition2[]
+  detailLevel?: 'full'
+}
+export interface SequenceFullParams extends SequenceBaseParams {
+  allRunDefs: LabwareDefinition2[]
+  detailLevel?: 'full'
+}
+
+export type GetLabwareLocationParams =
+  | LocationSlotOnlyParams
+  | LocationFullParams
+
+export type GetLabwareLocationFromSequenceParams =
+  | SequenceSlotOnlyParams
+  | SequenceFullParams
+
+export function getLabwareLocationFromSequence(
+  params: GetLabwareLocationFromSequenceParams
+): LocationResult {
+  const {
+    loadedLabwares,
+    loadedModules,
+    locationSequence,
+    detailLevel = 'full',
+  } = params
+  return locationSequence.reduce<LocationResult>(
+    (acc, sequenceItem, index) => {
+      if (sequenceItem.kind === 'notOnDeck') {
+        return {
+          ...acc,
+          slotName: sequenceItem.logicalLocationName,
+        }
+      } else if (
+        sequenceItem.kind === 'onCutoutFixture' &&
+        acc.slotName == null
+      ) {
+        return {
+          ...acc,
+          slotName: getCutoutDisplayName(sequenceItem.cutoutId as CutoutId),
+        }
+      } else if (
+        sequenceItem.kind === 'onAddressableArea' &&
+        (WASTE_CHUTE_ADDRESSABLE_AREAS.includes(
+          sequenceItem.addressableAreaName as AddressableAreaName
+        ) ||
+          MOVABLE_TRASH_ADDRESSABLE_AREAS.includes(
+            sequenceItem.addressableAreaName as AddressableAreaName
+          ))
+      ) {
+        return {
+          ...acc,
+          slotName: sequenceItem.addressableAreaName,
+        }
+      } else if (sequenceItem.kind === 'onAddressableArea') {
+        const slotName = getSlotFromAddressableAreaName(
+          sequenceItem.addressableAreaName as AddressableAreaName
+        )
+        const moduleModel = getModuleModelFromAddressableArea(
+          sequenceItem.addressableAreaName as AddressableAreaName
+        )
+        return {
+          ...acc,
+          slotName,
+          moduleModel:
+            moduleModel === FLEX_STACKER_MODULE_V1
+              ? undefined
+              : moduleModel ?? undefined,
+        }
+      } else if (sequenceItem.kind === 'onModule') {
+        const moduleModel = getModuleModel(loadedModules, sequenceItem.moduleId)
+        if (moduleModel == null) {
+          console.error('labware is located on an unknown module model')
+        } else {
+          return {
+            ...acc,
+            moduleModel:
+              moduleModel === FLEX_STACKER_MODULE_V1
+                ? undefined
+                : moduleModel ?? undefined,
+          }
+        }
+      }
+      // TODO(tz, 4-16-25): add inHopperLocation when logic is merged
+      else if (detailLevel === 'full') {
+        const { allRunDefs } = params as SequenceFullParams
+        if (sequenceItem.kind === 'onLabware' && acc.adapterName == null) {
+          if (!Array.isArray(loadedLabwares)) {
+            console.error('Cannot get location from loaded labwares object')
+          } else {
+            const nestedLabware = loadedLabwares.find(
+              lw => lw.id === sequenceItem.labwareId
+            )
+            const nestedLabwareDef = allRunDefs.find(
+              def => getLabwareDefURI(def) === nestedLabware?.definitionUri
+            )
+            const nestedLabwareName =
+              nestedLabwareDef != null
+                ? getLabwareDisplayName(nestedLabwareDef)
+                : ''
+            return {
+              ...acc,
+              adapterName: nestedLabwareName,
+            }
+          }
+        }
+      }
+      return { ...acc }
+    },
+    { slotName: '' }
+  )
+}
+
+// detailLevel returns additional information about the module and adapter in the same location, if applicable.
+// if 'slot-only', returns the underlying slot location.
+export function getLabwareLocation(
+  params: GetLabwareLocationParams
+): LocationResult | null {
+  const {
+    loadedLabwares,
+    loadedModules,
+    location,
+    detailLevel = 'full',
+  } = params
+
+  if (location == null) {
+    return null
+  } else if (location === 'offDeck') {
+    return { slotName: 'offDeck' }
+  } else if (location === 'systemLocation') {
+    return { slotName: 'systemLocation' }
+  } else if ('slotName' in location) {
+    return { slotName: location.slotName }
+  } else if ('addressableAreaName' in location) {
+    return {
+      slotName: getSlotFromAddressableAreaName(location.addressableAreaName),
+    }
+  } else if ('moduleId' in location) {
+    const moduleModel = getModuleModel(loadedModules, location.moduleId)
+    if (moduleModel == null) {
+      console.error('labware is located on an unknown module model')
+      return null
+    }
+    const slotName = getModuleDisplayLocation(loadedModules, location.moduleId)
+
+    return {
+      slotName,
+      moduleModel,
+    }
+  } else if ('labwareId' in location) {
+    if (!Array.isArray(loadedLabwares)) {
+      console.error('Cannot get location from loaded labwares object')
+      return null
+    }
+
+    const adapter = loadedLabwares.find(lw => lw.id === location.labwareId)
+
+    if (adapter == null) {
+      console.error('labware is located on an unknown adapter')
+      return null
+    } else if (detailLevel === 'slot-only') {
+      return getLabwareLocation({
+        ...params,
+        location: adapter.location,
+      })
+    } else if (detailLevel === 'full') {
+      const { allRunDefs } = params as LocationFullParams
+      const adapterDef = allRunDefs.find(
+        def => getLabwareDefURI(def) === adapter?.definitionUri
+      )
+      const adapterName =
+        adapterDef != null ? getLabwareDisplayName(adapterDef) : ''
+
+      if (
+        adapter.location === 'offDeck' ||
+        adapter.location === 'systemLocation'
+      ) {
+        return { slotName: 'offDeck', adapterName }
+      } else if (
+        'slotName' in adapter.location ||
+        'addressableAreaName' in adapter.location
+      ) {
+        const slotName =
+          'slotName' in adapter.location
+            ? adapter.location.slotName
+            : adapter.location.addressableAreaName
+        return { slotName, adapterName }
+      } else if ('moduleId' in adapter.location) {
+        const moduleIdUnderAdapter = adapter.location.moduleId
+
+        if (!Array.isArray(loadedModules)) {
+          console.error('Cannot get location from loaded modules object')
+          return null
+        }
+
+        const moduleModel = loadedModules.find(
+          module => module.id === moduleIdUnderAdapter
+        )?.model
+
+        if (moduleModel == null) {
+          console.error('labware is located on an adapter on an unknown module')
+          return null
+        }
+
+        const slotName = getModuleDisplayLocation(
+          loadedModules,
+          adapter.location.moduleId
+        )
+
+        return {
+          slotName,
+          moduleModel,
+          adapterName,
+        }
+      } else if ('labwareId' in adapter.location) {
+        return getLabwareLocation({
+          ...params,
+          location: adapter.location,
+        })
+      } else {
+        return null
+      }
+    } else {
+      console.error('Unhandled detailLevel.')
+      return null
+    }
+  } else {
+    return null
+  }
+}

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

@@ -0,0 +1,41 @@
+import { getLabwareDefURI, getLabwareDisplayName } from '@opentrons/shared-data'
+
+import { getLoadedLabware } from './getLoadedLabware'
+
+import type { LabwareDefinition2 } from '@opentrons/shared-data'
+import type { LoadedLabwares } from './types'
+
+const FIXED_TRASH_DEF_URIS = [
+  'opentrons/opentrons_1_trash_850ml_fixed/1',
+  'opentrons/opentrons_1_trash_1100ml_fixed/1',
+  'opentrons/opentrons_1_trash_3200ml_fixed/1',
+]
+const LID_STACK_OBJECT_LOADNAME = 'protocol_engine_lid_stack_object'
+
+export interface GetLabwareNameParams {
+  allRunDefs: LabwareDefinition2[]
+  loadedLabwares: LoadedLabwares
+  labwareId: string
+}
+
+export function getLabwareName({
+  allRunDefs,
+  loadedLabwares,
+  labwareId,
+}: GetLabwareNameParams): string {
+  const loadedLabware = getLoadedLabware(loadedLabwares, labwareId)
+  if (loadedLabware == null) {
+    return ''
+  } else if (FIXED_TRASH_DEF_URIS.includes(loadedLabware.definitionUri)) {
+    return 'Fixed Trash'
+  } else if (loadedLabware.loadName === LID_STACK_OBJECT_LOADNAME) {
+    return 'lid stack'
+  } else if (loadedLabware.displayName != null) {
+    return loadedLabware.displayName
+  } else {
+    const labwareDef = allRunDefs.find(
+      def => getLabwareDefURI(def) === loadedLabware.definitionUri
+    )
+    return labwareDef != null ? getLabwareDisplayName(labwareDef) : ''
+  }
+}

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

@@ -0,0 +1,10 @@
+import type { Liquid } from '@opentrons/shared-data'
+
+export function getLiquidDisplayName(
+  liquids: Liquid[],
+  liquidId: string
+): string {
+  const liquidDisplayName = liquids.find(liquid => liquid.id === liquidId)
+    ?.displayName
+  return liquidDisplayName ?? ''
+}

package/src/organisms/CommandText/useCommandTextString/utils/getLoadedLabware.tsx

@@ -0,0 +1,12 @@
+import type { LoadedLabware } from '@opentrons/shared-data'
+import type { LoadedLabwares } from './types'
+
+export function getLoadedLabware(
+  loadedLabware: LoadedLabwares,
+  labwareId: string
+): LoadedLabware | undefined {
+  // NOTE: old analysis contains a object dictionary of labware entities by id, this case is supported for backwards compatibility purposes
+  return Array.isArray(loadedLabware)
+    ? loadedLabware.find(l => l.id === labwareId)
+    : loadedLabware[labwareId]
+}

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

@@ -0,0 +1,12 @@
+import type { LoadedModule } from '@opentrons/shared-data'
+import type { LoadedModules } from './types'
+
+export function getLoadedModule(
+  loadedModules: LoadedModules,
+  moduleId: string
+): LoadedModule | undefined {
+  // NOTE: old analysis contains a object dictionary of module entities by id, this case is supported for backwards compatibility purposes
+  return Array.isArray(loadedModules)
+    ? loadedModules.find(l => l.id === moduleId)
+    : loadedModules[moduleId]
+}

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

@@ -0,0 +1,11 @@
+import { getLoadedModule } from './getLoadedModule'
+
+import type { LoadedModules } from './types'
+
+export function getModuleDisplayLocation(
+  loadedModules: LoadedModules,
+  moduleId: string
+): string {
+  const loadedModule = getLoadedModule(loadedModules, moduleId)
+  return loadedModule != null ? loadedModule.location.slotName : ''
+}

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

@@ -0,0 +1,12 @@
+import { getLoadedModule } from './getLoadedModule'
+
+import type { ModuleModel } from '@opentrons/shared-data'
+import type { LoadedModules } from './types'
+
+export function getModuleModel(
+  loadedModules: LoadedModules,
+  moduleId: string
+): ModuleModel | null {
+  const loadedModule = getLoadedModule(loadedModules, moduleId)
+  return loadedModule != null ? loadedModule.model : null
+}

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

@@ -0,0 +1,20 @@
+import type { LoadedPipette, PipetteName } from '@opentrons/shared-data'
+import type { LoadedPipettes } from './types'
+
+export function getLoadedPipette(
+  loadedPipettes: LoadedPipettes,
+  mount: string
+): LoadedPipette | undefined {
+  // NOTE: old analysis contains a object dictionary of pipette entities by id, this case is supported for backwards compatibility purposes
+  return Array.isArray(loadedPipettes)
+    ? loadedPipettes.find(l => l.mount === mount)
+    : loadedPipettes[mount]
+}
+
+export function getPipetteNameOnMount(
+  loadedPipettes: LoadedPipettes,
+  mount: string
+): PipetteName | null {
+  const loadedPipette = getLoadedPipette(loadedPipettes, mount)
+  return loadedPipette != null ? loadedPipette.pipetteName : null
+}

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

@@ -0,0 +1,65 @@
+import { getPipetteNameSpecs } from '@opentrons/shared-data'
+
+import type {
+  ConfigureNozzleLayoutRunTimeCommand,
+  PipetteName,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+
+const usedChannelsFromCommand = (
+  command: ConfigureNozzleLayoutRunTimeCommand | undefined,
+  defaultChannels: number
+): number =>
+  command?.params?.configurationParams?.style === 'SINGLE'
+    ? 1
+    : command?.params?.configurationParams?.style === 'COLUMN'
+    ? 8
+    : defaultChannels
+
+const usedChannelsForPipette = (
+  pipetteId: string,
+  commands: RunTimeCommand[],
+  defaultChannels: number
+): number =>
+  usedChannelsFromCommand(
+    commands.findLast(
+      (c: RunTimeCommand): c is ConfigureNozzleLayoutRunTimeCommand =>
+        c.commandType === 'configureNozzleLayout' &&
+        c.params?.pipetteId === pipetteId
+    ),
+    defaultChannels
+  )
+
+const usedChannels = (
+  pipetteId: string,
+  commands: RunTimeCommand[],
+  pipetteChannels: number
+): number =>
+  pipetteChannels === 96
+    ? usedChannelsForPipette(pipetteId, commands, pipetteChannels)
+    : pipetteChannels
+
+/**
+ * @param pipetteName name of pipette being used
+ * @param commands list of commands to search within
+ * @param wellName the target well for pickup tip
+ * @returns WellRange string of wells pipette will pickup tips from
+ */
+export function getWellRange(
+  pipetteId: string,
+  commands: RunTimeCommand[],
+  wellName: string,
+  pipetteName?: PipetteName
+): string {
+  const pipetteChannels = pipetteName
+    ? getPipetteNameSpecs(pipetteName)?.channels ?? 1
+    : 1
+  const channelCount = usedChannels(pipetteId, commands, pipetteChannels)
+  if (channelCount === 96) {
+    return 'A1 - H12'
+  } else if (channelCount === 8) {
+    const column = wellName.substr(1)
+    return `A${column} - H${column}`
+  }
+  return wellName
+}

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

@@ -0,0 +1,15 @@
+export const findLastAt = <T, U extends T = T>(
+  arr: readonly T[],
+  pred: ((el: T) => boolean) | ((el: T) => el is U)
+): [U, number] | [undefined, -1] => {
+  let arrayLoc = -1
+  const lastEl = arr.findLast((el: T, idx: number): el is U => {
+    arrayLoc = idx
+    return pred(el)
+  })
+  if (lastEl === undefined) {
+    return [undefined, -1]
+  } else {
+    return [lastEl, arrayLoc]
+  }
+}

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

@@ -0,0 +1,10 @@
+export * from './commandText'
+export * from './formatDuration'
+export * from './getLabwareDisplayLocation'
+export * from './getLabwareLocation'
+export * from './getLiquidDisplayName'
+export * from './getLoadedLabware'
+export * from './getLoadedModule'
+export * from './getModuleDisplayLocation'
+export * from './getLabwareDefinitionsFromCommands'
+export * from './types'

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

@@ -0,0 +1,19 @@
+import type {
+  LoadedLabware,
+  LoadedModule,
+  LoadedPipette,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+import type { GetCommandText, UseCommandTextStringParams } from '..'
+
+export type HandlesCommands<T extends RunTimeCommand> = Omit<
+  GetCommandText,
+  'command'
+> &
+  UseCommandTextStringParams & { command: T }
+
+export type LoadedPipettes = LoadedPipette[] | Record<string, LoadedPipette>
+
+export type LoadedLabwares = LoadedLabware[] | Record<string, LoadedLabware>
+
+export type LoadedModules = LoadedModule[] | Record<string, LoadedModule>