@opentrons/shared-data 0.0.0-alpha.14

package/js/helpers/__tests__/volume.test.ts

@@ -0,0 +1,108 @@
+// volume helpers tests
+import * as helpers from '..'
+
+interface BaseSpec<T extends (...args: any) => any> {
+  name: string
+  func: T
+  input: Parameters<T>
+  expected: ReturnType<T>
+}
+
+type GetDisplayVolumeSpec = BaseSpec<typeof helpers.getDisplayVolume>
+
+type GetAsciiVolumeUnitsSpec = BaseSpec<typeof helpers.getAsciiVolumeUnits>
+
+type EnsureVolumeUnitsSpec = BaseSpec<typeof helpers.ensureVolumeUnits>
+
+type TestSpec =
+  | GetDisplayVolumeSpec
+  | GetAsciiVolumeUnitsSpec
+  | EnsureVolumeUnitsSpec
+
+describe('volume helpers', () => {
+  const SPECS: TestSpec[] = [
+    {
+      name: 'getDisplayVolume outputs µL string by default',
+      func: helpers.getDisplayVolume,
+      input: [380],
+      expected: '380',
+    },
+    {
+      name: 'getDisplayVolume converts to mL',
+      func: helpers.getDisplayVolume,
+      input: [4200, 'mL'],
+      expected: '4.2',
+    },
+    {
+      name: 'getDisplayVolume converts to L',
+      func: helpers.getDisplayVolume,
+      input: [800000, 'L'],
+      expected: '0.8',
+    },
+    {
+      name: 'getDisplayVolume can round to fixed digits',
+      func: helpers.getDisplayVolume,
+      input: [123456789, 'L', 3],
+      expected: '123.457',
+    },
+    {
+      name: 'getAsciiVolumeUnits converts µL to uL',
+      func: helpers.getAsciiVolumeUnits,
+      input: ['µL'],
+      expected: 'uL',
+    },
+    {
+      name: 'getAsciiVolumeUnits leaves mL alone',
+      func: helpers.getAsciiVolumeUnits,
+      input: ['mL'],
+      expected: 'mL',
+    },
+    {
+      name: 'getAsciiVolumeUnits leaves L alone',
+      func: helpers.getAsciiVolumeUnits,
+      input: ['L'],
+      expected: 'L',
+    },
+    {
+      name: 'ensureVolumeUnits converts undefined to µL',
+      func: helpers.ensureVolumeUnits,
+      input: [undefined],
+      expected: 'µL',
+    },
+    {
+      name: 'ensureVolumeUnits converts uL to µL',
+      func: helpers.ensureVolumeUnits,
+      input: ['uL'],
+      expected: 'µL',
+    },
+    {
+      name: 'ensureVolumeUnits leaves mL alone',
+      func: helpers.ensureVolumeUnits,
+      input: ['mL'],
+      expected: 'mL',
+    },
+    {
+      name: 'ensureVolumeUnits leaves L alone',
+      func: helpers.ensureVolumeUnits,
+      input: ['L'],
+      expected: 'L',
+    },
+    {
+      name: 'ensureVolumeUnits converts ml to mL',
+      func: helpers.ensureVolumeUnits,
+      input: ['ml'],
+      expected: 'mL',
+    },
+    {
+      name: 'ensureVolumeUnits leaves l to L',
+      func: helpers.ensureVolumeUnits,
+      input: ['l'],
+      expected: 'L',
+    },
+  ]
+
+  SPECS.forEach(s => {
+    // @ts-expect-error(mc, 2021-04-27): rewrite as regular tests
+    it(`should ${s.name}`, () => expect(s.func(...s.input)).toEqual(s.expected))
+  })
+})

package/js/helpers/__tests__/wellSets.test.ts

