feat: improve error messages when sorting different groups

rules/sort-astro-attributes.ts

@@ -26,7 +26,9 @@ type Group<T extends string[]> =
  | 'unknown'
  | T[number]
 
-type MESSAGE_ID = 'unexpectedAstroAttributesOrder'
+type MESSAGE_ID =
+ | 'unexpectedAstroAttributesGroupOrder'
+ | 'unexpectedAstroAttributesOrder'
 
 type Options<T extends string[]> = [
  Partial<{
@@ -105,6 +107,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedAstroAttributesGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedAstroAttributesOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -201,10 +205,15 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  isPositive(compare(left, right, options)))
  ) {
  context.report({
- messageId: 'unexpectedAstroAttributesOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedAstroAttributesGroupOrder'
+ : 'unexpectedAstroAttributesOrder',
  data: {
  left: left.name,
  right: right.name,
+ leftGroup: left.group,
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => {

rules/sort-imports.ts

@@ -24,6 +24,7 @@ import { compare } from '../utils/compare'
 
 type MESSAGE_ID =
  | 'missedSpacingBetweenImports'
+ | 'unexpectedImportsGroupOrder'
  | 'extraSpacingBetweenImports'
  | 'unexpectedImportsOrder'
 
@@ -190,6 +191,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedImportsGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedImportsOrder: 'Expected "{{right}}" to come before "{{left}}".',
  missedSpacingBetweenImports:
  'Missed spacing between "{{left}}" and "{{right}}" imports.',
@@ -665,10 +668,15 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  isPositive(compare(left, right, options))))
  ) {
  context.report({
- messageId: 'unexpectedImportsOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedImportsGroupOrder'
+ : 'unexpectedImportsOrder',
  data: {
  left: left.name,
+ leftGroup: left.group,
  right: right.name,
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => fix(fixer, nodeList),

rules/sort-interfaces.ts

@@ -19,7 +19,9 @@ import { complete } from '../utils/complete'
 import { pairwise } from '../utils/pairwise'
 import { compare } from '../utils/compare'
 
-type MESSAGE_ID = 'unexpectedInterfacePropertiesOrder'
+type MESSAGE_ID =
+ | 'unexpectedInterfacePropertiesGroupOrder'
+ | 'unexpectedInterfacePropertiesOrder'
 
 type Group<T extends string[]> = 'multiline' | 'unknown' | T[number]
 
@@ -121,6 +123,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedInterfacePropertiesGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedInterfacePropertiesOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -310,11 +314,18 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  for (let nodes of formattedMembers) {
  pairwise(nodes, (left, right, iteration) => {
  if (checkOrder(nodes, left, right, iteration)) {
+ let leftNum = getGroupNumber(options.groups, left)
+ let rightNum = getGroupNumber(options.groups, right)
  context.report({
- messageId: 'unexpectedInterfacePropertiesOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedInterfacePropertiesGroupOrder'
+ : 'unexpectedInterfacePropertiesOrder',
  data: {
  left: toSingleLine(left.name),
+ leftGroup: left.group,
  right: toSingleLine(right.name),
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => {

rules/sort-intersection-types.ts

@@ -15,7 +15,9 @@ import { complete } from '../utils/complete'
 import { pairwise } from '../utils/pairwise'
 import { compare } from '../utils/compare'
 
-type MESSAGE_ID = 'unexpectedIntersectionTypesOrder'
+type MESSAGE_ID =
+ | 'unexpectedIntersectionTypesGroupOrder'
+ | 'unexpectedIntersectionTypesOrder'
 
 type Group =
  | 'intersection'
@@ -91,6 +93,8 @@ export default createEslintRule<Options, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedIntersectionTypesGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedIntersectionTypesOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -215,10 +219,15 @@ export default createEslintRule<Options, MESSAGE_ID>({
  (leftNum === rightNum && isPositive(compare(left, right, options)))
  ) {
  context.report({
- messageId: 'unexpectedIntersectionTypesOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedIntersectionTypesGroupOrder'
+ : 'unexpectedIntersectionTypesOrder',
  data: {
  left: toSingleLine(left.name),
+ leftGroup: left.group,
  right: toSingleLine(right.name),
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => {

rules/sort-jsx-props.ts

@@ -18,7 +18,7 @@ import { pairwise } from '../utils/pairwise'
 import { complete } from '../utils/complete'
 import { compare } from '../utils/compare'
 
-type MESSAGE_ID = 'unexpectedJSXPropsOrder'
+type MESSAGE_ID = 'unexpectedJSXPropsGroupOrder' | 'unexpectedJSXPropsOrder'
 
 type Group<T extends string[]> =
  | 'multiline'
@@ -112,6 +112,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedJSXPropsGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedJSXPropsOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -211,10 +213,15 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  isPositive(compare(left, right, options)))
  ) {
  context.report({
- messageId: 'unexpectedJSXPropsOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedJSXPropsGroupOrder'
+ : 'unexpectedJSXPropsOrder',
  data: {
  left: left.name,
+ leftGroup: left.group,
  right: right.name,
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => {

rules/sort-object-types.ts

@@ -18,7 +18,9 @@ import { complete } from '../utils/complete'
 import { pairwise } from '../utils/pairwise'
 import { compare } from '../utils/compare'
 
-type MESSAGE_ID = 'unexpectedObjectTypesOrder'
+type MESSAGE_ID =
+ | 'unexpectedObjectTypesGroupOrder'
+ | 'unexpectedObjectTypesOrder'
 
 type Group<T extends string[]> = 'multiline' | 'unknown' | T[number]
 
@@ -111,6 +113,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedObjectTypesGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedObjectTypesOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -277,10 +281,15 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
 
  if (compareValue) {
  context.report({
- messageId: 'unexpectedObjectTypesOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedObjectTypesGroupOrder'
+ : 'unexpectedObjectTypesOrder',
  data: {
  left: toSingleLine(left.name),
+ leftGroup: left.group,
  right: toSingleLine(right.name),
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => {

rules/sort-objects.ts

@@ -23,12 +23,13 @@ import { sortNodes } from '../utils/sort-nodes'
 import { complete } from '../utils/complete'
 import { pairwise } from '../utils/pairwise'
 
-type MESSAGE_ID = 'unexpectedObjectsOrder'
+type MESSAGE_ID = 'unexpectedObjectsGroupOrder' | 'unexpectedObjectsOrder'
 
 export enum Position {
  'exception' = 'exception',
  'ignore' = 'ignore',
 }
+
 type Group = 'unknown' | string
 type SortingNodeWithPosition = SortingNodeWithDependencies & {
  position: Position
@@ -155,6 +156,8 @@ export default createEslintRule<Options, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedObjectsGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedObjectsOrder: 'Expected "{{right}}" to come before "{{left}}".',
  },
  },
@@ -435,12 +438,18 @@ export default createEslintRule<Options, MESSAGE_ID>({
  makeFixes(fixer, nodes, sortedNodes, sourceCode, {
  partitionComment: options.partitionByComment,
  })
-
+ let leftNum = getGroupNumber(options.groups, left)
+ let rightNum = getGroupNumber(options.groups, right)
  context.report({
- messageId: 'unexpectedObjectsOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedObjectsGroupOrder'
+ : 'unexpectedObjectsOrder',
  data: {
  left: toSingleLine(left.name),
+ leftGroup: left.group,
  right: toSingleLine(right.name),
+ rightGroup: right.group,
  },
  node: right.node,
  fix,

rules/sort-svelte-attributes.ts

@@ -19,7 +19,9 @@ import { complete } from '../utils/complete'
 import { pairwise } from '../utils/pairwise'
 import { compare } from '../utils/compare'
 
-type MESSAGE_ID = 'unexpectedSvelteAttributesOrder'
+type MESSAGE_ID =
+ | 'unexpectedSvelteAttributesGroupOrder'
+ | 'unexpectedSvelteAttributesOrder'
 
 type Group<T extends string[]> =
  | 'svelte-shorthand'
@@ -105,6 +107,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedSvelteAttributesGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedSvelteAttributesOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -208,10 +212,15 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  isPositive(compare(left, right, options)))
  ) {
  context.report({
- messageId: 'unexpectedSvelteAttributesOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedSvelteAttributesGroupOrder'
+ : 'unexpectedSvelteAttributesOrder',
  data: {
  left: left.name,
+ leftGroup: left.group,
  right: right.name,
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => {

rules/sort-union-types.ts

@@ -15,7 +15,7 @@ import { complete } from '../utils/complete'
 import { pairwise } from '../utils/pairwise'
 import { compare } from '../utils/compare'
 
-type MESSAGE_ID = 'unexpectedUnionTypesOrder'
+type MESSAGE_ID = 'unexpectedUnionTypesGroupOrder' | 'unexpectedUnionTypesOrder'
 
 type Group =
  | 'intersection'
@@ -91,6 +91,8 @@ export default createEslintRule<Options, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedUnionTypesGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedUnionTypesOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -215,10 +217,15 @@ export default createEslintRule<Options, MESSAGE_ID>({
  (leftNum === rightNum && isPositive(compare(left, right, options)))
  ) {
  context.report({
- messageId: 'unexpectedUnionTypesOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedUnionTypesGroupOrder'
+ : 'unexpectedUnionTypesOrder',
  data: {
  left: toSingleLine(left.name),
+ leftGroup: left.group,
  right: toSingleLine(right.name),
+ rightGroup: right.group,
  },
  node: right.node,
  fix: fixer => {

rules/sort-vue-attributes.ts

@@ -18,7 +18,9 @@ import { complete } from '../utils/complete'
 import { pairwise } from '../utils/pairwise'
 import { compare } from '../utils/compare'
 
-type MESSAGE_ID = 'unexpectedVueAttributesOrder'
+type MESSAGE_ID =
+ | 'unexpectedVueAttributesGroupOrder'
+ | 'unexpectedVueAttributesOrder'
 
 type Group<T extends string[]> =
  | 'multiline'
@@ -103,6 +105,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  },
  ],
  messages: {
+ unexpectedVueAttributesGroupOrder:
+ 'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
  unexpectedVueAttributesOrder:
  'Expected "{{right}}" to come before "{{left}}".',
  },
@@ -212,10 +216,15 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
  isPositive(compare(left, right, options)))
  ) {
  context.report({
- messageId: 'unexpectedVueAttributesOrder',
+ messageId:
+ leftNum !== rightNum
+ ? 'unexpectedVueAttributesGroupOrder'
+ : 'unexpectedVueAttributesOrder',
  data: {
  left: left.name,
+ leftGroup: left.group,
  right: right.name,
+ rightGroup: right.group,
  },
  // @ts-ignore
  node: right.node,