@opentrons/shared-data 0.0.0-alpha.14

package/js/pipettes.ts

@@ -0,0 +1,89 @@
+import pipetteNameSpecs from '../pipette/definitions/1/pipetteNameSpecs.json'
+import pipetteModelSpecs from '../pipette/definitions/1/pipetteModelSpecs.json'
+import { OT3_PIPETTES } from './constants'
+
+import type { PipetteNameSpecs, PipetteModelSpecs } from './types'
+
+type SortableProps = 'maxVolume' | 'channels'
+
+// TODO(mc, 2021-04-30): use these types, pulled directly from the JSON,
+// to simplify return types in this module and possibly remove some `null`s
+export type PipetteName = keyof typeof pipetteNameSpecs
+export type PipetteModel = keyof typeof pipetteModelSpecs.config
+
+// models sorted by channels and then volume by default
+const ALL_PIPETTE_NAMES: PipetteName[] = (Object.keys(
+  pipetteNameSpecs
+) as PipetteName[]).sort(comparePipettes(['channels', 'maxVolume']))
+
+// use a name like 'p10_single' to get specs true for all models under that name
+export function getPipetteNameSpecs(
+  name: PipetteName
+): PipetteNameSpecs | null {
+  const config = pipetteNameSpecs[name] as
+    | Omit<PipetteNameSpecs, 'name'>
+    | undefined
+  return config != null ? { ...config, name } : null
+}
+
+// specify a model, eg 'p10_single_v1.3' to get
+// both the name specs + model-specific specs
+// NOTE: this should NEVER be used in PD, which is model-agnostic
+export function getPipetteModelSpecs(
+  model: PipetteModel
+): PipetteModelSpecs | null | undefined {
+  const modelSpecificFields = pipetteModelSpecs.config[model]
+  const modelFields =
+    modelSpecificFields &&
+    getPipetteNameSpecs(modelSpecificFields.name as PipetteName)
+  return modelFields && { ...modelFields, ...modelSpecificFields, model }
+}
+
+export function getAllPipetteNames(...sortBy: SortableProps[]): PipetteName[] {
+  const models = [...ALL_PIPETTE_NAMES]
+  if (sortBy.length) models.sort(comparePipettes(sortBy))
+  return models
+}
+
+function comparePipettes(sortBy: SortableProps[]) {
+  return (modelA: PipetteName, modelB: PipetteName) => {
+    // any cast is because we know these pipettes exist
+    const a = getPipetteNameSpecs(modelA) as PipetteNameSpecs
+    const b = getPipetteNameSpecs(modelB) as PipetteNameSpecs
+    let i
+
+    for (i = 0; i < sortBy.length; i++) {
+      const sortKey = sortBy[i]
+      if (a[sortKey] < b[sortKey]) return -1
+      if (a[sortKey] > b[sortKey]) return 1
+    }
+
+    return 0
+  }
+}
+
+export function shouldLevel(specs: PipetteNameSpecs): boolean {
+  return specs.displayCategory === 'GEN2' && specs.channels === 8
+}
+
+export function isFlexPipette(pipetteName: PipetteName): boolean {
+  return (
+    OT3_PIPETTES.includes(pipetteName) ||
+    getPipetteNameSpecs(pipetteName)?.displayCategory === 'FLEX'
+  )
+}
+
+export const getIncompatiblePipetteNames = (
+  currentPipette: PipetteName
+): string[] => {
+  if (isFlexPipette(currentPipette)) {
+    return getAllPipetteNames().filter(pipette => !isFlexPipette(pipette))
+  } else if (
+    getPipetteNameSpecs(currentPipette)?.displayCategory === 'GEN1' ||
+    getPipetteNameSpecs(currentPipette)?.displayCategory === 'GEN2'
+  ) {
+    return getAllPipetteNames().filter(pipette => isFlexPipette(pipette))
+  } else {
+    return []
+  }
+}

package/js/protocols.ts

