eslint-plugin-flawless 0.1.4 → 0.1.5

package/README.md

@@ -176,15 +176,16 @@ pnpm eslint-docs
 💭
 Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
-| Name                                                                                  | Description                                                          | 🔧  | 💭  |
-| :------------------------------------------------------------------------------------ | :------------------------------------------------------------------- | :-- | :-- |
-| [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)           | Disallow the shorthand fragment syntax in favour of a named fragment | 🔧  |     |
-| [naming-convention](src/rules/naming-convention/documentation.md)                     | Enforce naming conventions for everything across a codebase          |     | 💭  |
-| [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'                              |     |     |
-| [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      | 🔧  |     |
+| Name                                                                                          | Description                                                          | 🔧  | 💭  |
+| :-------------------------------------------------------------------------------------------- | :------------------------------------------------------------------- | :-- | :-- |
+| [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)                   | Disallow the shorthand fragment syntax in favour of a named fragment | 🔧  |     |
+| [naming-convention](src/rules/naming-convention/documentation.md)                             | Enforce naming conventions for everything across a codebase          |     | 💭  |
+| [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                 | 🔧  |     |
+| [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      | 🔧  |     |
 
 <!-- end auto-generated rules list -->
 

package/dist/index.d.mts

@@ -166,6 +166,9 @@ declare const plugin: {
     "no-unnecessary-use-memo": TSESLint.RuleModule<MessageIds, [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
+    "prefer-destructuring-assignment": TSESLint.RuleModule<"default", [], PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
     "toml-sort-keys": TSESLint.RuleModule<"unsorted", Options, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
@@ -201,6 +204,9 @@ declare const _default: {
             "no-unnecessary-use-memo": import("${configDir}").RuleModule<MessageIds, [], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
+            "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
             "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
@@ -233,6 +239,9 @@ declare const _default: {
     "no-unnecessary-use-memo": import("${configDir}").RuleModule<MessageIds, [], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
+    "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
     "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, 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.4";
+var version = "0.1.5";
 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$6 = "jsx-shorthand-boolean";
-const MESSAGE_ID$2 = "setAttributeValue";
-const messages$6 = { [MESSAGE_ID$2]: "Set an explicit value for boolean attribute '{{name}}'." };
-function create$6(context) {
+const RULE_NAME$7 = "jsx-shorthand-boolean";
+const MESSAGE_ID$3 = "setAttributeValue";
+const messages$7 = { [MESSAGE_ID$3]: "Set an explicit value for boolean attribute '{{name}}'." };
+function create$7(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$2,
+			messageId: MESSAGE_ID$3,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createEslintRule({
-	name: RULE_NAME$6,
-	create: create$6,
+	name: RULE_NAME$7,
+	create: create$7,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -62,22 +62,22 @@ const jsxShorthandBoolean = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$6,
+		messages: messages$7,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$5 = "jsx-shorthand-fragment";
-const MESSAGE_ID$1 = "useNamedFragment";
+const RULE_NAME$6 = "jsx-shorthand-fragment";
+const MESSAGE_ID$2 = "useNamedFragment";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$5 = { [MESSAGE_ID$1]: "Use the '{{name}}' component instead of fragment shorthand syntax." };
+const messages$6 = { [MESSAGE_ID$2]: "Use the '{{name}}' component instead of fragment shorthand syntax." };
 const schema$1 = [{
 	description: "The identifier to use for the named fragment element.",
 	type: "string"
 }];
-function create$5(context) {
+function create$6(context) {
 	const name = context.options[0] ?? DEFAULT_FRAGMENT_NAME;
 	return { JSXFragment(node) {
 		const { closingFragment, openingFragment } = node;
@@ -86,14 +86,14 @@ function create$5(context) {
 			fix: (fixer) => {
 				return [fixer.replaceText(openingFragment, `<${name}>`), fixer.replaceText(closingFragment, `</${name}>`)];
 			},
-			messageId: MESSAGE_ID$1,
+			messageId: MESSAGE_ID$2,
 			node
 		});
 	} };
 }
 const jsxShorthandFragment = createEslintRule({
-	name: RULE_NAME$5,
-	create: create$5,
+	name: RULE_NAME$6,
+	create: create$6,
 	defaultOptions: [DEFAULT_FRAGMENT_NAME],
 	meta: {
 		defaultOptions: [DEFAULT_FRAGMENT_NAME],
@@ -104,7 +104,7 @@ const jsxShorthandFragment = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$5,
+		messages: messages$6,
 		schema: schema$1,
 		type: "suggestion"
 	}
@@ -1269,8 +1269,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$4 = "naming-convention";
-const messages$4 = {
+const RULE_NAME$5 = "naming-convention";
+const messages$5 = {
 	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}}",
@@ -1300,7 +1300,7 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create$4(contextWithoutDefaults) {
+function create$5(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
 	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
@@ -1620,8 +1620,8 @@ function create$4(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$4,
-	create: create$4,
+	name: RULE_NAME$5,
+	create: create$5,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -1631,7 +1631,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$4,
+		messages: messages$5,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -1899,15 +1899,15 @@ function resolveFactory(sourceCode, node) {
 }
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$3 = "no-unnecessary-use-callback";
+const RULE_NAME$4 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$3 = {
+const messages$4 = {
 	[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$3,
+	name: RULE_NAME$4,
 	create: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -1923,22 +1923,22 @@ const noUnnecessaryUseCallback = createEslintRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$3,
+		messages: messages$4,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$2 = "no-unnecessary-use-memo";
+const RULE_NAME$3 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$2 = {
+const messages$3 = {
 	[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$2,
+	name: RULE_NAME$3,
 	create: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -1954,12 +1954,212 @@ const noUnnecessaryUseMemo = createEslintRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$2,
+		messages: messages$3,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
+//#region src/rules/prefer-destructuring-assignment/rule.ts
+const RULE_NAME$2 = "prefer-destructuring-assignment";
+const MESSAGE_ID$1 = "default";
+const messages$2 = { [MESSAGE_ID$1]: "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
+* destructuring pattern built from it (`{ default }`) would be a syntax error,
+* so the autofix bails when one is encountered.
+*/
+const RESERVED_WORDS = /* @__PURE__ */ new Set([
+	"arguments",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+/**
+* Collects the unique accessed property names, in first-seen order, when every
+* member reference is a simple non-computed `props.<identifier>` access.
+*
+* @param memberReferences - The member accesses to inspect.
+* @returns The property names, or `null` when any access is not destructurable
+*   (computed access such as `props[key]`, `props` used as a computed key, or a
+*   property whose name is a reserved word that cannot be a binding).
+*/
+function collectPropertyNames(memberReferences) {
+	const names = [];
+	for (const { member, reference } of memberReferences) {
+		if (member.object !== reference.identifier || member.computed || member.property.type !== AST_NODE_TYPES.Identifier || RESERVED_WORDS.has(member.property.name)) return null;
+		if (!names.includes(member.property.name)) names.push(member.property.name);
+	}
+	return names;
+}
+/**
+* Determines whether rewriting `props.foo` to `foo` would resolve to a different
+* binding than the new destructured parameter at any access site.
+*
+* A name is unsafe when it is already bound in the component scope (other than by
+* the props parameter itself) or in any scope nested between an access and the
+* component, since the rewritten `foo` reference would then resolve to that
+* binding instead of the destructured prop.
+*
+* @param sourceCode - Provides scope lookup for each reference.
+* @param componentScope - The component function's scope.
+* @param propsVariable - The props parameter variable (excluded from the check).
+* @param memberReferences - The member accesses that would be rewritten.
+* @returns `true` if any rewritten name would collide with an existing binding.
+*/
+function wouldShadowExistingBinding(sourceCode, componentScope, propsVariable, memberReferences) {
+	for (const { member, reference } of memberReferences) {
+		const { name } = member.property;
+		let scope = sourceCode.getScope(reference.identifier);
+		while (scope !== null) {
+			if (scope.variables.some((variable) => variable.name === name && variable !== propsVariable)) return true;
+			if (scope === componentScope) break;
+			scope = scope.upper;
+		}
+	}
+	return false;
+}
+/**
+* Reports every `props.<member>` access on a component's props parameter,
+* attaching an autofix when the parameter can be safely destructured.
+*
+* @param context - The rule context.
+* @param scope - The component function's scope.
+* @param propsParameter - The props parameter identifier.
+* @param propertyVariable - The resolved variable for the props parameter.
+*/
+function reportComponent(context, scope, propsParameter, propertyVariable) {
+	const memberReferences = [];
+	let hasNonMemberReference = false;
+	for (const reference of propertyVariable.references) {
+		const { parent } = reference.identifier;
+		if (parent.type === AST_NODE_TYPES.MemberExpression) memberReferences.push({
+			member: parent,
+			reference
+		});
+		else hasNonMemberReference = true;
+	}
+	if (memberReferences.length === 0) return;
+	memberReferences.sort((left, right) => left.member.range[0] - right.member.range[0]);
+	const propertyNames = collectPropertyNames(memberReferences);
+	if (!(!hasNonMemberReference && propertyNames !== null && !wouldShadowExistingBinding(context.sourceCode, scope, propertyVariable, memberReferences))) {
+		for (const { member } of memberReferences) context.report({
+			messageId: MESSAGE_ID$1,
+			node: member
+		});
+		return;
+	}
+	const needsParentheses = propsParameter.parent.type === AST_NODE_TYPES.ArrowFunctionExpression && context.sourceCode.getTokenAfter(propsParameter)?.value === "=>";
+	const destructured = `{ ${propertyNames.join(", ")} }`;
+	const pattern = needsParentheses ? `(${destructured})` : destructured;
+	const nameEnd = propsParameter.typeAnnotation?.range[0] ?? propsParameter.range[1];
+	for (const [index, { member }] of memberReferences.entries()) {
+		const propertyName = member.property.name;
+		context.report({
+			fix(fixer) {
+				const replaceAccess = fixer.replaceText(member, propertyName);
+				if (index === 0) return [fixer.replaceTextRange([propsParameter.range[0], nameEnd], pattern), replaceAccess];
+				return replaceAccess;
+			},
+			messageId: MESSAGE_ID$1,
+			node: member
+		});
+	}
+}
+/**
+* Faithfully ports `react-x/prefer-destructuring-assignment`, removed from
+* `eslint-plugin-react-x` in v5.0.0 (deprecated due to low usage). Component
+* detection is delegated to `@eslint-react/core` so it matches the upstream
+* semantics.
+*
+* Unlike upstream, this port adds an autofix that rewrites the props parameter
+* into a destructuring pattern (`(props) => props.id` becomes `({ id }) => id`).
+* The fix is only offered when it is unambiguously safe; see
+* {@link collectPropertyNames} and {@link wouldShadowExistingBinding}.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function create$2(context) {
+	const { api, visitor } = core.getFunctionComponentCollector(context);
+	return {
+		...visitor,
+		"Program:exit": function(program) {
+			for (const component of api.getAllComponents(program)) {
+				if (component.name === null || component.isExportDefaultDeclaration) continue;
+				const [propsParameter] = component.node.params;
+				if (propsParameter?.type !== AST_NODE_TYPES.Identifier) continue;
+				const scope = context.sourceCode.getScope(component.node);
+				const propertyVariable = scope.variables.find((variable) => variable.name === propsParameter.name);
+				if (propertyVariable === void 0) continue;
+				reportComponent(context, scope, propsParameter, propertyVariable);
+			}
+		}
+	};
+}
+const preferDestructuringAssignment = createEslintRule({
+	name: RULE_NAME$2,
+	create: create$2,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Enforce destructuring assignment for component props",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$2,
+		schema: [],
+		type: "problem"
+	}
+});
+//#endregion
 //#region src/rules/toml-sort-keys/rule.ts
 const RULE_NAME$1 = "toml-sort-keys";
 const MESSAGE_ID = "unsorted";
@@ -2260,6 +2460,7 @@ const plugin = {
 		"naming-convention": namingConvention,
 		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
+		"prefer-destructuring-assignment": preferDestructuringAssignment,
 		"toml-sort-keys": tomlSortKeys,
 		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
 	}

package/package.json

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