eslint-plugin-flawless 0.1.8 → 0.1.10

package/README.md

@@ -184,6 +184,7 @@ Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 | [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                             | 🔧  |     |
+| [prefer-parameter-destructuring](src/rules/prefer-parameter-destructuring/documentation.md)   | Enforce destructuring parameters in the function signature                       | 🔧  |     |
 | [purity](src/rules/purity/documentation.md)                                                   | Disallow impure calls such as `math.random` or `os.clock` during render          |     |     |
 | [toml-sort-keys](src/rules/toml-sort-keys/documentation.md)                                   | Enforce a configured sort order for TOML keys and tables                         | 🔧  |     |
 | [yaml-block-key-blank-lines](src/rules/yaml-block-key-blank-lines/documentation.md)           | Enforce blank lines around top-level YAML block collection keys                  | 🔧  |     |

package/dist/index.d.mts

@@ -24,7 +24,7 @@ interface JsxShorthandFragmentOptions {
    */
   readonly mode?: Mode;
 }
-type Options$3 = [JsxShorthandFragmentOptions?];
+type Options$4 = [JsxShorthandFragmentOptions?];
 type Mode = "element" | "syntax";
 //#endregion
 //#region src/rules/naming-convention/utils/enums.d.ts
@@ -135,7 +135,7 @@ interface NamingSelector {
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
 type MessageIds$2 = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
-type Options$2 = Array<NamingSelector>;
+type Options$3 = Array<NamingSelector>;
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.d.ts
 declare const MESSAGE_ID_DEFAULT$1 = "default";
@@ -147,6 +147,16 @@ declare const MESSAGE_ID_DEFAULT = "default";
 declare const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
 type MessageIds = typeof MESSAGE_ID_DEFAULT | typeof MESSAGE_ID_INSIDE_USE_EFFECT;
 //#endregion
+//#region src/rules/prefer-parameter-destructuring/rule.d.ts
+type Options$2 = [{
+  /**
+   * Whether the autofix may hoist pattern defaults and computed keys past
+   * earlier statements, reordering their side effects. Defaults to `true`;
+   * set to `false` to withhold the fix in those cases.
+   */
+  allowSideEffectReordering?: boolean;
+}];
+//#endregion
 //#region src/rules/purity/rule.d.ts
 interface PurityOptions {
   /**
@@ -182,10 +192,10 @@ declare const plugin: {
     "jsx-shorthand-boolean": TSESLint.RuleModule<"setAttributeValue", [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
-    "jsx-shorthand-fragment": TSESLint.RuleModule<MessageIds$3, Options$3, PluginDocumentation, TSESLint.RuleListener> & {
+    "jsx-shorthand-fragment": TSESLint.RuleModule<MessageIds$3, Options$4, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
-    "naming-convention": TSESLint.RuleModule<MessageIds$2, Options$2, PluginDocumentation, TSESLint.RuleListener> & {
+    "naming-convention": TSESLint.RuleModule<MessageIds$2, Options$3, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
     "no-unnecessary-use-callback": TSESLint.RuleModule<MessageIds$1, [], PluginDocumentation, TSESLint.RuleListener> & {
@@ -197,6 +207,9 @@ declare const plugin: {
     "prefer-destructuring-assignment": TSESLint.RuleModule<"default", [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
+    "prefer-parameter-destructuring": TSESLint.RuleModule<"default", Options$2, PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
     purity: TSESLint.RuleModule<"impureCall", Options$1, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
@@ -223,10 +236,10 @@ declare const _default: {
             "jsx-shorthand-boolean": import("${configDir}").RuleModule<"setAttributeValue", [], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
-            "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
+            "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$4, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
-            "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
+            "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
             "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
@@ -238,6 +251,9 @@ declare const _default: {
             "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
+            "prefer-parameter-destructuring": import("${configDir}").RuleModule<"default", Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
             purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
@@ -261,10 +277,10 @@ declare const _default: {
     "jsx-shorthand-boolean": import("${configDir}").RuleModule<"setAttributeValue", [], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
-    "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
+    "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$4, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
-    "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
+    "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
     "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
@@ -276,6 +292,9 @@ declare const _default: {
     "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
+    "prefer-parameter-destructuring": import("${configDir}").RuleModule<"default", Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
     purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };

package/dist/index.mjs

@@ -8,7 +8,7 @@ import { findVariable } from "@typescript-eslint/utils/ast-utils";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "0.1.8";
+var version = "0.1.10";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -35,24 +35,24 @@ function createEslintRule(rule) {
 }
 //#endregion
 //#region src/rules/jsx-shorthand-boolean/rule.ts
-const RULE_NAME$8 = "jsx-shorthand-boolean";
-const MESSAGE_ID$3 = "setAttributeValue";
-const messages$8 = { [MESSAGE_ID$3]: "Set an explicit value for boolean attribute '{{name}}'." };
-function create$8(context) {
+const RULE_NAME$9 = "jsx-shorthand-boolean";
+const MESSAGE_ID$4 = "setAttributeValue";
+const messages$9 = { [MESSAGE_ID$4]: "Set an explicit value for boolean attribute '{{name}}'." };
+function create$9(context) {
 	const { sourceCode } = context;
 	return { JSXAttribute(node) {
 		if (node.value !== null) return;
 		context.report({
 			data: { name: sourceCode.getText(node.name) },
 			fix: (fixer) => fixer.insertTextAfter(node.name, "={true}"),
-			messageId: MESSAGE_ID$3,
+			messageId: MESSAGE_ID$4,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createEslintRule({
-	name: RULE_NAME$8,
-	create: create$8,
+	name: RULE_NAME$9,
+	create: create$9,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -62,19 +62,19 @@ const jsxShorthandBoolean = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$8,
+		messages: messages$9,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$7 = "jsx-shorthand-fragment";
+const RULE_NAME$8 = "jsx-shorthand-fragment";
 const MESSAGE_ID_NAMED = "useNamedFragment";
 const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
 const DEFAULT_MODE = "syntax";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$7 = {
+const messages$8 = {
 	[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."
 };
@@ -110,7 +110,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function create$7(context) {
+function create$8(context) {
 	const options = context.options[0] ?? {};
 	const mode = options.mode ?? DEFAULT_MODE;
 	const fragmentName = options.fragmentName ?? DEFAULT_FRAGMENT_NAME;
@@ -148,8 +148,8 @@ function create$7(context) {
 	} };
 }
 const jsxShorthandFragment = createEslintRule({
-	name: RULE_NAME$7,
-	create: create$7,
+	name: RULE_NAME$8,
+	create: create$8,
 	defaultOptions: [{
 		fragmentName: DEFAULT_FRAGMENT_NAME,
 		mode: DEFAULT_MODE
@@ -166,7 +166,7 @@ const jsxShorthandFragment = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$7,
+		messages: messages$8,
 		schema: schema$2,
 		type: "suggestion"
 	}
@@ -1331,8 +1331,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$6 = "naming-convention";
-const messages$6 = {
+const RULE_NAME$7 = "naming-convention";
+const messages$7 = {
 	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}}",
@@ -1362,12 +1362,11 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create$6(contextWithoutDefaults) {
+function create$7(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
 	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
-	function handleMember(validator, node, modifiers) {
-		const { key } = node;
+	function handleMember(validator, { key }, modifiers) {
 		if (requiresQuoting$1(key, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
 		validator(key, modifiers);
 	}
@@ -1600,8 +1599,7 @@ function create$6(contextWithoutDefaults) {
 			validator: validators.enum
 		},
 		"TSEnumMember": {
-			handler: (node, validator) => {
-				const { id } = node;
+			handler: ({ id }, validator) => {
 				const modifiers = /* @__PURE__ */ new Set();
 				if (requiresQuoting$1(id, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
 				validator(id, modifiers);
@@ -1682,8 +1680,8 @@ function create$6(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$6,
-	create: create$6,
+	name: RULE_NAME$7,
+	create: create$7,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -1693,7 +1691,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$6,
+		messages: messages$7,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -1813,8 +1811,7 @@ function resolve(sourceCode, node) {
 * @returns A rule `create` function.
 * @template MessageIds - The rule's message identifiers.
 */
-function createUnnecessaryHookRule(config) {
-	const { hook, messageIds } = config;
+function createUnnecessaryHookRule({ hook, messageIds }) {
 	const skipComputation = hook === "useMemo";
 	return (context) => {
 		const { sourceCode } = context;
@@ -1961,15 +1958,15 @@ function resolveFactory(sourceCode, node) {
 }
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$5 = "no-unnecessary-use-callback";
+const RULE_NAME$6 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$5 = {
+const messages$6 = {
 	[MESSAGE_ID_DEFAULT$1]: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary.",
 	[MESSAGE_ID_INSIDE_USE_EFFECT$1]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
 };
 const noUnnecessaryUseCallback = createEslintRule({
-	name: RULE_NAME$5,
+	name: RULE_NAME$6,
 	create: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -1985,22 +1982,22 @@ const noUnnecessaryUseCallback = createEslintRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$5,
+		messages: messages$6,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$4 = "no-unnecessary-use-memo";
+const RULE_NAME$5 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$4 = {
+const messages$5 = {
 	[MESSAGE_ID_DEFAULT]: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary.",
 	[MESSAGE_ID_INSIDE_USE_EFFECT]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
 };
 const noUnnecessaryUseMemo = createEslintRule({
-	name: RULE_NAME$4,
+	name: RULE_NAME$5,
 	create: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -2016,16 +2013,16 @@ const noUnnecessaryUseMemo = createEslintRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$4,
+		messages: messages$5,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/prefer-destructuring-assignment/rule.ts
-const RULE_NAME$3 = "prefer-destructuring-assignment";
-const MESSAGE_ID$2 = "default";
-const messages$3 = { [MESSAGE_ID$2]: "Use destructuring assignment for component props." };
+const RULE_NAME$4 = "prefer-destructuring-assignment";
+const MESSAGE_ID$3 = "default";
+const messages$4 = { [MESSAGE_ID$3]: "Use destructuring assignment for component props." };
 /**
 * Identifiers that cannot be used as a binding name in strict-mode module code.
 * A property may be accessed with such a name (`props.default`), but a shorthand
@@ -2151,7 +2148,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 	const propertyNames = collectPropertyNames(memberReferences);
 	if (!(!hasNonMemberReference && propertyNames !== null && !wouldShadowExistingBinding(context.sourceCode, scope, propertyVariable, memberReferences))) {
 		for (const { member } of memberReferences) context.report({
-			messageId: MESSAGE_ID$2,
+			messageId: MESSAGE_ID$3,
 			node: member
 		});
 		return;
@@ -2168,7 +2165,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 				if (index === 0) return [fixer.replaceTextRange([propsParameter.range[0], nameEnd], pattern), replaceAccess];
 				return replaceAccess;
 			},
-			messageId: MESSAGE_ID$2,
+			messageId: MESSAGE_ID$3,
 			node: member
 		});
 	}
@@ -2187,7 +2184,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function create$3(context) {
+function create$4(context) {
 	const { api, visitor } = core.getFunctionComponentCollector(context);
 	return {
 		...visitor,
@@ -2205,8 +2202,8 @@ function create$3(context) {
 	};
 }
 const preferDestructuringAssignment = createEslintRule({
-	name: RULE_NAME$3,
-	create: create$3,
+	name: RULE_NAME$4,
+	create: create$4,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -2216,12 +2213,364 @@ const preferDestructuringAssignment = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$3,
+		messages: messages$4,
 		schema: [],
 		type: "problem"
 	}
 });
 //#endregion
+//#region src/rules/prefer-parameter-destructuring/rule.ts
+const RULE_NAME$3 = "prefer-parameter-destructuring";
+const MESSAGE_ID$2 = "default";
+const messages$3 = { [MESSAGE_ID$2]: "Destructure parameter '{{name}}' in the function signature instead of the body." };
+/**
+* Collects the binding names introduced by a pattern (or parameter), including
+* names nested in object/array patterns, defaults, and rest elements.
+*
+* @param node - The pattern node to walk.
+* @param out - Receives every bound name, in source order.
+*/
+function collectBoundNames(node, out) {
+	switch (node.type) {
+		case AST_NODE_TYPES.ArrayPattern:
+			for (const element of node.elements) if (element !== null) collectBoundNames(element, out);
+			break;
+		case AST_NODE_TYPES.AssignmentPattern:
+			collectBoundNames(node.left, out);
+			break;
+		case AST_NODE_TYPES.Identifier:
+			out.push(node.name);
+			break;
+		case AST_NODE_TYPES.ObjectPattern:
+			for (const property of node.properties) collectBoundNames(property, out);
+			break;
+		case AST_NODE_TYPES.Property:
+			collectBoundNames(node.value, out);
+			break;
+		case AST_NODE_TYPES.RestElement:
+			collectBoundNames(node.argument, out);
+			break;
+		case AST_NODE_TYPES.TSParameterProperty:
+			collectBoundNames(node.parameter, out);
+			break;
+		default: break;
+	}
+}
+/**
+* Collects every top-level-body object destructuring of the parameter, or
+* bails when the parameter has any other reference (member access, call
+* argument, reassignment, a destructure inside a nested block or closure, …) —
+* those mean the parameter is genuinely used and must stay.
+*
+* @param variable - The parameter's resolved scope variable.
+* @param identifier - The parameter identifier (its default-value write
+*   reference is not a use).
+* @param body - The function body; only its direct child declarations qualify.
+* @returns The qualifying destructuring statements in source order, or `null`
+*   when the parameter has a non-destructuring reference.
+*/
+function collectDestructureStatements(variable, identifier, body) {
+	const statements = [];
+	for (const reference of variable.references) {
+		const referenceIdentifier = reference.identifier;
+		if (referenceIdentifier === identifier) continue;
+		const { parent } = referenceIdentifier;
+		if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.init === referenceIdentifier && parent.id.type === AST_NODE_TYPES.ObjectPattern && parent.parent.parent === body) statements.push({
+			declaration: parent.parent,
+			declarator: parent,
+			pattern: parent.id
+		});
+		else return null;
+	}
+	statements.sort((left, right) => left.declarator.range[0] - right.declarator.range[0]);
+	return statements;
+}
+/**
+* Collects the binding names of every parameter other than the target one, so
+* the fix can avoid creating a duplicate parameter name (a SyntaxError in a
+* non-simple parameter list).
+*
+* @param node - The function whose parameters are inspected.
+* @param parameter - The parameter being rewritten (excluded).
+* @returns The other parameters' bound names.
+*/
+function collectOtherParameterNames(node, parameter) {
+	const names = [];
+	for (const other of node.params) if (other !== parameter) collectBoundNames(other, names);
+	return new Set(names);
+}
+/**
+* A structural check for AST nodes reached through visitor keys.
+*
+* @param value - The child value to test.
+* @returns `true` when the value is an AST node.
+*/
+function isNodeLike(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/**
+* Checks whether a pattern subtree contains `await` or `yield` (in a computed
+* key or default value). Parameter initializers may not contain either, so no
+* signature form exists and the destructuring is not reported.
+*
+* @param root - The pattern to walk.
+* @param visitorKeys - The parser's visitor keys, used to walk without
+*   following `parent` links.
+* @returns `true` if `await`/`yield` appears anywhere in the pattern.
+*/
+function containsAwaitOrYield(root, visitorKeys) {
+	const stack = [root];
+	for (let current = stack.pop(); current !== void 0; current = stack.pop()) {
+		if (current.type === AST_NODE_TYPES.AwaitExpression || current.type === AST_NODE_TYPES.YieldExpression) return true;
+		for (const key of visitorKeys[current.type] ?? []) {
+			const child = current[key];
+			const children = Array.isArray(child) ? child : [child];
+			for (const item of children) if (isNodeLike(item)) stack.push(item);
+		}
+	}
+	return false;
+}
+/**
+* Extracts the identifier a parameter binds, unwrapping a default value
+* (`obj = {}`); patterns, rest parameters, and TS parameter properties yield
+* `null`.
+*
+* @param parameter - The parameter node.
+* @returns The parameter's identifier, or `null` when it is not a plain one.
+*/
+function getParameterIdentifier(parameter) {
+	if (parameter.type === AST_NODE_TYPES.Identifier) return parameter;
+	if (parameter.type === AST_NODE_TYPES.AssignmentPattern && parameter.left.type === AST_NODE_TYPES.Identifier) return parameter.left;
+	return null;
+}
+/**
+* Determines whether any expression inside the patterns (computed keys,
+* default values, moved type annotations) references a binding that would be
+* out of scope — or in its temporal dead zone — at the parameter position:
+* anything declared in the function body, a parameter at or after the target,
+* or this function's own `arguments`.
+*
+* @param query - The rewrite being planned.
+* @param patterns - The object patterns being moved.
+* @returns `true` when moving the patterns would break a reference.
+*/
+function hasUnsafePatternReferences({ body, identifier, node, scope }, patterns) {
+	function inPattern(range) {
+		return patterns.some((pattern) => range[0] >= pattern.range[0] && range[1] <= pattern.range[1]);
+	}
+	const stack = [scope];
+	for (let current = stack.pop(); current !== void 0; current = stack.pop()) {
+		stack.push(...current.childScopes);
+		for (const reference of current.references) {
+			if (!inPattern(reference.identifier.range)) continue;
+			const { resolved } = reference;
+			if (resolved === null) continue;
+			if (resolved.defs.length === 0) {
+				const blockRange = resolved.scope.block.range;
+				if (blockRange[0] >= node.range[0] && blockRange[1] <= node.range[1]) return true;
+				continue;
+			}
+			if (resolved.defs.some((definition) => {
+				const { range } = definition.name;
+				if (inPattern(range)) return false;
+				if (range[1] <= node.range[0] || range[0] >= node.range[1]) return false;
+				if (range[0] >= body.range[0]) return true;
+				return range[0] >= identifier.range[0];
+			})) return true;
+		}
+	}
+	return false;
+}
+/**
+* Checks whether a function body opens with a `"use strict"` directive. A
+* destructured parameter makes the parameter list non-simple, and a function
+* with a non-simple parameter list may not contain a `"use strict"` directive,
+* so such functions are skipped entirely.
+*
+* @param body - The function body.
+* @returns `true` if the body has a `"use strict"` directive.
+*/
+function hasUseStrictDirective(body) {
+	for (const statement of body.body) {
+		if (statement.type !== AST_NODE_TYPES.ExpressionStatement || typeof statement.directive !== "string") break;
+		if (statement.directive === "use strict") return true;
+	}
+	return false;
+}
+/**
+* Checks whether evaluating the pattern can execute arbitrary code — a default
+* value or a computed key — as opposed to only performing property reads.
+*
+* @param node - The pattern node to walk.
+* @returns `true` when the pattern contains a default value or computed key.
+*/
+function patternExecutesCode(node) {
+	if (node.type === AST_NODE_TYPES.AssignmentPattern) return true;
+	if (node.type === AST_NODE_TYPES.Property) return node.computed || patternExecutesCode(node.value);
+	if (node.type === AST_NODE_TYPES.ObjectPattern) return node.properties.some((property) => patternExecutesCode(property));
+	if (node.type === AST_NODE_TYPES.ArrayPattern) return node.elements.some((element) => element !== null && patternExecutesCode(element));
+	if (node.type === AST_NODE_TYPES.RestElement) return patternExecutesCode(node.argument);
+	return false;
+}
+/**
+* Computes the removal range for a declaration, swallowing the whole line
+* (indentation and trailing newline) when the declaration is alone on it.
+*
+* @param sourceCode - Provides the raw text around the declaration.
+* @param statement - The declaration to remove.
+* @returns The range to delete.
+*/
+function statementRemovalRange({ text }, statement) {
+	const [start, end] = statement.range;
+	const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+	const newlineIndex = text.indexOf("\n", end);
+	const lineEnd = newlineIndex === -1 ? text.length : newlineIndex + 1;
+	const leadingIsBlank = text.slice(lineStart, start).trim().length === 0;
+	const trailingIsBlank = text.slice(end, newlineIndex === -1 ? text.length : newlineIndex).trim().length === 0;
+	if (leadingIsBlank && trailingIsBlank) return [lineStart, lineEnd];
+	return [start, end];
+}
+/**
+* Builds the autofix, or returns `null` when the rewrite is not unambiguously
+* safe: unrelated sibling declarators, unmergeable or annotated patterns,
+* duplicate or colliding binding names, expressions that reference bindings
+* unavailable at the parameter position, a defused temporal dead zone, or —
+* with `allowSideEffectReordering: false` — side effects that would be
+* reordered.
+*
+* @param query - The rewrite being planned.
+* @returns The fix plan, or `null` when only a report should be emitted.
+*/
+function planFix(query) {
+	const { allowSideEffectReordering, body, identifier, node, otherParameterNames, sourceCode, statements } = query;
+	const declaratorSet = new Set(statements.map((statement) => statement.declarator));
+	const declarations = [...new Set(statements.map((statement) => statement.declaration))];
+	if (!declarations.every((declaration) => {
+		return declaration.declarations.every((declarator) => declaratorSet.has(declarator));
+	})) return null;
+	const patterns = statements.map((statement) => statement.pattern);
+	if (!allowSideEffectReordering && patterns.some((pattern) => patternExecutesCode(pattern))) {
+		const leadingStatements = new Set(body.body.slice(0, declarations.length));
+		if (!declarations.every((declaration) => leadingStatements.has(declaration))) return null;
+	}
+	if (declarations.some((declaration) => {
+		return sourceCode.getDeclaredVariables(declaration).some((declared) => {
+			return declared.references.some((reference) => reference.identifier.range[0] < declaration.range[0]);
+		});
+	})) return null;
+	if (patterns.some((pattern) => pattern.typeAnnotation !== void 0) && (patterns.length > 1 || identifier.typeAnnotation !== void 0)) return null;
+	if (patterns.length > 1) {
+		if (patterns.some((pattern) => {
+			return pattern.properties.some((property) => property.type === AST_NODE_TYPES.RestElement);
+		})) return null;
+	}
+	const boundNames = [];
+	for (const pattern of patterns) collectBoundNames(pattern, boundNames);
+	if (new Set(boundNames).size !== boundNames.length) return null;
+	if (boundNames.some((name) => otherParameterNames.has(name))) return null;
+	if (hasUnsafePatternReferences(query, patterns)) return null;
+	const [firstPattern] = patterns;
+	let parameterText;
+	if (patterns.length === 1 && firstPattern !== void 0) parameterText = sourceCode.getText(firstPattern);
+	else {
+		const innerTexts = patterns.map((pattern) => sourceCode.getText(pattern).slice(1, -1).trim().replace(/,$/u, "").trim()).filter((text) => text.length > 0);
+		parameterText = innerTexts.length === 0 ? "{}" : `{ ${innerTexts.join(", ")} }`;
+	}
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression && sourceCode.getTokenAfter(identifier)?.value === "=>") parameterText = `(${parameterText})`;
+	const parameterRange = [identifier.range[0], identifier.typeAnnotation?.range[0] ?? identifier.range[1]];
+	const removalRanges = declarations.map((declaration) => {
+		return statementRemovalRange(sourceCode, declaration);
+	});
+	return {
+		parameterRange,
+		parameterText,
+		removalRanges
+	};
+}
+/**
+* Reports body destructuring statements of parameters that have no other use,
+* preferring the pattern in the function signature. The autofix rewrites the
+* parameter (merging multiple statements into one pattern) and removes the
+* statements; it is withheld when the rewrite is not unambiguously safe, see
+* {@link planFix}.
+*
+* @param context - The rule context.
+* @param optionsWithDefault - The resolved rule options.
+* @returns The rule listener.
+*/
+function create$3(context, optionsWithDefault) {
+	const [{ allowSideEffectReordering = true }] = optionsWithDefault;
+	function checkFunction(node) {
+		const { body, params } = node;
+		if (body.type !== AST_NODE_TYPES.BlockStatement || hasUseStrictDirective(body)) return;
+		const scope = context.sourceCode.getScope(node);
+		for (const parameter of params) {
+			const identifier = getParameterIdentifier(parameter);
+			if (identifier === null || identifier.name === "this") continue;
+			const variable = scope.variables.find((candidate) => {
+				return candidate.defs.some((definition) => definition.name === identifier);
+			});
+			if (variable?.defs.length !== 1) continue;
+			const statements = collectDestructureStatements(variable, identifier, body);
+			if (statements === null || statements.length === 0) continue;
+			if (statements.some(({ pattern }) => {
+				return containsAwaitOrYield(pattern, context.sourceCode.visitorKeys);
+			})) continue;
+			const otherParameterNames = collectOtherParameterNames(node, parameter);
+			if (otherParameterNames.has(identifier.name)) continue;
+			const plan = planFix({
+				allowSideEffectReordering,
+				body,
+				identifier,
+				node,
+				otherParameterNames,
+				scope,
+				sourceCode: context.sourceCode,
+				statements
+			});
+			for (const [index, statement] of statements.entries()) context.report({
+				data: { name: identifier.name },
+				fix(fixer) {
+					if (index !== 0 || plan === null) return null;
+					return [fixer.replaceTextRange(plan.parameterRange, plan.parameterText), ...plan.removalRanges.map((range) => fixer.removeRange(range))];
+				},
+				messageId: MESSAGE_ID$2,
+				node: statement.declarator
+			});
+		}
+	}
+	return {
+		ArrowFunctionExpression: checkFunction,
+		FunctionDeclaration: checkFunction,
+		FunctionExpression: checkFunction
+	};
+}
+const preferParameterDestructuring = createEslintRule({
+	name: RULE_NAME$3,
+	create: create$3,
+	defaultOptions: [{ allowSideEffectReordering: true }],
+	meta: {
+		defaultOptions: [{ allowSideEffectReordering: true }],
+		docs: {
+			description: "Enforce destructuring parameters in the function signature",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$3,
+		schema: [{
+			additionalProperties: false,
+			properties: { allowSideEffectReordering: {
+				description: "Whether the autofix may hoist pattern defaults and computed keys past earlier statements, reordering their side effects. Set to false to withhold the fix in those cases.",
+				type: "boolean"
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/rules/purity/rule.ts
 const RULE_NAME$2 = "purity";
 const MESSAGE_ID$1 = "impureCall";
@@ -2460,8 +2809,7 @@ function makeRank(order) {
 		return Number.POSITIVE_INFINITY;
 	};
 }
-function makeFallback(config) {
-	const { caseSensitive = true, natural = false, type = "asc" } = config;
+function makeFallback({ caseSensitive = true, natural = false, type = "asc" }) {
 	const sensitivity = caseSensitive ? "variant" : "accent";
 	return (a, b) => {
 		const result = a.localeCompare(b, "en", {
@@ -2709,6 +3057,7 @@ const plugin = {
 		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
 		"prefer-destructuring-assignment": preferDestructuringAssignment,
+		"prefer-parameter-destructuring": preferParameterDestructuring,
 		"purity": purity,
 		"toml-sort-keys": tomlSortKeys,
 		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-flawless",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",