exadev-eslint-config 2.20.0 → 2.20.2

package/README.md

@@ -273,7 +273,7 @@ Bundled into `exadevConfig()`'s default output the same way React/Next.js auto-d
 | `no-side-effects-in-index` | | **A barrel may contain only re-export statements** — nothing that could execute at import time. Self-scopes to any index file. |
 | `barrel-direct-siblings-only` | | **A barrel may re-export only from a direct sibling** (`./module`), never a nested path, parent, or bare package specifier (mode 3). |
 | `no-control-flow` | | **Bans `if`/`switch`/loops/the ternary operator outright.** Not part of `recommended` or `barrel` — ordinary code legitimately needs control flow, so this is opt-in, wired via a consumer's own `files` glob for the specific packages that want it (a composition-root package selecting an adapter/strategy by a validated key, say): a lookup table replaces a branch, a declarative array method (`map`/`filter`/`some`/`every`/...) replaces a loop. Requires no type information. |
-| `no-pointless-reassignment` | ✓ | **Flags a `const` alias that adds no transformation** (`const foo = bar` where both sides are plain identifiers). Autofix rewrites every read to the original name and deletes the declaration (including its `export` keyword, when exported). Still reported but deliberately not auto-fixable where collapsing the alias would change meaning: an explicit type annotation (`const exhaustive: never = item` — the annotation is the point), a read where the original name is shadowed, a read as a shorthand object property, more than one declarator in the statement, or a source that is written to anywhere. |
+| `no-pointless-reassignment` | ✓ | **Flags a `const` alias that adds no transformation** (`const foo = bar` where both sides are plain identifiers). Autofix rewrites every read to the original name and deletes the declaration. Still reported but deliberately not auto-fixable where collapsing the alias would change meaning: an explicit type annotation (`const exhaustive: never = item` — the annotation is the point), a read where the original name is shadowed, a read as a shorthand object property, more than one declarator in the statement, or a source that is written to anywhere. An alias that is itself part of the module's exported surface (`export const alias = original;`, a later `export { alias }`/`export { alias as other }`, or `export default alias;`) is neither reported nor fixed at all, since collapsing it would rename or delete a binding every importer of this module depends on. |
 | `no-object-assign` | ✓/suggestion | **`Object.assign` skips the type-checking object spread gets** — it doesn't check a source object's properties against the target's declared types. A fresh object-literal target autofixes to `{ ...target, ...source }`; mutating an existing reassignable binding offers a suggestion only (changes the object's identity); a `const` binding or a non-statement call site gets a plain report with no fix. |
 | `no-mutable-union-array-param` | ✓ | **A union-typed array parameter can be mutated with a value the caller's narrower array never declared.** A function parameter typed as an array of a union (`(string \| number)[]`) accepts a narrower caller array (`number[]`) by covariance; calling `push`/`unshift`/`splice`/`fill`/`copyWithin` on it can then insert a value the caller's own array was never declared to hold. Autofix marks the parameter `readonly`, turning the mutating call into a real compile error to resolve deliberately. Requires no type information. |
 | `prefer-readonly-array-param` | ✓ | **Every non-readonly array/tuple parameter should be `readonly`.** A narrower, safely-autofixable sibling of [`@typescript-eslint/prefer-readonly-parameter-types`](https://typescript-eslint.io/rules/prefer-readonly-parameter-types/) scoped to array/tuple parameter shapes only: fires unconditionally on every non-readonly array or tuple parameter, regardless of whether the function body mutates it, in any parameter position (a plain identifier, a rest parameter, a default-valued parameter, or a constructor parameter property) and any function-like shape (a concrete function/arrow/method, or a declaration-only ambient function, interface method, function type alias, call/construct signature, or abstract/ambient class method). A union containing an array/tuple member is fixed on that member alone. Autofix prepends `readonly ` (or renames `Array<T>` to `ReadonlyArray<T>`), turning any resulting mutation into a real compile error to resolve deliberately. Requires no type information — registered in both `plugin.configs.recommended` and the default (type-checked) export. |
@@ -284,7 +284,7 @@ Bundled into `exadevConfig()`'s default output the same way React/Next.js auto-d
 | `no-enum-number-widening` | | **A bare `number` is accepted anywhere a numeric enum is expected**, without checking it is actually one of the enum's members — only a numeric *literal* gets range-checked by `tsc`. No autofix: the only provably safe fix is a genuine runtime membership check against the enum's own values, which is a behavioural choice a mechanical fix cannot responsibly make. Requires type information — only in the default (type-checked) export, not `plugin.configs.recommended`. |
 | `no-enum-reverse-lookup-widening` | suggestion | **A numeric enum's reverse lookup can silently type as `string` for an out-of-range index.** Indexing a numeric enum's reverse mapping (`Direction[n]`) with a bare (non-literal) `number`, or with a different enum's member, types as plain `string` for any index, including one outside the enum's actual members, where it genuinely returns `undefined` at runtime — `tsc` does not range-check even a numeric literal index here. When the indexed expression is the init of a variable with an explicit `: string` annotation, a suggestion widens it to `: string \| undefined`, forcing later uses as a bare `string` to surface as real compile errors; every other syntactic position gets a plain report with no fix, and no case gets a full `--fix` autofix. Requires type information — only in the default (type-checked) export, not `plugin.configs.recommended`. |
 | `prefer-numeric-sort-compare` | suggestion | **`.sort()` on a number array sorts lexicographically by default.** A deliberately narrow addition alongside [`@typescript-eslint/require-array-sort-compare`](https://typescript-eslint.io/rules/require-array-sort-compare/) (which already flags any bare `.sort()`/`.toSorted()` except on a plain string array, with no fix): when the array's element type is definitively `number`, a suggestion offers an ascending compare function (`(a, b) => a - b`), since the default comparator sorts lexicographically (`[1, 2, 10].sort()` becomes `[1, 10, 2]`). Not a full autofix — descending order is a real, if less common, alternative intent. Requires type information — only in the default (type-checked) export, not `plugin.configs.recommended`, since it needs the checker to confirm the array's element type. |
-| `prefer-options-object-param` | suggestion | **A run of 2+ trailing optional parameters (`?`-marked or default-valued) should be bundled into one destructured `options` parameter.** Without this, a caller needing only the last optional parameter must still pass `undefined` for every optional parameter before it (the motivating case: a 10-parameter constructor with 8 trailing optional ones). The threshold is configurable (`{ minTrailingOptional }`, default `2`). A suggestion (not a full autofix) rewrites the parameter list and inserts a `const { ... } = options ?? {};` destructure as the body's first statement; call sites are never rewritten, since the signature edit alone turns every stale positional call site into a real compile error. Still reported, but with no suggestion offered, whenever collapsing the run would not be safe/mechanical: a parameter property in the run, a parameter with no simple resolvable name and explicit type of its own (including a destructured parameter, or one typed only through a separately-declared function-type alias), a decorated parameter, a rest parameter anywhere in the full parameter list, no `BlockStatement` body at all (an arrow's expression body, or any declaration-only signature — including an ambient `.d.ts` function, an interface method/construct signature, or an abstract/ambient class method), a `@param` JSDoc tag naming a parameter in the run, or a parameter/function-scope-local variable already named `options`. Complements `max-params` (see "Individual rule tuning" above), which catches the different shape (excessive REQUIRED parameters) this rule is deliberately blind to. Requires no type information, but is registered only in the default (type-checked) export — alongside `prefer-readonly-object-param` and `prefer-numeric-sort-compare` above, for a consistent "every rewrite-suggestion `prefer-*` rule lives here" story, not because it needs the checker for anything. |
+| `prefer-options-object-param` | suggestion | **A run of 2+ trailing optional parameters (`?`-marked or default-valued) should be bundled into one destructured `options` parameter.** Without this, a caller needing only the last optional parameter must still pass `undefined` for every optional parameter before it (the motivating case: a 10-parameter constructor with 8 trailing optional ones). The threshold is configurable (`{ minTrailingOptional }`, default `2`). A suggestion (not a full autofix) rewrites the parameter list and inserts a `const { ... } = options ?? {};` destructure as the body's first statement; call sites are never rewritten, since the signature edit alone turns every stale positional call site into a real compile error. Still reported, but with no suggestion offered, whenever collapsing the run would not be safe/mechanical: a parameter property in the run, a parameter with no simple resolvable name and explicit type of its own (including a destructured parameter, or one typed only through a separately-declared function-type alias), a decorated parameter, a rest parameter anywhere in the full parameter list, no `BlockStatement` body at all (an arrow's expression body, or any declaration-only signature — including an ambient `.d.ts` function, an interface method/construct signature, or an abstract/ambient class method), a `@param` JSDoc tag naming a parameter in the run, or a parameter/function-scope-local variable already named `options`. Complements `max-params` (see "Individual rule tuning" above), which catches the different shape (excessive REQUIRED parameters) this rule is deliberately blind to. Requires no type information — registered in both `plugin.configs.recommended` and the default (type-checked) export, like `prefer-readonly-array-param` above; unlike its own `prefer-readonly-object-param`/`prefer-numeric-sort-compare` siblings, which genuinely need the checker and so cannot be offered outside the default export at all. |
 | `package-json-key-order` | ✓ | **Requires `package.json`'s keys to match `syncpack format`'s order.** See [Optional package.json key ordering](#optional-packagejson-key-ordering) — opt-in via `exadevConfig({ packageJsonKeyOrder: true })`, not part of `recommended`/`barrel`. A JSON-language rule (`@eslint/json`'s `json/json`), not a TSESLint one — needs no type information and doesn't apply to any `.ts`/`.js` file. |
 | `test-file-kind` | | **A test file's name must declare its own test kind.** A filename suffix immediately before `.test`/`.spec` (e.g. `foo.unit.test.ts`), one of a configurable `{ kinds }` set (default: `unit`, `integration`, `e2e`). A naming-discipline rule, not a content classifier — it checks only the filename, never what the file actually tests. Self-scoped to real test/spec files (`context.filename`), so it never misfires when applied unscoped and never relies on a consumer's own `files` config. Requires no type information. |
 

package/dist/index.cjs

@@ -295,7 +295,7 @@ function buildNextjsConfig(options = {}) {
 }
 //#endregion
 //#region package.json
-var version = "2.20.0";
+var version = "2.20.2";
 //#endregion
 //#region src/react.ts
 const JSX_FILE_PATTERNS = ["**/*.jsx", "**/*.tsx"];
@@ -1274,6 +1274,13 @@ function isConstDeclarator(declarator) {
 	if (declarator.parent.type !== "VariableDeclaration") throw new Error(`Unreachable: expected a VariableDeclarator's own parent to be a VariableDeclaration, got "${declarator.parent.type}" instead.`);
 	return declarator.parent.kind === "const";
 }
+function asVariableDeclaration(node) {
+	if (node.type !== "VariableDeclaration") throw new Error(`Unreachable: expected a VariableDeclarator's own parent to be a VariableDeclaration, got "${node.type}" instead.`);
+	return node;
+}
+function findTopLevelScope(globalScope) {
+	return globalScope.childScopes.find((child) => child.type === "module") ?? globalScope;
+}
 function variableInScope(scope, name) {
 	const variable = scope.set.get(name);
 	if (variable === void 0) throw new Error(`Unreachable: expected scope.set to hold a variable named "${name}".`);
@@ -1297,6 +1304,14 @@ function isShorthandPropertyRead(sourceCode, identifier) {
 	if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
 	return hasEnclosingShorthandBoundary(sourceCode.getTokensBefore(identifier));
 }
+function isExportedAlias(declarationParentType, programBody, resolve, aliasVariable) {
+	if (declarationParentType === "ExportNamedDeclaration") return true;
+	return programBody.some((statement) => {
+		if (statement.type === "ExportNamedDeclaration" && statement.source == null) return (statement.specifiers ?? []).some((specifier) => specifier.local.type === "Identifier" && specifier.local.name !== void 0 && resolve(specifier.local.name) === aliasVariable);
+		const target = statement.type === "ExportDefaultDeclaration" ? statement.declaration : void 0;
+		return target?.type === "Identifier" && target.name !== void 0 && resolve(target.name) === aliasVariable;
+	});
+}
 const noPointlessReassignment = {
 	meta: {
 		type: "problem",
@@ -1305,6 +1320,7 @@ const noPointlessReassignment = {
 		messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
 	},
 	create(context) {
+		const moduleScope = findTopLevelScope(context.sourceCode.getScope(context.sourceCode.ast));
 		return { VariableDeclarator(node) {
 			if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
 			if (!isConstDeclarator(node)) return;
@@ -1314,6 +1330,9 @@ const noPointlessReassignment = {
 			const aliasName = node.id.name;
 			const originalName = node.init.name;
 			const aliasIsAnnotated = hasTypeAnnotation(node.id);
+			const variable = variableInScope(scope, aliasName);
+			const declaration = asVariableDeclaration(node.parent);
+			if (isExportedAlias(declaration.parent.type, context.sourceCode.ast.body, (name) => resolveFrom(moduleScope, name), variable)) return;
 			context.report({
 				node,
 				messageId: "pointlessReassignment",
@@ -1322,7 +1341,6 @@ const noPointlessReassignment = {
 					value: originalName
 				},
 				fix(fixer) {
-					const variable = variableInScope(scope, aliasName);
 					if (aliasIsAnnotated) return null;
 					if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
 					const readReferences = variable.references.filter((reference) => reference.isRead());
@@ -1331,9 +1349,8 @@ const noPointlessReassignment = {
 					if (readRefs.some((reference) => isShorthandPropertyRead(context.sourceCode, reference.identifier))) return null;
 					if (readRefs.some((reference) => resolveFrom(reference.from, originalName) !== sourceVariable)) return null;
 					const fixes = readRefs.map((reference) => fixer.replaceText(reference.identifier, originalName));
-					const declaration = node.parent;
-					if (declaration.type !== "VariableDeclaration" || declaration.declarations.length !== 1) return null;
-					fixes.push(fixer.remove(declaration.parent.type === "ExportNamedDeclaration" ? declaration.parent : declaration));
+					if (declaration.declarations.length !== 1) return null;
+					fixes.push(fixer.remove(declaration));
 					return fixes;
 				}
 			});
@@ -2144,6 +2161,7 @@ const plugin = {
 					"exadev/no-mutable-union-array-param": "error",
 					"exadev/no-object-assign": "error",
 					"exadev/no-pointless-reassignment": "error",
+					"exadev/prefer-options-object-param": "error",
 					"exadev/prefer-readonly-array-param": "error",
 					"exadev/test-file-kind": "error",
 					"max-params": ["error", { max: 4 }]

package/dist/index.js

@@ -261,7 +261,7 @@ function buildNextjsConfig(options = {}) {
 }
 //#endregion
 //#region package.json
-var version = "2.20.0";
+var version = "2.20.2";
 //#endregion
 //#region src/react.ts
 const JSX_FILE_PATTERNS = ["**/*.jsx", "**/*.tsx"];
@@ -1240,6 +1240,13 @@ function isConstDeclarator(declarator) {
 	if (declarator.parent.type !== "VariableDeclaration") throw new Error(`Unreachable: expected a VariableDeclarator's own parent to be a VariableDeclaration, got "${declarator.parent.type}" instead.`);
 	return declarator.parent.kind === "const";
 }
+function asVariableDeclaration(node) {
+	if (node.type !== "VariableDeclaration") throw new Error(`Unreachable: expected a VariableDeclarator's own parent to be a VariableDeclaration, got "${node.type}" instead.`);
+	return node;
+}
+function findTopLevelScope(globalScope) {
+	return globalScope.childScopes.find((child) => child.type === "module") ?? globalScope;
+}
 function variableInScope(scope, name) {
 	const variable = scope.set.get(name);
 	if (variable === void 0) throw new Error(`Unreachable: expected scope.set to hold a variable named "${name}".`);
@@ -1263,6 +1270,14 @@ function isShorthandPropertyRead(sourceCode, identifier) {
 	if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
 	return hasEnclosingShorthandBoundary(sourceCode.getTokensBefore(identifier));
 }
+function isExportedAlias(declarationParentType, programBody, resolve, aliasVariable) {
+	if (declarationParentType === "ExportNamedDeclaration") return true;
+	return programBody.some((statement) => {
+		if (statement.type === "ExportNamedDeclaration" && statement.source == null) return (statement.specifiers ?? []).some((specifier) => specifier.local.type === "Identifier" && specifier.local.name !== void 0 && resolve(specifier.local.name) === aliasVariable);
+		const target = statement.type === "ExportDefaultDeclaration" ? statement.declaration : void 0;
+		return target?.type === "Identifier" && target.name !== void 0 && resolve(target.name) === aliasVariable;
+	});
+}
 const noPointlessReassignment = {
 	meta: {
 		type: "problem",
@@ -1271,6 +1286,7 @@ const noPointlessReassignment = {
 		messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
 	},
 	create(context) {
+		const moduleScope = findTopLevelScope(context.sourceCode.getScope(context.sourceCode.ast));
 		return { VariableDeclarator(node) {
 			if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
 			if (!isConstDeclarator(node)) return;
@@ -1280,6 +1296,9 @@ const noPointlessReassignment = {
 			const aliasName = node.id.name;
 			const originalName = node.init.name;
 			const aliasIsAnnotated = hasTypeAnnotation(node.id);
+			const variable = variableInScope(scope, aliasName);
+			const declaration = asVariableDeclaration(node.parent);
+			if (isExportedAlias(declaration.parent.type, context.sourceCode.ast.body, (name) => resolveFrom(moduleScope, name), variable)) return;
 			context.report({
 				node,
 				messageId: "pointlessReassignment",
@@ -1288,7 +1307,6 @@ const noPointlessReassignment = {
 					value: originalName
 				},
 				fix(fixer) {
-					const variable = variableInScope(scope, aliasName);
 					if (aliasIsAnnotated) return null;
 					if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
 					const readReferences = variable.references.filter((reference) => reference.isRead());
@@ -1297,9 +1315,8 @@ const noPointlessReassignment = {
 					if (readRefs.some((reference) => isShorthandPropertyRead(context.sourceCode, reference.identifier))) return null;
 					if (readRefs.some((reference) => resolveFrom(reference.from, originalName) !== sourceVariable)) return null;
 					const fixes = readRefs.map((reference) => fixer.replaceText(reference.identifier, originalName));
-					const declaration = node.parent;
-					if (declaration.type !== "VariableDeclaration" || declaration.declarations.length !== 1) return null;
-					fixes.push(fixer.remove(declaration.parent.type === "ExportNamedDeclaration" ? declaration.parent : declaration));
+					if (declaration.declarations.length !== 1) return null;
+					fixes.push(fixer.remove(declaration));
 					return fixes;
 				}
 			});
@@ -2110,6 +2127,7 @@ const plugin = {
 					"exadev/no-mutable-union-array-param": "error",
 					"exadev/no-object-assign": "error",
 					"exadev/no-pointless-reassignment": "error",
+					"exadev/prefer-options-object-param": "error",
 					"exadev/prefer-readonly-array-param": "error",
 					"exadev/test-file-kind": "error",
 					"max-params": ["error", { max: 4 }]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "exadev-eslint-config",
   "description": "Shared custom ESLint rules and plugin for ExaDev projects",
-  "version": "2.20.0",
+  "version": "2.20.2",
   "dependencies": {
     "@eslint/js": "^10.0.1",
     "@typescript-eslint/utils": "8.67.0",