Bug: Incorrect Sorting of Numeric Object Keys

[AmanDevUI]

Describe the bug

When sorting objects that contain numeric keys, the rule sorts them as strings, not as numbers, resulting in incorrect ordering (e.g., 10 is placed after 1 instead of after 9).

Code example

Input code:
export const MASK_OBJECT = {
1: '999-999-9999',
2: '999 999 9999',
3: '(999) 999-9999',
4: '(999) 999 9999',
5: '(99) 9999-9999',
6: '9999999999',
7: '99999 999 999',
8: '9999 999 9999',
9: '999 9999 9999',
10: '99 99999-9999',
};

Current (Incorrect) Behavior
The rule automatically rearranges the keys as:
export const MASK_OBJECT = {
1: '999-999-9999',
10: '99 99999-9999',
2: '999 999 9999',
3: '(999) 999-9999',
4: '(999) 999 9999',
5: '(99) 9999-9999',
6: '9999999999',
7: '99999 999 999',
8: '9999 999 9999',
9: '999 9999 9999',
};

Expected Behavior
Numeric keys should be sorted in natural numeric order, not lexicographically:
export const MASK_OBJECT = {
1: '999-999-9999',
2: '999 999 9999',
3: '(999) 999-9999',
4: '(999) 999 9999',
5: '(99) 9999-9999',
6: '9999999999',
7: '99999 999 999',
8: '9999 999 9999',
9: '999 9999 9999',
10: '99 99999-9999',
};

Why This Matters
This string-based sorting makes numeric keys confusing and less readable, especially when there are multiple two-digit or higher keys.

It would be great if the rule could:

• Detect purely numeric keys, and
• Sort them using numeric order instead of string order.

ESLint version

v9.38.0

ESLint Plugin Perfectionist version

v4.15.1

Additional comments

Additional Context
This issue becomes more noticeable when working with configuration objects, masks, or enum-like constants using numeric keys.

Validations

• Read the docs.
• Check that there isn't already an issue that reports the same bug to avoid creating a duplicate.

[hugop95]

Hi @AmanDevUI

Please use the natural sort type. This should automatically resolve your issue.

[karanrampal04]

Hi @hugop95, I'm facing this issue as well. Still, what you have suggested can work if I only need natural type sort, In my project I need to sort the object on 'alphabetical' order. Still, there are few objects which has numeric keys, and they can't be changed to strings. Hence, the majority needs 'alphabetical', but then a few objects show that behaviour which @AmanDevUI already mentioned, so tell me what I should do in this situation?

[hugop95]

Hi @karanrampal04

In my project I need to sort the object on 'alphabetical' order

Could you provide with use cases on why the alphabetical sort is better than natural in your context ?

natural sorting is naturally (no pun intented) suited for number sorting, so implementing number sorting within the alphabetical sort is counter-intuitive.

[AmanDevUI]

Thanks for your reply, @hugop95

I understand that the natural sort type is intended for handling numeric keys properly.
However, in real-world projects, we often use alphabetical sorting as a global convention, and we can’t switch to natural globally because:

The majority of objects in our codebase follow alphabetical order,

Only a few specific objects (like constant maps or enums) contain numeric keys,

Changing the sort type globally just for those few cases would break consistency elsewhere.

So the issue here is not that natural sorting doesn’t work it’s that the alphabetical sort type could handle numeric keys more gracefully when they exist.
Maybe it can skip string-based comparison when all keys are numeric or cast them to numbers internally.

Essentially, this could be a configurable enhancement inside the rule rather than requiring users to switch sort types globally or install another package.

Would it make sense to consider this as an optional enhancement (e.g., ignoreNumericKeys: true or numericHandling: "auto") for the alphabetical type?

[hugop95]

@AmanDevUI

Thank you for the explanation.

---

Changing the sort type globally just for those few cases would break consistency elsewhere.

I'm genuinely curious regarding this: the package that we use for natural sorting shouldn't have much difference with alphabetical sorting outside of specific cases (number/dates, etc). So I'm interested in seeing the actual consistency break when switching from alphabetical to natural.

---

Essentially, this could be a configurable enhancement inside the rule rather than requiring users to switch sort types globally or install another package.

Would it make sense to consider this as an optional enhancement (e.g., ignoreNumericKeys: true or numericHandling: "auto") for the alphabetical type?

Should an implementation be done, I would rather go with a more generic approach by exposing a useConfigurationIf.hasNumericKeysOnly: boolean flag, and allowing the user to use type: 'natural' in that configuration.

{
  options: [
    {
      type: "natural",
      useConfigurationIf: {
        hasNumericKeysOnly: true
      }
    },
    {
       // Other configs
    }
  ]
}

[AmanDevUI]

Thanks a lot for the detailed explanation @hugop95, it really appreciate your openness to this idea
Your proposed approach with:

useConfigurationIf: { hasNumericKeysOnly: true }

sounds like a great solution 👍
It would let teams continue using alphabetical globally but automatically switch to natural when numeric-only keys are detected exactly solving the pain point we’ve described.

Could you please share if there’s any expected timeline or plan for when this might be implemented?
We’d be happy to help test or verify the behavior once it’s available.

[karanrampal04]

Hey @hugop95, the approach you suggested sounds like a good option to opt for, so are you guys going to implement that solution for numeric keys with type: 'alphabetical'?

[hugop95]

@AmanDevUI

Could you please share if there’s any expected timeline or plan for when this might be implemented?

This is going to be included in the V5 release. There is no fixed release ETA as of today.

---

@karanrampal04

The solution is type-independent: the idea is to allow users to setup a priority configuration that is used only when an object has numeric keys. Users should put type: "natural" on this configuration to have numeric objects sorted correctly.

{
  options: [
    {
      type: "natural",
      useConfigurationIf: {
        hasNumericKeysOnly: true
      }
    },
    {
       type: "alphabetical" // Config only applied to objects that don't have numeric keys only
    }
  ]
}