eslint-plugin-absolute 0.2.0 → 0.2.2

package/src/rules/sort-keys-fixable.ts

@@ -1,19 +1,19 @@
 import { TSESLint, TSESTree } from "@typescript-eslint/utils";
 
 /**
- * @fileoverview Enforce sorted keys in object literals (like ESLint’s built-in sort-keys)
+ * @fileoverview Enforce sorted keys in object literals (like ESLint's built-in sort-keys)
  * with an auto-fix for simple cases that preserves comments.
  *
  * Note: This rule reports errors just like the original sort-keys rule.
- * However, the auto-fix only applies if all properties are “fixable” – i.e.:
+ * However, the auto-fix only applies if all properties are "fixable" – i.e.:
  *  - They are of type Property (not SpreadElement, etc.)
  *  - They are not computed (e.g. [foo])
  *  - They are an Identifier or a Literal.
  *
  * Comments attached to the properties are preserved in the auto-fix.
  *
- * Use this rule with a grain of salt. I did not test every edge case and there’s
- * a reason the original rule doesn’t have auto-fix. Computed keys, spread elements,
+ * Use this rule with a grain of salt. I did not test every edge case and there's
+ * a reason the original rule doesn't have auto-fix. Computed keys, spread elements,
  * comments, and formatting are not handled perfectly.
  */
 
@@ -34,51 +34,107 @@ type KeyInfo = {
 	isFunction: boolean;
 };
 
-export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"enforce sorted keys in object literals with auto-fix (limited to simple cases, preserving comments)"
-		},
-		fixable: "code",
-		// The schema supports the same options as the built-in sort-keys rule plus:
-		//   variablesBeforeFunctions: boolean (when true, non-function properties come before function properties)
-		schema: [
-			{
-				type: "object",
-				properties: {
-					order: {
-						type: "string",
-						enum: ["asc", "desc"]
-					},
-					caseSensitive: {
-						type: "boolean"
-					},
-					natural: {
-						type: "boolean"
-					},
-					minKeys: {
-						type: "integer",
-						minimum: 2
-					},
-					variablesBeforeFunctions: {
-						type: "boolean"
-					}
-				},
-				additionalProperties: false
-			}
-		],
-		messages: {
-			unsorted: "Object keys are not sorted."
+const SORT_BEFORE = -1;
+
+const hasDuplicateNames = (names: Array<string | null>) => {
+	const seen = new Set<string>();
+	const nonNullNames = names.flatMap((name) => (name === null ? [] : [name]));
+
+	for (const name of nonNullNames) {
+		if (seen.has(name)) {
+			return true;
 		}
-	},
+		seen.add(name);
+	}
 
-	defaultOptions: [{}],
+	return false;
+};
+
+const isSafeStaticTemplate = (node: TSESTree.TemplateLiteral) =>
+	node.expressions.length === 0;
+
+const isSafeArrayElement: (node: TSESTree.Node | null) => boolean = (node) => {
+	if (!node || node.type === "SpreadElement") {
+		return false;
+	}
+
+	return isSafeToReorderExpression(node);
+};
+
+const isSafeObjectProperty: (
+	property: TSESTree.ObjectExpression["properties"][number]
+) => boolean = (property) => {
+	if (
+		property.type !== "Property" ||
+		property.computed ||
+		property.kind !== "init"
+	) {
+		return false;
+	}
+
+	if (property.key.type !== "Identifier" && property.key.type !== "Literal") {
+		return false;
+	}
+
+	if (property.method) {
+		return true;
+	}
+
+	return isSafeToReorderExpression(property.value);
+};
+
+const isSafeToReorderExpression: (node: TSESTree.Node | null) => boolean = (
+	node
+) => {
+	if (!node || node.type === "PrivateIdentifier") {
+		return false;
+	}
+
+	switch (node.type) {
+		case "Identifier":
+		case "Literal":
+		case "ThisExpression":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression":
+		case "ClassExpression":
+			return true;
+		case "TemplateLiteral":
+			return isSafeStaticTemplate(node);
+		case "UnaryExpression":
+			return isSafeToReorderExpression(node.argument);
+		case "ArrayExpression":
+			return node.elements.every(isSafeArrayElement);
+		case "ObjectExpression":
+			return node.properties.every(isSafeObjectProperty);
+		default:
+			return false;
+	}
+};
+
+const isSafeJSXAttributeValue = (value: TSESTree.JSXAttribute["value"]) => {
+	if (value === null) {
+		return true;
+	}
+
+	if (value.type === "Literal") {
+		return true;
+	}
+
+	if (value.type !== "JSXExpressionContainer") {
+		return false;
+	}
+
+	if (value.expression.type === "JSXEmptyExpression") {
+		return false;
+	}
+
+	return isSafeToReorderExpression(value.expression);
+};
 
