Improve sorting

src/combination/dimensions.js

@@ -44,8 +44,9 @@ const isUniqueCombDimension = function (combDimension, index, combDimensions) {
 // Retrieve one combination's dimensions.
 // Array order follows:
 //  - `DIMENSIONS` order
-//  - For dynamic dimensions, property order, i.e. user order specified in
-//    configuration
+//  - For dynamic dimensions, property order by lexicographic order
+//     - We do not use the configuration property order because it is too hard
+//       to implement
 export const getCombDimensions = function (combination) {
   return DIMENSIONS.flatMap((dimension) => getDimension(combination, dimension))
 }
@@ -57,8 +58,10 @@ const getDimension = function (
   { dimensions },
   { propName: dimensionPropName, prefixName, createdByUser },
 ) {
+  // eslint-disable-next-line fp/no-mutating-methods
   return Object.keys(dimensions)
     .filter((propName) => isDimension(propName, dimensionPropName, prefixName))
+    .sort()
     .map((propName) => ({
       propName,
       messageName: getMessageName(propName, prefixName),

src/system/footer/main.js

@@ -23,7 +23,7 @@ export const addFooter = function ({
   const footerA = omitFooterProps(footer, showMetadata, showSystem)
   const footerB = serializeFooter(footerA)
   const footerC = addSharedSystems(footerB)
-  const footerD = sortSystems(footerC, system)
+  const footerD = sortSystems(footerC)
   const footerE = addFooterTitles(footerD, titles, showTitles)
   const footerF = addSystemsTitles(footerE)
   const { footerParams, footerString } = applyFooterFormat(footerF, format)

src/system/footer/shared/redundant.js

@@ -18,19 +18,14 @@ export const skipRedundantInfo = function (dimensionsArray, systems) {
   )
 }
 
-// Sometimes, removing dimensions can result in several equivalent but different
-// result depending on the order in which dimensions are iterated.
-//  - We iterate from the last to the first dimensions, so that the last
-//    dimensions are removed instead of the first ones, since the first ones
-//    are more likely to be more significant for users.
 // eslint-disable-next-line max-params
 const skipRedundantDimensions = function (
   systems,
   dimensionsArray,
   dimensions,
   index,
 ) {
-  return Object.keys(dimensions).reduceRight(
+  return Object.keys(dimensions).reduce(
     skipRedundantDimension.bind(undefined, { systems, index }),
     dimensionsArray,
   )

src/system/footer/sort/dimensions.js

@@ -1,39 +1,25 @@
 import sortOn from 'sort-on'
 
-export const sortDimensionsArray = function (dimensionsArray, dimensionNames) {
+export const sortDimensionsArray = function (dimensionsArray) {
   // eslint-disable-next-line fp/no-mutating-methods
   return dimensionsArray
-    .map(sortDimensionsEntries.bind(undefined, dimensionNames))
+    .map(sortDimensionsEntries)
     .sort(compareDimensionsEntries)
 }
 
 // Sort each dimension within a given `dimensions` by its dimension name.
 // Then sort each dimension value's array item.
-const sortDimensionsEntries = function (dimensionNames, dimensionsEntries) {
-  const dimensionsEntriesA = dimensionsEntries.map((dimensionsEntry) =>
-    addDimensionNameOrder(dimensionsEntry, dimensionNames),
-  )
-  const dimensionsEntriesB = sortOn(dimensionsEntriesA, ['2'])
-  return dimensionsEntriesB.map(sortDimensionValueArray)
-}
-
-const addDimensionNameOrder = function (
-  [dimensionName, dimensionValueArray],
-  dimensionNames,
-) {
-  const dimensionNameIndex = dimensionNames.indexOf(dimensionName)
-  const dimensionNameOrder =
-    dimensionNameIndex === -1 ? Number.POSITIVE_INFINITY : dimensionNameIndex
-  return [dimensionName, dimensionValueArray, dimensionNameOrder]
+const sortDimensionsEntries = function (dimensionsEntries) {
+  const dimensionsEntriesA = sortOn(dimensionsEntries, ['0'])
+  return dimensionsEntriesA.map(sortDimensionValueArray)
 }
 
 const sortDimensionValueArray = function ([
   dimensionName,
   dimensionValueArray,
-  dimensionNameOrder,
 ]) {
   // eslint-disable-next-line fp/no-mutating-methods
-  return [dimensionName, [...dimensionValueArray].sort(), dimensionNameOrder]
+  return [dimensionName, [...dimensionValueArray].sort()]
 }
 
 // Sort the `dimensions` in each system's title, when it has several:
@@ -71,14 +57,14 @@ const compareDimensionsEntries = function (
 
 // eslint-disable-next-line complexity
 const compareDimensionsEntry = function (
-  [, dimensionValueArrayA, dimensionNameOrderA],
-  [, dimensionValueArrayB, dimensionNameOrderB],
+  [dimensionNameA, dimensionValueArrayA],
+  [dimensionNameB, dimensionValueArrayB],
 ) {
-  if (dimensionNameOrderA > dimensionNameOrderB) {
+  if (dimensionNameA > dimensionNameB) {
     return 1
   }
 
-  if (dimensionNameOrderA < dimensionNameOrderB) {
+  if (dimensionNameA < dimensionNameB) {
     return -1
   }
 

src/system/footer/sort/main.js

@@ -1,31 +1,25 @@
 import { sortDimensionsArray } from './dimensions.js'
-import { getDimensionNames } from './dimensions_names.js'
 import { addPropOrder, sortPropEntries, removePropOrder } from './props.js'
 import { compareSystems } from './systems.js'
 
 // Sort systems deeply so they are shown in a user-friendly and predictable way
 // in the footer
-export const sortSystems = function (footer, firstSystem) {
-  const dimensionNames = getDimensionNames(firstSystem, footer.systems)
+export const sortSystems = function (footer) {
   // eslint-disable-next-line fp/no-mutating-methods
   const systems = footer.systems
-    .map((system) => addSortProps(system, dimensionNames))
+    .map(addSortProps)
     .sort(compareSystems)
     .map(removeSortProps)
   return { ...footer, systems }
 }
 
 // Add properties used during sorting so they are only computed once
-const addSortProps = function (
-  { dimensions: dimensionsArray, props },
-  dimensionNames,
-) {
+const addSortProps = function ({ dimensions: dimensionsArray, props }) {
   const isTopSystem = dimensionsArray.length === 0
   const propEntries = Object.entries(props).map(addPropOrder)
   const propEntriesA = sortPropEntries(propEntries)
   const dimensionsArrayA = sortDimensionsArray(
     dimensionsArray.map(Object.entries),
-    dimensionNames,
   )
   return {
     isTopSystem,