@@ -0,0 +1,290 @@
+// Helper functions for validating protocols. Used only in tests right now but
+// intended for use as the thing that turns something from a json document into
+// a protocol inside the js ecosystem.
+
+import Ajv from 'ajv'
+
+import commandSchema8 from '../command/schemas/8.json'
+import commandSchema7 from '../command/schemas/7.json'
+import commandAnnotationSchema1 from '../commandAnnotation/schemas/1.json'
+import liquidSchema1 from '../liquid/schemas/1.json'
+import labwareSchema2 from '../labware/schemas/2.json'
+
+import protocolSchema8 from '../protocol/schemas/8.json'
+import protocolSchema7 from '../protocol/schemas/7.json'
+import protocolSchema6 from '../protocol/schemas/6.json'
+import protocolSchema5 from '../protocol/schemas/5.json'
+import protocolSchema4 from '../protocol/schemas/4.json'
+import protocolSchema3 from '../protocol/schemas/3.json'
+import protocolSchema1 from '../protocol/schemas/1.json'
+
+import type * as ProtocolSchemas from '../protocol'
+import type { CreateCommand } from '../command/types'
+import type { CommandAnnotation } from '../commandAnnotation/types'
+
+export type { ProtocolSchemas }
+
+const validateCommands8 = (
+  toValidate: ProtocolSchemas.ProtocolStructureV8
+): Promise<CreateCommand[]> =>
+  new Promise((resolve, reject) => {
+    const requestedSchema = toValidate.commandSchemaId
+    switch (requestedSchema) {
+      case 'opentronsCommandSchemaV8':
+        resolve(commandSchema8)
+        break
+      default:
+        // eslint-disable-next-line prefer-promise-reject-errors
+        reject([
+          {
+            keyword: 'Invalid command schema requested',
+            dataPath: requestedSchema,
+            schemaPath: '#/properties/commandSchemaId',
+            params: { allowedValues: ['opentronsCommandSchemaV8'] },
+          },
+        ])
+        break
+    }
+  }).then(
+    schema =>
+      new Promise((resolve, reject) => {
+        const generatedSchema = { type: 'array', items: schema }
+        const commandAjv = new Ajv({ allErrors: true, jsonPointers: true })
+        const validateCommands = commandAjv.compile(generatedSchema)
+        const ok = validateCommands(toValidate.commands)
+        if (!ok) {
+          // eslint-disable-next-line prefer-promise-reject-errors
+          reject(validateCommands.errors)
+        }
+        resolve(toValidate.commands)
+      })
+  )
+
+const validateCommandAnnotations8 = (
+  toValidate: ProtocolSchemas.ProtocolStructureV8
+): Promise<CommandAnnotation[]> =>
+  new Promise((resolve, reject) => {
+    const requestedSchema = toValidate.commandAnnotationSchemaId
+    switch (requestedSchema) {
+      case 'opentronsCommandAnnotationSchemaV1':
+        resolve(commandAnnotationSchema1)
+        break
+      default:
+        // eslint-disable-next-line prefer-promise-reject-errors
+        reject([
+          {
+            keyword: 'Invalid command annotation schema requested',
+            dataPath: requestedSchema,
+            schemaPath: '#/properties/commandAnnotationSchemaId',
+            params: { allowedValues: ['opentronsCommandAnnotationSchemaV1'] },
+          },
+        ])
+    }
+  }).then(
+    (schema: any) =>
+      new Promise((resolve, reject) => {
+        const generatedSchema = {
+          type: 'array',
+          items: { $ref: 'opentronsCommandAnnotationSchemaV1' },
+        }
+        const annotationAjv = new Ajv({ allErrors: true, jsonPointers: true })
+        annotationAjv.addSchema(schema)
+        const validateAnnotations = annotationAjv.compile(generatedSchema)
+        const ok = validateAnnotations(toValidate.commandAnnotations)
+        if (!ok) {
+          // eslint-disable-next-line prefer-promise-reject-errors
+          reject(validateAnnotations.errors)
+        }
+        resolve(toValidate.commandAnnotations)
+      })
+  )
+
+const validateLiquids8 = (
+  toValidate: ProtocolSchemas.ProtocolStructureV8
+): Promise<ProtocolSchemas.ProtocolFileV8['liquids']> =>
+  new Promise((resolve, reject) => {
+    const requestedSchema = toValidate.liquidSchemaId
+    switch (requestedSchema) {
+      case 'opentronsLiquidSchemaV1':
+        resolve(liquidSchema1)
+        break
+      default:
+        // eslint-disable-next-line prefer-promise-reject-errors
+        reject([
+          {
+            keyword: 'Invalid liquid schema requested',
+            dataPath: requestedSchema,
+            schemaPath: '#/properties/liquidSchemaId',
+            params: { allowedValues: ['opentronsLiquidSchemaV1'] },
+          },
+        ])
+    }
+  }).then(
+    schema =>
+      new Promise((resolve, reject) => {
+        const generatedSchema = {
+          type: 'object',
+          patternProperties: { '.+': schema },
+        }
+        const liquidAjv = new Ajv({ allErrors: true, jsonPointers: true })
+        const validateLiquids = liquidAjv.compile(generatedSchema)
+        const ok = validateLiquids(toValidate.liquids)
+        if (!ok) {
+          // eslint-disable-next-line prefer-promise-reject-errors
+          reject(validateLiquids.errors)
+        }
+        resolve(toValidate.liquids)
+      })
+  )
+
+const validateLabware8 = (
+  toValidate: ProtocolSchemas.ProtocolStructureV8
+): Promise<ProtocolSchemas.ProtocolFileV8['labwareDefinitions']> =>
+  new Promise((resolve, reject) => {
+    const requestedSchema = toValidate.labwareDefinitionSchemaId
+    switch (requestedSchema) {
+      case 'opentronsLabwareSchemaV2':
+        resolve(labwareSchema2)
+        break
+      default:
+        // eslint-disable-next-line prefer-promise-reject-errors
+        reject([
+          {
+            keyword: 'Invalid labware schema requested',
+            dataPath: requestedSchema,
+            schemaPath: '#/properties/labwareSchemaId',
+            params: { allowedValues: ['opentronsLabwareSchemaV2'] },
+          },
+        ])
+    }
+  }).then(
+    schema =>
+      new Promise((resolve, reject) => {
+        const generatedSchema = {
+          type: 'object',
+          patternProperties: { '.+': schema },
+        }
+        const labwareAjv = new Ajv({ allErrors: true, jsonPointers: true })
+        const validateLabware = labwareAjv.compile(generatedSchema)
+        const ok = validateLabware(toValidate.labwareDefinitions)
+        if (!ok) {
+          // eslint-disable-next-line prefer-promise-reject-errors
+          reject(validateLabware.errors)
+        }
+        resolve(toValidate.labwareDefinitions)
+      })
+  )
+
+const validate8 = (toValidate: any): Promise<ProtocolSchemas.ProtocolFileV8> =>
+  new Promise<ProtocolSchemas.ProtocolStructureV8>((resolve, reject) => {
+    const protoAjv = new Ajv({ allErrors: true, jsonPointers: true })
+    const validateProtocol = protoAjv.compile(protocolSchema8)
+    const valid = validateProtocol(toValidate)
+    if (!valid) {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      reject(validateProtocol.errors)
+    }
+    const validatedProtocol = toValidate as ProtocolSchemas.ProtocolStructureV8
+    resolve(validatedProtocol)
+  })
+    .then(protocol =>
+      Promise.all([
+        validateCommands8(protocol),
+        validateCommandAnnotations8(protocol),
+        validateLiquids8(protocol),
+        validateLabware8(protocol),
+      ])
+    )
+    .then(() => Promise.resolve(toValidate as ProtocolSchemas.ProtocolFileV8))
+
+const fakeAjvErrorForBadOTSharedSchema = (
+  requestedValue: any
+): Ajv.ErrorObject => ({
+  keyword: 'Invalid protocol schema requested',
+  dataPath: requestedValue,
+  schemaPath: '#/properties/$otSharedSchema',
+  params: {
+    allowedValues: [
+      '#/protocol/schemas/8',
+      '#/protocol/schemas/7',
+      '#/protocol/schemas/6',
+      '#/protocol/schemas/5',
+      '#/protocol/schemas/4',
+      '#/protocol/schemas/3',
+      '#/protocol/schemas/2',
+      '#/protocol/schemas/1',
+    ],
+  },
+})
+
+type ProtocolFileSub7 =
+  | ProtocolSchemas.ProtocolFileV6
+  | ProtocolSchemas.ProtocolFileV5<{}>
+  | ProtocolSchemas.ProtocolFileV4<{}>
+  | ProtocolSchemas.ProtocolFileV3<{}>
+  | ProtocolSchemas.ProtocolFileV1<{}>
+
+const validateSub7 = (
+  toValidate: any,
+  schemaObj: any
+): Promise<ProtocolFileSub7> =>
+  new Promise((resolve, reject) => {
+    const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+    ajv.addSchema(labwareSchema2)
+    const validateProtocol = ajv.compile(schemaObj)
+    const ok = validateProtocol(toValidate)
+    if (!ok) {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      reject(validateProtocol.errors)
+    }
+    resolve(toValidate as ProtocolFileSub7)
+  })
+
+const validate7 = (toValidate: any): Promise<ProtocolSchemas.ProtocolFileV7> =>
+  new Promise((resolve, reject) => {
+    const ajv = new Ajv({ allErrors: true, jsonPointers: true })
+    ajv.addSchema([commandSchema7, labwareSchema2])
+    const validateProtocol = ajv.compile(protocolSchema7)
+    const ok = validateProtocol(toValidate)
+    if (!ok) {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      reject(validateProtocol.errors)
+    }
+    resolve(toValidate as ProtocolSchemas.ProtocolFileV7)
+  })
+
+// note: rejects with an array of ajv errors
+export function validate(
+  toValidate: any
+): Promise<ProtocolSchemas.JsonProtocolFile> {
+  // eslint-disable-next-line @typescript-eslint/dot-notation
+  const requestedProtocolSchema = toValidate['$otSharedSchema']
+  switch (requestedProtocolSchema) {
+    case '#/protocol/schemas/8':
+      return validate8(toValidate)
+    case '#/protocol/schemas/7':
+      return validate7(toValidate)
+    case '#/protocol/schemas/6':
+      return validateSub7(toValidate, protocolSchema6)
+    case '#/protocol/schemas/5':
+      return validateSub7(toValidate, protocolSchema5)
+    case '#/protocol/schemas/4':
+      return validateSub7(toValidate, protocolSchema4)
+    default:
+      if (!Object.keys(toValidate).includes('$otSharedSchema')) {
+        const v3SchemaVersion = toValidate.schemaVersion
+        if (v3SchemaVersion === '3.0.0') {
+          return validateSub7(toValidate, protocolSchema3)
+        }
+        const v1SchemaVersion = toValidate['protocol-schema']
+        if (v1SchemaVersion === '1.0.0') {
+          return validateSub7(toValidate, protocolSchema1)
+        }
+      }
+
+      return new Promise((resolve, reject) => {
+        // eslint-disable-next-line prefer-promise-reject-errors
+        reject([fakeAjvErrorForBadOTSharedSchema(requestedProtocolSchema)])
+      })
+  }
+}

