eslint-plugin-flawless 0.1.9 → 0.1.10

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,7 +207,7 @@ declare const plugin: {
     "prefer-destructuring-assignment": TSESLint.RuleModule<"default", [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
-    "prefer-parameter-destructuring": TSESLint.RuleModule<"default", [], PluginDocumentation, TSESLint.RuleListener> & {
+    "prefer-parameter-destructuring": TSESLint.RuleModule<"default", Options$2, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
     purity: TSESLint.RuleModule<"impureCall", Options$1, PluginDocumentation, TSESLint.RuleListener> & {
@@ -226,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> & {
@@ -241,7 +251,7 @@ declare const _default: {
             "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
-            "prefer-parameter-destructuring": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+            "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> & {
@@ -267,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> & {
@@ -282,7 +292,7 @@ declare const _default: {
     "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
-    "prefer-parameter-destructuring": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+    "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> & {

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.9";
+var version = "0.1.10";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -2310,8 +2310,8 @@ function isNodeLike(value) {
 }
 /**
 * Checks whether a pattern subtree contains `await` or `yield` (in a computed
-* key or default value). Parameter initializers may not contain either, so the
-* fix bails.
+* 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
@@ -2398,6 +2398,21 @@ function hasUseStrictDirective(body) {
 	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.
 *
@@ -2418,20 +2433,31 @@ function statementRemovalRange({ text }, statement) {
 /**
 * 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, `await`/`yield` in the pattern, or
-* expressions that reference bindings unavailable at the parameter position.
+* 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 { identifier, node, otherParameterNames, sourceCode, statements } = 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) => {
@@ -2442,7 +2468,6 @@ function planFix(query) {
 	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 (patterns.some((pattern) => containsAwaitOrYield(pattern, sourceCode.visitorKeys))) return null;
 	if (hasUnsafePatternReferences(query, patterns)) return null;
 	const [firstPattern] = patterns;
 	let parameterText;
@@ -2470,9 +2495,11 @@ function planFix(query) {
 * {@link planFix}.
 *
 * @param context - The rule context.
+* @param optionsWithDefault - The resolved rule options.
 * @returns The rule listener.
 */
-function create$3(context) {
+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;
@@ -2486,9 +2513,13 @@ function create$3(context) {
 			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,
@@ -2517,8 +2548,9 @@ function create$3(context) {
 const preferParameterDestructuring = createEslintRule({
 	name: RULE_NAME$3,
 	create: create$3,
-	defaultOptions: [],
+	defaultOptions: [{ allowSideEffectReordering: true }],
 	meta: {
+		defaultOptions: [{ allowSideEffectReordering: true }],
 		docs: {
 			description: "Enforce destructuring parameters in the function signature",
 			recommended: false,
@@ -2527,7 +2559,14 @@ const preferParameterDestructuring = createEslintRule({
 		fixable: "code",
 		hasSuggestions: false,
 		messages: messages$3,
-		schema: [],
+		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"
 	}
 });

package/package.json

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