feat: refactor pipetting loss calculation for 'factorWithMinimum' type

Author: Simon Bigelmayr

src/MasterMix/index.stories.tsx

@@ -57,19 +57,20 @@ function Template({
   minPositions = 2,
   ...props
 }: StoryProps): React.ReactElement {
-  let pipettingLoss;
-
-  if (lossType === 'absolute') {
-    pipettingLoss = { type: 'absolute', count: lossValue };
-  } else if (lossType === 'factor') {
-    pipettingLoss = { type: 'factor', factor: lossValue };
-  } else {
-    pipettingLoss = {
-      type: 'factorWithMinimum',
-      factor: lossValue,
-      minPositions,
-    };
-  }
+  const pipettingLoss = (() => {
+    switch (lossType) {
+      case 'absolute':
+        return { type: lossType, count: lossValue };
+      case 'factor':
+        return { type: lossType, factor: lossValue };
+      case 'factorWithMinimum':
+        return {
+          type: lossType,
+          factor: lossValue,
+          minPositions,
+        };
+    }
+  })();
 
   return <MasterMix {...props} pipettingLoss={pipettingLoss} />;
 }

src/MasterMix/pipettingLossTableColumn.tsx

@@ -5,10 +5,28 @@ import { Tooltip } from '../Tooltip';
 import {
   IngredientWithStringOrNumberKey,
   PipettingLoss,
+  PipettingLossFactorWithMinimum,
   PipettingLossTableColumn,
   PipettingLossTableColumnArgs,
 } from './types';
 
+type PipettingLosses = {
+  factorLoss: number;
+  minPositionsLoss: number;
+};
+
+function calculatePipettingLosses(
+  count: number,
+  pipettingLoss: PipettingLossFactorWithMinimum,
+  volume = 1,
+): PipettingLosses {
+  const baseVolume = volume * count;
+  return {
+    factorLoss: baseVolume * pipettingLoss.factor,
+    minPositionsLoss: volume * pipettingLoss.minPositions,
+  };
+}
+
 function pipettingLossTitle(
   pipettingLoss: PipettingLoss,
   count: number,
@@ -20,8 +38,10 @@ function pipettingLossTitle(
     case 'factor':
       return `${pipettingLoss.factor * 100}%`;
     case 'factorWithMinimum': {
-      const factorLoss = count * pipettingLoss.factor;
-      const minPositionsLoss = pipettingLoss.minPositions;
+      const { factorLoss, minPositionsLoss } = calculatePipettingLosses(
+        count,
+        pipettingLoss,
+      );
       return factorLoss > minPositionsLoss
         ? `${(pipettingLoss.factor * 100).toFixed(0)}%`
         : `${pipettingLoss.minPositions}x`;
@@ -45,8 +65,11 @@ function totalVolume(
       ).toFixed(1);
     case 'factorWithMinimum': {
       const baseVolume = record.volume * args.count;
-      const factorLoss = baseVolume * args.pipettingLoss.factor;
-      const minPositionsLoss = record.volume * args.pipettingLoss.minPositions;
+      const { factorLoss, minPositionsLoss } = calculatePipettingLosses(
+        args.count,
+        args.pipettingLoss,
+        record.volume,
+      );
       const pipettingLoss = Math.max(factorLoss, minPositionsLoss);
       return (baseVolume + pipettingLoss).toFixed(1);
     }