@@ -0,0 +1,352 @@
+import pipetteNameSpecsFixtures from '../../../pipette/fixtures/name/pipetteNameSpecFixtures.json'
+import fixture_12_trough from '../../../labware/fixtures/2/fixture_12_trough.json'
+import fixture_96_plate from '../../../labware/fixtures/2/fixture_96_plate.json'
+import fixture_384_plate from '../../../labware/fixtures/2/fixture_384_plate.json'
+import fixture_overlappy_wellplate from '../../../labware/fixtures/2/fixture_overlappy_wellplate.json'
+import { makeWellSetHelpers } from '../wellSets'
+import { findWellAt } from '../getWellNamePerMultiTip'
+import { get96Channel384WellPlateWells, orderWells } from '..'
+
+import type { LabwareDefinition2, PipetteNameSpecs } from '../../types'
+import type { WellSetHelpers } from '../wellSets'
+
+const fixtureP10Single = pipetteNameSpecsFixtures.p10_single as PipetteNameSpecs
+const fixtureP10Multi = pipetteNameSpecsFixtures.p10_multi as PipetteNameSpecs
+const fixtureP100096 = (pipetteNameSpecsFixtures.p1000_96 as any) as PipetteNameSpecs
+const fixture12Trough = fixture_12_trough as LabwareDefinition2
+const fixture96Plate = fixture_96_plate as LabwareDefinition2
+const fixture384Plate = fixture_384_plate as LabwareDefinition2
+const fixtureOverlappyWellplate = fixture_overlappy_wellplate as LabwareDefinition2
+const EIGHT_CHANNEL = 8
+const NINETY_SIX_CHANNEL = 96
+const wellsForReservoir = [
+  'A1',
+  'A2',
+  'A3',
+  'A4',
+  'A5',
+  'A6',
+  'A7',
+  'A8',
+  'A9',
+  'A10',
+  'A11',
+  'A12',
+]
+
+const wellsFor96WellPlate = [
+  'A1',
+  'B1',
+  'C1',
+  'D1',
+  'E1',
+  'F1',
+  'G1',
+  'H1',
+  'A2',
+  'B2',
+  'C2',
+  'D2',
+  'E2',
+  'F2',
+  'G2',
+  'H2',
+  'A3',
+  'B3',
+  'C3',
+  'D3',
+  'E3',
+  'F3',
+  'G3',
+  'H3',
+  'A4',
+  'B4',
+  'C4',
+  'D4',
+  'E4',
+  'F4',
+  'G4',
+  'H4',
+  'A5',
+  'B5',
+  'C5',
+  'D5',
+  'E5',
+  'F5',
+  'G5',
+  'H5',
+  'A6',
+  'B6',
+  'C6',
+  'D6',
+  'E6',
+  'F6',
+  'G6',
+  'H6',
+  'A7',
+  'B7',
+  'C7',
+  'D7',
+  'E7',
+  'F7',
+  'G7',
+  'H7',
+  'A8',
+  'B8',
+  'C8',
+  'D8',
+  'E8',
+  'F8',
+  'G8',
+  'H8',
+  'A9',
+  'B9',
+  'C9',
+  'D9',
+  'E9',
+  'F9',
+  'G9',
+  'H9',
+  'A10',
+  'B10',
+  'C10',
+  'D10',
+  'E10',
+  'F10',
+  'G10',
+  'H10',
+  'A11',
+  'B11',
+  'C11',
+  'D11',
+  'E11',
+  'F11',
+  'G11',
+  'H11',
+  'A12',
+  'B12',
+  'C12',
+  'D12',
+  'E12',
+  'F12',
+  'G12',
+  'H12',
+]
+
+describe('findWellAt', () => {
+  it('should determine if given (x, y) is within a rectangular well', () => {
+    const def: any = {
+      wells: {
+        A1: {
+          shape: 'rectangular',
+          x: 200,
+          y: 200,
+          xDimension: 10,
+          yDimension: 10,
+        },
+      },
+    }
+    const middle = findWellAt(def, 200, 200)
+    expect(middle).toBe('A1')
+
+    const insideCornerNE = findWellAt(def, 200 - 4, 200 + 4)
+    expect(insideCornerNE).toEqual('A1')
+
+    // exactly at an edge doesn't count
+    const exactlyOnCornerNE = findWellAt(def, 200 - 5, 200 + 5)
+    expect(exactlyOnCornerNE).toBeUndefined()
+
+    const exactlyOnWEdge = findWellAt(def, 200, 200 - 5)
+    expect(exactlyOnWEdge).toBeUndefined()
+
+    const justOutsideToEast = findWellAt(def, 200 + 5.1, 200)
+    expect(justOutsideToEast).toBeUndefined()
+  })
+
+  it('should determine if given (x, y) is within a circular well', () => {
+    const def: any = {
+      wells: {
+        A1: {
+          shape: 'circular',
+          x: 200,
+          y: 200,
+          diameter: 10,
+        },
+      },
+    }
+    const middle = findWellAt(def, 200, 200)
+    expect(middle).toBe('A1')
+
+    const inside = findWellAt(def, 200 - 1, 200 + 1)
+    expect(inside).toEqual('A1')
+
+    // exactly at an edge doesn't count
+    const exactlyOnWEdge = findWellAt(def, 200, 200 - 5)
+    expect(exactlyOnWEdge).toBeUndefined()
+
+    const justOutsideToEast = findWellAt(def, 200 + 5.1, 200)
+    expect(justOutsideToEast).toBeUndefined()
+  })
+})
+describe('canPipetteUseLabware', () => {
+  let canPipetteUseLabware: WellSetHelpers['canPipetteUseLabware']
+
+  beforeEach(() => {
+    const helpers = makeWellSetHelpers()
+    canPipetteUseLabware = helpers.canPipetteUseLabware
+  })
+
+  it('returns false when wells are too close together for multi channel pipettes', () => {
+    const labwareDef = fixtureOverlappyWellplate
+    const pipette = fixtureP10Multi
+    const pipette96 = fixtureP100096
+
+    expect(canPipetteUseLabware(pipette, labwareDef)).toBe(false)
+    expect(canPipetteUseLabware(pipette96, labwareDef)).toBe(false)
+  })
+
+  it('returns true when pipette is single channel', () => {
+    const labwareDef = fixtureOverlappyWellplate
+    const pipette = fixtureP10Single
+
+    expect(canPipetteUseLabware(pipette, labwareDef)).toBe(true)
+  })
+})
+
+describe('getWellSetForMultichannel (integration test)', () => {
+  let getWellSetForMultichannel: WellSetHelpers['getWellSetForMultichannel']
+
+  beforeEach(() => {
+    const helpers = makeWellSetHelpers()
+    getWellSetForMultichannel = helpers.getWellSetForMultichannel
+  })
+
+  it('96-flat', () => {
+    const labwareDef = fixture96Plate
+
+    expect(getWellSetForMultichannel(labwareDef, 'A1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'B1',
+      'C1',
+      'D1',
+      'E1',
+      'F1',
+      'G1',
+      'H1',
+    ])
+
+    expect(getWellSetForMultichannel(labwareDef, 'B1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'B1',
+      'C1',
+      'D1',
+      'E1',
+      'F1',
+      'G1',
+      'H1',
+    ])
+
+    expect(getWellSetForMultichannel(labwareDef, 'H1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'B1',
+      'C1',
+      'D1',
+      'E1',
+      'F1',
+      'G1',
+      'H1',
+    ])
+
+    expect(getWellSetForMultichannel(labwareDef, 'A2', EIGHT_CHANNEL)).toEqual([
+      'A2',
+      'B2',
+      'C2',
+      'D2',
+      'E2',
+      'F2',
+      'G2',
+      'H2',
+    ])
+
+    //  96-channel
+    expect(
+      getWellSetForMultichannel(labwareDef, 'A1', NINETY_SIX_CHANNEL)
+    ).toEqual(wellsFor96WellPlate)
+  })
+
+  it('invalid well', () => {
+    const labwareDef = fixture96Plate
+
+    expect(
+      getWellSetForMultichannel(labwareDef, 'A13', EIGHT_CHANNEL)
+    ).toBeFalsy()
+  })
+
+  it('trough-12row', () => {
+    const labwareDef = fixture12Trough
+
+    expect(getWellSetForMultichannel(labwareDef, 'A1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+      'A1',
+    ])
+
+    expect(getWellSetForMultichannel(labwareDef, 'A2', EIGHT_CHANNEL)).toEqual([
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+      'A2',
+    ])
+
+    //  96-channel
+    expect(
+      getWellSetForMultichannel(labwareDef, 'A1', NINETY_SIX_CHANNEL)
+    ).toEqual(wellsForReservoir)
+  })
+
+  it('384-plate', () => {
+    const labwareDef = fixture384Plate
+    const well96Channel = 'A1'
+    const all384Wells = orderWells(labwareDef.ordering, 't2b', 'l2r')
+    const ninetySixChannelWells = get96Channel384WellPlateWells(
+      all384Wells,
+      well96Channel
+    )
+
+    expect(getWellSetForMultichannel(labwareDef, 'C1', EIGHT_CHANNEL)).toEqual([
+      'A1',
+      'C1',
+      'E1',
+      'G1',
+      'I1',
+      'K1',
+      'M1',
+      'O1',
+    ])
+
+    expect(getWellSetForMultichannel(labwareDef, 'F2', EIGHT_CHANNEL)).toEqual([
+      'B2',
+      'D2',
+      'F2',
+      'H2',
+      'J2',
+      'L2',
+      'N2',
+      'P2',
+    ])
+
+    //  96-channel
+    expect(
+      getWellSetForMultichannel(labwareDef, well96Channel, NINETY_SIX_CHANNEL)
+    ).toEqual(ninetySixChannelWells)
+  })
+})

