Refactor findStepColumns

- Map better represents key optionality
- Set lets us not use lodash without
- chooseStep moves that BL to a pure function

Author: CarsonF

src/components/pnp/findStepColumns.ts

@@ -1,6 +1,6 @@
 import { sortBy } from '@seedcompany/common';
 import levenshtein from 'fastest-levenshtein';
-import { startCase, without } from 'lodash';
+import { startCase } from 'lodash';
 import { type Column } from '~/common/xlsx.util';
 import { ProductStep as Step } from '../product/dto';
 import { type PnpExtractionResult, PnpProblemType } from './extraction-result';
@@ -15,8 +15,8 @@ export function findStepColumns(
   result?: PnpExtractionResult,
   availableSteps: readonly Step[] = [...Step],
 ) {
-  const matchedColumns: Partial<Record<Step, Column>> = {};
-  let remainingSteps = availableSteps;
+  const matchedColumns = new Map<Step, Column>();
+  const remainingSteps = new Set(availableSteps);
   const possibleSteps = sheet.stepLabels
     .walkRight()
     .filter((cell) => !!cell.asString)
@@ -25,33 +25,41 @@ export function findStepColumns(
   possibleSteps.forEach(({ label, column, cell }, index) => {
     if (index === possibleSteps.length - 1) {
       // The last step should always be called Completed in CORD per Seth.
-      // Written PnP already match, but OBS calls it Record. This is mislabeled
-      // depending on the methodology.
-      matchedColumns[Step.Completed] = column;
+      // Written PnP already matches, but OBS calls it Record.
+      // This is mislabeled depending on the methodology.
+      matchedColumns.set(Step.Completed, column);
       return;
     }
-    const distances = remainingSteps.map((step) => {
-      const humanLabel = startCase(step).replace(' And ', ' & ');
-      const distance = levenshtein.distance(label, humanLabel);
-      return [step, distance] as const;
-    });
-    // Pick the step that is the closest fuzzy match
-    const chosen = sortBy(
-      // 5 is too far ignore those
-      distances.filter(([_, distance]) => distance < 5),
-      ([_, distance]) => distance,
-    )[0]?.[0];
+
+    const chosen = chooseStep(label, remainingSteps);
     if (!chosen) {
       result?.addProblem(NonStandardStep, cell, { label });
       return;
     }
-    matchedColumns[chosen] = column;
-
-    remainingSteps = without(remainingSteps, chosen);
+    matchedColumns.set(chosen, column);
+    remainingSteps.delete(chosen);
   });
-  return matchedColumns as Record<Step, Column>;
+  return matchedColumns as ReadonlyMap<Step, Column>;
 }
 
+const chooseStep = (
+  label: string,
+  available: ReadonlySet<Step>,
+): Step | undefined => {
+  const distances = available.values().map((step) => {
+    const humanLabel = startCase(step).replace(' And ', ' & ');
+    const distance = levenshtein.distance(label, humanLabel);
+    return { step, distance };
+  });
+  // Pick the step that is the closest fuzzy match
+  const chosen = sortBy(
+    // 5 is too far ignoring those
+    distances.filter(({ distance }) => distance < 5),
+    ({ distance }) => distance,
+  ).at(0);
+  return chosen?.step;
+};
+
 const NonStandardStep = PnpProblemType.register({
   name: 'NonStandardStep',
   severity: 'Error',

src/components/product-progress/step-progress-extractor.service.ts

@@ -66,8 +66,8 @@ export class StepProgressExtractor {
 const parseProgressRow =
   (
     pnp: Pnp,
-    stepColumns: Record<Step, Column>,
-    planningStepColumns: Record<Step, Column>,
+    stepColumns: ReadonlyMap<Step, Column>,
+    planningStepColumns: ReadonlyMap<Step, Column>,
     result: PnpProgressExtractionResult,
   ) =>
   (cell: Cell<ProgressSheet>, index: number): ExtractedRow => {
@@ -81,7 +81,7 @@ const parseProgressRow =
     const steps = entries(stepColumns).flatMap<StepProgressInput>(
       ([step, column]) => {
         const fiscalYear = pnp.planning.cell(
-          planningStepColumns[step],
+          planningStepColumns.get(step)!,
           planningRow,
         );
 

src/components/product/product.extractor.ts

@@ -81,8 +81,8 @@ export class ProductExtractor {
 const parseProductRow =
   (
     pnp: Pnp,
-    stepColumns: Record<Step, Column>,
-    progressStepColumns: Record<Step, Column>,
+    stepColumns: ReadonlyMap<Step, Column>,
+    progressStepColumns: ReadonlyMap<Step, Column>,
     result: PnpPlanningExtractionResult,
   ) =>
   (cell: Cell<PlanningSheet>, index: number): ExtractedRow => {
@@ -94,7 +94,7 @@ const parseProductRow =
     const steps = entries(stepColumns).flatMap(([step, column]) => {
       const plannedCell = sheet.cell(column, row);
       const progressCell = pnp.progress.cell(
-        progressStepColumns[step],
+        progressStepColumns.get(step)!,
         progressRow,
       );