+export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 	create(context) {
-		const sourceCode = context.sourceCode;
-		const option = context.options[0];
+		const { sourceCode } = context;
+		const [option] = context.options;
 
 		const order: "asc" | "desc" =
 			option && option.order ? option.order : "asc";
@@ -105,110 +161,153 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 		 * Compare two key strings based on the provided options.
 		 * This function mimics the behavior of the built-in rule.
 		 */
-		function compareKeys(a: string, b: string) {
-			let keyA = a;
-			let keyB = b;
+		const compareKeys = (keyLeft: string, keyRight: string) => {
+			let left = keyLeft;
+			let right = keyRight;
 
 			if (!caseSensitive) {
-				keyA = keyA.toLowerCase();
-				keyB = keyB.toLowerCase();
+				left = left.toLowerCase();
+				right = right.toLowerCase();
 			}
 
 			if (natural) {
-				return keyA.localeCompare(keyB, undefined, {
+				return left.localeCompare(right, undefined, {
 					numeric: true
 				});
 			}
 
-			return keyA.localeCompare(keyB);
-		}
+			return left.localeCompare(right);
+		};
 
 		/**
 		 * Determines if a property is a function property.
 		 */
-		function isFunctionProperty(prop: TSESTree.Property) {
-			const value = prop.value;
+		const isFunctionProperty = (prop: TSESTree.Property) => {
+			const { value } = prop;
 			return (
-				!!value &&
+				Boolean(value) &&
 				(value.type === "FunctionExpression" ||
 					value.type === "ArrowFunctionExpression" ||
 					prop.method === true)
 			);
-		}
+		};
 
 		/**
 		 * Safely extracts a key name from a Property that we already know
 		 * only uses Identifier or Literal keys in the fixer.
 		 */
-		function getPropertyKeyName(prop: TSESTree.Property) {
-			const key = prop.key;
+		const getPropertyKeyName = (prop: TSESTree.Property) => {
+			const { key } = prop;
 			if (key.type === "Identifier") {
 				return key.name;
 			}
 			if (key.type === "Literal") {
-				const value = key.value;
+				const { value } = key;
 				if (typeof value === "string") {
 					return value;
 				}
 				return String(value);
 			}
 			return "";
-		}
+		};
 
 		/**
 		 * Get leading comments for a property, excluding any comments that
 		 * are on the same line as the previous property (those are trailing
 		 * comments of the previous property).
 		 */
-		function getLeadingComments(
+		const getLeadingComments = (
 			prop: TSESTree.Property,
 			prevProp: TSESTree.Property | null
-		): TSESTree.Comment[] {
+		) => {
 			const comments = sourceCode.getCommentsBefore(prop);
 			if (!prevProp || comments.length === 0) {
 				return comments;
 			}
 			// Filter out comments on the same line as the previous property
 			return comments.filter(
-				(c) => c.loc.start.line !== prevProp.loc.end.line
+				(comment) => comment.loc.start.line !== prevProp.loc.end.line
 			);
-		}
+		};
 
 		/**
 		 * Get trailing comments for a property that are on the same line.
 		 * This includes both getCommentsAfter AND any getCommentsBefore of the
 		 * next property that are on the same line as this property.
 		 */
-		function getTrailingComments(
+		const getTrailingComments = (
 			prop: TSESTree.Property,
 			nextProp: TSESTree.Property | null
-		): TSESTree.Comment[] {
+		) => {
 			const after = sourceCode
 				.getCommentsAfter(prop)
-				.filter((c) => c.loc.start.line === prop.loc.end.line);
-			if (nextProp) {
-				const beforeNext = sourceCode.getCommentsBefore(nextProp);
-				const trailingOfPrev = beforeNext.filter(
-					(c) => c.loc.start.line === prop.loc.end.line
+				.filter(
+					(comment) => comment.loc.start.line === prop.loc.end.line
 				);
-				// Merge, avoiding duplicates
-				for (const c of trailingOfPrev) {
-					if (!after.some((a) => a.range[0] === c.range[0])) {
-						after.push(c);
-					}
-				}
+			if (!nextProp) {
+				return after;
 			}
+
+			const beforeNext = sourceCode.getCommentsBefore(nextProp);
+			const trailingOfPrev = beforeNext.filter(
+				(comment) => comment.loc.start.line === prop.loc.end.line
+			);
+			// Merge, avoiding duplicates
+			const newComments = trailingOfPrev.filter(
+				(comment) =>
+					!after.some(
+						(existing) => existing.range[0] === comment.range[0]
+					)
+			);
+			after.push(...newComments);
 			return after;
-		}
+		};
+
+		const getChunkStart = (
+			idx: number,
+			fixableProps: TSESTree.Property[],
+			rangeStart: number,
+			fullStart: number
+		) => {
+			if (idx === 0) {
+				return rangeStart;
+			}
+
+			const prevProp = fixableProps[idx - 1]!;
+			const currentProp = fixableProps[idx]!;
+			const prevTrailing = getTrailingComments(prevProp, currentProp);
+			const prevEnd =
+				prevTrailing.length > 0
+					? prevTrailing[prevTrailing.length - 1]!.range[1]
+					: prevProp.range[1];
+			// Find the comma after the previous property/comments
+			const allTokens = sourceCode.getTokensBetween(
+				prevProp,
+				currentProp,
+				{
+					includeComments: false
+				}
+			);
+			const tokenAfterPrev =
+				allTokens.find((tok) => tok.range[0] >= prevEnd) ?? null;
+			if (
+				tokenAfterPrev &&
+				tokenAfterPrev.value === "," &&
+				tokenAfterPrev.range[1] <= fullStart
+			) {
+				return tokenAfterPrev.range[1];
+			}
+			return prevEnd;
+		};
 
 		/**
 		 * Build the sorted text from the fixable properties while preserving
 		 * comments and formatting.
 		 */
-		function buildSortedText(
+		const buildSortedText = (
 			fixableProps: TSESTree.Property[],
 			rangeStart: number
-		) {
+		) => {
 			// For each property, capture its "chunk": the property text plus
 			// its associated comments (leading comments on separate lines,
 			// trailing comments on the same line).
@@ -217,11 +316,13 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				text: string;
 			}[] = [];
 
-			for (let i = 0; i < fixableProps.length; i++) {
-				const prop = fixableProps[i]!;
-				const prevProp = i > 0 ? fixableProps[i - 1]! : null;
+			for (let idx = 0; idx < fixableProps.length; idx++) {
+				const prop = fixableProps[idx]!;
+				const prevProp = idx > 0 ? fixableProps[idx - 1]! : null;
 				const nextProp =
-					i < fixableProps.length - 1 ? fixableProps[i + 1]! : null;
+					idx < fixableProps.length - 1
+						? fixableProps[idx + 1]!
+						: null;
 
 				const leading = getLeadingComments(prop, prevProp);
 				const trailing = getTrailingComments(prop, nextProp);
@@ -233,52 +334,31 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 						? trailing[trailing.length - 1]!.range[1]
 						: prop.range[1];
 
-				// Find the chunk start (after previous property's separator)
-				let chunkStart: number;
-				if (i === 0) {
-					chunkStart = rangeStart;
-				} else {
-					const prevTrailing = getTrailingComments(prevProp!, prop);
-					const prevEnd =
-						prevTrailing.length > 0
-							? prevTrailing[prevTrailing.length - 1]!.range[1]
-							: prevProp!.range[1];
-					// Find the comma after the previous property/comments
-					const tokenAfterPrev = sourceCode.getTokenAfter(
-						{
-							range: [prevEnd, prevEnd]
-						} as TSESTree.Node,
-						{ includeComments: false }
-					);
-					if (
-						tokenAfterPrev &&
-						tokenAfterPrev.value === "," &&
-						tokenAfterPrev.range[1] <= fullStart
-					) {
-						chunkStart = tokenAfterPrev.range[1];
-					} else {
-						chunkStart = prevEnd;
-					}
-				}
+				const chunkStart = getChunkStart(
+					idx,
+					fixableProps,
+					rangeStart,
+					fullStart
+				);
 
 				const text = sourceCode.text.slice(chunkStart, fullEnd);
 				chunks.push({ prop, text });
 			}
 
 			// Sort the chunks
-			const sorted = chunks.slice().sort((a, b) => {
+			const sorted = chunks.slice().sort((left, right) => {
 				if (variablesBeforeFunctions) {
-					const aIsFunc = isFunctionProperty(a.prop);
-					const bIsFunc = isFunctionProperty(b.prop);
-					if (aIsFunc !== bIsFunc) {
-						return aIsFunc ? 1 : -1;
+					const leftIsFunc = isFunctionProperty(left.prop);
+					const rightIsFunc = isFunctionProperty(right.prop);
+					if (leftIsFunc !== rightIsFunc) {
+						return leftIsFunc ? 1 : SORT_BEFORE;
 					}
 				}
 
-				const aKey = getPropertyKeyName(a.prop);
-				const bKey = getPropertyKeyName(b.prop);
+				const leftKey = getPropertyKeyName(left.prop);
+				const rightKey = getPropertyKeyName(right.prop);
 
-				let res = compareKeys(aKey, bKey);
+				let res = compareKeys(leftKey, rightKey);
 				if (order === "desc") {
 					res = -res;
 				}
@@ -300,7 +380,7 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 					fixableProps[0]!.range[0] - col,
 					fixableProps[0]!.range[0]
 				);
-				separator = ",\n" + indent;
+				separator = `,\n${indent}`;
 			} else {
 				separator = ", ";
 			}
@@ -308,8 +388,8 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			// Rebuild: first chunk keeps original leading whitespace,
 			// subsequent chunks use the detected separator
 			return sorted
-				.map((chunk, i) => {
-					if (i === 0) {
+				.map((chunk, idx) => {
+					if (idx === 0) {
 						const originalFirstChunk = chunks[0]!;
 						const originalLeadingWs =
 							originalFirstChunk.text.match(/^(\s*)/)?.[1] ?? "";
@@ -320,7 +400,16 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 					return separator + stripped;
 				})
 				.join("");
-		}
+		};
+
+		const getFixableProps = (node: TSESTree.ObjectExpression) =>
+			node.properties.filter(
+				(prop): prop is TSESTree.Property =>
+					prop.type === "Property" &&
+					!prop.computed &&
+					(prop.key.type === "Identifier" ||
+						prop.key.type === "Literal")
+			);
 
 		/**
 		 * Checks an ObjectExpression node for unsorted keys.
@@ -329,7 +418,7 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 		 * For auto-fix purposes, only simple properties are considered fixable.
 		 * (Computed keys, spread elements, or non-Identifier/Literal keys disable the fix.)
 		 */
-		function checkObjectExpression(node: TSESTree.ObjectExpression) {
+		const checkObjectExpression = (node: TSESTree.ObjectExpression) => {
 			if (node.properties.length < minKeys) {
 				return;
 			}
@@ -340,251 +429,287 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				let keyName: string | null = null;
 				let isFunc = false;
 
-				if (prop.type === "Property") {
-					if (prop.computed) {
-						autoFixable = false;
-					}
+				if (prop.type !== "Property") {
+					autoFixable = false;
+					return {
+						isFunction: isFunc,
+						keyName,
+						node: prop
+					};
+				}
 
-					if (prop.key.type === "Identifier") {
-						keyName = prop.key.name;
-					} else if (prop.key.type === "Literal") {
-						const value = prop.key.value;
-						keyName =
-							typeof value === "string" ? value : String(value);
-					} else {
-						autoFixable = false;
-					}
+				if (prop.computed) {
+					autoFixable = false;
+				}
 
-					if (isFunctionProperty(prop)) {
-						isFunc = true;
-					}
+				if (prop.key.type === "Identifier") {
+					keyName = prop.key.name;
+				} else if (prop.key.type === "Literal") {
+					const { value } = prop.key;
+					keyName = typeof value === "string" ? value : String(value);
 				} else {
-					// Spread elements or other non-Property nodes.
 					autoFixable = false;
 				}
 
+				if (isFunctionProperty(prop)) {
+					isFunc = true;
+				}
+
 				return {
+					isFunction: isFunc,
 					keyName,
-					node: prop,
-					isFunction: isFunc
+					node: prop
 				};
 			});
 
-			const getFixableProps = () => {
-				const props: TSESTree.Property[] = [];
-				for (const prop of node.properties) {
-					if (prop.type !== "Property") {
-						continue;
-					}
-					if (prop.computed) {
-						continue;
-					}
-					if (
-						prop.key.type !== "Identifier" &&
-						prop.key.type !== "Literal"
-					) {
-						continue;
-					}
-					props.push(prop);
-				}
-				return props;
-			};
+			if (hasDuplicateNames(keys.map((key) => key.keyName))) {
+				autoFixable = false;
+			}
+
+			if (
+				autoFixable &&
+				keys.some(
+					(key) =>
+						key.node.type === "Property" &&
+						!isSafeToReorderExpression(key.node.value)
+				)
+			) {
+				autoFixable = false;
+			}
 
 			let fixProvided = false;
 
-			for (let i = 1; i < keys.length; i++) {
-				const prev = keys[i - 1];
-				const curr = keys[i];
+			const createReportWithFix = (curr: KeyInfo, shouldFix: boolean) => {
+				context.report({
+					fix: shouldFix
+						? (fixer) => {
+								const fixableProps = getFixableProps(node);
+								if (fixableProps.length < minKeys) {
+									return null;
+								}
+
+								const [firstProp] = fixableProps;
+								const lastProp =
+									fixableProps[fixableProps.length - 1];
 
-				if (!prev || !curr) {
-					continue;
-				}
+								if (!firstProp || !lastProp) {
+									return null;
+								}
+
+								const firstLeading = getLeadingComments(
+									firstProp,
+									null
+								);
+								const [firstLeadingComment] = firstLeading;
+								const rangeStart = firstLeadingComment
+									? firstLeadingComment.range[0]
+									: firstProp.range[0];
+								const lastTrailing = getTrailingComments(
+									lastProp,
+									null
+								);
+								const rangeEnd =
+									lastTrailing.length > 0
+										? lastTrailing[lastTrailing.length - 1]!
+												.range[1]
+										: lastProp.range[1];
+								const sortedText = buildSortedText(
+									fixableProps,
+									rangeStart
+								);
+
+								return fixer.replaceTextRange(
+									[rangeStart, rangeEnd],
+									sortedText
+								);
+							}
+						: null,
+					messageId: "unsorted",
+					node:
+						curr.node.type === "Property"
+							? curr.node.key
+							: curr.node
+				});
+				fixProvided = true;
+			};
 
-				if (prev.keyName === null || curr.keyName === null) {
-					continue;
+			keys.forEach((curr, idx) => {
+				if (idx === 0) {
+					return;
+				}
+				const prev = keys[idx - 1];
+
+				if (
+					!prev ||
+					!curr ||
+					prev.keyName === null ||
+					curr.keyName === null
+				) {
+					return;
 				}
 
 				const shouldFix = !fixProvided && autoFixable;
 
-				const reportWithFix = () => {
-					context.report({
-						node:
-							curr.node.type === "Property"
-								? curr.node.key
-								: curr.node,
-						messageId: "unsorted",
-						fix: shouldFix
-							? (fixer) => {
-									const fixableProps = getFixableProps();
-									if (fixableProps.length < minKeys) {
-										return null;
-									}
-
-									const firstProp = fixableProps[0];
-									const lastProp =
-										fixableProps[fixableProps.length - 1];
-
-									if (!firstProp || !lastProp) {
-										return null;
-									}
-
-									const firstLeading = getLeadingComments(
-										firstProp,
-										null
-									);
-									const rangeStart =
-										firstLeading.length > 0
-											? firstLeading[0]!.range[0]
-											: firstProp.range[0];
-									const lastTrailing = getTrailingComments(
-										lastProp,
-										null
-									);
-									const rangeEnd =
-										lastTrailing.length > 0
-											? lastTrailing[
-													lastTrailing.length - 1
-												]!.range[1]
-											: lastProp.range[1];
-									const sortedText = buildSortedText(
-										fixableProps,
-										rangeStart
-									);
-
-									return fixer.replaceTextRange(
-										[rangeStart, rangeEnd],
-										sortedText
-									);
-								}
-							: null
-					});
-					fixProvided = true;
-				};
+				if (
+					variablesBeforeFunctions &&
+					prev.isFunction &&
+					!curr.isFunction
+				) {
+					createReportWithFix(curr, shouldFix);
+					return;
+				}
 
-				if (variablesBeforeFunctions) {
-					if (prev.isFunction && !curr.isFunction) {
-						reportWithFix();
-						continue;
-					}
+				if (
+					variablesBeforeFunctions &&
+					prev.isFunction === curr.isFunction &&
+					compareKeys(prev.keyName, curr.keyName) > 0
+				) {
+					createReportWithFix(curr, shouldFix);
+					return;
+				}
 
-					if (
-						prev.isFunction === curr.isFunction &&
-						compareKeys(prev.keyName, curr.keyName) > 0
-					) {
-						reportWithFix();
-					}
-				} else {
-					if (compareKeys(prev.keyName, curr.keyName) > 0) {
-						reportWithFix();
-					}
+				if (
+					!variablesBeforeFunctions &&
+					compareKeys(prev.keyName, curr.keyName) > 0
+				) {
+					createReportWithFix(curr, shouldFix);
 				}
-			}
-		}
+			});
+		};
 
 		// Also check object literals inside JSX prop expressions
-		function checkJSXAttributeObject(attr: TSESTree.JSXAttribute) {
-			const value = attr.value;
-			if (value && value.type === "JSXExpressionContainer") {
-				const expr = value.expression;
-				if (expr && expr.type === "ObjectExpression") {
-					checkObjectExpression(expr);
-				}
+		const checkJSXAttributeObject = (attr: TSESTree.JSXAttribute) => {
+			const { value } = attr;
+			if (
+				value &&
+				value.type === "JSXExpressionContainer" &&
+				value.expression &&
+				value.expression.type === "ObjectExpression"
+			) {
+				checkObjectExpression(value.expression);
 			}
-		}
+		};
+
+		const getAttrName = (
+			attr: TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute
+		) => {
+			if (
+				attr.type !== "JSXAttribute" ||
+				attr.name.type !== "JSXIdentifier"
+			) {
+				return "";
+			}
+			return attr.name.name;
+		};
+
+		const compareAttrNames = (nameLeft: string, nameRight: string) => {
+			let res = compareKeys(nameLeft, nameRight);
+			if (order === "desc") {
+				res = -res;
+			}
+			return res;
+		};
+
+		const isOutOfOrder = (names: string[]) =>
+			names.some((currName, idx) => {
+				if (idx === 0 || !currName) {
+					return false;
+				}
+				const prevName = names[idx - 1];
+				return (
+					prevName !== undefined &&
+					compareAttrNames(prevName, currName) > 0
+				);
+			});
 
 		// Also sort JSX attributes on elements
-		function checkJSXOpeningElement(node: TSESTree.JSXOpeningElement) {
+		const checkJSXOpeningElement = (node: TSESTree.JSXOpeningElement) => {
 			const attrs = node.attributes;
 			if (attrs.length < minKeys) {
 				return;
 			}
 
-			if (attrs.some((a) => a.type !== "JSXAttribute")) {
+			if (attrs.some((attr) => attr.type !== "JSXAttribute")) {
 				return;
 			}
 			if (
 				attrs.some(
-					(a) =>
-						a.type === "JSXAttribute" &&
-						a.name.type !== "JSXIdentifier"
+					(attr) =>
+						attr.type === "JSXAttribute" &&
+						attr.name.type !== "JSXIdentifier"
 				)
 			) {
 				return;
 			}
 
-			const names = attrs.map((a) => {
-				if (a.type !== "JSXAttribute") {
-					return "";
-				}
-				if (a.name.type !== "JSXIdentifier") {
-					return "";
-				}
-				return a.name.name;
-			});
+			const names = attrs.map((attr) => getAttrName(attr));
 
-			const cmp = (a: string, b: string) => {
-				let res = compareKeys(a, b);
-				if (order === "desc") {
-					res = -res;
-				}
-				return res;
-			};
+			if (!isOutOfOrder(names)) {
+				return;
+			}
 
-			let outOfOrder = false;
-			for (let i = 1; i < names.length; i++) {
-				const prevName = names[i - 1];
-				const currName = names[i];
-				if (!prevName || !currName) {
-					continue;
-				}
-				if (cmp(prevName, currName) > 0) {
-					outOfOrder = true;
-					break;
-				}
+			if (hasDuplicateNames(names)) {
+				context.report({
+					messageId: "unsorted",
+					node:
+						attrs[0]!.type === "JSXAttribute"
+							? attrs[0]!.name
+							: attrs[0]!
+				});
+				return;
 			}
 
-			if (!outOfOrder) {
+			if (
+				attrs.some(
+					(attr) =>
+						attr.type === "JSXAttribute" &&
+						!isSafeJSXAttributeValue(attr.value)
+				)
+			) {
+				context.report({
+					messageId: "unsorted",
+					node:
+						attrs[0]!.type === "JSXAttribute"
+							? attrs[0]!.name
+							: attrs[0]!
+				});
 				return;
 			}
 
 			// Be conservative: only fix if there are no JSX comments/braces between attributes.
-			for (let i = 1; i < attrs.length; i++) {
-				const prevAttr = attrs[i - 1];
-				const currAttr = attrs[i];
-
-				if (!prevAttr || !currAttr) {
-					continue;
+			const braceConflict = attrs.find((currAttr, idx) => {
+				if (idx === 0) {
+					return false;
+				}
+				const prevAttr = attrs[idx - 1];
+				if (!prevAttr) {
+					return false;
 				}
-
 				const between = sourceCode.text.slice(
 					prevAttr.range[1],
 					currAttr.range[0]
 				);
-				if (between.includes("{")) {
-					context.report({
-						node:
-							currAttr.type === "JSXAttribute"
-								? currAttr.name
-								: currAttr,
-						messageId: "unsorted"
-					});
-					return;
-				}
+				return between.includes("{");
+			});
+
+			if (braceConflict) {
+				context.report({
+					messageId: "unsorted",
+					node:
+						braceConflict.type === "JSXAttribute"
+							? braceConflict.name
+							: braceConflict
+				});
+				return;
 			}
 
-			const sortedAttrs = attrs.slice().sort((a, b) => {
-				const aName =
-					a.type === "JSXAttribute" && a.name.type === "JSXIdentifier"
-						? a.name.name
-						: "";
-				const bName =
-					b.type === "JSXAttribute" && b.name.type === "JSXIdentifier"
-						? b.name.name
-						: "";
-				return cmp(aName, bName);
-			});
+			const sortedAttrs = attrs
+				.slice()
+				.sort((left, right) =>
+					compareAttrNames(getAttrName(left), getAttrName(right))
+				);
 
-			const firstAttr = attrs[0];
+			const [firstAttr] = attrs;
 			const lastAttr = attrs[attrs.length - 1];
 
 			if (!firstAttr || !lastAttr) {
@@ -592,30 +717,69 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			}
 
 			const replacement = sortedAttrs
-				.map((a) => sourceCode.getText(a))
+				.map((attr) => sourceCode.getText(attr))
 				.join(" ");
 
 			context.report({
-				node:
-					firstAttr.type === "JSXAttribute"
-						? firstAttr.name
-						: firstAttr,
-				messageId: "unsorted",
 				fix(fixer) {
 					return fixer.replaceTextRange(
 						[firstAttr.range[0], lastAttr.range[1]],
 						replacement
 					);
-				}
+				},
+				messageId: "unsorted",
+				node:
+					firstAttr.type === "JSXAttribute"
+						? firstAttr.name
+						: firstAttr
 			});
-		}
+		};
 
 		return {
-			ObjectExpression: checkObjectExpression,
 			JSXAttribute(node: TSESTree.JSXAttribute) {
 				checkJSXAttributeObject(node);
 			},
-			JSXOpeningElement: checkJSXOpeningElement
+			JSXOpeningElement: checkJSXOpeningElement,
+			ObjectExpression: checkObjectExpression
 		};
+	},
+	defaultOptions: [{}],
+	meta: {
+		docs: {
+			description:
+				"enforce sorted keys in object literals with auto-fix (limited to simple cases, preserving comments)"
+		},
+		fixable: "code",
+		messages: {
+			unsorted: "Object keys are not sorted."
+		},
+		// The schema supports the same options as the built-in sort-keys rule plus:
+		//   variablesBeforeFunctions: boolean (when true, non-function properties come before function properties)
+		schema: [
+			{
+				additionalProperties: false,
+				properties: {
+					caseSensitive: {
+						type: "boolean"
+					},
+					minKeys: {
+						minimum: 2,
+						type: "integer"
+					},
+					natural: {
+						type: "boolean"
+					},
+					order: {
+						enum: ["asc", "desc"],
+						type: "string"
+					},
+					variablesBeforeFunctions: {
+						type: "boolean"
+					}
+				},
+				type: "object"
+			}
+		],
+		type: "suggestion"
 	}
 };