@opentrons/shared-data 0.0.1-alpha.20 → 0.0.1-alpha.21

package/js/pipettes.ts

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

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

@@ -1,80 +0,0 @@
-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/generateDeckLayersFromSVG.js

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

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