@opentrons/shared-data 0.1.2-alpha.2 → 0.1.2

package/js/helpers/index.ts

@@ -1,348 +0,0 @@
-import assert from 'assert'
-import uniq from 'lodash/uniq'
-
-import { OPENTRONS_LABWARE_NAMESPACE } from '../constants'
-import standardOt2DeckDef from '../../deck/definitions/4/ot2_standard.json'
-import standardFlexDeckDef from '../../deck/definitions/4/ot3_standard.json'
-import type {
-  DeckDefinition,
-  LabwareDefinition2,
-  ModuleModel,
-  RobotType,
-  ThermalAdapterName,
-} from '../types'
-
-export { getWellNamePerMultiTip } from './getWellNamePerMultiTip'
-export { getWellTotalVolume } from './getWellTotalVolume'
-export { wellIsRect } from './wellIsRect'
-export { orderWells } from './orderWells'
-export { get96Channel384WellPlateWells } from './get96Channel384WellPlateWells'
-
-export * from './parseProtocolData'
-export * from './volume'
-export * from './wellSets'
-export * from './getModuleVizDims'
-export * from './getVectorDifference'
-export * from './getVectorSum'
-export * from './getLoadedLabwareDefinitionsByUri'
-export * from './getOccludedSlotCountForModule'
-export * from './labwareInference'
-export * from './getAddressableAreasInProtocol'
-export * from './getSimplestFlexDeckConfig'
-
-export const getLabwareDefIsStandard = (def: LabwareDefinition2): boolean =>
-  def?.namespace === OPENTRONS_LABWARE_NAMESPACE
-
-export const getLabwareDefURI = (def: LabwareDefinition2): string =>
-  constructLabwareDefURI(
-    def.namespace,
-    def.parameters.loadName,
-    String(def.version)
-  )
-
-export const constructLabwareDefURI = (
-  namespace: string,
-  loadName: string,
-  version: string
-): string => `${namespace}/${loadName}/${version}`
-
-// Load names of "retired" labware
-// TODO(mc, 2019-12-3): how should this correspond to LABWAREV2_DO_NOT_LIST?
-// see shared-data/js/getLabware.js
-const RETIRED_LABWARE = [
-  'geb_96_tiprack_10ul',
-  'geb_96_tiprack_1000ul',
-  'opentrons_1_trash_850ml_fixed',
-  'opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical_acrylic',
-  'opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap_acrylic',
-  'opentrons_24_tuberack_generic_0.75ml_snapcap_acrylic',
-  'opentrons_40_aluminumblock_eppendorf_24x2ml_safelock_snapcap_generic_16x0.2ml_pcr_strip',
-  'opentrons_96_aluminumblock_biorad_wellplate_200ul',
-  'tipone_96_tiprack_200ul',
-  'eppendorf_96_tiprack_1000ul_eptips',
-  'eppendorf_96_tiprack_10ul_eptips',
-  // Replaced by opentrons_96_wellplate_200ul_pcr_full_skirt
-  // https://opentrons.atlassian.net/browse/RLAB-230
-  'armadillo_96_wellplate_200ul_pcr_full_skirt',
-]
-
-export const getLabwareDisplayName = (
-  labwareDef: LabwareDefinition2
-): string => {
-  const { displayName } = labwareDef.metadata
-
-  if (
-    getLabwareDefIsStandard(labwareDef) &&
-    RETIRED_LABWARE.includes(labwareDef.parameters.loadName)
-  ) {
-    return `(Retired) ${displayName}`
-  }
-
-  return displayName
-}
-
-export const getTiprackVolume = (labwareDef: LabwareDefinition2): number => {
-  assert(
-    labwareDef.parameters.isTiprack,
-    `getTiprackVolume expected a tiprack labware ${getLabwareDefURI(
-      labwareDef
-    )}, but 'isTiprack' isn't true`
-  )
-  // NOTE: Ian 2019-04-16 assuming all tips are the same volume across the rack
-  const volume = labwareDef.wells.A1.totalLiquidVolume
-  assert(
-    volume >= 0,
-    `getTiprackVolume expected tip volume to be at least 0, got ${volume}`
-  )
-  return volume
-}
-
-export function getLabwareHasQuirk(
-  labwareDef: LabwareDefinition2,
-  quirk: string
-): boolean {
-  const quirks = labwareDef.parameters.quirks
-  return quirks ? quirks.includes(quirk) : false
-}
-
-export const intToAlphabetLetter = (
-  i: number,
-  lowerCase: boolean = false
-): string => String.fromCharCode((lowerCase ? 96 : 65) + i)
-// These utils are great candidates for unit tests
-export const toWellName = ({
-  rowNum,
-  colNum,
-}: {
-  rowNum: number
-  colNum: number
-}): string => String.fromCharCode(rowNum + 65) + (colNum + 1)
-
-function _parseWell(well: string): [string, number] {
-  const res = well.match(/([A-Z]+)(\d+)/)
-  const letters = res && res[1]
-  const number = res && parseInt(res[2])
-
-  if (!letters || number == null || Number.isNaN(number)) {
-    console.warn(
-      `Could not parse well ${well}. Got letters: "${
-        letters || 'void'
-      }", number: "${number || 'void'}"`
-    )
-    return ['', NaN]
-  }
-
-  return [letters, number]
-}
-
-/** A compareFunction for sorting an array of well names
- * Goes down the columns (A1 to H1 on 96 plate)
- * Then L to R across rows (1 to 12 on 96 plate)
- */
-export function sortWells(a: string, b: string): number {
-  const [letterA, numberA] = _parseWell(a)
-
-  const [letterB, numberB] = _parseWell(b)
-
-  if (numberA !== numberB) {
-    return numberA > numberB ? 1 : -1
-  }
-
-  if (letterA.length !== letterB.length) {
-    // Eg 'B' vs 'AA'
-    return letterA.length > letterB.length ? 1 : -1
-  }
-
-  return letterA > letterB ? 1 : -1
-}
-
-export function splitWellsOnColumn(sortedArray: string[]): string[][] {
-  return sortedArray.reduce<string[][]>((acc, curr) => {
-    const lastColumn = acc.slice(-1)
-
-    if (lastColumn === undefined || lastColumn.length === 0) {
-      return [[curr]]
-    }
-
-    const lastEle = lastColumn[0].slice(-1)[0].slice(1)
-
-    if (Number(curr.slice(1)) > Number(lastEle)) {
-      return [...acc, [curr]]
-    } else {
-      return [...acc.slice(0, -1), [...lastColumn[0], curr]]
-    }
-  }, [])
-}
-
-export const getWellDepth = (
-  labwareDef: LabwareDefinition2,
-  well: string
-): number => labwareDef.wells[well].depth
-
-// NOTE: this is used in PD for converting "offset from top" to "mm from bottom".
-// Assumes all wells have same offset because multi-offset not yet supported.
-// TODO: Ian 2019-07-13 return {[string: well]: offset} to support multi-offset
-export const getWellsDepth = (
-  labwareDef: LabwareDefinition2,
-  wells: string[]
-): number => {
-  const offsets = wells.map(well => getWellDepth(labwareDef, well))
-
-  if (uniq(offsets).length !== 1) {
-    console.warn(
-      `expected wells ${JSON.stringify(
-        wells
-      )} to all have same offset, but they were different. Labware def is ${getLabwareDefURI(
-        labwareDef
-      )}`
-    )
-  }
-
-  return offsets[0]
-}
-
-export const getSlotHasMatingSurfaceUnitVector = (
-  deckDef: DeckDefinition,
-  addressableAreaName: string
-): boolean => {
-  const matingSurfaceUnitVector = deckDef.locations.addressableAreas.find(
-    aa => aa.id === addressableAreaName
-  )?.matingSurfaceUnitVector
-
-  return Boolean(matingSurfaceUnitVector)
-}
-
-export const getAreSlotsHorizontallyAdjacent = (
-  slotNameA?: string | null,
-  slotNameB?: string | null
-): boolean => {
-  if (slotNameA == null || slotNameB == null) {
-    return false
-  }
-  const slotANumber = parseInt(slotNameA)
-  const slotBNumber = parseInt(slotNameB)
-  if (isNaN(slotBNumber) || isNaN(slotANumber)) {
-    return false
-  }
-  const orderedSlots = standardOt2DeckDef.locations.cutouts
-  // intentionally not substracting by 1 because trash (slot 12) should not count
-  const numSlots = orderedSlots.length
-  if (slotBNumber > numSlots || slotANumber > numSlots) {
-    return false
-  }
-  const slotWidth = orderedSlots[1].position[0] - orderedSlots[0].position[0]
-  const slotAPosition = orderedSlots[slotANumber - 1].position
-  const slotBPosition = orderedSlots[slotBNumber - 1].position
-
-  const yPositionSlotA = slotAPosition[1]
-  const yPositionSlotB = slotBPosition[1]
-
-  const xPositionSlotA = slotAPosition[0]
-  const xPositionSlotB = slotBPosition[0]
-
-  const areSlotsHorizontallyAdjacent =
-    yPositionSlotA === yPositionSlotB &&
-    Math.abs(xPositionSlotA - xPositionSlotB) === slotWidth
-
-  return areSlotsHorizontallyAdjacent
-}
-export const getAreSlotsVerticallyAdjacent = (
-  slotNameA?: string | null,
-  slotNameB?: string | null
-): boolean => {
-  if (slotNameA == null || slotNameB == null) {
-    return false
-  }
-  const slotANumber = parseInt(slotNameA)
-  const slotBNumber = parseInt(slotNameB)
-
-  if (isNaN(slotBNumber) || isNaN(slotANumber)) {
-    return false
-  }
-  const orderedSlots = standardOt2DeckDef.locations.cutouts
-  // intentionally not substracting by 1 because trash (slot 12) should not count
-  const numSlots = orderedSlots.length
-
-  if (slotBNumber > numSlots || slotANumber > numSlots) {
-    return false
-  }
-  // take the y coord of slot 4, and subtact from y coord of slot 1
-  const slotHeight = orderedSlots[3].position[1] - orderedSlots[0].position[1]
-  const slotAPosition = orderedSlots[slotANumber - 1].position
-  const slotBPosition = orderedSlots[slotBNumber - 1].position
-
-  const yPositionSlotA = slotAPosition[1]
-  const yPositionSlotB = slotBPosition[1]
-
-  const xPositionSlotA = slotAPosition[0]
-  const xPositionSlotB = slotBPosition[0]
-
-  const areSlotsVerticallyAdjacent =
-    xPositionSlotA === xPositionSlotB &&
-    Math.abs(yPositionSlotA - yPositionSlotB) === slotHeight
-
-  return areSlotsVerticallyAdjacent
-}
-//  TODO(jr, 11/12/23): rename this utility to mention that it
-//  is only used in the OT-2, same with getAreSlotsHorizontallyAdjacent
-//  and getAreSlotsVerticallyAdjacent
-export const getAreSlotsAdjacent = (
-  slotNameA?: string | null,
-  slotNameB?: string | null
-): boolean =>
-  getAreSlotsHorizontallyAdjacent(slotNameA, slotNameB) ||
-  getAreSlotsVerticallyAdjacent(slotNameA, slotNameB)
-
-export const getIsLabwareAboveHeight = (
-  labwareDef: LabwareDefinition2,
-  height: number
-): boolean => labwareDef.dimensions.zDimension > height
-
-export const getAdapterName = (labwareLoadname: string): ThermalAdapterName => {
-  let adapterName: ThermalAdapterName = 'Universal Flat Adapter'
-
-  if (
-    labwareLoadname ===
-    'opentrons_96_pcr_adapter_nest_wellplate_100ul_pcr_full_skirt'
-  ) {
-    adapterName = 'PCR Adapter'
-  } else if (
-    labwareLoadname === 'opentrons_96_deep_well_adapter_nest_wellplate_2ml_deep'
-  ) {
-    adapterName = 'Deep Well Adapter'
-  } else if (
-    labwareLoadname ===
-    'opentrons_96_flat_bottom_adapter_nest_wellplate_200ul_flat'
-  ) {
-    adapterName = '96 Flat Bottom Adapter'
-  }
-
-  return adapterName
-}
-
-export const getCalibrationAdapterLoadName = (
-  moduleModel: ModuleModel
-): string | null => {
-  switch (moduleModel) {
-    case 'heaterShakerModuleV1':
-      return 'opentrons_calibration_adapter_heatershaker_module'
-    case 'temperatureModuleV2':
-      return 'opentrons_calibration_adapter_temperature_module'
-    case 'thermocyclerModuleV2':
-      return 'opentrons_calibration_adapter_thermocycler_module'
-    default:
-      console.error(
-        `${moduleModel} does not have an associated calibration adapter`
-      )
-      return null
-  }
-}
-
-export const getDeckDefFromRobotType = (
-  robotType: RobotType
-): DeckDefinition => {
-  // @ts-expect-error imported JSON not playing nice with TS. see https://github.com/microsoft/TypeScript/issues/32063
-  return robotType === 'OT-3 Standard'
-    ? standardFlexDeckDef
-    : standardOt2DeckDef
-}

