eslint-plugin-flawless 0.1.11 → 0.1.12

package/README.md

@@ -200,9 +200,11 @@ Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
 | Name                                                                                          | Description                                                                      | 🔧  | 💭  |
 | :-------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------- | :-- | :-- |
+| [arrow-return-style](src/rules/arrow-return-style/documentation.md)                           | Enforce arrow function return style based on line length                         | 🔧  |     |
 | [jsx-shorthand-boolean](src/rules/jsx-shorthand-boolean/documentation.md)                     | Disallow shorthand boolean JSX attributes                                        | 🔧  |     |
 | [jsx-shorthand-fragment](src/rules/jsx-shorthand-fragment/documentation.md)                   | Enforce a consistent fragment form: the shorthand `<>...</>` or a named fragment | 🔧  |     |
 | [naming-convention](src/rules/naming-convention/documentation.md)                             | Enforce naming conventions for everything across a codebase                      |     | 💭  |
+| [no-export-default-arrow](src/rules/no-export-default-arrow/documentation.md)                 | Disallow anonymous arrow functions as export default declarations                | 🔧  |     |
 | [no-unnecessary-use-callback](src/rules/no-unnecessary-use-callback/documentation.md)         | Disallow unnecessary usage of 'useCallback'                                      |     |     |
 | [no-unnecessary-use-memo](src/rules/no-unnecessary-use-memo/documentation.md)                 | Disallow unnecessary usage of 'useMemo'                                          |     |     |
 | [prefer-destructuring-assignment](src/rules/prefer-destructuring-assignment/documentation.md) | Enforce destructuring assignment for component props                             | 🔧  |     |

package/dist/index.d.mts

@@ -44,6 +44,31 @@ type FlawlessRuleModule<Options extends ReadonlyArray<unknown>, MessageIds exten
   createOnce: (context: RuleContextWithSourceCode<MessageIds, Options, SourceCode>) => FlawlessRuleListener;
 };
 //#endregion
+//#region src/rules/arrow-return-style/rule.d.ts
+declare const IMPLICIT = "useImplicitReturn";
+declare const EXPLICIT = "useExplicitReturn";
+declare const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
+type MessageIds$4 = typeof COMPLEX_EXPLICIT | typeof EXPLICIT | typeof IMPLICIT;
+type ObjectReturnStyle = "always-explicit" | "complex-explicit" | "off";
+type Options$5 = [{
+  /** Always use explicit returns for JSX bodies. */
+  jsxAlwaysUseExplicitReturn?: boolean;
+  /** Maximum emitted line length (tab-expanded) before requiring an explicit return. */
+  maxLen?: number;
+  /** Object property / array element count above which a literal body counts as complex. */
+  maxObjectProperties?: number;
+  /** Always use explicit returns for arrows assigned to named exports. */
+  namedExportsAlwaysUseExplicitReturn?: boolean;
+  /** When to force explicit returns for object/array literal bodies. */
+  objectReturnStyle?: ObjectReturnStyle;
+  /** Columns a tab occupies when measuring against `maxLen`. */
+  tabWidth?: number;
+  /** Consult oxfmt for boundary decisions; `printWidth` defaults to `maxLen`. */
+  useOxfmt?: boolean | {
+    printWidth?: number;
+  };
+}];
+//#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.d.ts
 declare const MESSAGE_ID_NAMED = "useNamedFragment";
 declare const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
