@opentrons/shared-data 0.1.7-alpha.1 → 0.2.1-alpha.0

package/lib/js/constants.d.ts

@@ -1,6 +1,6 @@
-import type { WellOrigin } from '../command';
+import type { WellLocation, WellOrigin } from '../command';
 import type { AddressableAreaName, CutoutFixtureId, CutoutId } from '../deck';
-import type { ModuleModel, ModuleType, PositionReference } from './types';
+import type { AddressableArea, AreaType, FakeAddressableArea, ModuleModel, ModuleType, PositionReference } from './types';
 export declare const SLOT_LENGTH_MM = 127.76;
 export declare const SLOT_WIDTH_MM = 85.48;
 export declare const SLOT_RENDER_WIDTH = 127.76;
@@ -57,11 +57,6 @@ export declare const MODULE_MODELS: ("thermocyclerModuleV2" | "heaterShakerModul
 export declare const MODULE_MODELS_OT2_ONLY: ("magneticModuleV1" | "magneticModuleV2" | "temperatureModuleV1" | "thermocyclerModuleV1")[];
 export declare const MODULE_TYPES: ("magneticModuleType" | "temperatureModuleType" | "heaterShakerModuleType" | "thermocyclerModuleType" | "magneticBlockType" | "absorbanceReaderType" | "flexStackerModuleType")[];
 export declare const GEN_ONE_MULTI_PIPETTES: string[];
-export declare const IDENTITY_VECTOR: {
-    x: number;
-    y: number;
-    z: number;
-};
 export declare const ROBOT_MODELS: string[];
 export declare const OT2_ROBOT_TYPE: "OT-2 Standard";
 export declare const FLEX_ROBOT_TYPE: "OT-3 Standard";
@@ -100,6 +95,7 @@ export declare const WEIGHT_OF_96_CHANNEL: '~10kg';
 export declare const MOVABLE_TRASH_CUTOUTS: CutoutId[];
 export declare const SINGLE_LEFT_CUTOUTS: CutoutId[];
 export declare const SINGLE_CENTER_CUTOUTS: CutoutId[];
+export declare const LEFT_AND_CENTER_CUTOUTS: CutoutId[];
 export declare const SINGLE_RIGHT_CUTOUTS: CutoutId[];
 export declare const STAGING_AREA_CUTOUTS: CutoutId[];
 export declare const TEMPERATURE_MODULE_CUTOUTS: CutoutId[];
@@ -123,6 +119,17 @@ export declare const D1_ADDRESSABLE_AREA: 'D1';
 export declare const D2_ADDRESSABLE_AREA: 'D2';
 export declare const D3_ADDRESSABLE_AREA: 'D3';
 export declare const D4_ADDRESSABLE_AREA: 'D4';
+export declare const FAKE_D4_ADDRESSABLE_AREA: 'fakeD4';
+export declare const FAKE_C4_ADDRESSABLE_AREA: 'fakeC4';
+export declare const FAKE_B4_ADDRESSABLE_AREA: 'fakeB4';
+export declare const FAKE_A4_ADDRESSABLE_AREA: 'fakeA4';
+export declare const FAKE_AA: ("fakeA4" | "fakeB4" | "fakeC4")[];
+export type FlexFakeAddressableAreaName = 'fakeA4' | 'fakeB4' | 'fakeC4' | 'fakeD4';
+export type FakeCutoutFixtureId = 'fakeStagingAreaRightSlot' | 'fakeWasteChuteWithEmptySlot' | 'fakeStagingSlotWithMagBlockV1';
+export type AddressableAreaNamesWithFakes = AddressableAreaName | FlexFakeAddressableAreaName;
+export type AddressableAreaWithFakes = AddressableArea | FakeAddressableArea;
+export type CutoutFixtureIdsWithFakes = CutoutFixtureId | FakeCutoutFixtureId;
+export type AreaTypeWithFakes = AreaType | 'fakeStagingSlot';
 export declare const MOVABLE_TRASH_A1_ADDRESSABLE_AREA: 'movableTrashA1';
 export declare const MOVABLE_TRASH_A3_ADDRESSABLE_AREA: 'movableTrashA3';
 export declare const MOVABLE_TRASH_B1_ADDRESSABLE_AREA: 'movableTrashB1';
@@ -184,6 +191,7 @@ export declare const FLEX_STACKER_ADDRESSABLE_AREAS: AddressableAreaName[];
 export declare const FLEX_USB_MODULE_ADDRESSABLE_AREAS: AddressableAreaName[];
 export declare const FLEX_MODULE_ADDRESSABLE_AREAS: AddressableAreaName[];
 export declare const FLEX_STAGING_ADDRESSABLE_AREAS: AddressableAreaName[];
+export declare const FLEX_STAGING_ADDRESSABLE_AREAS_WITH_FAKES: AddressableAreaNamesWithFakes[];
 export declare const ADDRESSABLE_AREA_1: '1';
 export declare const ADDRESSABLE_AREA_2: '2';
 export declare const ADDRESSABLE_AREA_3: '3';
@@ -204,6 +212,9 @@ export declare const SINGLE_LEFT_SLOT_FIXTURE: 'singleLeftSlot';
 export declare const SINGLE_CENTER_SLOT_FIXTURE: 'singleCenterSlot';
 export declare const SINGLE_RIGHT_SLOT_FIXTURE: 'singleRightSlot';
 export declare const STAGING_AREA_RIGHT_SLOT_FIXTURE: 'stagingAreaRightSlot';
+export declare const FAKE_STAGING_AREA_RIGHT_SLOT: 'fakeStagingAreaRightSlot';
+export declare const FAKE_WASTE_CHUTE_WITH_EMPTY_SLOT: 'fakeWasteChuteWithEmptySlot';
+export declare const FAKE_STAGING_SLOT_WITH_MAG_BLOCK: 'fakeStagingSlotWithMagBlockV1';
 export declare const TRASH_BIN_FIXTURE: 'trashBin';
 export declare const TRASH_BIN_ADAPTER_FIXTURE: 'trashBinAdapter';
 export declare const WASTE_CHUTE_RIGHT_ADAPTER_COVERED_FIXTURE: 'wasteChuteRightAdapterCovered';
@@ -224,13 +235,19 @@ export declare const FLEX_STACKER_WITH_MAG_BLOCK_FIXTURE: 'flexStackerModuleV1Wi
 export declare const MODULE_FIXTURES_BY_MODEL: {
     [moduleModel in ModuleModel]?: CutoutFixtureId[];
 };
+export declare const FLEX_MODULE_AA_TYPE_BY_MODEL: {
+    [moduleModel in ModuleModel]?: AreaType;
+};
 export declare const FLEX_USB_MODULE_FIXTURES: CutoutFixtureId[];
 export declare const MAGNETIC_BLOCK_FIXTURES: CutoutFixtureId[];
-export declare const SINGLE_SLOT_FIXTURES: CutoutFixtureId[];
+export declare const SINGLE_SLOT_FIXTURES: CutoutFixtureIdsWithFakes[];
 export declare const WASTE_CHUTE_FIXTURES: CutoutFixtureId[];
+export declare const WASTE_CHUTE_WITH_FAKE_FIXTURES: CutoutFixtureIdsWithFakes[];
 export declare const WASTE_CHUTE_ONLY_FIXTURES: CutoutFixtureId[];
 export declare const WASTE_CHUTE_STAGING_AREA_FIXTURES: CutoutFixtureId[];
-export declare const FLEX_STACKER_FIXTURES: CutoutFixtureId[];
+export declare const FLEX_STACKER_FIXTURES: CutoutFixtureIdsWithFakes[];
+export declare const COMBO_FIXTURES: CutoutFixtureIdsWithFakes[];
+export declare const DEFAULT_AA_FOR_WASTE_CHUTE = "96ChannelWasteChute";
 export declare const LOW_VOLUME_PIPETTES: string[];
 export declare const DEFAULT_LIQUID_COLORS: string[];
 export declare const DEPRECATED_WHALE_GREY = "#9395a0";
@@ -245,3 +262,5 @@ export declare const WELL_ORIGIN_CENTER: 'center';
 export declare const WELL_ORIGIN_MENISCUS: 'meniscus';
 export declare const POSITION_REFERENCE_MAPPED_TO_WELL_ORIGIN: Record<PositionReference, WellOrigin>;
 export declare const SAFE_MOVE_TO_WELL_OFFSET_FROM_TOP_MM = 2;
+export declare const SAFE_MOVE_TO_WELL_LOCATION: WellLocation;
+export declare const FAKE_FIXTURE_IDS: CutoutFixtureIdsWithFakes[];

package/lib/js/fixtures.d.ts

@@ -1,7 +1,14 @@
+/**
+ * Code to deal with fixtures in the sense of deck configuration.
+ * Not to be confused with fixtures in the sense of dummy test data.
+ */
+import type { TFunction } from 'i18next';
 import type { ModuleLocation } from '../command';
 import type { AddressableAreaName, CutoutFixtureId, CutoutId, OT2CutoutId } from '../deck';
-import type { AddressableArea, CoordinateTuple, CutoutFixture, DeckDefinition, ModuleModel } from './types';
+import type { AddressableAreaNamesWithFakes, AddressableAreaWithFakes, AreaTypeWithFakes, CutoutFixtureIdsWithFakes } from './constants';
+import type { AddressableArea, CoordinateTuple, CutoutConfig, CutoutConfigMap, CutoutFixture, DeckDefinition, DeckDefinitionWithFakes, ModuleModel } from './types';
 export declare function getCutoutDisplayName(cutout: CutoutId): string;
+export declare function getAADisplayName(aadressableAreaId: AddressableAreaNamesWithFakes): string;
 export declare const OT2_CUTOUT_BY_SLOT_ID: {
     [slotId: string]: OT2CutoutId;
 };
@@ -11,8 +18,33 @@ export declare const FLEX_CUTOUT_BY_SLOT_ID: {
 export declare const FLEX_SINGLE_SLOT_BY_CUTOUT_ID: {
     [CutoutId: string]: string;
 };
+export declare const FAKE_FIXTURES_AND_AA: DeckDefinitionWithFakes;
 export declare function getPositionFromSlotId(slotId: string, deckDef: DeckDefinition): CoordinateTuple | null;
 export declare function getAddressableAreaFromSlotId(slotId: string, deckDef: DeckDefinition): AddressableArea | null;
+export declare const getCutoutFixtureReplacementIfNeeded: (cutoutFixtureId: CutoutFixtureId, cutoutId: CutoutId, deckDefinition: DeckDefinition) => CutoutFixtureIdsWithFakes;
+export declare const getReplacementFixtureForFixtureRemoval: (cutoutFixtureId: CutoutFixtureIdsWithFakes, cutoutId: CutoutId, addressableAreaId?: AddressableAreaNamesWithFakes) => CutoutFixtureId;
+/**
+ * Given a fake cutout fixutre find a replacment to store on the server
+ * @param cutoutFixtureId: a cutoutId we wish to replace with a non fake fixture
+ * @returns the relevant cutoutFixtureId to store on the server
+ */
+export declare const getReplacementFixtureForFakeFixture: (cutoutFixtureId: CutoutFixtureIdsWithFakes) => CutoutFixtureId;
+/**
+ * Given a list of cutout configs replace fixtures with their fake fixtures
+ * @param: a list of cutout config from the server
+ * @returns: a list of cutout config with relevant AA
+ */
+export declare const replaceFixtureToFakeFixtureAndTransformCutoutFixturesToAA: (cutoutFixtures: CutoutConfig[]) => CutoutConfigMap[];
+export declare const filterAAByAreaType: (cutoutFixtures: CutoutConfigMap[], deckDef: DeckDefinition, areaType: AreaTypeWithFakes) => CutoutConfigMap[];
+/**
+ * Given a deck def add all fake cutout fixtures and fake AA
+ * @param deckDefinition: deck def we wish to extend
+ * @returns a new deck def with fake fixtures
+ */
+export declare const getDeckDefWithFakes: (deckDefinition: DeckDefinition) => DeckDefinitionWithFakes;
+export declare const getAALocationForCutoutAndFixtureId: (addressableArea: AddressableAreaNamesWithFakes, deckDefinition: DeckDefinition) => CoordinateTuple;
+export declare const getAAByAAId: (addressableAreaId: AddressableAreaNamesWithFakes, deckDefinition: DeckDefinition) => AddressableAreaWithFakes;
+export declare const getAAWithFakesFromCutoutFixtureId: (inputCutoutId: CutoutId, cutoutFixtureId: CutoutFixtureIdsWithFakes, deckDefinition: DeckDefinition) => AddressableAreaNamesWithFakes[] | null;
 export declare function getCutoutFixtureIdsForModuleModel(moduleModel: ModuleModel): CutoutFixtureId[];
 export declare function getCutoutFixturesForModuleModel(moduleModel: ModuleModel, deckDef: DeckDefinition): CutoutFixture[];
 export declare function getFixtureIdByCutoutIdFromModuleAnchorCutoutId(anchorCutoutId: CutoutId | null, moduleFixtures: CutoutFixture[]): {
@@ -25,7 +57,50 @@ deckDef: DeckDefinition): {
 export declare function getCutoutIdsFromModuleSlotName(slotName: string, moduleFixtures: CutoutFixture[], // cutout fixtures for a specific module model
 deckDef: DeckDefinition): CutoutId[];
 export declare function getAddressableAreaNamesFromLoadedModule(moduleModel: ModuleModel, slotName: ModuleLocation['slotName'], deckDef: DeckDefinition): AddressableAreaName[];
-export declare function getFixtureDisplayName(cutoutFixtureId: CutoutFixtureId | null, usbPortNumber?: number | string): string;
+export declare const getModuleDisplayNameWithPort: (usbPortNumber: number | string) => string;
+export declare function getAAComboFixtureDisplayName(cutoutFixtureId: CutoutFixtureIdsWithFakes | null, addressableAreaId: AddressableAreaNamesWithFakes, deckDef: DeckDefinition, t: TFunction, usbPortNumber?: number | string): string | null;
+export declare function getFixtureDisplayName(cutoutFixtureId: CutoutFixtureIdsWithFakes | null, usbPortNumber?: number | string): string;
 export declare const STANDARD_OT2_SLOTS: AddressableAreaName[];
 export declare const STANDARD_FLEX_SLOTS: AddressableAreaName[];
+export type VISUAL_SLOTS = 'VSA1' | 'VSB1' | 'VSC1' | 'VSD1' | 'VSA2' | 'VSB2' | 'VSC2' | 'VSD2' | 'VSA3' | 'VSB3' | 'VSC3' | 'VSD3' | 'VSA4' | 'VSB4' | 'VSC4' | 'VSD4';
+export declare const VS_TO_AA: Record<VISUAL_SLOTS, AddressableAreaNamesWithFakes[]>;
+export declare const getVisualSlotIdFromAAId: (aaId: AddressableAreaNamesWithFakes) => string;
+export declare const getAAWithFakesFromVSId: (vsId: string) => AddressableAreaNamesWithFakes | null;
 export declare const isAddressableAreaStandardSlot: (addressableAreaName: AddressableAreaName, deckDef: DeckDefinition) => boolean;
+/**
+ * Given a cutout id get a key value pair of all possibilities for fixture id and related AA
+ * @param addedCutoutConfigs: fixtures list selected to add to deck
+ * @param cutoutId: cutout if we are adding a fixture to.
+ * @returns key value pair of of all possibilities for fixture id and related AA
+ */
+export declare const getAAsToFixtureIdFromDeckDefWithFakes: (cutoutId: CutoutId, deckDef: DeckDefinition) => Record<CutoutFixtureIdsWithFakes, AddressableAreaNamesWithFakes[]>;
+export declare const getAAForModuleFixture: (cutoutId: CutoutId, fixtureId: CutoutFixtureIdsWithFakes, moduleModel: ModuleModel) => AddressableAreaNamesWithFakes;
+/**
+ * get relevent aa name that match with cutoutId and fixtureId.
+ *
+ * @param cutoutId - The cutoutId we are looking for.
+ * @param fixtureId - The fixtureId we are looking for.
+ * @returns The aa name or null if not match found.
+ */
+export declare const getMainAAForAFixture: (cutoutId: CutoutId, fixtureId: CutoutFixtureId, addressableAreaId: AddressableAreaNamesWithFakes) => AddressableAreaNamesWithFakes | null;
+export declare const isModuleAllowedOnAA: (cutoutId: CutoutId, aa: AddressableAreaNamesWithFakes, moduleModel: ModuleModel) => boolean;
+export declare const getVisualSlotIdForAA: (cutoutId: CutoutId, fixtureId: CutoutFixtureIdsWithFakes, addressableAreaId: AddressableAreaNamesWithFakes) => string;
+export declare const getAASlotDisplayName: (addressableAreaId: AddressableAreaNamesWithFakes) => string;
+/**
+ * Given a cutout fixture find if should be changed to a combo fixture
+ * @param addedCutoutConfigs: fixtures list selected to add to deck
+ * @param deckConfigWithAA: current deck state
+ * @param cutoutId:
+ * @returns update list of the current deck with the combo fixtures replacements
+ */
+export declare const replaceCutoutFixtureWithComboFixture: (addedCutoutConfigs: CutoutConfigMap[], deckConfigWithAA: CutoutConfigMap[], cutoutId: CutoutId) => CutoutConfigMap[];
+/**
+ * Given a cutout fixture to remove find what fixture to use instead
+ * @param cutoutFixtureRemoved: fixtures to remove
+ * @param cutoutId
+ * @param addressableAreaId to remove from fixture
+ * @returns fixture to replace with
+ */
+export declare const replaceCutoutFixtureRemove: (cutoutFixtureRemoved: CutoutFixtureIdsWithFakes, cutoutId: CutoutId, addressableAreaId: AddressableAreaNamesWithFakes) => CutoutFixtureIdsWithFakes;
+export declare const isFixtureInUsbModules: (fixtureId: CutoutFixtureId) => boolean;
+export declare const getCutoutConfigReplacmentForModule: (cutoutId: CutoutId, fixtureId: CutoutFixtureId, moduleModel: ModuleModel, deckConfig: CutoutConfig[]) => CutoutFixtureId;

package/lib/js/getLabware.d.ts

@@ -1,8 +1,8 @@
-import type { LabwareDefinition1, LabwareDefinition2, WellDefinition } from './types';
+import type { LabwareDefinition, LabwareDefinition1, WellDefinition } from './types';
 export declare const LABWAREV2_DO_NOT_LIST: string[];
 export declare const PD_DO_NOT_LIST: string[];
 export declare function getIsLabwareV1Tiprack(def: LabwareDefinition1): boolean;
-export declare function getIsTiprack(labwareDef: LabwareDefinition2): boolean;
-export declare function getLabwareDefaultEngageHeight(labwareDef: LabwareDefinition2): number | null;
+export declare function getIsTiprack(labwareDef: LabwareDefinition): boolean;
+export declare function getLabwareDefaultEngageHeight(labwareDef: LabwareDefinition): number | null;
 /** For display. Flips Y axis to match SVG, applies offset to wells */
 export declare function getWellPropsForSVGLabwareV1(def: LabwareDefinition1): Record<string, WellDefinition>;

package/lib/js/helpers/__tests__/getMaxPushOutVolume.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/helpers/__tests__/getStackedItemsOnStartingDeck.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/helpers/__tests__/labwareSchemaShims.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/helpers/__tests__/pairsFromArray.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/helpers/__tests__/vectorMath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/helpers/getFixedTrashLabwareDefinition.d.ts

@@ -1,2 +1,2 @@
-import type { LabwareDefinition2 } from '..';
-export declare function getFixedTrashLabwareDefinition(): LabwareDefinition2;
+import type { LabwareDefinition } from '..';
+export declare function getFixedTrashLabwareDefinition(): LabwareDefinition;

package/lib/js/helpers/getLabwareDefURI.d.ts

@@ -0,0 +1,3 @@
+import type { LabwareDefinition } from '../types';
+export declare const getLabwareDefURI: (def: LabwareDefinition) => string;
+export declare const constructLabwareDefURI: (namespace: string, loadName: string, version: string) => string;

package/lib/js/helpers/getLabwareDefinitionsByURIForProtocol.d.ts

@@ -0,0 +1,6 @@
+import type { RunTimeCommand } from '../../protocol';
+import type { LabwareDefinition } from '../types';
+export interface LabwareDefinitionsByURI {
+    [labwareDefURI: string]: LabwareDefinition;
+}
+export declare function getLabwareDefinitionsByURIForProtocol(commands: RunTimeCommand[]): LabwareDefinitionsByURI;

package/lib/js/helpers/getLabwareInfoByLiquidId.d.ts

@@ -0,0 +1,10 @@
+import type { RunTimeCommand } from '../../command';
+export interface LabwareByLiquidId {
+    [liquidId: string]: Array<{
+        labwareId: string;
+        volumeByWell: {
+            [well: string]: number;
+        };
+    }>;
+}
+export declare function getLabwareInfoByLiquidId(commands: RunTimeCommand[]): LabwareByLiquidId;

package/lib/js/helpers/getLiquidsByIdForLabware.d.ts

@@ -0,0 +1,2 @@
+import type { LabwareByLiquidId } from './getLabwareInfoByLiquidId';
+export declare function getLiquidsByIdForLabware(labwareId: string, labwareByLiquidId: LabwareByLiquidId): LabwareByLiquidId;

package/lib/js/helpers/getLoadedLabwareDefinitionsByUri.d.ts

@@ -1,5 +1,5 @@
-import type { LabwareDefinition2, RunTimeCommand } from '..';
+import type { LabwareDefinition, RunTimeCommand } from '..';
 export interface LabwareDefinitionsByUri {
-    [defURI: string]: LabwareDefinition2;
+    [defURI: string]: LabwareDefinition;
 }
 export declare function getLoadedLabwareDefinitionsByUri(commands: RunTimeCommand[]): LabwareDefinitionsByUri;

package/lib/js/helpers/getMaxPushOutVolume.d.ts

@@ -0,0 +1,2 @@
+import type { PipetteV2Specs } from '../types';
+export declare const getMaxPushOutVolume: (transferVolume: number, pipetteSpecs: PipetteV2Specs) => number;

package/lib/js/helpers/getStackedItemsOnStartingDeck.d.ts

@@ -0,0 +1,50 @@
+import type { RunTimeCommand } from '../../protocol';
+import type { LoadedLabware, LoadedModule, ModuleModel } from '../types';
+import type { LabwareByLiquidId } from './getLabwareInfoByLiquidId';
+export interface LabwareInStack {
+    definitionUri: string;
+    displayName: string;
+    labwareId: string;
+    lidId?: string;
+    lidDisplayName?: string;
+}
+export interface ModuleInStack {
+    moduleModel: ModuleModel;
+    moduleId: string;
+    moduleSlotName: string;
+}
+export type StackItem = LabwareInStack | ModuleInStack;
+export interface StackedItemsOnDeck {
+    [slotName: string]: StackItem[];
+}
+export interface LabwareLiquidRenderInfo extends LabwareInStack {
+    quantity: number;
+    liquids: number;
+}
+export declare function getStackerLocationFromSlotName(slotName: string): string;
+/**
+ * This function parses all commands that load labware in reverse order and makes a map of
+ * shape [slotName]: ordered list of stacked items in slot at the start of a protocol, returning
+ * exactly one array per utilized slot in the starting deck state
+ * with an additional list for all off deck items
+ * @param commands
+ * @param loadedLabware
+ * @param loadedModules
+ * @returns [slotName]: StackItem[]
+ */
+export declare function getStackedItemsOnStartingDeck(commands: RunTimeCommand[], loadedLabware: LoadedLabware[], loadedModules: LoadedModule[]): StackedItemsOnDeck;
+export declare function getLabwareLiquidRenderInfoFromStack(labwareInStack: LabwareInStack[], labwareByLiquidId?: LabwareByLiquidId): LabwareLiquidRenderInfo[];
+export declare function getLabwareOnDeck(itemsOnDeck: StackedItemsOnDeck): {
+    [slotName: string]: LabwareInStack[];
+};
+export declare function getStacksWithLabware(itemsOnDeck: StackedItemsOnDeck): {
+    [slotName: string]: StackItem[];
+};
+export declare function getStacksOnModules(itemsOnDeck: StackedItemsOnDeck): {
+    [slotName: string]: {
+        allItemsInStack: StackItem[];
+        moduleInStack: ModuleInStack;
+    };
+};
+export declare function getTopLabwareFromStack(itemsOnDeck: StackItem[]): LabwareInStack | null;
+export declare function getModuleFromStack(itemsOnDeck: StackItem[]): ModuleInStack | null;

package/lib/js/helpers/getStandardDeckViewLayerBlockList.d.ts

@@ -0,0 +1,2 @@
+import type { RobotType } from '../types';
+export declare const getStandardDeckViewLayerBlockList: (robotType: RobotType) => string[];

package/lib/js/helpers/getTipTypeFromTipRackDefinition.d.ts

@@ -1,2 +1,2 @@
-import type { LabwareDefinition2 } from '..';
-export declare function getTipTypeFromTipRackDefinition(tipRackDef: LabwareDefinition2): string;
+import type { LabwareDefinition } from '..';
+export declare function getTipTypeFromTipRackDefinition(tipRackDef: LabwareDefinition): string;

package/lib/js/helpers/getWellFillFromLabwareId.d.ts

@@ -0,0 +1,4 @@
+import type { Liquid } from '../types';
+import type { LabwareByLiquidId } from './getLabwareInfoByLiquidId';
+export type WellFill = Record<string, string>;
+export declare function getWellFillFromLabwareId(labwareId: string, liquidsInLoadOrder: Liquid[], labwareByLiquidId: LabwareByLiquidId): WellFill;

package/lib/js/helpers/getWellNamePerMultiTip.d.ts

@@ -1,3 +1,3 @@
-import type { LabwareDefinition2 } from '../types';
-export declare function findWellAt(labwareDef: LabwareDefinition2, x: number, y: number): string | null | undefined;
-export declare function getWellNamePerMultiTip(labwareDef: LabwareDefinition2, topWellName: string, channels: 8 | 96): string[] | null;
+import type { LabwareDefinition } from '../types';
+export declare function findWellAt(labwareDef: LabwareDefinition, x: number, y: number): string | null | undefined;
+export declare function getWellNamePerMultiTip(labwareDef: LabwareDefinition, topWellName: string, channels: 8 | 96): string[] | null;

package/lib/js/helpers/getWellTotalVolume.d.ts

@@ -1,2 +1,2 @@
-import type { LabwareDefinition2 } from '../types';
-export declare const getWellTotalVolume: (labwareDef: LabwareDefinition2, wellName: string) => number | null | undefined;
+import type { LabwareDefinition } from '../types';
+export declare const getWellTotalVolume: (labwareDef: LabwareDefinition, wellName: string) => number | null | undefined;

package/lib/js/helpers/index.d.ts

@@ -1,5 +1,5 @@
 import type { CutoutId } from '../../deck/types/schemaV5';
-import type { DeckDefinition, LabwareDefinition2, LabwareDefinition3, LiquidClass, ModuleModel, RobotType, ThermalAdapterName } from '../types';
+import type { DeckDefinition, LabwareDefinition, LiquidClass, ModuleModel, RobotType, ThermalAdapterName } from '../types';
 export { getWellNamePerMultiTip } from './getWellNamePerMultiTip';
 export { getWellTotalVolume } from './getWellTotalVolume';
 export { wellIsRect } from './wellIsRect';
@@ -14,8 +14,8 @@ export * from './wellSets';
 export * from './getAreFlexSlotsAdjacent';
 export * from './getMmFromBottom';
 export * from './getModuleVizDims';
-export * from './getVectorDifference';
-export * from './getVectorSum';
+export * from './vectorMath';
+export * from './matrixMath';
 export * from './getLoadedLabwareDefinitionsByUri';
 export * from './getFixedTrashLabwareDefinition';
 export * from './getOccludedSlotCountForModule';
@@ -33,9 +33,17 @@ export * from './sortRunTimeParameters';
 export * from './parseAddressableArea';
 export * from './validateCustomLabwareHelper';
 export * from './getWellRangeForLiquidLabwarePair';
-export declare const getLabwareDefIsStandard: (def: LabwareDefinition2) => boolean;
-export declare const getLabwareDefURI: (def: LabwareDefinition2 | LabwareDefinition3) => string;
-export declare const constructLabwareDefURI: (namespace: string, loadName: string, version: string) => string;
+export * from './positionMath';
+export * from './pairsFromArray';
+export * from './getMaxPushOutVolume';
+export * from './getLabwareDefinitionsByURIForProtocol';
+export * from './getLabwareDefURI';
+export * from './getLabwareInfoByLiquidId';
+export * from './getLiquidsByIdForLabware';
+export * from './getStackedItemsOnStartingDeck';
+export * from './getStandardDeckViewLayerBlockList';
+export * from './getWellFillFromLabwareId';
+export declare const getLabwareDefIsStandard: (def: LabwareDefinition) => boolean;
 export interface URIDetails {
     loadName: string;
     namespace: string;
@@ -43,9 +51,9 @@ export interface URIDetails {
 }
 export declare const splitLabwareDefURI: (uri: string) => URIDetails;
 export declare const RETIRED_LABWARE: string[];
-export declare const getLabwareDisplayName: (labwareDef: LabwareDefinition2) => string;
-export declare const getTiprackVolume: (labwareDef: LabwareDefinition2) => number;
-export declare function getLabwareHasQuirk(labwareDef: LabwareDefinition2, quirk: string): boolean;
+export declare const getLabwareDisplayName: (labwareDef: LabwareDefinition) => string;
+export declare const getTiprackVolume: (labwareDef: LabwareDefinition) => number;
+export declare function getLabwareHasQuirk(labwareDef: LabwareDefinition, quirk: string): boolean;
 export declare const intToAlphabetLetter: (i: number, lowerCase?: boolean) => string;
 export declare const toWellName: ({ rowNum, colNum, }: {
     rowNum: number;
@@ -57,16 +65,16 @@ export declare const toWellName: ({ rowNum, colNum, }: {
  */
 export declare function sortWells(a: string, b: string): number;
 export declare function splitWellsOnColumn(sortedArray: string[]): string[][];
-export declare const getWellDepth: (labwareDef: LabwareDefinition2, well: string) => number;
-export declare const getWellsDepth: (labwareDef: LabwareDefinition2, wells: string[]) => number;
+export declare const getWellDepth: (labwareDef: LabwareDefinition, well: string) => number;
+export declare const getWellsDepth: (labwareDef: LabwareDefinition, wells: string[]) => number;
 type XYPlaneDimension = 'x' | 'y';
-export declare const getWellDimension: (labwareDef: LabwareDefinition2, wells: string[], position: XYPlaneDimension) => number;
-export declare const getMinXYDimension: (labwareDef: LabwareDefinition2, wells: string[]) => number | null;
+export declare const getWellDimension: (labwareDef: LabwareDefinition, wells: string[], position: XYPlaneDimension) => number;
+export declare const getMinXYDimension: (labwareDef: LabwareDefinition, wells: string[]) => number | null;
 export declare const getSlotHasMatingSurfaceUnitVector: (deckDef: DeckDefinition, addressableAreaName: string) => boolean;
 export declare const getAreSlotsHorizontallyAdjacent: (slotNameA?: string | null, slotNameB?: string | null) => boolean;
 export declare const getAreSlotsVerticallyAdjacent: (slotNameA?: string | null, slotNameB?: string | null) => boolean;
 export declare const getAreSlotsAdjacent: (slotNameA?: string | null, slotNameB?: string | null) => boolean;
-export declare const getIsLabwareAboveHeight: (labwareDef: LabwareDefinition2, height: number) => boolean;
+export declare const getIsLabwareAboveHeight: (labwareDef: LabwareDefinition, height: number) => boolean;
 export declare const getAdapterName: (labwareLoadname: string) => ThermalAdapterName;
 export declare const getCalibrationAdapterLoadName: (moduleModel: ModuleModel) => string | null;
 export declare const getDeckDefFromRobotType: (robotType: RobotType) => DeckDefinition;

package/lib/js/helpers/labwareInference.d.ts

@@ -1,7 +1,7 @@
-import type { LabwareBrand, LabwareDefinition2, LabwareWell, LabwareWellGroupMetadata, LabwareWellShapeProperties } from '../types';
+import type { LabwareBrand, LabwareDefinition, LabwareWell, LabwareWellGroupMetadata, LabwareWellShapeProperties } from '../types';
 export interface LabwareWellGroupProperties {
     xOffsetFromLeft: number;
-    yOffsetFromTop: number;
+    yOffsetFromBack: number;
     xSpacing: number | null;
     ySpacing: number | null;
     wellCount: number;
@@ -11,6 +11,6 @@ export interface LabwareWellGroupProperties {
     metadata: LabwareWellGroupMetadata;
     brand: LabwareBrand | null;
 }
-export declare function getUniqueWellProperties(definition: LabwareDefinition2): LabwareWellGroupProperties[];
+export declare function getUniqueWellProperties(definition: LabwareDefinition): LabwareWellGroupProperties[];
 export declare function getIfConsistent<T>(items: T[]): T | null;
 export declare function getSpacingIfUniform(wells: LabwareWell[], axis: 'x' | 'y'): number | null;

package/lib/js/helpers/liquidClasses.d.ts

@@ -1,8 +1,10 @@
 import type { PipetteV2Specs } from '..';
-export declare const getCorrectionVolume: (args: {
+export declare const getByVolumeValue: (args: {
     liquidClass: string | null;
     pipetteSpecs: PipetteV2Specs;
     tiprackDefUri: string;
     targetVolume: number;
     liquidHandlingAction: 'aspirate' | 'singleDispense' | 'multiDispense';
-}) => number;
+    byVolumeProperty: 'correctionByVolume' | 'flowRateByVolume';
+    defaultValue?: number | null;
+}) => number | null;

package/lib/js/helpers/matrixMath.d.ts

@@ -0,0 +1,3 @@
+import type { AffineTransformMatrix } from '../types';
+export declare const IDENTITY_AFFINE_TRANSFORM: AffineTransformMatrix;
+export declare function multiplyMatrices(a: number[][], b: number[][]): number[][];

package/lib/js/helpers/pairsFromArray.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return all pairs of consecutive elements.
+ *
+ * [1, 2, 3, 4] -> [[1, 2], [2, 3], [3, 4]]
+ * [1] -> []
+ * [] -> []
+ */
+export declare function pairsFromArray<T>(array: T[]): Array<[T, T]>;

package/lib/js/helpers/parseProtocolCommands.d.ts

@@ -1,6 +1,6 @@
 import type { LabwareLocation, LoadLabwareRunTimeCommand, LoadModuleRunTimeCommand, RunTimeCommand } from '../../command/types';
 import type { PipetteName } from '../pipettes';
-import type { LabwareDefinition2, Liquid, LoadedLabware, LoadedModule, LoadedPipette, ModuleModel } from '../types';
+import type { LabwareDefinition, Liquid, LoadedLabware, LoadedModule, LoadedPipette, ModuleModel } from '../types';
 interface PipetteNamesByMount {
     left: PipetteName | null;
     right: PipetteName | null;
@@ -15,7 +15,7 @@ interface LoadedLabwareBySlot {
 export declare function parseInitialLoadedLabwareBySlot(commands: RunTimeCommand[]): LoadedLabwareBySlot;
 export declare function getTopLabwareInfo(labwareId: string, loadLabwareCommands: LoadLabwareRunTimeCommand[], currentStackHeight?: number): {
     topLabwareId: string;
-    topLabwareDefinition?: LabwareDefinition2;
+    topLabwareDefinition?: LabwareDefinition;
     topLabwareDisplayName?: string;
 };
 export declare function getLabwareStackCountAndLocation(topLabwareId: string, commands: RunTimeCommand[], initialQuantity?: number): {
@@ -53,9 +53,9 @@ interface LabwareLiquidInfo {
     };
 }
 /** @deprecated instead use LabwareByLiquidId from components/src/hardware-sim/ProtocolDeck/types */
-export interface LabwareByLiquidId {
+interface DeprecatedLabwareByLiquidId {
     [liquidId: string]: LabwareLiquidInfo[];
 }
 /** @deprecated instead use getLabwareInfoByLiquidId from components/src/hardware-sim/ProtocolDeck/utils */
-export declare function parseLabwareInfoByLiquidId(commands: RunTimeCommand[]): LabwareByLiquidId;
+export declare function parseLabwareInfoByLiquidId(commands: RunTimeCommand[]): DeprecatedLabwareByLiquidId;
 export {};

package/lib/js/helpers/positionMath.d.ts

@@ -0,0 +1,121 @@
+/** Compute positions of labware stacked upon other labware, modules, deck slots, etc. */
+import type { AddressableArea, DeckDefinition, LabwareDefinition, LabwareDefinition2, ModuleDefinition, Vector3D } from '../types';
+/** Return dimensions of the total labware bounding box in the style of labware schema 2. */
+export declare function getSchema2Dimensions(definition: LabwareDefinition): LabwareDefinition2['dimensions'];
+/**
+ * Return a bounding box, in coordinates relative to the labware's origin,
+ * that encloses the labware when viewed from the top down.
+ */
+export declare function getLabwareViewBox(definition: LabwareDefinition): {
+    /** The minimum x-coord, i.e. the left of the labware. */
+    minX: number;
+    /** The minimum y-coord, i.e. the front of the labware. */
+    minY: number;
+    xDimension: number;
+    yDimension: number;
+};
+/** Logically specifies where a labware is located. */
+export interface ComputeLabwareOriginInput {
+    /** The underlying deck. */
+    deckDefinition: DeckDefinition;
+    /**
+     * The underlying slot. If this is a Flex and the labware is on a module, this should
+     * be the slot that the module replaces.
+     */
+    slotId: string;
+    /**
+     * The definition of the module underneath the labware, if there is one.
+     * This should be specified even if it's only transitively underneath the labware,
+     * like slot -> module -> adapter -> labware in question.
+     */
+    moduleDefinition: ModuleDefinition | null;
+    /** The labware and all the labware underneath it. */
+    labwareDefinitionsBottomToTop: LabwareDefinition[];
+}
+/**
+ * Computes the absolute deck coordinates of a labware.
+ * Returns null if there was some internal error.
+ */
+export declare function computeLabwareOrigin(input: ComputeLabwareOriginInput): Vector3D | null;
+/**
+ * Return the offset from a deck slot's origin (the slot's front-left, -x, -y)
+ * to a labware's origin (varies depending on the labware),
+ * supposing the labware is placed in that slot.
+ */
+export declare function getDeckSlotOriginToLabwareOrigin(slotDefinition: AddressableArea, labwareDefinition: LabwareDefinition): Vector3D;
+/**
+ * Given a stackup like:
+ *
+ * deck slot --> module --> labware
+ *
+ * This computes the offset from the deck slot's origin (its front-left / -x,-y corner)
+ * to the labware's origin (varies depending on the labware).
+ *
+ * This is currently how it works even for Flex modules, even though they are not really
+ * "in a slot." The slot in this case is the slot that the module replaces.
+ *
+ * The API is like this for transitional reasons. Ideally, we would have one function
+ * to go slot->module and a second function to go module->labware.
+ */
+export declare function getModuleParentOriginToLabwareOrigin(deckId: string, slotId: string | null, moduleDefinition: ModuleDefinition, labwareDefinition: LabwareDefinition): Vector3D;
+/**
+ * Given a labware -> labware stackup, compute the offset from the parent (bottom)
+ * labware's origin to the child (top) labware's origin.
+ */
+export declare function getLabwareOriginToLabwareOrigin(parentDefinition: LabwareDefinition, childDefinition: LabwareDefinition): Vector3D;
+/**
+ * Given a module, computes the offset from the origin (front-left, -x,-y corner) of the
+ * deck slot that the module is in, to the origin (again, front-left, -x,-y corner) of
+ * the slot atop that module.
+ *
+ * On a Flex, modules are not really "in deck slots". There, "the deck slot that the
+ * module is in" means "the deck slot that the module replaces."
+ *
+ * @deprecated We are trying to move away from the idea that modules always have slots
+ *  atop them and that things should be positioned relative to those slots' -x,-y
+ *  corners. That idea is especially untrue for things like the Thermocycler and
+ *  Heater-Shaker. You probably want `getModuleParentOriginToLabwareOrigin()` instead,
+ *  which is higher-level and can model different ways that a labware can mate with a
+ *  module. This is exported to support things like UI controls that want to cover
+ *  a module's "labware area" and whose implementations assume the traditional
+ *  slot -x,-y corner idea.
+ */
+export declare function getModuleParentOriginToChildSlotOrigin(deckId: string, slotId: string | null, moduleDefinition: ModuleDefinition): Vector3D;
+/**
+ * Return the offset from a labware's back-left-bottom (-x, +y, -z) corner to its origin.
+ *
+ * This is a lower-level helper for the rare cases where we want to position a labware
+ * specifically by its back-left corner. Typically, you'll want something higher-level,
+ * like `getLabwareViewBox()` or `getDeckSlotOriginToLabwareOrigin()`, instead.
+ */
+export declare function getLabwareBackLeftBottomToOrigin(definition: LabwareDefinition): Vector3D;
+/**
+ * Return a definition's cornerOffsetFromSlot in the style of labware schema 2.
+ *
+ * @deprecated This is probably an inherently wrong interface to attempt, for a couple
+ * reasons.
+ *
+ * FIRST, depending on what the call site does with this, it might expect the return
+ * value to be either:
+ *
+ * - The vector from the (-x, -y) corner of the parent slot to the (-x, -y) corner of
+ *   the labware
+ * - The vector from the (-x, -y) corner of the parent slot to the origin of the
+ *   labware
+ *
+ * In labware schema 2, these were the same thing, but not in schema 3.
+ *
+ * SECOND, in labware schema 2, how a child labware sits on its parent is almost
+ * entirely a function of the child's definition. In labware schema 3, it is
+ * much more dependent on information only available in the parent. For example, to
+ * line up a child's well A1 with a parent's well A1, we need to know where the
+ * parent's well A1 is. (Schema 2 just did not attempt to support that).
+ *
+ * For schema-2 definitions, this will return cornerOffsetFromSlot as-is.
+ *
+ * For schema-3 definitions, this currently returns the placeholder (12, 34, 56), which
+ * is certainly wrong and will cause all manner of visual mayhem, but at least it's
+ * wrong in an obvious way and it unblocks importing schema-3 definitions. Solving this
+ * properly is call-site-dependent, as described above.
+ */
+export declare function getSchema2CornerOffsetFromSlot(definition: LabwareDefinition): LabwareDefinition2['cornerOffsetFromSlot'];