package/js/helpers/get96Channel384WellPlateWells.ts

@@ -0,0 +1,44 @@
+//  TODO(jr, 10/19/23): should extend getWellNamePerMultiTip to use similar math for 96-channel and 384 well plates
+//  instead of special casing using this util
+export function get96Channel384WellPlateWells(
+  all384Wells: string[],
+  well: string
+): string[] {
+  const totalWells = 96 * 2 //  multiplying 2 because we will remove either odd or even numbers
+
+  const filterWellsFor96Channel = (start: number, isOdd: boolean): string[] => {
+    const filteredWells: string[] = []
+    let count = start
+    for (let i = 0; i < totalWells; i++) {
+      if (count < all384Wells.length) {
+        const well = all384Wells[count]
+        const numberFromWell = well.match(/\d+/)
+        if (numberFromWell) {
+          const number = parseInt(numberFromWell[0])
+          if ((number % 2 === 1 && isOdd) || (number % 2 === 0 && !isOdd)) {
+            filteredWells.push(well)
+          }
+        }
+        count += 2
+      } else {
+        break
+      }
+    }
+    return filteredWells
+  }
+
+  const allSetsOfWells = [
+    filterWellsFor96Channel(0, true),
+    filterWellsFor96Channel(1, true),
+    filterWellsFor96Channel(0, false),
+    filterWellsFor96Channel(1, false),
+  ]
+
+  for (const wells of allSetsOfWells) {
+    if (wells.includes(well)) {
+      return wells
+    }
+  }
+
+  return []
+}