package/js/schema.ts

@@ -0,0 +1,80 @@
+const NumberType = {
+  type: 'number',
+}
+const PositiveNumber = {
+  type: 'number',
+  minimum: 0,
+}
+const LabwareFormats = ['96-standard', '384-standard', 'trough', 'irregular']
+// TODO IMMEDIATELY move to labware/flowTypes/
+// TODO(mc, 2020-02-21) move to labware/schemas/1.json? delete?
+// this only appears to be used in a single test file
+// shared-data/js/__tests__/labwareDefSchemaV1.test.js
+export const labwareSchemaV1 = {
+  type: 'object',
+  required: ['metadata', 'ordering', 'wells'],
+  additionalProperties: false,
+  properties: {
+    metadata: {
+      type: 'object',
+      required: ['name', 'format'],
+      properties: {
+        name: {
+          type: 'string',
+        },
+        format: {
+          enum: LabwareFormats,
+        },
+        deprecated: {
+          enum: [true],
+        },
+        displayName: {
+          type: 'string',
+        },
+        displayCategory: {
+          type: 'string',
+        },
+        isValidSource: {
+          enum: [false],
+        },
+        isTiprack: {
+          enum: [true],
+        },
+        tipVolume: PositiveNumber,
+      },
+    },
+    ordering: {
+      type: 'array',
+      items: {
+        type: 'array',
+        items: {
+          type: 'string',
+        },
+      },
+    },
+    wells: {
+      type: 'object',
+      patternProperties: {
+        '.*': {
+          // TODO: use ^[A-Z]+[1-9]+[0-9]*$ (eg A1, AB16, not A03) -- but make sure invalid well keys fail instead of slip past
+          type: 'object',
+          required: ['height', 'length', 'width', 'x', 'y', 'z'],
+          properties: {
+            height: NumberType,
+            length: PositiveNumber,
+            width: PositiveNumber,
+            x: NumberType,
+            y: NumberType,
+            z: NumberType,
+            // Optional
+            diameter: PositiveNumber,
+            // NOTE: presence of diameter indicates a circular well
+            depth: PositiveNumber,
+            // TODO Ian 2018-03-12: depth should be required, but is missing in MALDI-plate
+            'total-liquid-volume': PositiveNumber,
+          },
+        },
+      },
+    },
+  },
+}

