Preserve source iteration order in cloneCustomUnitWithNewIDs

The previous version inserted non-default rates first and the rebound
default last. When a non-default source rate had no `index` field
(treated as CONST.DEFAULT_NUMBER_ID = 0 by getDefaultMileageRate's
sort), it tied with the default's index 0, and JavaScript's stable
sort then placed whichever came first in iteration order. With
non-defaults inserted first, the default fell behind — so the rate
the expense flow treated as default in the duplicated workspace was
the no-index rate, not the original default.

Iterate source rates in their original order and just swap the
default's key to newDefaultRateID. The default keeps its first-tied
position in the rates dict, getDefaultMileageRate's stable sort
behaves as it does on the source, and the original default is picked.

Author: wildan-m

src/libs/PolicyUtils.ts

@@ -306,19 +306,20 @@ function cloneCustomUnitWithNewIDs(unit: CustomUnit, newCustomUnitID: string, ne
         // rate the expense flow will later treat as default. Non-default rates keep their source
         // IDs so they remain visible offline; successData clears them after the API succeeds so
         // the server response can repopulate with fresh server IDs without leaving duplicates.
+        // Iteration order is preserved from the source (default's key swapped in place) so
+        // getDefaultMileageRate's stable sort still picks the original default when other rates
+        // have a missing index (which would otherwise tie at CONST.DEFAULT_NUMBER_ID).
         const defaultRate = Object.values(unit.rates)
             .filter((rate) => rate.enabled !== false)
             .sort((a, b) => (a.index ?? CONST.DEFAULT_NUMBER_ID) - (b.index ?? CONST.DEFAULT_NUMBER_ID))
             .at(0);
         const rates: Record<string, Rate> = {};
         for (const rate of Object.values(unit.rates)) {
             if (rate.customUnitRateID === defaultRate?.customUnitRateID) {
-                continue;
+                rates[newDefaultRateID] = {...rate, customUnitRateID: newDefaultRateID};
+            } else {
+                rates[rate.customUnitRateID] = rate;
             }
-            rates[rate.customUnitRateID] = rate;
-        }
-        if (defaultRate) {
-            rates[newDefaultRateID] = {...defaultRate, customUnitRateID: newDefaultRateID};
         }
         return {
             ...unit,

tests/unit/PolicyUtilsTest.ts

@@ -433,6 +433,51 @@ describe('PolicyUtils', () => {
                 newRate: {customUnitRateID: 'newRate', name: 'No-Index Rate', rate: 70, currency: 'USD', enabled: true},
             });
         });
+
+        it('preserves source iteration order so getDefaultMileageRate still picks the original default when a non-default rate has a missing index', () => {
+            // Source has 3 rates: Default (index 0), Indexed (index 1), and No-Index (no index field).
+            // No-Index ties with Default at the index-0 sort key after `?? CONST.DEFAULT_NUMBER_ID`.
+            // The optimistic clone must keep the source's iteration order so JavaScript's stable
+            // sort still places Default before No-Index — otherwise getDefaultMileageRate would
+            // pick whichever tied rate appeared first in iteration order, swapping the default.
+            const sourceUnit = {
+                customUnitID: 'srcDist',
+                name: CONST.CUSTOM_UNITS.NAME_DISTANCE,
+                enabled: true,
+                attributes: {unit: CONST.CUSTOM_UNITS.DISTANCE_UNIT_MILES},
+                rates: {
+                    rateA: {customUnitRateID: 'rateA', name: 'Default Rate', rate: 72.5, currency: 'USD', enabled: true, index: 0},
+                    rateB: {customUnitRateID: 'rateB', name: 'Indexed Rate', rate: 100, currency: 'USD', enabled: true, index: 1},
+                    rateC: {customUnitRateID: 'rateC', name: 'No-Index Rate', rate: 200, currency: 'USD', enabled: true},
+                },
+            };
+            const policyWithTiedIndex: Policy = {
+                ...createRandomPolicy(0),
+                customUnits: {[sourceUnit.customUnitID]: sourceUnit},
+            };
+            const result = getCustomUnitsForDuplication(policyWithTiedIndex, true, false, {
+                distanceCustomUnitID: 'newDist',
+                perDiemCustomUnitID: 'newPerDiem',
+                customUnitRateID: 'newRate',
+            });
+
+            const cloned = result?.newDist;
+            if (!cloned) {
+                throw new Error('Expected cloned distance unit');
+            }
+            // Iteration order: the rebound default should still be first, before the No-Index rate.
+            const orderedKeys = Object.keys(cloned.rates);
+            expect(orderedKeys).toEqual(['newRate', 'rateB', 'rateC']);
+
+            // Sanity-check that getDefaultMileageRate's selection (enabled, sorted by index ?? 0,
+            // first) lands on the rebound default and not on No-Index Rate.
+            const pickedDefault = Object.values(cloned.rates)
+                .filter((rate) => rate.enabled !== false)
+                .sort((a, b) => (a.index ?? CONST.DEFAULT_NUMBER_ID) - (b.index ?? CONST.DEFAULT_NUMBER_ID))
+                .at(0);
+            expect(pickedDefault?.customUnitRateID).toBe('newRate');
+            expect(pickedDefault?.name).toBe('Default Rate');
+        });
     });
     describe('getRateDisplayValue', () => {
         it('should return an empty string for NaN', () => {