package/js/helpers/labwareInference.ts

@@ -1,92 +0,0 @@
-import isEqual from 'lodash/isEqual'
-import uniqWith from 'lodash/uniqWith'
-import round from 'lodash/round'
-import sortedUniq from 'lodash/sortedUniq'
-import uniq from 'lodash/uniq'
-import type {
-  LabwareWell,
-  LabwareWellShapeProperties,
-  LabwareDefinition2,
-  LabwareWellGroupMetadata,
-  LabwareBrand,
-} from '../types'
-
-export interface LabwareWellGroupProperties {
-  xOffsetFromLeft: number
-  yOffsetFromTop: number
-  xSpacing: number | null
-  ySpacing: number | null
-  wellCount: number
-  shape: LabwareWellShapeProperties | null
-  depth: number | null
-  totalLiquidVolume: number | null
-  metadata: LabwareWellGroupMetadata
-  brand: LabwareBrand | null
-}
-const ROUNDING_PRECISION = 2
-
-export function getUniqueWellProperties(
-  definition: LabwareDefinition2
-): LabwareWellGroupProperties[] {
-  const { groups, wells, dimensions } = definition
-
-  return groups.map(group => {
-    const wellProps = group.wells.map(n => wells[n])
-
-    const wellDepths = wellProps.map<number>(w => w.depth)
-    const wellVolumes = wellProps.map<number>(w => w.totalLiquidVolume)
-    const wellShapes = wellProps.map<LabwareWellShapeProperties>(
-      (well: LabwareWell) =>
-        well.shape === 'circular'
-          ? { shape: well.shape, diameter: well.diameter }
-          : {
-              shape: well.shape,
-              xDimension: well.xDimension,
-              yDimension: well.yDimension,
-            }
-    )
-
-    const xStart = wellProps[0]?.x ?? 0
-    const yStart = wellProps[0]?.y ?? 0
-
-    return {
-      metadata: group.metadata,
-      brand: group.brand || null,
-      xSpacing: getSpacingIfUniform(wellProps, 'x'),
-      ySpacing: getSpacingIfUniform(wellProps, 'y'),
-      xOffsetFromLeft: xStart,
-      yOffsetFromTop: round(dimensions.yDimension - yStart, ROUNDING_PRECISION),
-      wellCount: wellProps.length,
-      depth: getIfConsistent(wellDepths),
-      totalLiquidVolume: getIfConsistent(wellVolumes),
-      shape: getIfConsistent(wellShapes),
-    }
-  })
-}
-
-export function getIfConsistent<T>(items: T[]): T | null {
-  return uniqWith(items, isEqual).length === 1 ? items[0] : null
-}
-
-// returning null means "spacing is irregular"; returning 0 means "there is only 1 well along the given axis"
-export function getSpacingIfUniform(
-  wells: LabwareWell[],
-  axis: 'x' | 'y'
-): number | null {
-  const wellPositions = sortedUniq(uniq(wells.map(well => well[axis])))
-  if (wellPositions.length < 2) return 0
-
-  const initialSpacing = round(
-    wellPositions[1] - wellPositions[0],
-    ROUNDING_PRECISION
-  )
-
-  for (let i = 2; i < wellPositions.length; i++) {
-    const pos = wellPositions[i]
-    const prevWellPos = wellPositions[i - 1]
-    const spacing = round(pos - prevWellPos, ROUNDING_PRECISION)
-    if (spacing !== initialSpacing) return null
-  }
-
-  return Math.abs(initialSpacing)
-}