@@ -225,11 +250,13 @@ declare const plugin: {
     version: string;
   };
   rules: {
+    "arrow-return-style": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<TSESLint.SourceCode>>;
     "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<TSESLint.SourceCode>>;
     "jsx-shorthand-fragment": FlawlessRuleModule<Options$4, MessageIds$3, Readonly<TSESLint.SourceCode>>;
     "naming-convention": TSESLint.RuleModule<MessageIds$2, Options$3, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
+    "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<TSESLint.SourceCode>>;
     "no-unnecessary-use-callback": FlawlessRuleModule<[], MessageIds$1, Readonly<TSESLint.SourceCode>>;
     "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds, Readonly<TSESLint.SourceCode>>;
     "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<TSESLint.SourceCode>>;
@@ -262,11 +289,13 @@ declare const _default: {
             version: string;
           };
           rules: {
+            "arrow-return-style": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
             "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<import("${configDir}").SourceCode>>;
             "jsx-shorthand-fragment": FlawlessRuleModule<Options$4, MessageIds$3, Readonly<import("${configDir}").SourceCode>>;
             "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
+            "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
             "no-unnecessary-use-callback": FlawlessRuleModule<[], MessageIds$1, Readonly<import("${configDir}").SourceCode>>;
             "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds, Readonly<import("${configDir}").SourceCode>>;
             "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<import("${configDir}").SourceCode>>;
@@ -296,11 +325,13 @@ declare const _default: {
     version: string;
   };
   rules: {
+    "arrow-return-style": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
     "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<import("${configDir}").SourceCode>>;
     "jsx-shorthand-fragment": FlawlessRuleModule<Options$4, MessageIds$3, Readonly<import("${configDir}").SourceCode>>;
     "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
+    "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
     "no-unnecessary-use-callback": FlawlessRuleModule<[], MessageIds$1, Readonly<import("${configDir}").SourceCode>>;
     "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds, Readonly<import("${configDir}").SourceCode>>;
     "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<import("${configDir}").SourceCode>>;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as plugin, t as PLUGIN_NAME } from "./plugin-BvQt8gSt.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-DYVtpuio.mjs";
 //#region src/configs/index.ts
 const configs = { recommended: {
 	plugins: { [PLUGIN_NAME]: plugin },

package/dist/oxlint.mjs

@@ -1,4 +1,4 @@
-import { n as plugin, t as PLUGIN_NAME } from "./plugin-BvQt8gSt.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-DYVtpuio.mjs";
 import { definePlugin } from "@oxlint/plugins";
 //#region src/oxlint.ts
 /**

package/dist/{plugin-BvQt8gSt.mjs → plugin-DYVtpuio.mjs}

@@ -1,5 +1,9 @@
-import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSyncFn } from "synckit";
+import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
 import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
 import { requiresQuoting } from "@typescript-eslint/type-utils";
 import assert from "node:assert";
@@ -9,7 +13,7 @@ import ts9 from "typescript";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "0.1.11";
+var version = "0.1.12";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -78,24 +82,480 @@ function createFlawlessRule({ createOnce, ...meta }) {
 	return Object.assign(module, { createOnce });
 }
 //#endregion
+//#region src/rules/arrow-return-style/rule.ts
+const RULE_NAME$12 = "arrow-return-style";
+const IMPLICIT = "useImplicitReturn";
+const EXPLICIT = "useExplicitReturn";
+const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
+const DEFAULTS = {
+	jsxAlwaysUseExplicitReturn: false,
+	maxLen: 80,
+	maxObjectProperties: 4,
+	namedExportsAlwaysUseExplicitReturn: true,
+	objectReturnStyle: "complex-explicit",
+	tabWidth: 4,
+	useOxfmt: true
+};
+/** `undefined` = not initialized yet; `null` = initialization failed. */
+let formatSync;
+function getFormatSync() {
+	if (formatSync !== void 0) return formatSync;
+	try {
+		const directory = path.dirname(fileURLToPath(import.meta.url));
+		const workerPath = [
+			path.join(directory, "worker.mjs"),
+			path.join(directory, "rules", "arrow-return-style", "worker.mjs"),
+			path.join(directory, "worker.ts")
+		].find((candidate) => existsSync(candidate));
+		if (workerPath === void 0) formatSync = null;
+		else formatSync = createSyncFn(workerPath, {
+			timeout: 15e3,
+			...workerPath.endsWith(".ts") ? { tsRunner: "tsx" } : {}
+		});
+	} catch {
+		formatSync = null;
+	}
+	return formatSync;
+}
+/**
+* Worker verdicts cached across files and fix passes: a snippet formats the
+* same way regardless of which file (or autofix iteration) asked. Bounded LRU
+* so long sessions (editors, watch mode) cannot grow it without limit.
+*/
+const formatCache = /* @__PURE__ */ new Map();
+const FORMAT_CACHE_MAX_ENTRIES = 1024;
+function formatCacheGet(key) {
+	const value = formatCache.get(key);
+	if (value !== void 0) {
+		formatCache.delete(key);
+		formatCache.set(key, value);
+	}
+	return value;
+}
+function formatCacheSet(key, value) {
+	formatCache.delete(key);
+	formatCache.set(key, value);
+	if (formatCache.size > FORMAT_CACHE_MAX_ENTRIES) {
+		const oldest = formatCache.keys().next().value;
+		if (oldest !== void 0) formatCache.delete(oldest);
+	}
+}
+/**
+* Visual width of `text` with tabs expanded to `tabWidth`-column tab stops.
+*
+* @param text - The text to measure.
+* @param tabWidth - Columns a tab occupies.
+* @returns The tab-expanded width in columns.
+*/
+function expandedWidth(text, tabWidth) {
+	let width = 0;
+	for (const character of text) width += character === "	" ? tabWidth - width % tabWidth : 1;
+	return width;
+}
+function leadingWhitespace(line) {
+	return /^[\t ]*/.exec(line)?.[0] ?? "";
+}
+function isJsx(node) {
+	return node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment;
+}
+function isNamedExportArrow(node) {
+	if (node.parent.type !== AST_NODE_TYPES.VariableDeclarator) return false;
+	return node.parent.parent.parent.type === AST_NODE_TYPES.ExportNamedDeclaration;
+}
+/**
+* Does the collapsed body need wrapping parens to stay an expression body?
+*
+* @param node - The would-be implicit body expression.
+* @returns Whether the fixer must wrap the body in parentheses.
+*/
+function needsParens(node) {
+	return node.type === AST_NODE_TYPES.ObjectExpression || node.type === AST_NODE_TYPES.SequenceExpression;
+}
+function countObjectComplexity(node) {
+	let features = 0;
+	for (const property of node.properties) {
+		if (property.type === AST_NODE_TYPES.SpreadElement) {
+			features += 1;
+			continue;
+		}
+		if (property.computed) features += 1;
+		if (property.value.type === AST_NODE_TYPES.CallExpression) features += 1;
+	}
+	return features;
+}
+function isComplexLiteral(node, maxObjectProperties) {
+	if (node.type === AST_NODE_TYPES.ObjectExpression) {
+		if (node.properties.length > maxObjectProperties) return true;
+		return countObjectComplexity(node) >= 2;
+	}
+	if (node.type === AST_NODE_TYPES.ArrayExpression) {
+		const spreads = node.elements.filter((element) => element?.type === AST_NODE_TYPES.SpreadElement).length;
+		const calls = node.elements.filter((element) => element?.type === AST_NODE_TYPES.CallExpression).length;
+		return spreads >= 1 && node.elements.length > 1 || calls >= 2 || spreads + calls >= 2;
+	}
+	return false;
+}
+function isLiteralBody(node) {
+	return node.type === AST_NODE_TYPES.ObjectExpression || node.type === AST_NODE_TYPES.ArrayExpression;
+}
+/**
+* Walks up to the outermost node whose parent is the Program.
+*
+* @param node - The node to walk up from.
+* @returns The top-level statement containing `node`.
+*/
+function statementOf(node) {
+	let current = node;
+	while (current.parent !== void 0 && current.parent.type !== AST_NODE_TYPES.Program) current = current.parent;
+	return current;
+}
+function pushChildNodes$1(stack, value) {
+	const candidates = Array.isArray(value) ? value : [value];
+	for (const item of candidates) if (typeof item === "object" && item !== null && "type" in item) stack.push(item);
+}
+/**
+* Collects arrow functions in `root`'s subtree, ordered by source position.
+*
+* @param root - The subtree to search.
+* @returns All arrow function nodes, sorted by range start.
+*/
+function collectArrows(root) {
+	const arrows = [];
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0) continue;
+		if (current.type === AST_NODE_TYPES.ArrowFunctionExpression) arrows.push(current);
+		for (const [key, value] of Object.entries(current)) if (key !== "parent" && key !== "loc" && key !== "range") pushChildNodes$1(stack, value);
+	}
+	return arrows.sort((a, b) => a.range[0] - b.range[0]);
+}
+const arrowReturnStyle = createFlawlessRule({
+	name: RULE_NAME$12,
+	createOnce(context) {
+		let config = DEFAULTS;
+		let sourceCode;
+		let lines;
+		let pendingConsults;
+		/**
+		* Effective line-length limit for emitted lines: the fixer must never
+		* produce a line the formatter would immediately rewrap.
+		*
+		* @returns The maximum permitted tab-expanded line width.
+		*/
+		function limit() {
+			const { maxLen, useOxfmt } = config;
+			return useOxfmt === false ? maxLen : Math.min(maxLen, printWidth());
+		}
+		function printWidth() {
+			const { maxLen, useOxfmt } = config;
+			if (typeof useOxfmt === "object" && typeof useOxfmt.printWidth === "number") return useOxfmt.printWidth;
+			return maxLen;
+		}
+		function width(text) {
+			return expandedWidth(text, config.tabWidth);
+		}
+		function lineOf(lineNumber) {
+			return lines[lineNumber - 1] ?? "";
+		}
+		function objectStyleWantsExplicit(body) {
+			if (!isLiteralBody(body) || config.objectReturnStyle === "off") return false;
+			if (config.objectReturnStyle === "always-explicit") return true;
+			return isComplexLiteral(body, config.maxObjectProperties);
+		}
+		function arrowTokenOf(node) {
+			let token = sourceCode.getTokenBefore(node.body);
+			while (token !== null && token.value === "(") token = sourceCode.getTokenBefore(token);
+			if (token?.value !== "=>") throw new Error("arrow-return-style: could not locate the => token");
+			return token;
+		}
+		/**
+		* The `(`/`)` pair directly wrapping the body, if any.
+		*
+		* @param node - Function whose body may be parenthesized.
+		* @param arrowToken - Token of the `=>` operator, used to distinguish
+		*   body parens from parameter-list parens.
+		* @returns The wrapping paren tokens, or `null` when not parenthesized.
+		*/
+		function bodyParens(node, arrowToken) {
+			const before = sourceCode.getTokenBefore(node.body);
+			if (before?.value !== "(" || before.range[0] < arrowToken.range[1]) return null;
+			const after = sourceCode.getTokenAfter(node.body);
+			if (after?.value !== ")") return null;
+			return {
+				close: after,
+				open: before
+			};
+		}
+		/**
+		* Resolves every deferred oxfmt consult with a single worker round-trip:
+		* would the formatter render each arrow (params through body) on a single
+		* line that fits `maxLen`? Arrows the formatter cannot keep on one fitting
+		* line are reported. Fails open (no report) when the worker or oxfmt is
+		* unavailable so that an unavailable formatter can never introduce reports
+		* it would have to fight over.
+		*/
+		function resolvePendingConsults() {
+			if (pendingConsults.length === 0) return;
+			const nodes = pendingConsults;
+			pendingConsults = [];
+			const worker = getFormatSync();
+			if (worker === null) return;
+			const consults = nodes.flatMap((node) => {
+				const statement = statementOf(node);
+				const snippet = sourceCode.getText(statement);
+				const baseIndent = leadingWhitespace(lineOf(statement.loc.start.line));
+				const arrowIndex = collectArrows(statement).findIndex((arrow) => arrow.range[0] === node.range[0]);
+				if (arrowIndex === -1) return [];
+				const request = {
+					arrowIndex,
+					code: `${snippet}\n`,
+					printWidth: printWidth(),
+					tabWidth: config.tabWidth
+				};
+				return [{
+					baseIndent,
+					cacheKey: `${arrowIndex}${request.printWidth}${request.tabWidth}${snippet}`,
+					node,
+					request
+				}];
+			});
+			const misses = /* @__PURE__ */ new Map();
+			for (const consult of consults) if (formatCacheGet(consult.cacheKey) === void 0) misses.set(consult.cacheKey, consult.request);
+			if (misses.size > 0) {
+				let responses = [];
+				try {
+					responses = worker([...misses.values()]);
+				} catch {
+					responses = [];
+				}
+				for (const [index, cacheKey] of [...misses.keys()].entries()) {
+					const response = responses[index];
+					if (response !== void 0) formatCacheSet(cacheKey, response);
+				}
+			}
+			for (const consult of consults) {
+				const response = formatCacheGet(consult.cacheKey);
+				if (response === void 0) continue;
+				if (response.lineText === null) continue;
+				if (!(response.singleLine && width(consult.baseIndent) + width(response.lineText) <= config.maxLen)) reportExplicit(consult.node, EXPLICIT);
+			}
+		}
+		/**
+		* Derives the one-level indent unit for an inserted block: prefer the
+		* offset between the arrow's line and the body's (or its continuation's)
+		* deeper indentation; otherwise infer from the indent character in use.
+		*
+		* @param arrowIndent - Leading whitespace of the arrow's line.
+		* @param node - The arrow function being fixed.
+		* @param bodyStart - The body's first token or node (including parens).
+		* @param bodyEnd - The body's last token or node (including parens).
+		* @returns The whitespace string for one indentation level.
+		*/
+		function indentUnit(arrowIndent, node, bodyStart, bodyEnd) {
+			const referenceLines = [];
+			const arrowLine = bodyStart.loc.start.line;
+			if (bodyStart.loc.start.line !== node.loc.start.line) referenceLines.push(bodyStart.loc.start.line);
+			else if (bodyEnd.loc.end.line > arrowLine) referenceLines.push(arrowLine + 1);
+			for (const lineNumber of referenceLines) {
+				const reference = leadingWhitespace(lineOf(lineNumber));
+				if (reference.length > arrowIndent.length && reference.startsWith(arrowIndent)) return reference.slice(arrowIndent.length);
+			}
+			if (arrowIndent.includes("	")) return "	";
+			return arrowIndent.length > 0 ? "  " : "	";
+		}
+		/**
+		* Reports and fixes an implicit arrow into an explicit block body.
+		*
+		* @param node - The arrow function to convert.
+		* @param messageId - The violation to report.
+		*/
+		function reportExplicit(node, messageId) {
+			const arrowToken = arrowTokenOf(node);
+			const parens = bodyParens(node, arrowToken);
+			const bodyStart = parens?.open ?? node.body;
+			const bodyEnd = parens?.close ?? node.body;
+			const comments = sourceCode.getCommentsBefore(bodyStart);
+			const arrowIndent = leadingWhitespace(lineOf(node.loc.start.line));
+			const targetIndent = arrowIndent + indentUnit(arrowIndent, node, bodyStart, bodyEnd);
+			const bodyLines = sourceCode.getText(node.body).split("\n");
+			const [firstLine, ...restLines] = bodyLines;
+			const lastLineIndent = leadingWhitespace(bodyLines.at(-1) ?? "");
+			let shifted = restLines;
+			if (restLines.length > 0) {
+				if (targetIndent.startsWith(lastLineIndent)) {
+					const prefix = targetIndent.slice(lastLineIndent.length);
+					shifted = restLines.map((line) => prefix + line);
+				} else if (lastLineIndent.startsWith(targetIndent)) {
+					const strip = lastLineIndent.length - targetIndent.length;
+					shifted = restLines.map((line) => {
+						return leadingWhitespace(line).length >= strip ? line.slice(strip) : line;
+					});
+				}
+			}
+			const commentLines = comments.map((comment) => targetIndent + sourceCode.getText(comment));
+			const returnLine = `${targetIndent}return ${[firstLine, ...shifted].join("\n")};`;
+			const replacement = ` {\n${[...commentLines, returnLine].join("\n")}\n${arrowIndent}}`;
+			context.report({
+				fix: (fixer) => fixer.replaceTextRange([arrowToken.range[1], bodyEnd.range[1]], replacement),
+				messageId,
+				node
+			});
+		}
+		/**
+		* Reports and fixes a single-`return` block into an implicit body.
+		*
+		* @param node - The arrow function to convert.
+		* @param block - The block body being replaced.
+		* @param replacement - The implicit body text.
+		*/
+		function reportImplicit(node, block, replacement) {
+			context.report({
+				fix: (fixer) => fixer.replaceTextRange(block.range, replacement),
+				messageId: IMPLICIT,
+				node
+			});
+		}
+		function checkBlockBody(node) {
+			const block = node.body;
+			if (block.body.length !== 1) return;
+			const [statement] = block.body;
+			if (statement?.type !== AST_NODE_TYPES.ReturnStatement || statement.argument === null) return;
+			if (sourceCode.getCommentsInside(block).length > 0) return;
+			const { argument } = statement;
+			if (isJsx(argument) && config.jsxAlwaysUseExplicitReturn) return;
+			if (isNamedExportArrow(node) && config.namedExportsAlwaysUseExplicitReturn) return;
+			if (objectStyleWantsExplicit(argument)) return;
+			if (argument.loc.start.line !== argument.loc.end.line) return;
+			const argumentText = sourceCode.getText(argument);
+			const collapsed = needsParens(argument) ? `(${argumentText})` : argumentText;
+			const prefix = lineOf(block.loc.start.line).slice(0, block.loc.start.column);
+			const suffix = lineOf(block.loc.end.line).slice(block.loc.end.column);
+			if (width(prefix + collapsed + suffix) > limit()) return;
+			reportImplicit(node, block, collapsed);
+		}
+		function checkExpressionBody(node) {
+			const body = node.body;
+			const arrowToken = arrowTokenOf(node);
+			const parens = bodyParens(node, arrowToken);
+			const bodyStart = parens?.open ?? body;
+			const bodyEnd = parens?.close ?? body;
+			if (sourceCode.getCommentsBefore(bodyStart).length > 0) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (isJsx(body) && config.jsxAlwaysUseExplicitReturn) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (isNamedExportArrow(node) && config.namedExportsAlwaysUseExplicitReturn) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (bodyStart.loc.start.line !== arrowToken.loc.end.line) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (bodyEnd.loc.end.line !== bodyStart.loc.start.line) {
+				if (body.type === AST_NODE_TYPES.ObjectExpression) reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (width(lineOf(bodyStart.loc.start.line)) > limit()) {
+				if (config.useOxfmt !== false) pendingConsults.push(node);
+				else reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (objectStyleWantsExplicit(body)) reportExplicit(node, COMPLEX_EXPLICIT);
+		}
+		return {
+			"ArrowFunctionExpression": function(node) {
+				if (node.body.type === AST_NODE_TYPES.BlockStatement) checkBlockBody(node);
+				else checkExpressionBody(node);
+			},
+			"before": function() {
+				config = {
+					...DEFAULTS,
+					...context.options[0]
+				};
+				({sourceCode} = context);
+				lines = [...sourceCode.lines];
+				pendingConsults = [];
+			},
+			"Program:exit": function() {
+				resolvePendingConsults();
+			}
+		};
+	},
+	defaultOptions: [DEFAULTS],
+	meta: {
+		docs: {
+			description: "Enforce arrow function return style based on line length",
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		messages: {
+			[COMPLEX_EXPLICIT]: "Use an explicit return block for complex object or array bodies.",
+			[EXPLICIT]: "Use an explicit return block for this arrow function body.",
+			[IMPLICIT]: "Use an implicit return for this arrow function body."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				jsxAlwaysUseExplicitReturn: { type: "boolean" },
+				maxLen: {
+					minimum: 0,
+					type: "integer"
+				},
+				maxObjectProperties: {
+					minimum: 0,
+					type: "integer"
+				},
+				namedExportsAlwaysUseExplicitReturn: { type: "boolean" },
+				objectReturnStyle: {
+					enum: [
+						"always-explicit",
+						"complex-explicit",
+						"off"
+					],
+					type: "string"
+				},
+				tabWidth: {
+					minimum: 1,
+					type: "integer"
+				},
+				useOxfmt: { oneOf: [{ type: "boolean" }, {
+					additionalProperties: false,
+					properties: { printWidth: {
+						minimum: 0,
+						type: "integer"
+					} },
+					type: "object"
+				}] }
+			},
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/rules/jsx-shorthand-boolean/rule.ts
-const RULE_NAME$10 = "jsx-shorthand-boolean";
-const MESSAGE_ID$4 = "setAttributeValue";
-const messages$10 = { [MESSAGE_ID$4]: "Set an explicit value for boolean attribute '{{name}}'." };
-function createOnce$6(context) {
+const RULE_NAME$11 = "jsx-shorthand-boolean";
+const MESSAGE_ID$5 = "setAttributeValue";
+const messages$11 = { [MESSAGE_ID$5]: "Set an explicit value for boolean attribute '{{name}}'." };
+function createOnce$7(context) {
 	return { JSXAttribute(node) {
 		if (node.value !== null) return;
 		context.report({
 			data: { name: context.sourceCode.getText(node.name) },
 			fix: (fixer) => fixer.insertTextAfter(node.name, "={true}"),
-			messageId: MESSAGE_ID$4,
+			messageId: MESSAGE_ID$5,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createFlawlessRule({
-	name: RULE_NAME$10,
-	createOnce: createOnce$6,
+	name: RULE_NAME$11,
+	createOnce: createOnce$7,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -105,19 +565,19 @@ const jsxShorthandBoolean = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		messages: messages$11,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$9 = "jsx-shorthand-fragment";
+const RULE_NAME$10 = "jsx-shorthand-fragment";
 const MESSAGE_ID_NAMED = "useNamedFragment";
 const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
 const DEFAULT_MODE = "syntax";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$9 = {
+const messages$10 = {
 	[MESSAGE_ID_NAMED]: "Use the '{{name}}' component instead of fragment shorthand syntax.",
 	[MESSAGE_ID_SHORTHAND]: "Use the fragment shorthand syntax '<>...</>' instead of the '{{name}}' component."
 };
@@ -153,7 +613,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$5(context) {
+function createOnce$6(context) {
 	let mode;
 	let fragmentName;
 	let namedFragments;
@@ -200,8 +660,8 @@ function createOnce$5(context) {
 	};
 }
 const jsxShorthandFragment = createFlawlessRule({
-	name: RULE_NAME$9,
-	createOnce: createOnce$5,
+	name: RULE_NAME$10,
+	createOnce: createOnce$6,
 	defaultOptions: [{
 		fragmentName: DEFAULT_FRAGMENT_NAME,
 		mode: DEFAULT_MODE
@@ -218,7 +678,7 @@ const jsxShorthandFragment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$10,
 		schema: schema$2,
 		type: "suggestion"
 	}
@@ -1383,8 +1843,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$8 = "naming-convention";
-const messages$8 = {
+const RULE_NAME$9 = "naming-convention";
+const messages$9 = {
 	doesNotMatchFormat: "{{type}} name `{{name}}` must match one of the following formats: {{formats}}",
 	doesNotMatchFormatTrimmed: "{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}",
 	missingAffix: "{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}",
@@ -1732,7 +2192,7 @@ function create$3(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$8,
+	name: RULE_NAME$9,
 	create: create$3,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
@@ -1743,7 +2203,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$8,
+		messages: messages$9,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -1773,6 +2233,121 @@ function requiresQuoting$1(node, target) {
 	return requiresQuoting(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target);
 }
 //#endregion
+//#region src/rules/no-export-default-arrow/rule.ts
+const RULE_NAME$8 = "no-export-default-arrow";
+const MESSAGE_ID$4 = "disallowExportDefaultArrow";
+const messages$8 = { [MESSAGE_ID$4]: "Assign the arrow function to a named constant instead of exporting it anonymously." };
+/**
+* Converts a filename stem to camelCase, treating `-`, `_`, and whitespace as
+* word separators (`use-mouse` -> `useMouse`).
+*
+* @param value - The filename stem.
+* @returns The camelCase name.
+*/
+function toCamelCase(value) {
+	return value.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() ?? "").replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+/**
+* Converts a filename stem to PascalCase, treating `-`, `_`, and whitespace as
+* word separators (`use-mouse` -> `UseMouse`).
+*
+* @param value - The filename stem.
+* @returns The PascalCase name.
+*/
+function toPascalCase(value) {
+	return value.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() ?? "").replace(/^[a-z]/, (char) => char.toUpperCase());
+}
+/**
+* Checks whether a node is a JSX element or fragment.
+*
+* @param node - The expression to test.
+* @returns `true` when the node renders JSX.
+*/
+function isJsxElement(node) {
+	return node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment;
+}
+/**
+* Collects the expressions an arrow function can return: the body itself for a
+* concise arrow, or every `return` argument for a block body.
+*
+* @param body - The arrow function's body.
+* @returns The returned expressions, in source order.
+*/
+function getArrowReturnValues(body) {
+	if (body.type !== AST_NODE_TYPES.BlockStatement) return [body];
+	return body.body.filter((node) => node.type === AST_NODE_TYPES.ReturnStatement).map((node) => node.argument).filter((argument) => argument !== null);
+}
+/**
+* Determines whether an arrow function is a component — that is, whether any of
+* its return values is JSX — which selects PascalCase for the generated name.
+*
+* @param body - The arrow function's body.
+* @returns `true` when the arrow can return JSX.
+*/
+function arrowReturnIsJsxElement(body) {
+	return getArrowReturnValues(body).some((node) => isJsxElement(node));
+}
+/**
+* Builds the autofix: replaces the `export default` declaration with a named
+* `const` derived from the filename, and appends `export default <name>` after
+* the file's last token (comments included, so a trailing comment keeps its
+* position).
+*
+* @param options - The reported arrow, its export declaration, and the context
+*   and source code needed to derive the name and locate the file's end.
+* @returns A fixer callback producing both edits.
+*/
+function createFixFunction({ arrowFunction, context, exportDeclaration, sourceCode }) {
+	return (fixer) => {
+		const program = sourceCode.ast;
+		const lastToken = sourceCode.getLastToken(program, { includeComments: true });
+		const fileName = context.physicalFilename || context.filename || "namedFunction";
+		const { name: stem } = path.parse(fileName);
+		const functionName = arrowReturnIsJsxElement(arrowFunction.body) ? toPascalCase(stem) : toCamelCase(stem);
+		return [fixer.replaceText(exportDeclaration, `const ${functionName} = ${sourceCode.getText(arrowFunction)}`), fixer.insertTextAfter(lastToken ?? exportDeclaration, `\n\nexport default ${functionName}`)];
+	};
+}
+/**
+* Reports anonymous arrow functions used as `export default`, which surface as
+* unnamed functions in stack traces and devtools.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$5(context) {
+	return { ArrowFunctionExpression(node) {
+		const { parent } = node;
+		if (parent.type !== AST_NODE_TYPES.ExportDefaultDeclaration) return;
+		context.report({
+			fix: createFixFunction({
+				arrowFunction: node,
+				context,
+				exportDeclaration: parent,
+				sourceCode: context.sourceCode
+			}),
+			messageId: MESSAGE_ID$4,
+			node
+		});
+	} };
+}
+const noExportDefaultArrow = createFlawlessRule({
+	name: RULE_NAME$8,
+	createOnce: createOnce$5,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow anonymous arrow functions as export default declarations",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$8,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/utils/nested-expressions.ts
 /**
 * Determines whether the given AST subtree contains a call or `new`
@@ -3631,9 +4206,11 @@ const plugin = {
 		version
 	},
 	rules: {
+		"arrow-return-style": arrowReturnStyle,
 		"jsx-shorthand-boolean": jsxShorthandBoolean,
 		"jsx-shorthand-fragment": jsxShorthandFragment,
 		"naming-convention": namingConvention,
+		"no-export-default-arrow": noExportDefaultArrow,
 		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
 		"prefer-destructuring-assignment": preferDestructuringAssignment,

package/dist/rules/arrow-return-style/worker.d.mts

@@ -0,0 +1,25 @@
+//#region src/rules/arrow-return-style/worker.d.ts
+/**
+ * One entry of the batched request sent by the rule: format `code` with oxfmt
+ * and locate the `arrowIndex`-th arrow function (in source order) in the
+ * formatted output. Requests are batched per linted file so a file pays the
+ * worker round-trip cost once, not once per arrow.
+ */
+interface FormatRequest {
+  arrowIndex: number;
+  code: string;
+  printWidth: number;
+  tabWidth: number;
+}
+/**
+ * Response: whether the arrow (params through body) occupies a single line in
+ * the formatted output, and that line's text for width measurement. `lineText`
+ * is `null` when formatting failed or the arrow could not be located, which
+ * callers must treat as "no verdict".
+ */
+interface FormatResponse {
+  lineText: null | string;
+  singleLine: boolean;
+}
+//#endregion
+export { FormatRequest, FormatResponse };

package/dist/rules/arrow-return-style/worker.mjs

@@ -0,0 +1,90 @@
+import { runAsWorker } from "synckit";
+//#region src/rules/arrow-return-style/worker.ts
+function isNodeLike(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+/**
+* Collects all arrow function nodes in the tree, ordered by source position.
+*
+* @param root - The parsed AST to search.
+* @returns All arrow function nodes, sorted by start offset.
+*/
+function collectArrows(root) {
+	const arrows = [];
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (typeof current !== "object" || current === null) continue;
+		if (isNodeLike(current) && current.type === "ArrowFunctionExpression") arrows.push(current);
+		for (const value of Object.values(current)) if (Array.isArray(value)) stack.push(...value);
+		else if (typeof value === "object" && value !== null) stack.push(value);
+	}
+	return arrows.sort((a, b) => a.start - b.start);
+}
+/**
+* Start offsets of every line in `code`, for offset-to-line lookups.
+*
+* @param code - The source text.
+* @returns Ascending offsets at which each line begins.
+*/
+function lineStartsOf(code) {
+	const starts = [0];
+	for (let index = 0; index < code.length; index += 1) if (code.charAt(index) === "\n") starts.push(index + 1);
+	return starts;
+}
+/**
+* Index (0-based) of the line containing `offset`.
+*
+* @param starts - Line start offsets from {@link lineStartsOf}.
+* @param offset - The source offset to locate.
+* @returns The containing line's index.
+*/
+function lineIndexOf(starts, offset) {
+	let low = 0;
+	let high = starts.length - 1;
+	while (low < high) {
+		const mid = Math.ceil((low + high) / 2);
+		if ((starts[mid] ?? 0) <= offset) low = mid;
+		else high = mid - 1;
+	}
+	return low;
+}
+async function formatOne(request) {
+	const { format } = await import("oxfmt");
+	const { parseSync } = await import("oxc-parser");
+	const result = await format("snippet.tsx", request.code, {
+		endOfLine: "lf",
+		printWidth: request.printWidth,
+		semi: true,
+		tabWidth: request.tabWidth,
+		useTabs: true
+	});
+	if (result.errors.length > 0) return {
+		lineText: null,
+		singleLine: false
+	};
+	const parsed = parseSync("snippet.tsx", result.code);
+	if (parsed.errors.length > 0) return {
+		lineText: null,
+		singleLine: false
+	};
+	const arrow = collectArrows(parsed.program)[request.arrowIndex];
+	if (arrow === void 0) return {
+		lineText: null,
+		singleLine: false
+	};
+	const starts = lineStartsOf(result.code);
+	const startLine = lineIndexOf(starts, arrow.start);
+	const lineEnd = starts[startLine + 1] ?? result.code.length + 1;
+	return {
+		lineText: result.code.slice(starts[startLine], lineEnd - 1),
+		singleLine: startLine === lineIndexOf(starts, arrow.end)
+	};
+}
+runAsWorker(async (requests) => {
+	const responses = [];
+	for (const request of requests) responses.push(await formatOne(request));
+	return responses;
+});
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-flawless",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",
@@ -40,6 +40,9 @@
     "@typescript-eslint/scope-manager": "8.62.1",
     "@typescript-eslint/type-utils": "8.62.1",
     "@typescript-eslint/utils": "8.62.1",
+    "oxc-parser": "0.112.0",
+    "oxfmt": "0.59.0",
+    "synckit": "0.11.13",
     "toml-eslint-parser": "1.0.3"
   },
   "devDependencies": {
@@ -58,6 +61,7 @@
     "eslint-plugin-pnpm": "1.6.1",
     "eslint-plugin-toml": "1.4.0",
     "eslint-plugin-yml": "3.5.0",
+    "eslint-rule-benchmark": "0.8.0",
     "eslint-vitest-rule-tester": "3.1.0",
     "jiti": "2.7.0",
     "lint-staged": "17.0.8",
@@ -82,6 +86,8 @@
     "provenance": true
   },
   "scripts": {
+    "prebench": "nr build",
+    "bench": "eslint-rule-benchmark run --eslint-config benchmark/eslint.config.mjs",
     "build": "tsdown --clean --dts",
     "create-rule": "tsx scripts/create-rule.ts",
     "dev": "tsdown --stub",