package/js/helpers/getLoadedLabwareDefinitionsByUri.ts

@@ -0,0 +1,30 @@
+import { getLabwareDefURI } from '.'
+import type { RunTimeCommand, LabwareDefinition2 } from '..'
+
+export interface LabwareDefinitionsByUri {
+  [defURI: string]: LabwareDefinition2
+}
+
+export function getLoadedLabwareDefinitionsByUri(
+  commands: RunTimeCommand[]
+): LabwareDefinitionsByUri {
+  return commands.reduce((acc, command) => {
+    if (command.commandType === 'loadLabware') {
+      const labwareDef: LabwareDefinition2 | undefined =
+        command.result?.definition
+      if (labwareDef == null) {
+        console.warn(
+          `could not find a labware definition in the results of load labware command: ${JSON.stringify(
+            command
+          )}`
+        )
+        return acc
+      } else {
+        const definitionUri = getLabwareDefURI(labwareDef)
+        return { ...acc, [definitionUri]: labwareDef }
+      }
+    } else {
+      return acc
+    }
+  }, {})
+}

package/js/helpers/getModuleVizDims.ts

@@ -0,0 +1,118 @@
+// NOTE: Ian 2019-10-24 these are by-eye numbers that intentionally
+// ignore the real-life data to emphasize overhangs etc
+import {
+  MAGNETIC_MODULE_TYPE,
+  TEMPERATURE_MODULE_TYPE,
+  THERMOCYCLER_MODULE_TYPE,
+  HEATERSHAKER_MODULE_TYPE,
+  STD_SLOT_X_DIM as SLOT_X,
+  STD_SLOT_Y_DIM as SLOT_Y,
+  STD_SLOT_DIVIDER_WIDTH as DIVIDER,
+  SPAN7_8_10_11_SLOT,
+  MAGNETIC_BLOCK_TYPE,
+} from '../constants'
+import { ModuleType, ModuleOrientation } from '../types'
+// NOTE: all dims are in 'left' orientation. Rotate & transform to obtain 'right' orientation.
+
+export interface ModuleVizDims {
+  xOffset: number
+  yOffset: number
+  xDimension: number
+  yDimension: number
+  childXOffset: number
+  childYOffset: number
+  childXDimension: number
+  childYDimension: number
+}
+const MODULE_VIZ_DIMS: Record<ModuleType, ModuleVizDims> = {
+  [MAGNETIC_MODULE_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.2 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.2 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  [TEMPERATURE_MODULE_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.4 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.4 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  [THERMOCYCLER_MODULE_TYPE]: {
+    xOffset: -8,
+    yOffset: 0,
+    xDimension: SLOT_X + DIVIDER + 32,
+    yDimension: SLOT_Y * 2.4,
+    childXOffset: 12,
+    childYOffset: SLOT_Y,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  // TODO(sh, 2022-02-28): This is stubbed out using magdeck dimensions, all of this logic should be deprecated
+  [HEATERSHAKER_MODULE_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.2 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.2 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  // TODO(sh, 2022-02-28): This is stubbed out using magdeck dimensions, all of this logic should be deprecated
+  [MAGNETIC_BLOCK_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.2 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.2 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+}
+export const getModuleVizDims = (
+  orientation: ModuleOrientation,
+  moduleType: ModuleType
+): ModuleVizDims => {
+  const dims = MODULE_VIZ_DIMS[moduleType]
+  if (orientation === 'left') return dims
+  // if orientation is 'right', get origins by rotating 180 about slot center
+  return {
+    ...dims,
+    xOffset: SLOT_X - dims.xOffset - dims.xDimension,
+    yOffset: SLOT_Y - dims.yOffset - dims.yDimension,
+    childXOffset: SLOT_X - dims.childXOffset - dims.childXDimension,
+    childYOffset: SLOT_Y - dims.childYOffset - dims.childYDimension,
+  }
+}
+type DeckSlot = string
+const LEFT_SIDE_SLOTS: DeckSlot[] = ['1', '4', '7', '10', SPAN7_8_10_11_SLOT]
+export const inferModuleOrientationFromSlot = (
+  slot: DeckSlot
+): ModuleOrientation => {
+  // NOTE: defaults to 'left' even for center slots and spanning slots.
+  // That's consistent with non-rotatable modules (thermocycler) being
+  // considered as 'left' all the time, like we do in MODULE_VIZ_DIMS.
+  if (!LEFT_SIDE_SLOTS.includes(slot)) {
+    return 'right'
+  }
+
+  return 'left'
+}
+
+export const inferModuleOrientationFromXCoordinate = (
+  xCoordinate: number
+): ModuleOrientation => {
+  if (xCoordinate === 0) {
+    return 'left'
+  }
+  return 'right'
+}

package/js/helpers/getOccludedSlotCountForModule.ts

@@ -0,0 +1,13 @@
+import { OT2_ROBOT_TYPE, THERMOCYCLER_MODULE_TYPE } from '..'
+import type { ModuleType, RobotType } from '..'
+
+export function getOccludedSlotCountForModule(
+  moduleType: ModuleType,
+  robotType: RobotType
+): number {
+  if (moduleType === THERMOCYCLER_MODULE_TYPE) {
+    return robotType === OT2_ROBOT_TYPE ? 4 : 2
+  } else {
+    return 1
+  }
+}

package/js/helpers/getVectorDifference.ts

@@ -0,0 +1,12 @@
+import type { Coordinates } from '../types'
+
+export function getVectorDifference(
+  pointA: Coordinates,
+  pointB: Coordinates
+): Coordinates {
+  return {
+    x: pointA.x - pointB.x,
+    y: pointA.y - pointB.y,
+    z: pointA.z - pointB.z,
+  }
+}

package/js/helpers/getVectorSum.ts

@@ -0,0 +1,12 @@
+import type { Coordinates } from '../types'
+
+export function getVectorSum(
+  pointA: Coordinates,
+  pointB: Coordinates
+): Coordinates {
+  return {
+    x: pointA.x + pointB.x,
+    y: pointA.y + pointB.y,
+    z: pointA.z + pointB.z,
+  }
+}