package/js/scripts/build.js

@@ -0,0 +1,32 @@
+// This build script is run by `make setup`
+
+// Merge all v1 labware files into a single JSON file, build/labware.json,
+// with each filename as a key in the final JSON file.
+const fs = require('fs')
+const path = require('path')
+const glob = require('glob')
+
+const buildDir = process.argv[2]
+
+if (!buildDir) {
+  throw new Error(
+    'build.js requires a build directory given as an argument. eg `node js/scripts/build.js path/to/build/`'
+  )
+}
+
+const output = {}
+
+const files = glob.sync(
+  path.join(__dirname, '../../labware/definitions/1/*.json')
+)
+
+files.forEach(filename => {
+  const contents = require(filename)
+  const labwareName = path.parse(filename).name
+
+  output[labwareName] = contents
+})
+
+const jsonOutput = JSON.stringify(output)
+
+fs.writeFileSync(path.join(buildDir, 'labware.json'), jsonOutput)

package/js/scripts/generateDeckLayersFromSVG.js

@@ -0,0 +1,46 @@
+const assert = require('assert')
+const fs = require('fs')
+const path = require('path')
+const camelCase = require('lodash/camelCase')
+const JSDOM = require('jsdom').JSDOM
+const { promisify } = require('util')
+const readFile = promisify(fs.readFile)
+const writeFile = promisify(fs.writeFile)
+
+// NOTE: the expected source SVG is an output SVG from Adobe Illustrator
+// when using `Save as` or `Save as a Copy` and not `Export`
+// Furthermore, the .ai file should contain no groups and all layers
+// will be directly translated to layer groups in the JSON output
+
+const svgPath = process.argv[2]
+const buildDir = process.argv[3]
+
+const USAGE =
+  'Expected Params Not Present:   (e.g. node ./scripts/generateDeckLayersFromSVG ./path/to/source/svg ./path/to/output/dir)'
+assert(svgPath && buildDir, USAGE)
+
+readFile(svgPath, 'utf8')
+  .then(data => {
+    const doc = new JSDOM(data, 'text/xml')
+    const groups = Array.from(doc.window.document.querySelectorAll('g'))
+
+    let layers = {}
+    groups.forEach(g => {
+      const groupId = g.getAttribute('id')
+      if (groupId && g.hasChildNodes()) {
+        const features = Array.from(g.querySelectorAll('path'))
+        const paths = features.map(f => ({
+          footprint: f.getAttribute('d').replace(/\s|  {2}|\r\n|\n|\r/gm, ''), // clean up whitespaces and newlines
+        }))
+        layers = { ...layers, [camelCase(groupId)]: paths }
+      }
+    })
+
+    const jsonOutput = JSON.stringify(layers)
+    return writeFile(path.join(buildDir, 'deckLayers.json'), jsonOutput)
+  })
+  .then(() => process.exit(0))
+  .catch(error => {
+    console.error(error)
+    process.exit(1)
+  })

