eslint-plugin-flawless 1.4.1 → 1.4.3

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as plugin, t as PLUGIN_NAME } from "./plugin-p3_AxnS4.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-rI_n00SA.mjs";
 //#region src/configs/index.ts
 const configs = { recommended: {
 	plugins: { [PLUGIN_NAME]: plugin },

package/dist/oxlint.mjs

@@ -1,4 +1,4 @@
-import { n as plugin, t as PLUGIN_NAME } from "./plugin-p3_AxnS4.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-rI_n00SA.mjs";
 import { definePlugin } from "@oxlint/plugins";
 //#region src/oxlint.ts
 /**

package/dist/{plugin-p3_AxnS4.mjs → plugin-rI_n00SA.mjs}

@@ -14,7 +14,7 @@ import * as core from "@eslint-react/core";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "1.4.1";
+var version = "1.4.3";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -3030,6 +3030,11 @@ const DEFAULTS$1 = {
 };
 /** Callee identifiers that name a vitest test block (`describe` is excluded). */
 const TEST_BLOCK_NAMES$1 = /* @__PURE__ */ new Set(["it", "test"]);
+/**
+* Root identifiers whose call arguments are assertion conditions. Matched by
+* name as well as by vitest resolution, so `assert` from `node:assert` counts.
+*/
+const ASSERTION_ROOT_NAMES = /* @__PURE__ */ new Set(["assert", "expect"]);
 const messages$14 = { [MESSAGE_ID$9]: "Avoid having conditionals in tests." };
 const schema$3 = [{
 	additionalProperties: false,
@@ -3113,12 +3118,43 @@ function resolveVitestName$1(sourceCode, identifier) {
 	return null;
 }
 /**
-* Collects the `?.` tokens along an optional chain's primary spine and the text
-* that replaces each with a non-null assertion. A non-computed member becomes
-* `!.` (`a?.b` -> `a!.b`); a computed member or optional call becomes `!`
-* (`a?.[x]` -> `a![x]`, `fn?.()` -> `fn!()`). Only the object/callee spine is
-* walked — optional chains inside computed keys or call arguments are their own
-* `ChainExpression` nodes and are visited (and fixed) separately.
+* Determines whether a node sits directly in the argument list of an assertion
+* call (`expect(...)`, `assert(...)`, `assert.ok(...)`, `expect(x).toBe(...)`).
+* The search walks up to the nearest enclosing call and stops there, so an
+* argument of some other function nested inside an assertion
+* (`expect(wrap(a && b))`) does not qualify; it also stops at a function
+* boundary, since a callback's body runs on the callback's terms rather than as
+* part of the assertion's condition.
+*
+* @param node - The node to locate.
+* @param sourceCode - Provides the scope used to resolve the callee.
+* @returns `true` when the node is an argument of an assertion call.
+*/
+function isInAssertionArgument(node, sourceCode) {
+	let current = node;
+	while (current.type !== AST_NODE_TYPES.Program) {
+		const { parent } = current;
+		if (parent.type === AST_NODE_TYPES.ArrowFunctionExpression || parent.type === AST_NODE_TYPES.FunctionDeclaration || parent.type === AST_NODE_TYPES.FunctionExpression) return false;
+		if (parent.type === AST_NODE_TYPES.CallExpression) {
+			if (current === parent.callee) return false;
+			const root = getRootIdentifier$1(parent.callee);
+			if (root === null) return false;
+			return ASSERTION_ROOT_NAMES.has(root.name) || ASSERTION_ROOT_NAMES.has(resolveVitestName$1(sourceCode, root) ?? "");
+		}
+		current = parent;
+	}
+	return false;
+}
+/**
+* Collects the `?.` tokens along an optional chain's primary spine and the parts
+* that convert each into a non-null assertion. The `!` is anchored to the token
+* preceding `?.` rather than written in place of it, because TypeScript forbids
+* a line break before `!` — a chain wrapped as `a\n?.b` has to become `a!\n.b`,
+* not `a\n!.b`. What replaces `?.` is therefore only the connector: `.` for a
+* plain member (`a?.b` -> `a!.b`), nothing for a computed member or optional
+* call (`a?.[x]` -> `a![x]`, `fn?.()` -> `fn!()`). Only the object/callee spine
+* is walked — optional chains inside computed keys or call arguments are their
+* own `ChainExpression` nodes and are visited (and fixed) separately.
 *
 * @param chain - The chain expression to convert.
 * @param sourceCode - Provides token lookups.
@@ -3131,8 +3167,10 @@ function collectOptionalTokenFixes(chain, sourceCode) {
 		if (node.type === AST_NODE_TYPES.MemberExpression) {
 			if (node.optional) {
 				const token = sourceCode.getTokenAfter(node.object, { filter: (candidate) => candidate.value === "?." });
-				if (token !== null) fixes.push({
-					text: node.computed ? "!" : "!.",
+				const anchor = token === null ? null : sourceCode.getTokenBefore(token);
+				if (token !== null && anchor !== null) fixes.push({
+					anchor,
+					text: node.computed ? "" : ".",
 					token
 				});
 			}
@@ -3142,8 +3180,10 @@ function collectOptionalTokenFixes(chain, sourceCode) {
 		if (node.type === AST_NODE_TYPES.CallExpression) {
 			if (node.optional) {
 				const token = sourceCode.getTokenAfter(node.callee, { filter: (candidate) => candidate.value === "?." });
-				if (token !== null) fixes.push({
-					text: "!",
+				const anchor = token === null ? null : sourceCode.getTokenBefore(token);
+				if (token !== null && anchor !== null) fixes.push({
+					anchor,
+					text: "",
 					token
 				});
 			}
@@ -3165,13 +3205,13 @@ function collectOptionalTokenFixes(chain, sourceCode) {
 function createOnce$10(context) {
 	let config;
 	let sourceCode;
-	let inTestCase = false;
+	const testBlocks = [];
 	/**
-	* Determines whether a call opens a test block (a resolved vitest `it`/`test`,
+	* Determines whether a call names a test block (a resolved vitest `it`/`test`,
 	* or a configured `additionalTestBlockFunctions` name).
 	*
 	* @param node - The call to inspect.
-	* @returns `true` when the call opens a test.
+	* @returns `true` when the call is rooted at a test block name.
 	*/
 	function isTestBlock(node) {
 		const root = getRootIdentifier$1(node.callee);
@@ -3180,12 +3220,46 @@ function createOnce$10(context) {
 		return name !== null && config.additionalTestBlockFunctions.includes(name);
 	}
 	/**
+	* Determines whether a test block call is a modifier applied to the block
+	* rather than the call that opens it. In `it.skipIf(cond)("works", fn)` both
+	* calls are rooted at `it`, but only the outer one takes the test body — the
+	* inner one sits in its callee position.
+	*
+	* @param node - The test block call to inspect.
+	* @returns `true` when the call is a modifier in a callee chain.
+	*/
+	function isTestBlockModifier(node) {
+		const { parent } = node;
+		return parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node;
+	}
+	/**
+	* Determines whether a node sits in the body of the innermost open test block.
+	* A node reached through that block's callee — a modifier's arguments
+	* (`it.skipIf(cond)`, `it.each(cases)`) or a computed key (`it[flag ? …]`) —
+	* decides whether and how the test runs rather than what it does, so it is not
+	* part of the body.
+	*
+	* @param node - The node to locate.
+	* @returns `true` when the node is inside a test body.
+	*/
+	function isInTestBody(node) {
+		const block = testBlocks.at(-1);
+		if (block === void 0) return false;
+		let current = node;
+		while (current.type !== AST_NODE_TYPES.Program) {
+			const { parent } = current;
+			if (parent === block) return current !== block.callee;
+			current = parent;
+		}
+		return false;
+	}
+	/**
 	* Reports a conditional node when the traversal is inside a test body.
 	*
 	* @param node - The `if`/`switch`/ternary/logical construct to flag.
 	*/
 	function maybeReportConditional(node) {
-		if (inTestCase) context.report({
+		if (isInTestBody(node)) context.report({
 			messageId: MESSAGE_ID$9,
 			node
 		});
@@ -3198,20 +3272,20 @@ function createOnce$10(context) {
 				allowOptionalChaining: options?.allowOptionalChaining ?? DEFAULTS$1.allowOptionalChaining
 			};
 			({sourceCode} = context);
-			inTestCase = false;
+			testBlocks.length = 0;
 		},
 		"CallExpression": function(node) {
-			if (isTestBlock(node)) inTestCase = true;
+			if (isTestBlock(node) && !isTestBlockModifier(node)) testBlocks.push(node);
 		},
 		"CallExpression:exit": function(node) {
-			if (isTestBlock(node)) inTestCase = false;
+			if (testBlocks.at(-1) === node) testBlocks.pop();
 		},
 		"ChainExpression": function(node) {
-			if (!inTestCase || config.allowOptionalChaining) return;
+			if (config.allowOptionalChaining || !isInTestBody(node)) return;
 			context.report({
 				fix: (fixer) => {
-					return collectOptionalTokenFixes(node, sourceCode).map((optionalFix) => {
-						return fixer.replaceText(optionalFix.token, optionalFix.text);
+					return collectOptionalTokenFixes(node, sourceCode).flatMap((optionalFix) => {
+						return [fixer.insertTextAfter(optionalFix.anchor, "!"), fixer.replaceText(optionalFix.token, optionalFix.text)];
 					});
 				},
 				messageId: MESSAGE_ID$9,
@@ -3220,7 +3294,10 @@ function createOnce$10(context) {
 		},
 		"ConditionalExpression": maybeReportConditional,
 		"IfStatement": maybeReportConditional,
-		"LogicalExpression": maybeReportConditional,
+		"LogicalExpression": function(node) {
+			if (node.operator === "&&" && isInAssertionArgument(node, sourceCode)) return;
+			maybeReportConditional(node);
+		},
 		"SwitchStatement": maybeReportConditional
 	};
 }

package/package.json

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