Refactoring

src/system/footer/shared_2.js

@@ -4,7 +4,8 @@ import mapObj from 'map-obj'
 import omit from 'omit.js'
 import sortOn from 'sort-on'
 
-import { uniqueDeep } from '../../utils/unique.js'
+import { isSameArray } from '../../utils/equal.js'
+import { uniqueDeep, uniqueDeepUnordered } from '../../utils/unique.js'
 
 /* eslint-disable max-nested-callbacks, max-lines-per-function, complexity, max-lines, fp/no-loops, max-statements, max-depth, no-unreachable-loop */
 const mainLogic = function (systems) {
@@ -67,25 +68,14 @@ const getPropGroups = function (propEntries) {
 }
 
 const getUniqueDimensions = function (propEntries) {
-  return propEntries.map(getPropEntryDimensions).filter(isUniqueDimensionsArray)
+  const dimensionsArrays = propEntries.map(getPropEntryDimensions)
+  return uniqueDeepUnordered(dimensionsArrays)
 }
 
 const getPropEntryDimensions = function ({ dimensionsArray }) {
   return dimensionsArray
 }
 
-const isUniqueDimensionsArray = function (
-  dimensionsArray,
-  index,
-  dimensionsArrays,
-) {
-  return dimensionsArrays
-    .slice(index + 1)
-    .every(
-      (dimensionsArrayB) => !isSameArray(dimensionsArray, dimensionsArrayB),
-    )
-}
-
 const getPropGroup = function (dimensionsArray, propEntries) {
   const propEntriesA = propEntries
     .filter(({ dimensionsArray: dimensionsArrayB }) =>
@@ -110,7 +100,7 @@ const reduceEachPropDimensions = function (
   systems,
 ) {
   const dimensionsArrayA = reduceAllPropDimensions(dimensionsArray, systems)
-  const dimensionsArrayB = removeDuplicateDimensions(dimensionsArrayA)
+  const dimensionsArrayB = uniqueDeep(dimensionsArrayA)
   const dimensionsArrayC = normalizeTopSystem(dimensionsArrayB)
   const dimensionsArrayD = appendValues(dimensionsArrayC)
   return { propEntries, dimensionsArray: dimensionsArrayD }
@@ -202,10 +192,6 @@ const isReducibleDimension = function ({
   )
 }
 
-const removeDuplicateDimensions = function (dimensionsArray) {
-  return uniqueDeep(dimensionsArray)
-}
-
 const normalizeTopSystem = function (dimensionsArray) {
   return dimensionsArray.filter(isNotEmptyDimensions)
 }
@@ -367,18 +353,6 @@ const getPropEntry = function ({ propName, propValue }) {
   return [propName, propValue]
 }
 
-const isSameArray = function (arrayA, arrayB) {
-  return (
-    arrayA.length === arrayB.length &&
-    arrayA.every((value) => hasArrayValue(arrayB, value))
-  )
-}
-
-// Like `Array.includes()` but using deep comparison
-const hasArrayValue = function (array, valueA) {
-  return array.some((valueB) => isDeepStrictEqual(valueA, valueB))
-}
-
 const PROP_ORDER = ['aa', 'ff', 'bb', 'cc', 'dd', 'ee', 'gg', 'hh']
 
 const getSystemTitle = function (allDimensions) {

src/utils/equal.js

@@ -0,0 +1,20 @@
+import { isDeepStrictEqual } from 'util'
+
+// Compare two arrays deeply and unorderedly
+export const isSameArray = function (arrayA, arrayB) {
+  if (arrayA.length !== arrayB.length) {
+    return false
+  }
+
+  const matchedIndexes = new Set()
+  return arrayA.every((value) => includesValue(arrayB, value, matchedIndexes))
+}
+
+const includesValue = function (arrayB, value, matchedIndexes) {
+  const foundIndex = arrayB.findIndex(
+    (valueB, index) =>
+      !matchedIndexes.has(index) && isDeepStrictEqual(value, valueB),
+  )
+  matchedIndexes.add(foundIndex)
+  return foundIndex !== -1
+}

src/utils/unique.js

@@ -1,19 +1,27 @@
 import { isDeepStrictEqual } from 'util'
 
+import { isSameArray } from './equal.js'
+
 // Remove duplicate elements using a deep comparison.
 // Uses imperative code for performance.
 // Avoids creating intermediary arrays for memory.
 export const uniqueDeep = function (array) {
-  return array.filter(isUniqueDeep)
+  return array.filter(isUniqueValue.bind(undefined, isDeepStrictEqual))
+}
+
+// Same except arrays are compared as if they were unordered
+export const uniqueDeepUnordered = function (array) {
+  return array.filter(isUniqueValue.bind(undefined, isSameArray))
 }
 
-const isUniqueDeep = function (value, valueIndex, array) {
+// eslint-disable-next-line max-params
+const isUniqueValue = function (isEqual, value, valueIndex, array) {
   // eslint-disable-next-line fp/no-loops, fp/no-mutation, fp/no-let
   for (let index = valueIndex + 1; index < array.length; index += 1) {
     const valueB = array[index]
 
     // eslint-disable-next-line max-depth
-    if (isDeepStrictEqual(value, valueB)) {
+    if (isEqual(value, valueB)) {
       return false
     }
   }