eslint-plugin-unslop 0.1.5 → 0.2.0

package/dist/index.cjs

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-unslop",
-  version: "0.1.5",
+  version: "0.2.0",
   description: "ESLint plugin with rules for reducing AI-generated code smells",
   repository: {
     type: "git",
@@ -63,8 +63,8 @@ var package_default = {
   },
   scripts: {
     build: "tsup",
-    format: "prettier . --write",
-    verify: "prettier . --check && tsc --noEmit && tsup && eslint . && knip",
+    fix: "knip --fix && eslint . --fix && prettier . --write",
+    verify: "prettier . --check && knip && depcruise src && jscpd && tsc --noEmit && tsup && eslint .",
     test: "vitest run",
     "test:watch": "vitest",
     prepublishOnly: "npm run build"
@@ -92,8 +92,10 @@ var package_default = {
     "@types/estree": "^1.0.8",
     "@types/node": "^22.18.0",
     "@typescript-eslint/parser": "^8.57.2",
+    "dependency-cruiser": "^17.3.10",
     eslint: "^9.39.1",
     globals: "^17.4.0",
+    jscpd: "^4.0.8",
     knip: "^6.1.0",
     prettier: "^3.8.1",
     tsup: "^8.5.0",
@@ -117,6 +119,19 @@ function createStringLiteralListener(includeEscapedUnicode, visitLiteral) {
     TemplateLiteral: inspect
   };
 }
+function extractContentAndWrapper(text, node) {
+  if (node.type === "Literal" && typeof node.value === "string" && typeof node.raw === "string") {
+    const quote = node.raw[0];
+    if (quote === '"' || quote === "'") {
+      return { content: node.raw.slice(1, -1), wrapper: quote };
+    }
+    return { content: null, wrapper: "" };
+  }
+  if (node.type === "TemplateLiteral") {
+    return { content: text, wrapper: "`" };
+  }
+  return { content: null, wrapper: "" };
+}
 function getStringValue(node, includeEscapedUnicode) {
   if (node.type === "TemplateLiteral") {
     return node.quasis.map(
@@ -129,7 +144,7 @@ function getStringValue(node, includeEscapedUnicode) {
   return includeEscapedUnicode ? node.raw ?? node.value : node.value;
 }
 
-// src/rules/no-special-unicode.ts
+// src/rules/no-special-unicode/index.ts
 var no_special_unicode_default = {
   meta: {
     type: "problem",
@@ -137,6 +152,7 @@ var no_special_unicode_default = {
       description: "Disallow special unicode punctuation and whitespace in strings",
       recommended: true
     },
+    fixable: "code",
     schema: [],
     messages: {
       bannedCharacter: "String contains {{name}} (U+{{code}}). Use the ASCII equivalent."
@@ -158,36 +174,68 @@ var no_special_unicode_default = {
           data: {
             name,
             code: code.toString(16).toUpperCase().padStart(4, "0")
+          },
+          fix(fixer) {
+            const fixedText = computeFixedText(text, node);
+            if (!fixedText) return null;
+            return fixer.replaceText(node, fixedText);
           }
         });
       }
     });
   }
 };
-var BANNED_CHARS = /* @__PURE__ */ new Map([
-  ["\u201C", "left double quotation mark"],
-  ["\u201D", "right double quotation mark"],
-  ["\u2018", "left single quotation mark"],
-  ["\u2019", "right single quotation mark"],
-  ["\xA0", "non-breaking space"],
-  ["\u202F", "narrow no-break space"],
-  ["\u2007", "figure space"],
-  ["\u2008", "punctuation space"],
-  ["\u2009", "thin space"],
-  ["\u200A", "hair space"],
-  ["\u200B", "zero-width space"],
-  ["\u2002", "en space"],
-  ["\u2003", "em space"],
-  ["\u205F", "medium mathematical space"],
-  ["\u3000", "ideographic space"],
-  ["\uFEFF", "zero-width no-break space"],
-  ["\u2013", "en dash"],
-  ["\u2014", "em dash"],
-  ["\u2026", "horizontal ellipsis"]
-]);
-var BANNED_CHARS_RE = new RegExp([...BANNED_CHARS.keys()].join("|"));
+var CHAR_RULES = [
+  { char: "\u201C", name: "left double quotation mark", replacement: '"' },
+  { char: "\u201D", name: "right double quotation mark", replacement: '"' },
+  { char: "\u2018", name: "left single quotation mark", replacement: "'" },
+  { char: "\u2019", name: "right single quotation mark", replacement: "'" },
+  { char: "\xA0", name: "non-breaking space", replacement: " " },
+  { char: "\u202F", name: "narrow no-break space", replacement: " " },
+  { char: "\u2007", name: "figure space", replacement: " " },
+  { char: "\u2008", name: "punctuation space", replacement: " " },
+  { char: "\u2009", name: "thin space", replacement: " " },
+  { char: "\u200A", name: "hair space", replacement: " " },
+  { char: "\u200B", name: "zero-width space", replacement: "" },
+  { char: "\u2002", name: "en space", replacement: " " },
+  { char: "\u2003", name: "em space", replacement: " " },
+  { char: "\u205F", name: "medium mathematical space", replacement: " " },
+  { char: "\u3000", name: "ideographic space", replacement: " " },
+  { char: "\uFEFF", name: "zero-width no-break space", replacement: "" },
+  { char: "\u2013", name: "en dash", replacement: "-" },
+  { char: "\u2014", name: "em dash", replacement: "-" },
+  { char: "\u2026", name: "horizontal ellipsis", replacement: "..." }
+];
+var BANNED_CHARS = new Map(CHAR_RULES.map(({ char, name }) => [char, name]));
+var BANNED_CHARS_RE = new RegExp(CHAR_RULES.map(({ char }) => char).join("|"));
+function computeFixedText(text, node) {
+  const { content, wrapper } = extractContentAndWrapper(text, node);
+  if (!content) return null;
+  const wrapperQuote = wrapper === "`" ? null : wrapper;
+  const result = applyReplacements(content, wrapperQuote);
+  if (!result) return null;
+  return wrapper + result + wrapper;
+}
+function applyReplacements(content, wrapperQuote) {
+  let result = content;
+  let madeReplacement = false;
+  for (const [char, replacement] of CHAR_REPLACEMENTS) {
+    if (!content.includes(char)) continue;
+    if (isUnsafeReplacement(wrapperQuote, replacement)) continue;
+    madeReplacement = true;
+    result = result.split(char).join(replacement);
+  }
+  return madeReplacement ? result : null;
+}
+var CHAR_REPLACEMENTS = new Map(CHAR_RULES.map(({ char, replacement }) => [char, replacement]));
+function isUnsafeReplacement(wrapperQuote, replacement) {
+  if (!wrapperQuote) return false;
+  if (wrapperQuote === '"' && replacement.includes('"')) return true;
+  if (wrapperQuote === "'" && replacement.includes("'")) return true;
+  return false;
+}
 
-// src/rules/no-unicode-escape.ts
+// src/rules/no-unicode-escape/index.ts
 var no_unicode_escape_default = {
   meta: {
     type: "suggestion",
@@ -195,6 +243,7 @@ var no_unicode_escape_default = {
       description: "Prefer literal unicode characters over \\uXXXX escape sequences",
       recommended: true
     },
+    fixable: "code",
     schema: [],
     messages: {
       preferLiteral: "Use the actual character instead of a \\uXXXX escape sequence."
@@ -203,14 +252,49 @@ var no_unicode_escape_default = {
   create(context) {
     return createStringLiteralListener(true, (node, text) => {
       if (UNICODE_ESCAPE_RE.test(text)) {
-        context.report({ node, messageId: "preferLiteral" });
+        context.report({
+          node,
+          messageId: "preferLiteral",
+          fix(fixer) {
+            const replacement = computeReplacement(text, node);
+            if (!replacement) return null;
+            return fixer.replaceText(node, replacement);
+          }
+        });
       }
     });
   }
 };
-var UNICODE_ESCAPE_RE = /\\u[0-9a-fA-F]{4}/;
+function computeReplacement(text, node) {
+  const { content, wrapper } = extractContentAndWrapper(text, node);
+  if (!content) return null;
+  if (!allEscapesSafe(content)) return null;
+  const result = content.replace(UNICODE_ESCAPE_RE, toLiteralCharacter);
+  return wrapper + result + wrapper;
+}
+function allEscapesSafe(content) {
+  const escapes = content.match(UNICODE_ESCAPE_RE);
+  if (!escapes) return false;
+  for (const escape of escapes) {
+    const code = parseEscapeCode(escape);
+    if (isUnsafeChar(code)) return false;
+  }
+  return true;
+}
+function toLiteralCharacter(escape) {
+  return String.fromCharCode(parseEscapeCode(escape));
+}
+function parseEscapeCode(escape) {
+  return Number.parseInt(escape.slice(2), 16);
+}
+function isUnsafeChar(code) {
+  if (code <= 31) return true;
+  if (code === 34 || code === 39 || code === 92 || code === 96) return true;
+  return false;
+}
+var UNICODE_ESCAPE_RE = /\\u[0-9a-fA-F]{4}/g;
 
-// src/rules/no-deep-imports.ts
+// src/rules/no-deep-imports/index.ts
 var import_node_fs2 = require("fs");
 var import_node_path3 = __toESM(require("path"), 1);
 
@@ -328,7 +412,7 @@ function buildContext(filename, projectRoot, sourceRoot) {
   };
 }
 
-// src/rules/no-deep-imports.ts
+// src/rules/no-deep-imports/index.ts
 var NO_DEEP_IMPORTS_SCHEMA = [
   {
     type: "object",
@@ -397,7 +481,7 @@ function findViolation(specifier, filename, sourceRoot, sourceRelativePath) {
   };
 }
 function resolveImportSourceRelative(specifier, filename, sourceRoot) {
-  const normalizedSpecifier = specifier.replace(/\.js$/, "");
+  const normalizedSpecifier = specifier.replace(/\.(js|ts|tsx|jsx)$/, "");
   if (normalizedSpecifier.startsWith("@/")) {
     return normalizedSpecifier.slice(2);
   }
@@ -582,7 +666,7 @@ function deriveEntity(consumerPath, mode) {
 }
 var MAX_DIR_DEPTH = 3;
 
-// src/rules/no-false-sharing.ts
+// src/rules/no-false-sharing/index.ts
 var SCHEMA = [
   {
     type: "object",
@@ -647,30 +731,148 @@ var no_false_sharing_default = {
 };
 function extractTsProgram(context) {
   const services = context.sourceCode.parserServices;
-  if (!isRecord2(services) || !("program" in services)) {
-    return void 0;
+  if (!isRecord(services)) return void 0;
+  const program = "program" in services ? services.program : void 0;
+  return isTsProgram(program) ? program : void 0;
+}
+function isTsProgram(value) {
+  return isRecord(value) && "getTypeChecker" in value;
+}
+
+// src/rules/read-friendly-order/fixer-utils.ts
+function stableTopologicalOrder(count, edges) {
+  const adjacency = createAdjacency(count);
+  const inDegree = new Array(count).fill(0);
+  applyEdges(adjacency, inDegree, edges);
+  const queue = buildInitialQueue(inDegree);
+  const ordered = consumeQueue(queue, adjacency, inDegree);
+  return ordered.length === count ? ordered : void 0;
+}
+function applyEdges(adjacency, inDegree, edges) {
+  for (const [from, to] of edges) {
+    if (isEdgeIgnored(adjacency, from, to)) continue;
+    adjacency[from].add(to);
+    inDegree[to] += 1;
+  }
+}
+function isEdgeIgnored(adjacency, from, to) {
+  if (from === to) return true;
+  return adjacency[from].has(to);
+}
+function createReplaceTextRangeFix(fixRange) {
+  return (fixer) => {
+    if (!fixRange) return null;
+    return fixer.replaceTextRange([fixRange[0], fixRange[1]], fixRange[2]);
+  };
+}
+function isSameIndexOrder(original, candidate) {
+  if (original.length !== candidate.length) return false;
+  for (let i = 0; i < original.length; i += 1) {
+    if (original[i]?.index !== candidate[i]?.index) return false;
   }
-  const program = services.program;
-  if (!isTsProgram(program)) {
-    return void 0;
+  return true;
+}
+function consumeQueue(queue, adjacency, inDegree) {
+  const ordered = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    ordered.push(current);
+    visitNextNodes(adjacency[current] ?? [], inDegree, queue);
   }
-  return program;
+  return ordered;
 }
-function isTsProgram(value) {
-  return isRecord2(value) && "getTypeChecker" in value;
+function visitNextNodes(nextNodes, inDegree, queue) {
+  for (const next of nextNodes) {
+    inDegree[next] -= 1;
+    if (inDegree[next] === 0) insertSorted(queue, next);
+  }
 }
-function isRecord2(value) {
-  return value != void 0 && typeof value === "object";
+function createAdjacency(count) {
+  const adjacency = [];
+  for (let i = 0; i < count; i += 1) adjacency.push(/* @__PURE__ */ new Set());
+  return adjacency;
+}
+function buildInitialQueue(inDegree) {
+  const queue = [];
+  for (const [index, degree] of inDegree.entries()) {
+    if (degree === 0) queue.push(index);
+  }
+  return queue;
+}
+function insertSorted(queue, value) {
+  const index = queue.findIndex((entry) => value < entry);
+  if (index < 0) {
+    queue.push(value);
+    return;
+  }
+  queue.splice(index, 0, value);
+}
+function createSafeReorderFix(sourceCode, originalNodes, orderedNodes, options) {
+  const originalRanges = extractSortedRanges(originalNodes);
+  if (!originalRanges) return void 0;
+  if (hasAmbiguousComments(sourceCode, originalRanges, originalNodes)) return void 0;
+  const [start] = originalRanges[0];
+  const [, end] = originalRanges[originalRanges.length - 1];
+  const text = orderedNodes.map((node) => formatNodeText(sourceCode.getText(node), options)).join("\n\n");
+  return [start, end, text];
+}
+function formatNodeText(text, options) {
+  if (!options?.leadingIndent) return text;
+  if (/^\s/.test(text)) return text;
+  return options.leadingIndent + text;
+}
+function extractSortedRanges(nodes) {
+  const ranges = [];
+  for (const node of nodes) {
+    if (!node.range) return void 0;
+    ranges.push(node.range);
+  }
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+  for (let i = 1; i < sorted.length; i += 1) {
+    if (sorted[i - 1][1] > sorted[i][0]) return void 0;
+  }
+  return sorted;
+}
+function hasAmbiguousComments(sourceCode, sortedRanges, nodes) {
+  const [start] = sortedRanges[0];
+  const [, end] = sortedRanges[sortedRanges.length - 1];
+  for (const comment of sourceCode.getAllComments()) {
+    const range = comment.range;
+    if (!range) continue;
+    if (range[0] < start || range[1] > end) continue;
+    if (!isInsideAnyNode(range, nodes)) return true;
+  }
+  return false;
+}
+function isInsideAnyNode(commentRange, nodes) {
+  for (const node of nodes) {
+    const range = node.range;
+    if (!range) continue;
+    if (commentRange[0] >= range[0] && commentRange[1] <= range[1]) return true;
+  }
+  return false;
 }
 
 // src/rules/read-friendly-order/class-order.ts
 function reportClassOrdering(program, context) {
   for (const classNode of collectClassDeclarations(program)) {
     const members = collectClassMembers(classNode);
-    reportConstructorOrder(members, classNode, context);
-    reportPublicFieldOrder(members, context);
-    reportClassDependencyOrder(members, context);
+    const supportsFix = !hasUnsupportedClassMember(classNode);
+    const fixRange = supportsFix ? buildClassFixRange(members, context) : void 0;
+    reportConstructorOrder(members, classNode, context, fixRange);
+    reportPublicFieldOrder(members, context, fixRange);
+    reportClassDependencyOrder(members, context, fixRange);
+  }
+}
+function hasUnsupportedClassMember(classNode) {
+  for (const member of classNode.body.body) {
+    if ("computed" in member && member.computed) return true;
+    if ("decorators" in member && Array.isArray(member.decorators) && member.decorators.length > 0) {
+      return true;
+    }
   }
+  return false;
 }
 function collectClassDeclarations(program) {
   const classes = [];
@@ -690,16 +892,17 @@ function extractClassNode(statement) {
   }
   return void 0;
 }
-function reportConstructorOrder(members, classNode, context) {
+function reportConstructorOrder(members, classNode, context, fixRange) {
   const ctor = members.find((m) => m.kind === "constructor");
   if (!ctor || ctor.index === 0) return;
   context.report({
     node: ctor.node,
     messageId: "constructorFirst",
-    data: { className: classNode.id?.name ?? "anonymous class" }
+    data: { className: classNode.id?.name ?? "anonymous class" },
+    fix: createReplaceTextRangeFix(fixRange)
   });
 }
-function reportPublicFieldOrder(members, context) {
+function reportPublicFieldOrder(members, context, fixRange) {
   const ctorIndex = members.find((m) => m.kind === "constructor")?.index ?? -1;
   const startIndex = ctorIndex >= 0 ? ctorIndex + 1 : 0;
   let seenOther = false;
@@ -710,7 +913,8 @@ function reportPublicFieldOrder(members, context) {
         context.report({
           node: member.node,
           messageId: "publicFieldOrder",
-          data: { memberName: member.name }
+          data: { memberName: member.name },
+          fix: createReplaceTextRangeFix(fixRange)
         });
       }
       continue;
@@ -718,7 +922,7 @@ function reportPublicFieldOrder(members, context) {
     seenOther = true;
   }
 }
-function reportClassDependencyOrder(members, context) {
+function reportClassDependencyOrder(members, context, fixRange) {
   const others = members.filter((m) => m.kind === "other");
   for (const member of others) {
     const consumer = findFirstClassConsumer(others, member, context);
@@ -726,16 +930,56 @@ function reportClassDependencyOrder(members, context) {
     context.report({
       node: member.node,
       messageId: "moveMemberBelow",
-      data: { memberName: member.name, consumerName: consumer.name }
+      data: { memberName: member.name, consumerName: consumer.name },
+      fix: createReplaceTextRangeFix(fixRange)
     });
   }
 }
+function buildClassFixRange(members, context) {
+  if (members.length < 2) return void 0;
+  const orderedMembers = getCanonicalClassMembers(members, context);
+  if (!orderedMembers || isSameIndexOrder(members, orderedMembers)) return void 0;
+  const originalNodes = members.map((member) => member.node);
+  const orderedNodes = orderedMembers.map((member) => member.node);
+  return createSafeReorderFix(context.sourceCode, originalNodes, orderedNodes);
+}
+function getCanonicalClassMembers(members, context) {
+  const constructorMembers = members.filter((member) => member.kind === "constructor");
+  const publicFields = members.filter((member) => member.kind === "public-field");
+  const others = members.filter((member) => member.kind === "other");
+  const orderedOthers = orderOtherMembers(others, context);
+  if (!orderedOthers) return void 0;
+  return [...constructorMembers, ...publicFields, ...orderedOthers];
+}
+function orderOtherMembers(others, context) {
+  const indexedOthers = others.map((member, indexInGroup) => ({ ...member, indexInGroup }));
+  const edges = collectOtherMemberEdges(indexedOthers, context);
+  if (edges.length === 0) return [...others];
+  const order = stableTopologicalOrder(indexedOthers.length, edges);
+  if (!order) return void 0;
+  return order.map((index) => indexedOthers[index]);
+}
+function collectOtherMemberEdges(others, context) {
+  const edges = [];
+  for (const member of others) {
+    const consumer = findFirstClassConsumer(others, member, context);
+    if (!consumer) continue;
+    edges.push([consumer.indexInGroup, member.indexInGroup]);
+  }
+  return edges;
+}
 function collectClassMembers(classNode) {
   const members = [];
   for (const [index, raw] of classNode.body.body.entries()) {
     const named = toNamedMember(raw);
     if (!named) continue;
-    members.push({ name: named.name, node: named.node, index, kind: classifyMember(named.node) });
+    members.push({
+      name: named.name,
+      node: named.node,
+      index,
+      indexInGroup: -1,
+      kind: classifyMember(named.node)
+    });
   }
   return members;
 }
@@ -785,8 +1029,23 @@ function reportTestOrdering(program, context) {
   if (!entries.some((entry) => entry.kind === "test")) {
     return;
   }
-  reportSetupOrder(entries, context);
-  reportTeardownOrder(entries, context);
+  const fixRange = buildTestPhaseFixRange(entries, context);
+  reportSetupOrder(entries, context, fixRange);
+  reportTeardownOrder(entries, context, fixRange);
+}
+function buildTestPhaseFixRange(entries, context) {
+  if (entries.length < 2) return void 0;
+  const ordered = getCanonicalPhaseEntries(entries);
+  if (isSameIndexOrder(entries, ordered)) return void 0;
+  const originalNodes = entries.map((entry) => entry.node);
+  const orderedNodes = ordered.map((entry) => entry.node);
+  return createSafeReorderFix(context.sourceCode, originalNodes, orderedNodes);
+}
+function getCanonicalPhaseEntries(entries) {
+  const setup = entries.filter((entry) => entry.kind === "setup");
+  const teardown = entries.filter((entry) => entry.kind === "teardown");
+  const tests = entries.filter((entry) => entry.kind === "test");
+  return [...setup, ...teardown, ...tests];
 }
 function collectTestPhaseEntries(program) {
   const entries = [];
@@ -803,13 +1062,8 @@ function toTestPhaseEntry(statement, index) {
     return void 0;
   }
   const rootName = getCallRootName(statement.expression);
-  if (!rootName) {
-    return void 0;
-  }
-  const kind = classifyHookName(rootName);
-  if (!kind) {
-    return void 0;
-  }
+  const kind = rootName ? classifyHookName(rootName) : void 0;
+  if (!kind || !rootName) return void 0;
   return { index, kind, hookName: rootName, node: statement };
 }
 function classifyHookName(name) {
@@ -822,19 +1076,15 @@ var SETUP_HOOKS = /* @__PURE__ */ new Set(["beforeAll", "beforeEach", "before"])
 var TEARDOWN_HOOKS = /* @__PURE__ */ new Set(["afterAll", "afterEach", "after"]);
 var TEST_CALLS = /* @__PURE__ */ new Set(["test", "it"]);
 function getCallRootName(call) {
-  const callee = call.callee;
-  if (callee.type === "Identifier") return callee.name;
-  if (callee.type === "MemberExpression") return readObjectRoot(callee.object);
-  if (callee.type === "CallExpression") return getCallRootName(callee);
-  return void 0;
+  return getRootName(call.callee);
 }
-function readObjectRoot(node) {
+function getRootName(node) {
   if (node.type === "Identifier") return node.name;
-  if (node.type === "MemberExpression") return readObjectRoot(node.object);
-  if (node.type === "CallExpression") return getCallRootName(node);
+  if (node.type === "MemberExpression") return getRootName(node.object);
+  if (node.type === "CallExpression") return getRootName(node.callee);
   return void 0;
 }
-function reportSetupOrder(entries, context) {
+function reportSetupOrder(entries, context, fixRange) {
   const firstTeardown = findFirstIndex(entries, "teardown");
   const firstTest = findFirstIndex(entries, "test");
   for (const entry of entries) {
@@ -843,7 +1093,8 @@ function reportSetupOrder(entries, context) {
       context.report({
         node: entry.node,
         messageId: "setupBeforeTeardown",
-        data: { hookName: entry.hookName }
+        data: { hookName: entry.hookName },
+        fix: createReplaceTextRangeFix(fixRange)
       });
       continue;
     }
@@ -851,12 +1102,13 @@ function reportSetupOrder(entries, context) {
       context.report({
         node: entry.node,
         messageId: "setupBeforeTests",
-        data: { hookName: entry.hookName }
+        data: { hookName: entry.hookName },
+        fix: createReplaceTextRangeFix(fixRange)
       });
     }
   }
 }
-function reportTeardownOrder(entries, context) {
+function reportTeardownOrder(entries, context, fixRange) {
   const firstTest = findFirstIndex(entries, "test");
   if (firstTest < 0) return;
   for (const entry of entries) {
@@ -864,7 +1116,8 @@ function reportTeardownOrder(entries, context) {
     context.report({
       node: entry.node,
       messageId: "teardownBeforeTests",
-      data: { hookName: entry.hookName }
+      data: { hookName: entry.hookName },
+      fix: createReplaceTextRangeFix(fixRange)
     });
   }
 }
@@ -873,7 +1126,7 @@ function findFirstIndex(entries, kind) {
   return match ? match.index : -1;
 }
 
-// src/rules/read-friendly-order.ts
+// src/rules/read-friendly-order/index.ts
 var READ_FRIENDLY_ORDER_MESSAGES = {
   moveHelperBelow: 'Place helper "{{helperName}}" below the top-level symbol "{{symbolName}}" that depends on it.',
   moveConstantBelow: 'Place constant "{{constantName}}" below the top-level symbol "{{symbolName}}" that uses it.',
@@ -892,6 +1145,7 @@ var read_friendly_order_default = {
       recommended: false
     },
     schema: [],
+    fixable: "code",
     messages: READ_FRIENDLY_ORDER_MESSAGES
   },
   create(context) {
@@ -909,10 +1163,11 @@ function reportTopLevelOrdering(program, context) {
   const helpers = collectHelpers(body);
   const refs = collectReferences(context.sourceCode.scopeManager.globalScope);
   const cyclicNames = findCyclicHelperNames(body, helpers, refs);
+  const fixRange = buildTopLevelFixRange({ body, helpers, refs, cyclicNames, context });
   for (const helper of helpers) {
     if (cyclicNames.has(helper.name)) continue;
     if (hasEagerReference(body, helper, refs)) continue;
-    const consumer = findFirstConsumer(body, helper, refs);
+    const consumer = findFirstConsumerEntry(body, helper, refs)?.statement;
     if (!consumer) continue;
     context.report({
       node: helper.node,
@@ -921,10 +1176,34 @@ function reportTopLevelOrdering(program, context) {
         helperName: helper.name,
         constantName: helper.name,
         symbolName: getSymbolName(consumer)
-      }
+      },
+      fix: createReplaceTextRangeFix(fixRange)
     });
   }
 }
+function buildTopLevelFixRange(input) {
+  const { body, helpers, refs, cyclicNames, context } = input;
+  if (body.length < 2) return void 0;
+  const edges = collectTopLevelEdges(body, helpers, refs, cyclicNames);
+  if (edges.length === 0) return void 0;
+  const order = stableTopologicalOrder(body.length, edges);
+  if (!order || isIdentityOrder(order)) return void 0;
+  const orderedBody = order.map((index) => body[index]);
+  return createSafeReorderFix(context.sourceCode, body, orderedBody);
+}
+function collectTopLevelEdges(body, helpers, refs, cyclicNames) {
+  const edges = [];
+  for (const helper of helpers) {
+    if (cyclicNames.has(helper.name) || hasEagerReference(body, helper, refs)) continue;
+    const consumer = findFirstConsumerEntry(body, helper, refs);
+    if (!consumer) continue;
+    edges.push([consumer.index, helper.index]);
+  }
+  return edges;
+}
+function isIdentityOrder(order) {
+  return order.every((value, index) => index === value);
+}
 function getTopLevelStatements(program) {
   return program.body.filter((s) => s.type !== "ImportDeclaration");
 }
@@ -986,11 +1265,11 @@ function collectVariableHelpers(decl, index) {
 function isFunctionInit(node) {
   return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
 }
-function findFirstConsumer(body, helper, refs) {
+function findFirstConsumerEntry(body, helper, refs) {
   for (let i = helper.index + 1; i < body.length; i += 1) {
     const stmt = body[i];
     if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) continue;
-    if (statementUsesName(stmt, helper.name, refs)) return stmt;
+    if (statementUsesName(stmt, helper.name, refs)) return { statement: stmt, index: i };
   }
   return void 0;
 }
@@ -1027,6 +1306,7 @@ function canReachSelf(start, deps) {
   const queue = [...deps.get(start) ?? []];
   while (queue.length > 0) {
     const current = queue.shift();
+    if (current === void 0) break;
     if (current === start) return true;
     if (visited.has(current)) continue;
     visited.add(current);