package/js/helpers/orderWells.ts

@@ -1,69 +0,0 @@
-import zipWith from 'lodash/zipWith'
-import uniq from 'lodash/uniq'
-import compact from 'lodash/compact'
-import flatten from 'lodash/flatten'
-
-export type WellOrderOption = 'l2r' | 'r2l' | 't2b' | 'b2t'
-
-// labware definitions in shared-data have an ordering
-// attribute which is an Array of Arrays of wells. Each inner
-// Array represents a physical column of wells on the labware
-// this function takes that 2d Array of columns and returns
-// the same wells in a 2d Array where each inner Array represents
-// a physical row of wells on the labware.
-// e.g.
-// [                      \       [
-//   ['A1', 'B1'],     === \        ['A1', 'A2']
-//   ['A2', 'B2']      === /        ['B1', 'B2']
-// ]                      /       ]
-//
-const _orderingColsToRows = (ordering: string[][]): string[][] =>
-  zipWith(...ordering, (...col) => compact(uniq(col)))
-
-// given a default "ordering" 2d array from labware definitions
-// where each inner array represents a physical column of wells
-// and well order option selections (e.g. 'l2r', 'r2l', 't2b', 'b2t')
-// this function returns a 1d array of wells from the labware
-// ordered by the given traversal technique
-export const orderWells = (
-  defaultOrdering: string[][],
-  first: WellOrderOption,
-  second: WellOrderOption
-): string[] => {
-  let orderedWells: string[][] = []
-
-  if (first === 't2b') {
-    if (second === 'l2r') {
-      orderedWells = defaultOrdering
-    } else if (second === 'r2l') {
-      orderedWells = defaultOrdering.slice().reverse()
-    }
-  } else if (first === 'b2t') {
-    if (second === 'l2r') {
-      orderedWells = defaultOrdering.map(col => col.slice().reverse())
-    } else if (second === 'r2l') {
-      orderedWells = defaultOrdering
-        .slice()
-        .reverse()
-        .map(col => col.slice().reverse())
-    }
-  } else if (first === 'l2r') {
-    if (second === 't2b') {
-      orderedWells = _orderingColsToRows(defaultOrdering)
-    } else if (second === 'b2t') {
-      orderedWells = _orderingColsToRows(defaultOrdering).slice().reverse()
-    }
-  } else if (first === 'r2l') {
-    if (second === 't2b') {
-      orderedWells = _orderingColsToRows(defaultOrdering).map(col =>
-        col.slice().reverse()
-      )
-    } else if (second === 'b2t') {
-      orderedWells = _orderingColsToRows(defaultOrdering)
-        .slice()
-        .reverse()
-        .map(col => col.slice().reverse())
-    }
-  }
-  return flatten(orderedWells)
-}

