Refactoring

src/combination/result.js

@@ -1,29 +1,29 @@
 import { getCombinationIds } from './ids/get.js'
 
-// Filter out the `combinations` that are not in `result`
-export const keepResultCombinations = function (resultA, resultB) {
-  const combinations = resultA.combinations.filter((combination) =>
-    resultHasCombination(resultB, combination),
+// Filter out the `result.combinations` that are not in `combinations`
+export const keepResultCombinations = function (result, combinations) {
+  const combinationsA = result.combinations.filter((combination) =>
+    hasCombination(combinations, combination),
   )
-  return { ...resultA, combinations }
+  return { ...result, combinations: combinationsA }
 }
 
-// Filter out the `combinations` that are in `result`
-export const removeResultCombinations = function (combinations, result) {
-  return combinations.filter(
-    (combination) => !resultHasCombination(result, combination),
+// Filter out the `combinationsA` that are in `combinationsB`
+export const removeSameCombinations = function (combinationsA, combinations) {
+  return combinationsA.filter(
+    (combination) => !hasCombination(combinations, combination),
   )
 }
 
 // Return whether a result combinations is a subset of another
-export const hasSameCombinations = function ({ combinations }, result) {
-  return combinations.every((combination) =>
-    resultHasCombination(result, combination),
+export const hasSameCombinations = function (resultA, resultB) {
+  return resultA.combinations.every((combination) =>
+    hasCombination(resultB.combinations, combination),
   )
 }
 
 // Return whether a result has a specific combination
-const resultHasCombination = function ({ combinations }, combination) {
+const hasCombination = function (combinations, combination) {
   return getMatchingCombination(combinations, combination) !== undefined
 }
 

src/history/merge/results.js

@@ -3,7 +3,7 @@ import sortOn from 'sort-on'
 
 import { addDefaultIds } from '../../combination/default.js'
 import {
-  removeResultCombinations,
+  removeSameCombinations,
   hasSameCombinations,
 } from '../../combination/result.js'
 import { mergeSystems } from '../../top/system/merge.js'
@@ -117,9 +117,9 @@ const mergeDimensions = function (rawResult, previousRawResult) {
 }
 
 const mergeCombinations = function (rawResult, previousRawResult) {
-  const previousCombinations = removeResultCombinations(
+  const previousCombinations = removeSameCombinations(
     previousRawResult.combinations,
-    rawResult,
+    rawResult.combinations,
   )
   const combinations = [...rawResult.combinations, ...previousCombinations]
   return { ...rawResult, combinations }

src/report/normalize/raw.js

@@ -36,17 +36,18 @@ export const normalizeReportedResults = function (
     targetResult,
   )
   const targetResultB = selectResult(targetResultA, select)
-  const historyB = addDefaultIds(historyA, targetResultB.combinations)
-  const historyC = filterUnusedCombinations(historyB, targetResultB)
-  const noDimensions = getNoDimensions(targetResultB.combinations)
+  const { combinations } = targetResultB
+  const historyB = addDefaultIds(historyA, combinations)
+  const historyC = filterUnusedCombinations(historyB, combinations)
+  const noDimensions = getNoDimensions(combinations)
   return { result: targetResultB, history: historyC, noDimensions }
 }
 
 // We ignore the combinations from history results that do not exist in the
 // target result.
 // This simplifies both the implementation and the user experience.
-const filterUnusedCombinations = function (history, targetResult) {
+const filterUnusedCombinations = function (history, combinations) {
   return history.map((historyResult) =>
-    keepResultCombinations(historyResult, targetResult),
+    keepResultCombinations(historyResult, combinations),
   )
 }