@exadev/eslint-config 2.4.0 → 2.6.0

package/dist/index.js

@@ -2,8 +2,9 @@ import tseslint from "typescript-eslint";
 import { posix } from "node:path";
 import { AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
 import * as ts from "typescript";
+import { isPropertyReadonlyInType, isTypeReference } from "ts-api-utils";
 //#region package.json
-var version = "2.4.0";
+var version = "2.6.0";
 //#endregion
 //#region src/rules/barrel-helpers.ts
 const INDEX_BASENAME$1 = /^index\.[cm]?[tj]sx?$/;
@@ -247,45 +248,45 @@ const MUTATING_INSERT_METHODS$1 = /* @__PURE__ */ new Set([
 	"fill",
 	"copyWithin"
 ]);
-const createRule$2 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$7 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
 function isArrayIsArrayCall(node) {
 	return node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.object.name === "Array" && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "isArray";
 }
-function definitelyExits(statement) {
+function definitelyExits$2(statement) {
 	if (statement.type === AST_NODE_TYPES.ReturnStatement || statement.type === AST_NODE_TYPES.ThrowStatement || statement.type === AST_NODE_TYPES.ContinueStatement || statement.type === AST_NODE_TYPES.BreakStatement) return true;
 	if (statement.type === AST_NODE_TYPES.BlockStatement) {
 		const last = statement.body.at(-1);
-		return last !== void 0 && definitelyExits(last);
+		return last !== void 0 && definitelyExits$2(last);
 	}
 	return false;
 }
-const noArrayIsArrayMutation = createRule$2({
+const noArrayIsArrayMutation = createRule$7({
 	name: "no-array-isarray-mutation",
 	meta: {
 		type: "problem",
 		schema: [],
-		docs: { description: "Disallow mutating-insertion calls on a parameter whose real type includes a readonly array, narrowed via Array.isArray, which silently discards the declared readonly guarantee." },
-		messages: { unsound: "'{{ method }}' mutates a parameter narrowed by Array.isArray -- Array.isArray's own type declaration cannot preserve a readonly modifier through the guard, so a caller's genuinely readonly array can be mutated here even though the parameter's real type includes a readonly array. Copy the array before inserting (e.g. a spread into a new array), or narrow with a check that preserves readonly instead of Array.isArray." }
+		docs: { description: "Disallow mutating-insertion calls on a parameter or local variable whose real type includes a readonly array, narrowed via Array.isArray, which silently discards the declared readonly guarantee." },
+		messages: { unsound: "'{{ method }}' mutates a parameter or local variable narrowed by Array.isArray -- Array.isArray's own type declaration cannot preserve a readonly modifier through the guard, so a value whose real type includes a readonly array (a caller's array, for a parameter; the value's own declared type, for a local variable) can be mutated here despite that readonly guarantee. Copy the array before inserting (e.g. a spread into a new array), or narrow with a check that preserves readonly instead of Array.isArray." }
 	},
 	defaultOptions: [],
 	create(context) {
 		const services = ESLintUtils.getParserServices(context);
 		const checker = services.program.getTypeChecker();
-		function parameterHasReadonlyArrayConstituent(parameterNode) {
-			const tsNode = services.esTreeNodeToTSNodeMap.get(parameterNode);
-			const parameterType = checker.getTypeAtLocation(tsNode);
-			return (parameterType.isUnion() ? parameterType.types : [parameterType]).some((constituent) => checker.isArrayType(constituent) && constituent.getSymbol()?.name === "ReadonlyArray");
+		function declarationHasReadonlyArrayConstituent(declarationNode) {
+			const tsNode = services.esTreeNodeToTSNodeMap.get(declarationNode);
+			const declaredType = checker.getTypeAtLocation(tsNode);
+			return (declaredType.isUnion() ? declaredType.types : [declaredType]).some((constituent) => checker.isArrayType(constituent) && constituent.getSymbol()?.name === "ReadonlyArray");
 		}
 		return { CallExpression(node) {
 			const { callee } = node;
 			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier || !MUTATING_INSERT_METHODS$1.has(callee.property.name)) return;
 			const variable = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === callee.object)?.resolved;
 			if (!variable) return;
-			const parameterDefinition = variable.defs.find((definition) => definition.type === TSESLint.Scope.DefinitionType.Parameter);
-			if (!parameterDefinition) return;
-			const parameterNode = parameterDefinition.name;
-			if (parameterNode.type !== AST_NODE_TYPES.Identifier) return;
-			if (!parameterHasReadonlyArrayConstituent(parameterNode)) return;
+			const declarationDefinition = variable.defs.find((definition) => definition.type === TSESLint.Scope.DefinitionType.Parameter || definition.type === TSESLint.Scope.DefinitionType.Variable);
+			if (!declarationDefinition) return;
+			const declarationNode = declarationDefinition.name;
+			if (declarationNode.type !== AST_NODE_TYPES.Identifier) return;
+			if (!declarationHasReadonlyArrayConstituent(declarationNode)) return;
 			if (!isGuardedByArrayIsArray(node, variable, context)) return;
 			context.report({
 				node,
@@ -332,7 +333,7 @@ const noArrayIsArrayMutation = createRule$2({
 					}
 					if (ownIndex > 0) for (let i = ownIndex - 1; i >= 0; i--) {
 						const sibling = statements[i];
-						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedArrayIsArrayCall(sibling.test, parameterVariable, ruleContext) && definitelyExits(sibling.consequent)) return true;
+						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedArrayIsArrayCall(sibling.test, parameterVariable, ruleContext) && definitelyExits$2(sibling.consequent)) return true;
 					}
 				}
 				current = parent;
@@ -466,6 +467,107 @@ const noIndexFiles = {
 	}
 };
 //#endregion
+//#region src/rules/no-map-instanceof-mutation.ts
+const createRule$6 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const MUTATING_MAP_METHODS = /* @__PURE__ */ new Set([
+	"set",
+	"delete",
+	"clear"
+]);
+function isInstanceofMapExpression(node) {
+	return node.type === AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && node.right.type === AST_NODE_TYPES.Identifier && node.right.name === "Map";
+}
+function definitelyExits$1(statement) {
+	if (statement.type === AST_NODE_TYPES.ReturnStatement || statement.type === AST_NODE_TYPES.ThrowStatement || statement.type === AST_NODE_TYPES.ContinueStatement || statement.type === AST_NODE_TYPES.BreakStatement) return true;
+	if (statement.type === AST_NODE_TYPES.BlockStatement) {
+		const last = statement.body.at(-1);
+		return last !== void 0 && definitelyExits$1(last);
+	}
+	return false;
+}
+const noMapInstanceofMutation = createRule$6({
+	name: "no-map-instanceof-mutation",
+	meta: {
+		type: "problem",
+		schema: [],
+		docs: { description: "Disallow mutating calls on a parameter or local variable whose real type includes a ReadonlyMap, narrowed via `instanceof Map`, which silently discards the declared readonly guarantee." },
+		messages: { unsound: "'{{ method }}' mutates a parameter or local variable narrowed by 'instanceof Map' -- Map is declared as extending ReadonlyMap, so 'instanceof Map' narrows straight past the readonly guarantee to the full mutable interface, and a value whose real type includes ReadonlyMap (a caller's map, for a parameter; the value's own declared type, for a local variable) can be mutated here despite that readonly guarantee. Copy the map before mutating (e.g. `new Map(input)`), or narrow with a check that preserves readonly instead of 'instanceof Map'." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		function declarationHasReadonlyMapConstituent(declarationNode) {
+			const tsNode = services.esTreeNodeToTSNodeMap.get(declarationNode);
+			const declaredType = checker.getTypeAtLocation(tsNode);
+			return (declaredType.isUnion() ? declaredType.types : [declaredType]).some((constituent) => constituent.getSymbol()?.name === "ReadonlyMap");
+		}
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier || !MUTATING_MAP_METHODS.has(callee.property.name)) return;
+			const variable = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === callee.object)?.resolved;
+			if (!variable) return;
+			const declarationDefinition = variable.defs.find((definition) => definition.type === TSESLint.Scope.DefinitionType.Parameter || definition.type === TSESLint.Scope.DefinitionType.Variable);
+			if (!declarationDefinition) return;
+			const declarationNode = declarationDefinition.name;
+			if (declarationNode.type !== AST_NODE_TYPES.Identifier) return;
+			if (!declarationHasReadonlyMapConstituent(declarationNode)) return;
+			if (!isGuardedByInstanceofMap(node, variable, context)) return;
+			context.report({
+				node,
+				messageId: "unsound",
+				data: { method: callee.property.name }
+			});
+		} };
+		function resolvesToVariable(identifier, target, atNode, ruleContext) {
+			return ruleContext.sourceCode.getScope(atNode).references.find((reference) => reference.identifier === identifier)?.resolved === target;
+		}
+		function isNegatedInstanceofMapExpression(testNode, target, ruleContext) {
+			if (testNode.type !== AST_NODE_TYPES.UnaryExpression || testNode.operator !== "!") return false;
+			return matchesInstanceofMapOn(testNode.argument, target, ruleContext);
+		}
+		function matchesInstanceofMapOn(testNode, target, ruleContext) {
+			if (!isInstanceofMapExpression(testNode)) return false;
+			const { left } = testNode;
+			return left.type === AST_NODE_TYPES.Identifier && resolvesToVariable(left, target, testNode, ruleContext);
+		}
+		function isGuardedByInstanceofMap(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.IfStatement) {
+					if (parent.consequent === current && matchesInstanceofMapOn(parent.test, parameterVariable, ruleContext)) return true;
+					if (parent.alternate === current && isNegatedInstanceofMapExpression(parent.test, parameterVariable, ruleContext)) return true;
+				}
+				if (parent.type === AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesInstanceofMapOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === AST_NODE_TYPES.ConditionalExpression && parent.consequent === current && matchesInstanceofMapOn(parent.test, parameterVariable, ruleContext)) return true;
+				current = parent;
+			}
+			return isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext);
+		}
+		function isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.BlockStatement || parent.type === AST_NODE_TYPES.Program) {
+					const statements = parent.body;
+					let ownIndex = -1;
+					for (let i = 0; i < statements.length; i++) if (statements[i] === current) {
+						ownIndex = i;
+						break;
+					}
+					if (ownIndex > 0) for (let i = ownIndex - 1; i >= 0; i--) {
+						const sibling = statements[i];
+						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedInstanceofMapExpression(sibling.test, parameterVariable, ruleContext) && definitelyExits$1(sibling.consequent)) return true;
+					}
+				}
+				current = parent;
+			}
+			return false;
+		}
+	}
+});
+//#endregion
 //#region src/rules/no-mutable-union-array-param.ts
 const MUTATING_INSERT_METHODS = /* @__PURE__ */ new Set([
 	"push",
@@ -474,7 +576,7 @@ const MUTATING_INSERT_METHODS = /* @__PURE__ */ new Set([
 	"fill",
 	"copyWithin"
 ]);
-const createRule$1 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$5 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
 function isUnionArrayType(typeAnnotation) {
 	if (typeAnnotation.type === AST_NODE_TYPES.TSArrayType && typeAnnotation.elementType.type === AST_NODE_TYPES.TSUnionType) return typeAnnotation.elementType;
 	if (typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "Array" && typeAnnotation.typeArguments?.params.length === 1) {
@@ -482,7 +584,7 @@ function isUnionArrayType(typeAnnotation) {
 		if (firstParam?.type === AST_NODE_TYPES.TSUnionType) return firstParam;
 	}
 }
-const noMutableUnionArrayParam = createRule$1({
+const noMutableUnionArrayParam = createRule$5({
 	name: "no-mutable-union-array-param",
 	meta: {
 		type: "problem",
@@ -608,14 +710,14 @@ const noNonBarrelReexport = {
 };
 //#endregion
 //#region src/rules/no-object-assign.ts
-const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const createRule$4 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
 function resolveFrom$1(scope, name) {
 	for (let current = scope; current; current = current.upper) {
 		const found = current.set.get(name);
 		if (found) return found;
 	}
 }
-const noObjectAssign = createRule({
+const noObjectAssign = createRule$4({
 	name: "no-object-assign",
 	meta: {
 		type: "problem",
@@ -690,6 +792,378 @@ function resolveFrom(scope, name) {
 		if (found) return found;
 	}
 }
+const noPointlessReassignment = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		schema: [],
+		messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
+	},
+	create(context) {
+		return { VariableDeclarator(node) {
+			if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
+			if (node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") return;
+			const scope = context.sourceCode.getScope(node);
+			const sourceVariable = scope.references.find((reference) => reference.identifier === node.init)?.resolved;
+			if (!sourceVariable || sourceVariable.references.some((reference) => reference.isWrite() && reference.init !== true)) return;
+			const aliasName = node.id.name;
+			const originalName = node.init.name;
+			const aliasIsAnnotated = hasTypeAnnotation(node.id);
+			context.report({
+				node,
+				messageId: "pointlessReassignment",
+				data: {
+					name: aliasName,
+					value: originalName
+				},
+				fix(fixer) {
+					const variable = scope.set.get(aliasName);
+					if (!variable) return null;
+					if (aliasIsAnnotated) return null;
+					if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
+					const readRefs = variable.references.filter((reference) => reference.isRead() && isIdentifierReference(reference));
+					if (readRefs.some((reference) => {
+						const afterToken = context.sourceCode.getTokenAfter(reference.identifier);
+						if (afterToken?.value === ":") return false;
+						if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
+						let token = context.sourceCode.getTokenBefore(reference.identifier);
+						while (token) {
+							if (token.value === "{") return true;
+							if (token.value === "[" || token.value === "(") return false;
+							if (token.value === ":") return false;
+							token = context.sourceCode.getTokenBefore(token);
+						}
+						return false;
+					})) 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));
+					return fixes;
+				}
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/no-set-instanceof-mutation.ts
+const MUTATING_SET_METHODS = /* @__PURE__ */ new Set([
+	"add",
+	"delete",
+	"clear"
+]);
+const createRule$3 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function isSetInstanceofExpression(node) {
+	return node.type === AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && node.right.type === AST_NODE_TYPES.Identifier && node.right.name === "Set";
+}
+function definitelyExits(statement) {
+	if (statement.type === AST_NODE_TYPES.ReturnStatement || statement.type === AST_NODE_TYPES.ThrowStatement || statement.type === AST_NODE_TYPES.ContinueStatement || statement.type === AST_NODE_TYPES.BreakStatement) return true;
+	if (statement.type === AST_NODE_TYPES.BlockStatement) {
+		const last = statement.body.at(-1);
+		return last !== void 0 && definitelyExits(last);
+	}
+	return false;
+}
+const noSetInstanceofMutation = createRule$3({
+	name: "no-set-instanceof-mutation",
+	meta: {
+		type: "problem",
+		schema: [],
+		docs: { description: "Disallow mutating calls on a parameter or local variable whose real type includes a ReadonlySet, narrowed via instanceof Set, which silently discards the declared read-only guarantee." },
+		messages: { unsound: "'{{ method }}' mutates a parameter or local variable narrowed by instanceof Set -- instanceof Set's own narrowing widens straight to the mutable Set interface, so a value whose real type includes a ReadonlySet (a caller's set, for a parameter; the value's own declared type, for a local variable) can be mutated here despite that readonly guarantee. Copy the set before mutating (e.g. new Set(input)), or narrow with a check that preserves read-only instead of instanceof Set." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		function declarationHasReadonlySetConstituent(declarationNode) {
+			const tsNode = services.esTreeNodeToTSNodeMap.get(declarationNode);
+			const declaredType = checker.getTypeAtLocation(tsNode);
+			return (declaredType.isUnion() ? declaredType.types : [declaredType]).some((constituent) => constituent.getSymbol()?.name === "ReadonlySet");
+		}
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier || !MUTATING_SET_METHODS.has(callee.property.name)) return;
+			const variable = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === callee.object)?.resolved;
+			if (!variable) return;
+			const declarationDefinition = variable.defs.find((definition) => definition.type === TSESLint.Scope.DefinitionType.Parameter || definition.type === TSESLint.Scope.DefinitionType.Variable);
+			if (!declarationDefinition) return;
+			const declarationNode = declarationDefinition.name;
+			if (declarationNode.type !== AST_NODE_TYPES.Identifier) return;
+			if (!declarationHasReadonlySetConstituent(declarationNode)) return;
+			if (!isGuardedBySetInstanceof(node, variable, context)) return;
+			context.report({
+				node,
+				messageId: "unsound",
+				data: { method: callee.property.name }
+			});
+		} };
+		function resolvesToVariable(identifier, target, atNode, ruleContext) {
+			return ruleContext.sourceCode.getScope(atNode).references.find((reference) => reference.identifier === identifier)?.resolved === target;
+		}
+		function isNegatedSetInstanceofExpression(testNode, target, ruleContext) {
+			if (testNode.type !== AST_NODE_TYPES.UnaryExpression || testNode.operator !== "!") return false;
+			return matchesSetInstanceofOn(testNode.argument, target, ruleContext);
+		}
+		function matchesSetInstanceofOn(testNode, target, ruleContext) {
+			if (!isSetInstanceofExpression(testNode)) return false;
+			const { left } = testNode;
+			return left.type === AST_NODE_TYPES.Identifier && resolvesToVariable(left, target, testNode, ruleContext);
+		}
+		function isGuardedBySetInstanceof(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.IfStatement) {
+					if (parent.consequent === current && matchesSetInstanceofOn(parent.test, parameterVariable, ruleContext)) return true;
+					if (parent.alternate === current && isNegatedSetInstanceofExpression(parent.test, parameterVariable, ruleContext)) return true;
+				}
+				if (parent.type === AST_NODE_TYPES.LogicalExpression && parent.operator === "&&" && parent.right === current && matchesSetInstanceofOn(parent.left, parameterVariable, ruleContext)) return true;
+				if (parent.type === AST_NODE_TYPES.ConditionalExpression && parent.consequent === current && matchesSetInstanceofOn(parent.test, parameterVariable, ruleContext)) return true;
+				current = parent;
+			}
+			return isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext);
+		}
+		function isGuardedByPrecedingEarlyReturn(startNode, parameterVariable, ruleContext) {
+			let current = startNode;
+			while (current.parent) {
+				const { parent } = current;
+				if (parent.type === AST_NODE_TYPES.BlockStatement || parent.type === AST_NODE_TYPES.Program) {
+					const statements = parent.body;
+					let ownIndex = -1;
+					for (let i = 0; i < statements.length; i++) if (statements[i] === current) {
+						ownIndex = i;
+						break;
+					}
+					if (ownIndex > 0) for (let i = ownIndex - 1; i >= 0; i--) {
+						const sibling = statements[i];
+						if (sibling?.type === AST_NODE_TYPES.IfStatement && !sibling.alternate && isNegatedSetInstanceofExpression(sibling.test, parameterVariable, ruleContext) && definitelyExits(sibling.consequent)) return true;
+					}
+				}
+				current = parent;
+			}
+			return false;
+		}
+	}
+});
+//#endregion
+//#region src/rules/no-side-effects-in-index.ts
+const noSideEffectsInIndex = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { notAPureReexport: "A barrel (index) file may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') -- nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}." }
+	},
+	create(context) {
+		if (!isIndexFile(context.filename)) return {};
+		return { Program(node) {
+			for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+				node: statement,
+				messageId: "notAPureReexport",
+				data: { description: statement.type }
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/prefer-numeric-sort-compare.ts
+const createRule$2 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+const SORT_METHOD_NAMES = /* @__PURE__ */ new Set(["sort", "toSorted"]);
+function isDefinitelyNumberType(type) {
+	if (type.isUnion()) return type.types.every((constituent) => isDefinitelyNumberType(constituent));
+	return (type.flags & ts.TypeFlags.NumberLike) !== 0;
+}
+const preferNumericSortCompare = createRule$2({
+	name: "prefer-numeric-sort-compare",
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Suggest an ascending numeric compare function for a bare '.sort()'/'.toSorted()' call on an array whose element type is definitively 'number' -- the default comparator sorts lexicographically, so a bare numeric sort is essentially always a bug." },
+		schema: [],
+		messages: {
+			preferNumericCompare: "'.{{ method }}()' on a number array with no compare function sorts lexicographically (e.g. [1, 2, 10].sort() becomes [1, 10, 2]), not in ascending numeric order. Provide a compare function.",
+			addAscendingCompare: "Add an ascending numeric compare function: '(a, b) => a - b'."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (node.arguments.length > 0) return;
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed) return;
+			if (callee.property.type !== AST_NODE_TYPES.Identifier || !SORT_METHOD_NAMES.has(callee.property.name)) return;
+			const receiverTsNode = services.esTreeNodeToTSNodeMap.get(callee.object);
+			if (!ts.isExpression(receiverTsNode)) return;
+			const receiverType = checker.getTypeAtLocation(receiverTsNode);
+			if (!checker.isArrayType(receiverType)) return;
+			if (!isTypeReference(receiverType)) return;
+			const [elementType] = checker.getTypeArguments(receiverType);
+			if (!elementType || !isDefinitelyNumberType(elementType)) return;
+			context.report({
+				node,
+				messageId: "preferNumericCompare",
+				data: { method: callee.property.name },
+				suggest: [{
+					messageId: "addAscendingCompare",
+					fix(fixer) {
+						const closingParen = context.sourceCode.getLastToken(node);
+						if (!closingParen) return null;
+						return fixer.insertTextBefore(closingParen, "(a, b) => a - b");
+					}
+				}]
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prefer-readonly-array-param.ts
+const createRule$1 = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function getFixableArrayOrTupleType(typeNode) {
+	if (typeNode.type === AST_NODE_TYPES.TSTypeOperator && typeNode.operator === "readonly") return void 0;
+	if (typeNode.type === AST_NODE_TYPES.TSArrayType) return typeNode;
+	if (typeNode.type === AST_NODE_TYPES.TSTupleType) return typeNode;
+	if (typeNode.type === AST_NODE_TYPES.TSTypeReference && typeNode.typeName.type === AST_NODE_TYPES.Identifier && typeNode.typeName.name === "Array") return typeNode;
+}
+function getFixableTypesForAnnotation(typeNode) {
+	if (typeNode.type === AST_NODE_TYPES.TSUnionType) return typeNode.types.flatMap(getFixableTypesForAnnotation);
+	const fixable = getFixableArrayOrTupleType(typeNode);
+	return fixable ? [fixable] : [];
+}
+function getAnnotatedParamNode$1(param) {
+	if (param.type === AST_NODE_TYPES.TSParameterProperty) return getAnnotatedParamNode$1(param.parameter);
+	if (param.type === AST_NODE_TYPES.AssignmentPattern) return param.left.type === AST_NODE_TYPES.Identifier ? param.left : void 0;
+	if (param.type === AST_NODE_TYPES.RestElement || param.type === AST_NODE_TYPES.Identifier) return param;
+}
+const FUNCTION_LIKE_SELECTOR$1 = [
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSCallSignatureDeclaration",
+	"TSConstructSignatureDeclaration",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression",
+	"TSFunctionType",
+	"TSMethodSignature"
+].join(", ");
+const preferReadonlyArrayParam = createRule$1({
+	name: "prefer-readonly-array-param",
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require array and tuple parameters to be typed readonly, regardless of whether the function body mutates them -- a narrower, safely-autofixable sibling of @typescript-eslint/prefer-readonly-parameter-types scoped to array/tuple shapes only." },
+		schema: [],
+		messages: { preferReadonly: "Array and tuple parameters should be typed readonly ({{ suggestion }}) so a caller can pass a readonly or shared array with confidence, and so any mutation inside the function becomes a deliberate, visible compile error instead of a silent side effect on the caller's data." }
+	},
+	defaultOptions: [],
+	create(context) {
+		function checkParam(param) {
+			const annotatedNode = getAnnotatedParamNode$1(param);
+			if (!annotatedNode?.typeAnnotation) return;
+			const fixableTypes = getFixableTypesForAnnotation(annotatedNode.typeAnnotation.typeAnnotation);
+			if (fixableTypes.length === 0) return;
+			const suggestion = fixableTypes.map((fixableType) => fixableType.type === AST_NODE_TYPES.TSTypeReference ? "ReadonlyArray<T>" : `readonly ${fixableType.type === AST_NODE_TYPES.TSTupleType ? "[T, U]" : "T[]"}`).join(" / ");
+			context.report({
+				node: param,
+				messageId: "preferReadonly",
+				data: { suggestion },
+				fix(fixer) {
+					return fixableTypes.map((fixableType) => fixableType.type === AST_NODE_TYPES.TSTypeReference ? fixer.replaceText(fixableType.typeName, "ReadonlyArray") : fixer.insertTextBefore(fixableType, "readonly "));
+				}
+			});
+		}
+		return { [FUNCTION_LIKE_SELECTOR$1](node) {
+			for (const param of node.params) checkParam(param);
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prefer-readonly-object-param.ts
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/ExaDev/eslint-config/blob/main/src/rules/${name}.ts`);
+function getAnnotatedParamNode(param) {
+	if (param.type === AST_NODE_TYPES.TSParameterProperty) return getAnnotatedParamNode(param.parameter);
+	if (param.type === AST_NODE_TYPES.AssignmentPattern) return param.left.type === AST_NODE_TYPES.Identifier ? param.left : void 0;
+	if (param.type === AST_NODE_TYPES.RestElement || param.type === AST_NODE_TYPES.Identifier) return param;
+}
+const FUNCTION_LIKE_SELECTOR = [
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSCallSignatureDeclaration",
+	"TSConstructSignatureDeclaration",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression",
+	"TSFunctionType",
+	"TSMethodSignature"
+].join(", ");
+function getCandidateTypeNode(typeNode) {
+	if (typeNode.type === AST_NODE_TYPES.TSTypeLiteral) return typeNode;
+	if (typeNode.type !== AST_NODE_TYPES.TSTypeReference) return void 0;
+	if (typeNode.typeName.type !== AST_NODE_TYPES.Identifier) return void 0;
+	if (typeNode.typeName.name === "Readonly") return void 0;
+	return typeNode;
+}
+const PRIMITIVE_LIKE_FLAGS = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined;
+function isFlatPropertyType(checker, type) {
+	if (type.isUnion()) return type.types.every((constituent) => isFlatPropertyType(checker, constituent));
+	if ((type.flags & PRIMITIVE_LIKE_FLAGS) !== 0) return true;
+	return checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0 && checker.getPropertiesOfType(type).length === 0 && checker.getIndexInfosOfType(type).length === 0;
+}
+function isFlatObjectType(checker, type, location) {
+	if (type.flags & (ts.TypeFlags.Union | ts.TypeFlags.Intersection | ts.TypeFlags.TypeParameter)) return false;
+	if (checker.isArrayType(type) || checker.isTupleType(type)) return false;
+	if (checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0) return false;
+	if (checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length > 0) return false;
+	if ((type.getSymbol()?.flags ?? 0) & ts.SymbolFlags.Class) return false;
+	const symbolName = type.getSymbol()?.name;
+	if (symbolName === "Map" || symbolName === "ReadonlyMap" || symbolName === "Set" || symbolName === "ReadonlySet") return false;
+	for (const property of checker.getPropertiesOfType(type)) if (!isFlatPropertyType(checker, checker.getTypeOfSymbolAtLocation(property, location))) return false;
+	for (const indexInfo of checker.getIndexInfosOfType(type)) if (!isFlatPropertyType(checker, indexInfo.type)) return false;
+	return true;
+}
+function isAlreadyFullyReadonly(checker, type) {
+	const properties = checker.getPropertiesOfType(type);
+	const indexInfos = checker.getIndexInfosOfType(type);
+	if (properties.length === 0 && indexInfos.length === 0) return false;
+	return properties.every((property) => isPropertyReadonlyInType(type, property.getEscapedName(), checker)) && indexInfos.every((indexInfo) => indexInfo.isReadonly);
+}
+const preferReadonlyObjectParam = createRule({
+	name: "prefer-readonly-object-param",
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Require a 'flat' object parameter (every property is a primitive or a callback, so a shallow wrapper is provably sufficient) to be typed 'Readonly<T>' -- a narrower, safely-autofixable sibling of @typescript-eslint/prefer-readonly-parameter-types and of this package's own prefer-readonly-array-param, scoped to the object shapes where a shallow fix is genuinely complete." },
+		schema: [],
+		messages: { preferReadonlyObject: "This object parameter is 'flat' -- every property (and index-signature value, if any) is a primitive or a callback, so there is no nested mutable state a shallow wrapper could miss. Wrap it in 'Readonly<...>' so a caller can pass a readonly or shared object with confidence, and so any attempt to mutate it inside the function becomes a deliberate, visible compile error instead of a silent side effect on the caller's data." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		function checkParam(param) {
+			const annotatedNode = getAnnotatedParamNode(param);
+			if (!annotatedNode?.typeAnnotation) return;
+			const candidateTypeNode = getCandidateTypeNode(annotatedNode.typeAnnotation.typeAnnotation);
+			if (!candidateTypeNode) return;
+			const tsNode = services.esTreeNodeToTSNodeMap.get(annotatedNode);
+			const type = checker.getTypeAtLocation(tsNode);
+			if (!isFlatObjectType(checker, type, tsNode)) return;
+			if (isAlreadyFullyReadonly(checker, type)) return;
+			context.report({
+				node: param,
+				messageId: "preferReadonlyObject",
+				fix(fixer) {
+					return [fixer.insertTextBefore(candidateTypeNode, "Readonly<"), fixer.insertTextAfter(candidateTypeNode, ">")];
+				}
+			});
+		}
+		return { [FUNCTION_LIKE_SELECTOR](node) {
+			for (const param of node.params) checkParam(param);
+		} };
+	}
+});
 //#endregion
 //#region src/plugin.ts
 const plugin = {
@@ -705,81 +1179,17 @@ const plugin = {
 		"no-enum-number-widening": noEnumNumberWidening,
 		"no-enum-reverse-lookup-widening": noEnumReverseLookupWidening,
 		"no-index-files": noIndexFiles,
+		"no-map-instanceof-mutation": noMapInstanceofMutation,
 		"no-mutable-union-array-param": noMutableUnionArrayParam,
 		"no-non-barrel-index": noNonBarrelIndex,
 		"no-non-barrel-reexport": noNonBarrelReexport,
 		"no-object-assign": noObjectAssign,
-		"no-pointless-reassignment": {
-			meta: {
-				type: "problem",
-				fixable: "code",
-				schema: [],
-				messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
-			},
-			create(context) {
-				return { VariableDeclarator(node) {
-					if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
-					if (node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") return;
-					const scope = context.sourceCode.getScope(node);
-					const sourceVariable = scope.references.find((reference) => reference.identifier === node.init)?.resolved;
-					if (!sourceVariable || sourceVariable.references.some((reference) => reference.isWrite() && reference.init !== true)) return;
-					const aliasName = node.id.name;
-					const originalName = node.init.name;
-					const aliasIsAnnotated = hasTypeAnnotation(node.id);
-					context.report({
-						node,
-						messageId: "pointlessReassignment",
-						data: {
-							name: aliasName,
-							value: originalName
-						},
-						fix(fixer) {
-							const variable = scope.set.get(aliasName);
-							if (!variable) return null;
-							if (aliasIsAnnotated) return null;
-							if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
-							const readRefs = variable.references.filter((reference) => reference.isRead() && isIdentifierReference(reference));
-							if (readRefs.some((reference) => {
-								const afterToken = context.sourceCode.getTokenAfter(reference.identifier);
-								if (afterToken?.value === ":") return false;
-								if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
-								let token = context.sourceCode.getTokenBefore(reference.identifier);
-								while (token) {
-									if (token.value === "{") return true;
-									if (token.value === "[" || token.value === "(") return false;
-									if (token.value === ":") return false;
-									token = context.sourceCode.getTokenBefore(token);
-								}
-								return false;
-							})) 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));
-							return fixes;
-						}
-					});
-				} };
-			}
-		},
-		"no-side-effects-in-index": {
-			meta: {
-				type: "problem",
-				schema: [],
-				messages: { notAPureReexport: "A barrel (index) file may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') -- nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}." }
-			},
-			create(context) {
-				if (!isIndexFile(context.filename)) return {};
-				return { Program(node) {
-					for (const statement of node.body) if (!isPureReexport(statement)) context.report({
-						node: statement,
-						messageId: "notAPureReexport",
-						data: { description: statement.type }
-					});
-				} };
-			}
-		}
+		"no-pointless-reassignment": noPointlessReassignment,
+		"no-set-instanceof-mutation": noSetInstanceofMutation,
+		"no-side-effects-in-index": noSideEffectsInIndex,
+		"prefer-numeric-sort-compare": preferNumericSortCompare,
+		"prefer-readonly-array-param": preferReadonlyArrayParam,
+		"prefer-readonly-object-param": preferReadonlyObjectParam
 	},
 	configs: {
 		get recommended() {
@@ -790,7 +1200,8 @@ const plugin = {
 					"exadev/barrel-policy": ["error", { mode: "banned" }],
 					"exadev/no-mutable-union-array-param": "error",
 					"exadev/no-object-assign": "error",
-					"exadev/no-pointless-reassignment": "error"
+					"exadev/no-pointless-reassignment": "error",
+					"exadev/prefer-readonly-array-param": "error"
 				}
 			};
 		},
@@ -816,11 +1227,18 @@ const recommendedTypeChecked = [
 			"exadev/no-array-isarray-mutation": "error",
 			"exadev/no-enum-number-widening": "error",
 			"exadev/no-enum-reverse-lookup-widening": "error",
+			"exadev/no-map-instanceof-mutation": "error",
 			"exadev/no-mutable-union-array-param": "error",
 			"exadev/no-object-assign": "error",
 			"exadev/no-pointless-reassignment": "error",
+			"exadev/no-set-instanceof-mutation": "error",
+			"exadev/prefer-numeric-sort-compare": "error",
+			"exadev/prefer-readonly-array-param": "error",
+			"exadev/prefer-readonly-object-param": "error",
 			"@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": true }],
 			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+			"@typescript-eslint/consistent-type-exports": "error",
+			"@typescript-eslint/consistent-type-imports": "error",
 			"@typescript-eslint/method-signature-style": ["error", "property"],
 			"@typescript-eslint/no-deprecated": "error",
 			"@typescript-eslint/no-magic-numbers": ["error", {
@@ -840,6 +1258,7 @@ const recommendedTypeChecked = [
 			"@typescript-eslint/no-non-null-assertion": "error",
 			"@typescript-eslint/no-unnecessary-condition": "error",
 			"@typescript-eslint/prefer-readonly": "error",
+			"@typescript-eslint/promise-function-async": "error",
 			"@typescript-eslint/require-array-sort-compare": "error",
 			"@typescript-eslint/strict-boolean-expressions": "error",
 			"@typescript-eslint/switch-exhaustiveness-check": "error",