package/js/helpers/parseProtocolData.ts

@@ -1,141 +0,0 @@
-import Ajv from 'ajv'
-import labwareV2Schema from '../../labware/schemas/2.json'
-import protocolSchemaV1 from '../../protocol/schemas/1.json'
-import protocolSchemaV2 from '../../protocol/schemas/2.json'
-import protocolSchemaV3 from '../../protocol/schemas/3.json'
-import protocolSchemaV4 from '../../protocol/schemas/4.json'
-import protocolSchemaV5 from '../../protocol/schemas/5.json'
-
-import type { ErrorObject } from 'ajv'
-import type { JsonProtocolFile } from '../../protocol'
-
-export type ProtocolParseErrorKey = 'INVALID_FILE_TYPE' | 'INVALID_JSON_FILE'
-
-interface ProtocolParseErrorDetails {
-  rawError?: string
-  schemaErrors?: ErrorObject[] | null
-}
-
-export type ProtocolParseErrorHandler = (
-  errorKey: ProtocolParseErrorKey,
-  errorDetails?: ProtocolParseErrorDetails
-) => unknown
-
-type ProtocolSchema =
-  | typeof protocolSchemaV1
-  | typeof protocolSchemaV2
-  | typeof protocolSchemaV3
-  | typeof protocolSchemaV4
-  | typeof protocolSchemaV5
-
-const SCHEMA_BY_VERSION: { [version: string]: ProtocolSchema } = {
-  '1': protocolSchemaV1,
-  '2': protocolSchemaV2,
-  '3': protocolSchemaV3,
-  '4': protocolSchemaV4,
-  '5': protocolSchemaV5,
-}
-
-export interface PythonProtocolMetadata {
-  source?: string
-  [key: string]: unknown
-}
-
-// data may be a full JSON protocol or just a metadata dict from Python
-export type ProtocolData =
-  | JsonProtocolFile
-  | { metadata: PythonProtocolMetadata }
-
-export function parseProtocolData(
-  file: File,
-  contents: string,
-  handleError?: ProtocolParseErrorHandler,
-  metadata?: PythonProtocolMetadata | null // optional Python protocol metadata
-): ProtocolData | null {
-  if (fileExtensionIsJson(file.name)) {
-    return validateJsonProtocolFileContents(contents, handleError)
-  } else if (fileExtensionIsPython(file.name)) {
-    // grab Python protocol metadata, if any
-    return metadata != null ? { metadata } : null
-  } else if (fileExtensionIsZip(file.name)) {
-    return null
-  }
-
-  handleError && handleError('INVALID_FILE_TYPE')
-  return null
-}
-
-export function fileExtensionIsPython(filename: string): boolean {
-  return Boolean(/\.py$/i.test(filename))
-}
-export function fileExtensionIsJson(filename: string): boolean {
-  return Boolean(/\.json$/i.test(filename))
-}
-export function fileExtensionIsZip(filename: string): boolean {
-  return Boolean(/\.zip$/i.test(filename))
-}
-export function fileIsBinary(file: File): boolean {
-  // bundles are always binary files, and currently nothing else is binary
-  return fileExtensionIsZip(file.name)
-}
-
-export function validateJsonProtocolFileContents(
-  fileContents: string,
-  handleError?: ProtocolParseErrorHandler
-): JsonProtocolFile | null {
-  try {
-    if (typeof fileContents !== 'string') {
-      handleError && handleError('INVALID_FILE_TYPE')
-      return null
-    } else {
-      const ajv = new Ajv({ allErrors: true, jsonPointers: true })
-      // protocol schema contains reference to v2 labware schema, so give AJV access to it
-      ajv.addSchema(labwareV2Schema)
-
-      const parsedProtocol = JSON.parse(fileContents) as any
-      let validateAgainstSchema
-      if ('protocol-schema' in parsedProtocol) {
-        // 'protocol-schema' key only present in V1
-        validateAgainstSchema = ajv.compile(protocolSchemaV1)
-      } else {
-        const { schemaVersion } = parsedProtocol
-        validateAgainstSchema = ajv.compile(
-          SCHEMA_BY_VERSION[String(schemaVersion)]
-        )
-      }
-
-      if (!validateAgainstSchema(parsedProtocol)) {
-        handleError &&
-          handleError('INVALID_JSON_FILE', {
-            schemaErrors: validateAgainstSchema.errors,
-          })
-        return null
-      }
-
-      return parsedProtocol
-    }
-  } catch (error) {
-    handleError && handleError('INVALID_JSON_FILE', { rawError: error })
-    return null
-  }
-}
-
-export function getProtocolDesignerApplicationName(
-  protocol: JsonProtocolFile
-): string | null {
-  if (
-    'designerApplication' in protocol &&
-    protocol.designerApplication != null
-  ) {
-    return 'name' in protocol.designerApplication &&
-      protocol.designerApplication.name != null
-      ? protocol.designerApplication.name
-      : null
-  } else if (
-    'designer-application' in protocol &&
-    protocol['designer-application']['application-name'] != null
-  ) {
-    return protocol['designer-application']['application-name']
-  }
-  return null
-}

