fix: sort-keys autofix fully sorts keys in a single pass

src/rules/sort-keys.js

@@ -215,23 +215,20 @@ const rule = {
 
 		return {
 			Object(node) {
+				if (node.members.length < minKeys) {
+					return;
+				}
+
 				/** @type {MemberNode} */
 				let prevMember;
 				/** @type {string} */
 				let prevName;
 				/** @type {string} */
 				let prevRawName;
 
-				if (node.members.length < minKeys) {
-					return;
-				}
-
 				for (const member of node.members) {
 					const thisName = getKey(member);
 					const thisRawName = getRawKey(member, sourceCode);
-					// Capture `prevMember` for this iteration so the fixer closure uses the
-					// intended node even though `prevMember` is reassigned in the loop.
-					const prevMemberNode = prevMember;
 
 					if (
 						prevMember &&
@@ -250,25 +247,80 @@ const rule = {
 								sortName,
 							},
 							fix(fixer) {
-								if (
-									hasAdjacentComment(member) ||
-									hasAdjacentComment(prevMemberNode)
-								) {
-									return null;
+								let group = node.members;
+
+								if (allowLineSeparatedGroups) {
+									let start = node.members.indexOf(member);
+									while (
+										start > 0 &&
+										!isLineSeparated(
+											node.members[start - 1],
+											node.members[start],
+										)
+									) {
+										start--;
+									}
+									let end = node.members.indexOf(member);
+									while (
+										end < node.members.length - 1 &&
+										!isLineSeparated(
+											node.members[end],
+											node.members[end + 1],
+										)
+									) {
+										end++;
+									}
+									group = node.members.slice(start, end + 1);
 								}
 
-								return [
-									fixer.replaceText(
-										member,
-										sourceCode.getText(prevMemberNode),
-									),
-									fixer.replaceText(
-										prevMemberNode,
-										sourceCode.getText(member),
-									),
-								];
+								const sortedGroup = group.toSorted((a, b) => {
+									const nameA = getKey(a);
+									const nameB = getKey(b);
+
+									if (nameA === nameB) {
+										return 0;
+									}
+
+									const aFirst = isValidOrder(nameA, nameB);
+									const bFirst = isValidOrder(nameB, nameA);
+
+									if (aFirst && bFirst) {
+										return 0;
+									}
+									return aFirst ? -1 : 1;
+								});
+
+								const fixes = [];
+								for (let i = 0; i < group.length; i++) {
+									const origMember = group[i];
+									const replacementMember = sortedGroup[i];
+
+									if (origMember === replacementMember) {
+										continue;
+									}
+
+									if (
+										hasAdjacentComment(origMember) ||
+										hasAdjacentComment(replacementMember)
+									) {
+										return null;
+									}
+
+									fixes.push(
+										fixer.replaceText(
+											origMember,
+											sourceCode.getText(
+												replacementMember,
+											),
+										),
+									);
+								}
+
+								return fixes;
 							},
 						});
+
+						break;
 					}
 
 					prevMember = member;