@opentrons/shared-data 0.0.1-alpha.20 → 0.1.0-alpha.0

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

@@ -1,108 +0,0 @@
-// 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

@@ -1,352 +0,0 @@
-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

@@ -1,44 +0,0 @@
-//  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/getAddressableAreasInProtocol.ts

@@ -1,59 +0,0 @@
-import type { AddressableAreaName } from '../../deck'
-import type { RunTimeCommand } from '../../protocol'
-
-export function getAddressableAreasInProtocol(
-  commands: RunTimeCommand[]
-): AddressableAreaName[] {
-  return commands.reduce<AddressableAreaName[]>((acc, command) => {
-    if (
-      command.commandType === 'moveLabware' &&
-      command.params.newLocation !== 'offDeck' &&
-      'slotName' in command.params.newLocation &&
-      !acc.includes(command.params.newLocation.slotName as AddressableAreaName)
-    ) {
-      return [
-        ...acc,
-        command.params.newLocation.slotName as AddressableAreaName,
-      ]
-    } else if (
-      command.commandType === 'moveLabware' &&
-      command.params.newLocation !== 'offDeck' &&
-      'addressableAreaName' in command.params.newLocation &&
-      !acc.includes(
-        command.params.newLocation.addressableAreaName as AddressableAreaName
-      )
-    ) {
-      return [
-        ...acc,
-        command.params.newLocation.addressableAreaName as AddressableAreaName,
-      ]
-    } else if (
-      (command.commandType === 'loadLabware' ||
-        command.commandType === 'loadModule') &&
-      command.params.location !== 'offDeck' &&
-      'slotName' in command.params.location &&
-      !acc.includes(command.params.location.slotName as AddressableAreaName)
-    ) {
-      return [...acc, command.params.location.slotName as AddressableAreaName]
-    } else if (
-      command.commandType === 'loadLabware' &&
-      command.params.location !== 'offDeck' &&
-      'addressableAreaName' in command.params.location &&
-      !acc.includes(
-        command.params.location.addressableAreaName as AddressableAreaName
-      )
-    ) {
-      return [
-        ...acc,
-        command.params.location.addressableAreaName as AddressableAreaName,
-      ]
-    } else if (
-      command.commandType === 'moveToAddressableArea' &&
-      !acc.includes(command.params.addressableAreaName as AddressableAreaName)
-    ) {
-      return [...acc, command.params.addressableAreaName as AddressableAreaName]
-    } else {
-      return acc
-    }
-  }, [])
-}

package/js/helpers/getLoadedLabwareDefinitionsByUri.ts

@@ -1,30 +0,0 @@
-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

@@ -1,118 +0,0 @@
-// 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'
-}