package/js/helpers/volume.ts

@@ -1,35 +0,0 @@
-// utilities for working with volumes in µL
-import round from 'lodash/round'
-
-import type { LabwareVolumeUnits } from '../types'
-
-const SCALE_BY_UNITS = {
-  µL: 1,
-  mL: 1000,
-  L: 1000000,
-}
-
-export function getDisplayVolume(
-  volumeInMicroliters: number,
-  displayUnits: LabwareVolumeUnits = 'µL',
-  digits?: number
-): string {
-  const volume = volumeInMicroliters / SCALE_BY_UNITS[displayUnits]
-
-  return `${typeof digits === 'number' ? round(volume, digits) : volume}`
-}
-
-export function getAsciiVolumeUnits(displayUnits: LabwareVolumeUnits): string {
-  if (displayUnits === 'µL') return 'uL'
-
-  return displayUnits
-}
-
-export function ensureVolumeUnits(
-  maybeUnits: string | null | undefined
-): LabwareVolumeUnits {
-  if (maybeUnits === 'mL' || maybeUnits === 'ml') return 'mL'
-  if (maybeUnits === 'L' || maybeUnits === 'l') return 'L'
-
-  return 'µL'
-}

package/js/helpers/wellIsRect.ts

@@ -1,6 +0,0 @@
-import type { WellDefinition } from '../types'
-
-/** Well is either rect or circle. Depends on whether `diameter` exists */
-export function wellIsRect(wellDef: WellDefinition): boolean {
-  return !(typeof wellDef.diameter === 'number')
-}