package/js/titleCase.ts

@@ -0,0 +1,30 @@
+const SMALL_WORDS = /\b(?:an?d?|a[st]|because|but|by|en|for|i[fn]|neither|nor|o[fnr]|only|over|per|μL|so|some|tha[tn]|the|to|up|upon|vs?\.?|versus|via|when|with|without|yet)\b/i
+const TOKENS = /[^\s:–—-]+|./g
+const WHITESPACE = /\s/
+const IS_MANUAL_CASE = /.(?=[A-Z]|\..)/
+const ALPHANUMERIC_PATTERN = /[A-Za-z0-9\u00C0-\u00FF]/
+
+export function titleCase(input: string): string {
+  let result = ''
+  let m: RegExpExecArray | null
+
+  while ((m = TOKENS.exec(input)) !== null) {
+    const { 0: token, index } = m
+
+    if (
+      !IS_MANUAL_CASE.test(token) &&
+      (!SMALL_WORDS.test(token) ||
+        index === 0 ||
+        index + token.length === input.length) &&
+      (input.charAt(index + token.length) !== ':' ||
+        WHITESPACE.test(input.charAt(index + token.length + 1)))
+    ) {
+      result += token.replace(ALPHANUMERIC_PATTERN, m => m.toUpperCase())
+      continue
+    }
+
+    result += token
+  }
+
+  return result
+}