eslint-plugin-flawless 1.2.1 → 1.4.0

package/README.md

@@ -205,12 +205,15 @@ Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 | [jsx-shorthand-fragment](src/rules/jsx-shorthand-fragment/documentation.md)                   | Enforce a consistent fragment form: the shorthand `<>...</>` or a named fragment                 | 🔧  |     |
 | [max-lines-per-function](src/rules/max-lines-per-function/documentation.md)                   | Enforce a maximum number of lines of code in a function                                          |     |     |
 | [naming-convention](src/rules/naming-convention/documentation.md)                             | Enforce naming conventions for everything across a codebase                                      |     | 💭  |
+| [no-conditional-in-test](src/rules/no-conditional-in-test/documentation.md)                   | Disallow conditional logic in tests                                                              | 🔧  |     |
 | [no-export-default-arrow](src/rules/no-export-default-arrow/documentation.md)                 | Disallow anonymous arrow functions as export default declarations                                | 🔧  |     |
 | [no-redundant-tsconfig-options](src/rules/no-redundant-tsconfig-options/documentation.md)     | Disallow tsconfig options that redundantly re-set a value already provided by an extended config | 🔧  |     |
 | [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'                                                          |     |     |
 | [padding-after-expect-assertions](src/rules/padding-after-expect-assertions/documentation.md) | Enforce a blank line after `expect.assertions` and `expect.hasAssertions`                        | 🔧  |     |
 | [prefer-destructuring-assignment](src/rules/prefer-destructuring-assignment/documentation.md) | Enforce destructuring assignment for component props                                             | 🔧  |     |
+| [prefer-ending-with-an-expect](src/rules/prefer-ending-with-an-expect/documentation.md)       | Prefer having the last statement in a test be an assertion                                       |     |     |
+| [prefer-expect-assertions-count](src/rules/prefer-expect-assertions-count/documentation.md)   | Prefer `expect.assertions(<count>)` over `expect.hasAssertions()`                                |     |     |
 | [prefer-parameter-destructuring](src/rules/prefer-parameter-destructuring/documentation.md)   | Enforce destructuring parameters in the function signature                                       | 🔧  |     |
 | [prefer-read-only-props](src/rules/prefer-read-only-props/documentation.md)                   | Enforce that function component props are read-only                                              | 🔧  | 💭  |
 | [purity](src/rules/purity/documentation.md)                                                   | Disallow impure calls such as `math.random` or `os.clock` during render                          |     |     |

package/dist/index.d.mts

@@ -51,7 +51,7 @@ declare const EXPLICIT = "useExplicitReturn";
 declare const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
 type MessageIds$5 = typeof COMPLEX_EXPLICIT | typeof EXPLICIT | typeof IMPLICIT;
 type ObjectReturnStyle = "always-explicit" | "complex-explicit" | "off";
-type Options$6 = [{
+type Options$8 = [{
   /** Always use explicit returns for JSX bodies. */
   jsxAlwaysUseExplicitReturn?: boolean;
   /** Maximum emitted line length (tab-expanded) before requiring an explicit return. */
@@ -86,7 +86,7 @@ interface JsxShorthandFragmentOptions {
    */
   readonly mode?: Mode;
 }
-type Options$5 = [JsxShorthandFragmentOptions?];
+type Options$7 = [JsxShorthandFragmentOptions?];
 type Mode = "element" | "syntax";
 //#endregion
 //#region src/rules/max-lines-per-function/rule.d.ts
@@ -119,7 +119,7 @@ interface MaxLinesPerFunctionOptions {
    */
   readonly skipComments?: boolean;
 }
-type Options$4 = [MaxLinesPerFunctionOptions?];
+type Options$6 = [MaxLinesPerFunctionOptions?];
 //#endregion
 //#region src/rules/naming-convention/utils/enums.d.ts
 declare const Selector: {
@@ -246,7 +246,23 @@ interface NamingSelector {
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
 type MessageIds$3 = "doesNotMatchFormat" | "doesNotMatchFormatForeignContract" | "doesNotMatchFormatTrimmed" | "doesNotMatchFormatTrimmedForeignContract" | "missingAffix" | "missingAffixForeignContract" | "missingUnderscore" | "missingUnderscoreForeignContract" | "satisfyCustom" | "satisfyCustomForeignContract" | "unexpectedUnderscore" | "unexpectedUnderscoreForeignContract";
-type Options$3 = Array<NamingSelector>;
+type Options$5 = Array<NamingSelector>;
+//#endregion
+//#region src/rules/no-conditional-in-test/rule.d.ts
+interface NoConditionalInTestOptions {
+  /**
+   * Callee names, in addition to a resolved vitest `it`/`test`, whose call is
+   * treated as a test block. Matched by exact dotted name (no scope resolution),
+   * for libraries with custom test blocks such as `myTest` or `each.test`.
+   */
+  readonly additionalTestBlockFunctions?: ReadonlyArray<string>;
+  /**
+   * Whether optional chaining (`?.`) is allowed in tests. When `false`, optional
+   * chains are reported and auto-fixed to a non-null assertion (`a?.b` -> `a!.b`).
+   */
+  readonly allowOptionalChaining?: boolean;
+}
+type Options$4 = [NoConditionalInTestOptions?];
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.d.ts
 declare const MESSAGE_ID_DEFAULT$1 = "default";
@@ -258,6 +274,24 @@ declare const MESSAGE_ID_DEFAULT = "default";
 declare const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
 type MessageIds$1 = typeof MESSAGE_ID_DEFAULT | typeof MESSAGE_ID_INSIDE_USE_EFFECT;
 //#endregion
+//#region src/rules/prefer-ending-with-an-expect/rule.d.ts
+interface PreferEndingWithAnExpectOptions {
+  /**
+   * Callee names, in addition to a resolved vitest `it`/`test`, whose second
+   * argument is treated as a test body. Matched by exact dotted name (no scope
+   * resolution), for libraries with custom test blocks such as `each.test`.
+   */
+  readonly additionalTestBlockFunctions?: ReadonlyArray<string>;
+  /**
+   * Function names, in addition to a resolved vitest `expect`, that count as an
+   * assertion when they end a test. Matched by name against the callee chain,
+   * so no scope resolution applies. A `*` matches a single dotted segment and
+   * `**` matches any number, allowing patterns such as `request.*.expect`.
+   */
+  readonly assertFunctionNames?: ReadonlyArray<string>;
+}
+type Options$3 = [PreferEndingWithAnExpectOptions?];
+//#endregion
 //#region src/rules/prefer-parameter-destructuring/rule.d.ts
 type Options$2 = [{
   /**
@@ -305,13 +339,14 @@ declare const plugin: {
     version: string;
   };
   rules: {
-    "arrow-return-style": FlawlessRuleModule<Options$6, MessageIds$5, Readonly<TSESLint.SourceCode>>;
+    "arrow-return-style": FlawlessRuleModule<Options$8, MessageIds$5, Readonly<TSESLint.SourceCode>>;
     "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<TSESLint.SourceCode>>;
-    "jsx-shorthand-fragment": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<TSESLint.SourceCode>>;
-    "max-lines-per-function": FlawlessRuleModule<Options$4, "exceed", Readonly<TSESLint.SourceCode>>;
-    "naming-convention": TSESLint.RuleModule<MessageIds$3, Options$3, PluginDocumentation, TSESLint.RuleListener> & {
+    "jsx-shorthand-fragment": FlawlessRuleModule<Options$7, MessageIds$4, Readonly<TSESLint.SourceCode>>;
+    "max-lines-per-function": FlawlessRuleModule<Options$6, "exceed", Readonly<TSESLint.SourceCode>>;
+    "naming-convention": TSESLint.RuleModule<MessageIds$3, Options$5, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
+    "no-conditional-in-test": FlawlessRuleModule<Options$4, "conditionalInTest", Readonly<TSESLint.SourceCode>>;
     "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<TSESLint.SourceCode>>;
     "no-redundant-tsconfig-options": TSESLint.RuleModule<"redundant", [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
@@ -320,6 +355,8 @@ declare const plugin: {
     "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds$1, Readonly<TSESLint.SourceCode>>;
     "padding-after-expect-assertions": FlawlessRuleModule<[], "missingPadding", Readonly<TSESLint.SourceCode>>;
     "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<TSESLint.SourceCode>>;
+    "prefer-ending-with-an-expect": FlawlessRuleModule<Options$3, "mustEndWithExpect", Readonly<TSESLint.SourceCode>>;
+    "prefer-expect-assertions-count": FlawlessRuleModule<[], "preferCount", Readonly<TSESLint.SourceCode>>;
     "prefer-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<TSESLint.SourceCode>>;
     "prefer-read-only-props": TSESLint.RuleModule<"preferReadOnlyProps", [{
       fixStyle?: "modifier" | "wrap";
@@ -350,13 +387,14 @@ declare const _default: {
             version: string;
           };
           rules: {
-            "arrow-return-style": FlawlessRuleModule<Options$6, MessageIds$5, Readonly<import("${configDir}").SourceCode>>;
+            "arrow-return-style": FlawlessRuleModule<Options$8, MessageIds$5, Readonly<import("${configDir}").SourceCode>>;
             "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<import("${configDir}").SourceCode>>;
-            "jsx-shorthand-fragment": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
-            "max-lines-per-function": FlawlessRuleModule<Options$4, "exceed", Readonly<import("${configDir}").SourceCode>>;
-            "naming-convention": import("${configDir}").RuleModule<MessageIds$3, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
+            "jsx-shorthand-fragment": FlawlessRuleModule<Options$7, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
+            "max-lines-per-function": FlawlessRuleModule<Options$6, "exceed", Readonly<import("${configDir}").SourceCode>>;
+            "naming-convention": import("${configDir}").RuleModule<MessageIds$3, Options$5, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
+            "no-conditional-in-test": FlawlessRuleModule<Options$4, "conditionalInTest", Readonly<import("${configDir}").SourceCode>>;
             "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
             "no-redundant-tsconfig-options": import("${configDir}").RuleModule<"redundant", [], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
@@ -365,6 +403,8 @@ declare const _default: {
             "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds$1, Readonly<import("${configDir}").SourceCode>>;
             "padding-after-expect-assertions": FlawlessRuleModule<[], "missingPadding", Readonly<import("${configDir}").SourceCode>>;
             "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<import("${configDir}").SourceCode>>;
+            "prefer-ending-with-an-expect": FlawlessRuleModule<Options$3, "mustEndWithExpect", Readonly<import("${configDir}").SourceCode>>;
+            "prefer-expect-assertions-count": FlawlessRuleModule<[], "preferCount", Readonly<import("${configDir}").SourceCode>>;
             "prefer-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<import("${configDir}").SourceCode>>;
             "prefer-read-only-props": import("${configDir}").RuleModule<"preferReadOnlyProps", [{
               fixStyle?: "modifier" | "wrap";
@@ -392,13 +432,14 @@ declare const _default: {
     version: string;
   };
   rules: {
-    "arrow-return-style": FlawlessRuleModule<Options$6, MessageIds$5, Readonly<import("${configDir}").SourceCode>>;
+    "arrow-return-style": FlawlessRuleModule<Options$8, MessageIds$5, Readonly<import("${configDir}").SourceCode>>;
     "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<import("${configDir}").SourceCode>>;
-    "jsx-shorthand-fragment": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
-    "max-lines-per-function": FlawlessRuleModule<Options$4, "exceed", Readonly<import("${configDir}").SourceCode>>;
-    "naming-convention": import("${configDir}").RuleModule<MessageIds$3, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
+    "jsx-shorthand-fragment": FlawlessRuleModule<Options$7, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
+    "max-lines-per-function": FlawlessRuleModule<Options$6, "exceed", Readonly<import("${configDir}").SourceCode>>;
+    "naming-convention": import("${configDir}").RuleModule<MessageIds$3, Options$5, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
+    "no-conditional-in-test": FlawlessRuleModule<Options$4, "conditionalInTest", Readonly<import("${configDir}").SourceCode>>;
     "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
     "no-redundant-tsconfig-options": import("${configDir}").RuleModule<"redundant", [], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
@@ -407,6 +448,8 @@ declare const _default: {
     "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds$1, Readonly<import("${configDir}").SourceCode>>;
     "padding-after-expect-assertions": FlawlessRuleModule<[], "missingPadding", Readonly<import("${configDir}").SourceCode>>;
     "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<import("${configDir}").SourceCode>>;
+    "prefer-ending-with-an-expect": FlawlessRuleModule<Options$3, "mustEndWithExpect", Readonly<import("${configDir}").SourceCode>>;
+    "prefer-expect-assertions-count": FlawlessRuleModule<[], "preferCount", Readonly<import("${configDir}").SourceCode>>;
     "prefer-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<import("${configDir}").SourceCode>>;
     "prefer-read-only-props": import("${configDir}").RuleModule<"preferReadOnlyProps", [{
       fixStyle?: "modifier" | "wrap";

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as plugin, t as PLUGIN_NAME } from "./plugin-DfRbpogP.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-BVNImiZB.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-DfRbpogP.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-BVNImiZB.mjs";
 import { definePlugin } from "@oxlint/plugins";
 //#region src/oxlint.ts
 /**

package/dist/{plugin-DfRbpogP.mjs → plugin-BVNImiZB.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.2.1";
+var version = "1.4.0";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -84,11 +84,11 @@ function createFlawlessRule({ createOnce, ...meta }) {
 }
 //#endregion
 //#region src/rules/arrow-return-style/rule.ts
-const RULE_NAME$16 = "arrow-return-style";
+const RULE_NAME$19 = "arrow-return-style";
 const IMPLICIT = "useImplicitReturn";
 const EXPLICIT = "useExplicitReturn";
 const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
-const DEFAULTS$1 = {
+const DEFAULTS$3 = {
 	jsxAlwaysUseExplicitReturn: false,
 	maxLen: 80,
 	maxObjectProperties: 4,
@@ -232,9 +232,9 @@ function collectArrows(root) {
 	return arrows.sort((a, b) => a.range[0] - b.range[0]);
 }
 const arrowReturnStyle = createFlawlessRule({
-	name: RULE_NAME$16,
+	name: RULE_NAME$19,
 	createOnce(context) {
-		let config = DEFAULTS$1;
+		let config = DEFAULTS$3;
 		let sourceCode;
 		let lines;
 		let pendingConsults;
@@ -533,7 +533,7 @@ const arrowReturnStyle = createFlawlessRule({
 			},
 			"before": function() {
 				config = {
-					...DEFAULTS$1,
+					...DEFAULTS$3,
 					...context.options[0]
 				};
 				({sourceCode} = context);
@@ -545,7 +545,7 @@ const arrowReturnStyle = createFlawlessRule({
 			}
 		};
 	},
-	defaultOptions: [DEFAULTS$1],
+	defaultOptions: [DEFAULTS$3],
 	meta: {
 		docs: {
 			description: "Enforce arrow function return style based on line length",
@@ -598,23 +598,23 @@ const arrowReturnStyle = createFlawlessRule({
 });
 //#endregion
 //#region src/rules/jsx-shorthand-boolean/rule.ts
-const RULE_NAME$15 = "jsx-shorthand-boolean";
-const MESSAGE_ID$7 = "setAttributeValue";
-const messages$15 = { [MESSAGE_ID$7]: "Set an explicit value for boolean attribute '{{name}}'." };
-function createOnce$10(context) {
+const RULE_NAME$18 = "jsx-shorthand-boolean";
+const MESSAGE_ID$10 = "setAttributeValue";
+const messages$18 = { [MESSAGE_ID$10]: "Set an explicit value for boolean attribute '{{name}}'." };
+function createOnce$13(context) {
 	return { JSXAttribute(node) {
 		if (node.value !== null) return;
 		context.report({
 			data: { name: context.sourceCode.getText(node.name) },
 			fix: (fixer) => fixer.insertTextAfter(node.name, "={true}"),
-			messageId: MESSAGE_ID$7,
+			messageId: MESSAGE_ID$10,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createFlawlessRule({
-	name: RULE_NAME$15,
-	createOnce: createOnce$10,
+	name: RULE_NAME$18,
+	createOnce: createOnce$13,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -624,23 +624,23 @@ const jsxShorthandBoolean = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$15,
+		messages: messages$18,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$14 = "jsx-shorthand-fragment";
+const RULE_NAME$17 = "jsx-shorthand-fragment";
 const MESSAGE_ID_NAMED = "useNamedFragment";
 const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
 const DEFAULT_MODE = "syntax";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$14 = {
+const messages$17 = {
 	[MESSAGE_ID_NAMED]: "Use the '{{name}}' component instead of fragment shorthand syntax.",
 	[MESSAGE_ID_SHORTHAND]: "Use the fragment shorthand syntax '<>...</>' instead of the '{{name}}' component."
 };
-const schema$3 = [{
+const schema$5 = [{
 	additionalProperties: false,
 	properties: {
 		fragmentName: {
@@ -672,7 +672,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$9(context) {
+function createOnce$12(context) {
 	let mode;
 	let fragmentName;
 	let namedFragments;
@@ -719,8 +719,8 @@ function createOnce$9(context) {
 	};
 }
 const jsxShorthandFragment = createFlawlessRule({
-	name: RULE_NAME$14,
-	createOnce: createOnce$9,
+	name: RULE_NAME$17,
+	createOnce: createOnce$12,
 	defaultOptions: [{
 		fragmentName: DEFAULT_FRAGMENT_NAME,
 		mode: DEFAULT_MODE
@@ -737,8 +737,8 @@ const jsxShorthandFragment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$14,
-		schema: schema$3,
+		messages: messages$17,
+		schema: schema$5,
 		type: "suggestion"
 	}
 });
@@ -877,19 +877,19 @@ function getOpeningParenOfParameters(node, sourceCode) {
 }
 //#endregion
 //#region src/rules/max-lines-per-function/rule.ts
-const RULE_NAME$13 = "max-lines-per-function";
+const RULE_NAME$16 = "max-lines-per-function";
 const MESSAGE_ID_EXCEED = "exceed";
 /** A line that is empty or holds only whitespace. */
 const BLANK_LINE = /^\s*$/u;
-const DEFAULTS = {
+const DEFAULTS$2 = {
 	countFrom: "body",
 	IIFEs: false,
 	max: 50,
 	skipBlankLines: false,
 	skipComments: false
 };
-const messages$13 = { [MESSAGE_ID_EXCEED]: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." };
-const schema$2 = [{
+const messages$16 = { [MESSAGE_ID_EXCEED]: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." };
+const schema$4 = [{
 	additionalProperties: false,
 	properties: {
 		countFrom: {
@@ -991,7 +991,7 @@ function getCountedLoc(countFrom, funcNode, reportNode) {
 * @param context - The rule context.
 * @returns The visitors measuring each function.
 */
-function createOnce$8(context) {
+function createOnce$11(context) {
 	let commentLineNumbers;
 	let config;
 	let lines;
@@ -1032,11 +1032,11 @@ function createOnce$8(context) {
 		before() {
 			const options = context.options[0];
 			config = {
-				countFrom: options?.countFrom ?? DEFAULTS.countFrom,
-				IIFEs: options?.IIFEs ?? DEFAULTS.IIFEs,
-				max: options?.max ?? DEFAULTS.max,
-				skipBlankLines: options?.skipBlankLines ?? DEFAULTS.skipBlankLines,
-				skipComments: options?.skipComments ?? DEFAULTS.skipComments
+				countFrom: options?.countFrom ?? DEFAULTS$2.countFrom,
+				IIFEs: options?.IIFEs ?? DEFAULTS$2.IIFEs,
+				max: options?.max ?? DEFAULTS$2.max,
+				skipBlankLines: options?.skipBlankLines ?? DEFAULTS$2.skipBlankLines,
+				skipComments: options?.skipComments ?? DEFAULTS$2.skipComments
 			};
 			({sourceCode} = context);
 			lines = [...sourceCode.lines];
@@ -1047,19 +1047,19 @@ function createOnce$8(context) {
 	};
 }
 const maxLinesPerFunction = createFlawlessRule({
-	name: RULE_NAME$13,
-	createOnce: createOnce$8,
-	defaultOptions: [DEFAULTS],
+	name: RULE_NAME$16,
+	createOnce: createOnce$11,
+	defaultOptions: [DEFAULTS$2],
 	meta: {
-		defaultOptions: [DEFAULTS],
+		defaultOptions: [DEFAULTS$2],
 		docs: {
 			description: "Enforce a maximum number of lines of code in a function",
 			recommended: false,
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$13,
-		schema: schema$2,
+		messages: messages$16,
+		schema: schema$4,
 		type: "suggestion"
 	}
 });
@@ -2459,9 +2459,9 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$12 = "naming-convention";
+const RULE_NAME$15 = "naming-convention";
 const FOREIGN_CONTRACT_HINT = " If this is data conforming to an external shape, declare it with `satisfies` instead.";
-const messages$12 = {
+const messages$15 = {
 	doesNotMatchFormat: "{{type}} name `{{name}}` must match one of the following formats: {{formats}}",
 	doesNotMatchFormatForeignContract: `{{type}} name \`{{name}}\` must match one of the following formats: {{formats}}${FOREIGN_CONTRACT_HINT}`,
 	doesNotMatchFormatTrimmed: "{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}",
@@ -2770,7 +2770,7 @@ function create$4(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$12,
+	name: RULE_NAME$15,
 	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
@@ -2781,7 +2781,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$12,
+		messages: messages$15,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -3021,10 +3021,232 @@ function requiresQuoting(node, target) {
 	return !isValidIdentifierText(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target ?? ScriptTarget.Latest);
 }
 //#endregion
+//#region src/rules/no-conditional-in-test/rule.ts
+const RULE_NAME$14 = "no-conditional-in-test";
+const MESSAGE_ID$9 = "conditionalInTest";
+const DEFAULTS$1 = {
+	additionalTestBlockFunctions: [],
+	allowOptionalChaining: true
+};
+/** Callee identifiers that name a vitest test block (`describe` is excluded). */
+const TEST_BLOCK_NAMES$1 = /* @__PURE__ */ new Set(["it", "test"]);
+const messages$14 = { [MESSAGE_ID$9]: "Avoid having conditionals in tests." };
+const schema$3 = [{
+	additionalProperties: false,
+	properties: {
+		additionalTestBlockFunctions: {
+			description: "Callee names, besides a resolved vitest it/test, whose call is a test block (matched by exact dotted name).",
+			items: { type: "string" },
+			type: "array"
+		},
+		allowOptionalChaining: {
+			description: "Allow optional chaining (?.) in tests. When false, it is reported and auto-fixed to a non-null assertion (a?.b -> a!.b).",
+			type: "boolean"
+		}
+	},
+	type: "object"
+}];
+/**
+* Builds the dotted name of a callee chain, unwrapping intervening calls
+* (`each.test` -> `each.test`, `request(app).get` -> `request.get`). A computed
+* member access yields `null`, since its property is not a static name. Ported
+* from eslint-plugin-jest's `getNodeName`.
+*
+* @param node - The callee node.
+* @returns The dotted name, or `null` when it cannot be built statically.
+*/
+function getNodeName$1(node) {
+	if (node.type === AST_NODE_TYPES.Identifier) return node.name;
+	if (node.type === AST_NODE_TYPES.CallExpression) return getNodeName$1(node.callee);
+	if (node.type === AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
+		const objectName = getNodeName$1(node.object);
+		return objectName === null ? null : `${objectName}.${node.property.name}`;
+	}
+	return null;
+}
+/**
+* Walks a callee chain down to the identifier it is rooted at, stepping through
+* member accesses (`it.each` -> `it`) and intervening calls
+* (`it.each(cases)()` -> `it`).
+*
+* @param node - The callee node.
+* @returns The root identifier, or `null` when the chain is not rooted at one.
+*/
+function getRootIdentifier$1(node) {
+	let current = node;
+	for (;;) {
+		if (current.type === AST_NODE_TYPES.Identifier) return current;
+		if (current.type === AST_NODE_TYPES.CallExpression) {
+			current = current.callee;
+			continue;
+		}
+		if (current.type === AST_NODE_TYPES.MemberExpression) {
+			current = current.object;
+			continue;
+		}
+		return null;
+	}
+}
+/**
+* Resolves the vitest name an identifier refers to. An unresolved reference is a
+* global (vitest's `globals: true` / `@vitest/globals`); a named import from
+* `"vitest"` resolves to its imported name (so aliases work); anything bound to
+* a local variable, function, or parameter resolves to `null` and is ignored.
+* Ported from eslint-plugin-flawless's `prefer-ending-with-an-expect`.
+*
+* @param sourceCode - Provides the scope used to look up the binding.
+* @param identifier - The identifier to resolve.
+* @returns The vitest name (`it`/`test`/...), or `null` when the identifier is a
+*   local binding rather than a vitest global or import.
+*/
+function resolveVitestName$1(sourceCode, identifier) {
+	const variable = findVariable(sourceCode.getScope(identifier), identifier);
+	if (variable === null) return identifier.name;
+	const definition = variable.defs.at(0);
+	if (definition === void 0) return identifier.name;
+	if (definition.type !== DefinitionType.ImportBinding) return null;
+	const importDefinition = definition;
+	const declaration = importDefinition.parent;
+	if (declaration.type !== AST_NODE_TYPES.ImportDeclaration || declaration.source.value !== "vitest") return null;
+	const { node } = importDefinition;
+	if (node.type === AST_NODE_TYPES.ImportSpecifier && node.imported.type === AST_NODE_TYPES.Identifier) return node.imported.name;
+	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.
+*
+* @param chain - The chain expression to convert.
+* @param sourceCode - Provides token lookups.
+* @returns The per-token replacements, outermost link first.
+*/
+function collectOptionalTokenFixes(chain, sourceCode) {
+	const fixes = [];
+	let node = chain.expression;
+	for (;;) {
+		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 ? "!" : "!.",
+					token
+				});
+			}
+			node = node.object;
+			continue;
+		}
+		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: "!",
+					token
+				});
+			}
+			node = node.callee;
+			continue;
+		}
+		return fixes;
+	}
+}
+/**
+* Disallows conditional logic inside vitest test bodies (`it`/`test`), which
+* makes a test's behavior depend on runtime state. Ported from
+* eslint-plugin-jest's `no-conditional-in-test` with vitest-aware resolution and
+* an auto-fix that rewrites disallowed optional chaining to a non-null assertion.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$10(context) {
+	let config;
+	let sourceCode;
+	let inTestCase = false;
+	/**
+	* Determines whether a call opens 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.
+	*/
+	function isTestBlock(node) {
+		const root = getRootIdentifier$1(node.callee);
+		if (root !== null && TEST_BLOCK_NAMES$1.has(resolveVitestName$1(sourceCode, root) ?? "")) return true;
+		const name = getNodeName$1(node.callee);
+		return name !== null && config.additionalTestBlockFunctions.includes(name);
+	}
+	/**
+	* 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({
+			messageId: MESSAGE_ID$9,
+			node
+		});
+	}
+	return {
+		"before": function() {
+			const options = context.options[0];
+			config = {
+				additionalTestBlockFunctions: options?.additionalTestBlockFunctions ?? DEFAULTS$1.additionalTestBlockFunctions,
+				allowOptionalChaining: options?.allowOptionalChaining ?? DEFAULTS$1.allowOptionalChaining
+			};
+			({sourceCode} = context);
+			inTestCase = false;
+		},
+		"CallExpression": function(node) {
+			if (isTestBlock(node)) inTestCase = true;
+		},
+		"CallExpression:exit": function(node) {
+			if (isTestBlock(node)) inTestCase = false;
+		},
+		"ChainExpression": function(node) {
+			if (!inTestCase || config.allowOptionalChaining) return;
+			context.report({
+				fix: (fixer) => {
+					return collectOptionalTokenFixes(node, sourceCode).map((optionalFix) => {
+						return fixer.replaceText(optionalFix.token, optionalFix.text);
+					});
+				},
+				messageId: MESSAGE_ID$9,
+				node
+			});
+		},
+		"ConditionalExpression": maybeReportConditional,
+		"IfStatement": maybeReportConditional,
+		"LogicalExpression": maybeReportConditional,
+		"SwitchStatement": maybeReportConditional
+	};
+}
+const noConditionalInTest = createFlawlessRule({
+	name: RULE_NAME$14,
+	createOnce: createOnce$10,
+	defaultOptions: [DEFAULTS$1],
+	meta: {
+		defaultOptions: [DEFAULTS$1],
+		docs: {
+			description: "Disallow conditional logic in tests",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$14,
+		schema: schema$3,
+		type: "problem"
+	}
+});
+//#endregion
 //#region src/rules/no-export-default-arrow/rule.ts
-const RULE_NAME$11 = "no-export-default-arrow";
-const MESSAGE_ID$6 = "disallowExportDefaultArrow";
-const messages$11 = { [MESSAGE_ID$6]: "Assign the arrow function to a named constant instead of exporting it anonymously." };
+const RULE_NAME$13 = "no-export-default-arrow";
+const MESSAGE_ID$8 = "disallowExportDefaultArrow";
+const messages$13 = { [MESSAGE_ID$8]: "Assign the arrow function to a named constant instead of exporting it anonymously." };
 /**
 * Converts a filename stem to camelCase, treating `-`, `_`, and whitespace as
 * word separators (`use-mouse` -> `useMouse`).
@@ -3102,7 +3324,7 @@ function createFixFunction({ arrowFunction, context, exportDeclaration, sourceCo
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$7(context) {
+function createOnce$9(context) {
 	return { ArrowFunctionExpression(node) {
 		const { parent } = node;
 		if (parent.type !== AST_NODE_TYPES.ExportDefaultDeclaration) return;
@@ -3113,14 +3335,14 @@ function createOnce$7(context) {
 				exportDeclaration: parent,
 				sourceCode: context.sourceCode
 			}),
-			messageId: MESSAGE_ID$6,
+			messageId: MESSAGE_ID$8,
 			node
 		});
 	} };
 }
 const noExportDefaultArrow = createFlawlessRule({
-	name: RULE_NAME$11,
-	createOnce: createOnce$7,
+	name: RULE_NAME$13,
+	createOnce: createOnce$9,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -3130,7 +3352,7 @@ const noExportDefaultArrow = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$11,
+		messages: messages$13,
 		schema: [],
 		type: "suggestion"
 	}
@@ -3295,8 +3517,8 @@ function flatten(file, context) {
 }
 //#endregion
 //#region src/rules/no-redundant-tsconfig-options/rule.ts
-const RULE_NAME$10 = "no-redundant-tsconfig-options";
-const MESSAGE_ID$5 = "redundant";
+const RULE_NAME$12 = "no-redundant-tsconfig-options";
+const MESSAGE_ID$7 = "redundant";
 /**
 * Compiler options TypeScript resolves case-insensitively; a child that re-sets
 * one differing only in case is still redundant.
@@ -3331,7 +3553,7 @@ const PATH_KEYS = /* @__PURE__ */ new Set([
 	"tsBuildInfoFile",
 	"typeRoots"
 ]);
-const messages$10 = { [MESSAGE_ID$5]: "'{{option}}' is redundant: it is already set to this value by {{source}}. Remove it." };
+const messages$12 = { [MESSAGE_ID$7]: "'{{option}}' is redundant: it is already set to this value by {{source}}. Remove it." };
 /**
 * Structural equality between two static JSON values. Strings compare
 * case-insensitively when `caseInsensitive` is set (used for enum-valued
@@ -3445,7 +3667,7 @@ function create$3(context) {
 			},
 			fix: buildFix(property),
 			loc: property.key.loc,
-			messageId: MESSAGE_ID$5
+			messageId: MESSAGE_ID$7
 		});
 	}
 	function buildFix(property) {
@@ -3503,7 +3725,7 @@ function create$3(context) {
 	} };
 }
 const noRedundantTsconfigOptions = createEslintRule({
-	name: RULE_NAME$10,
+	name: RULE_NAME$12,
 	create: create$3,
 	defaultOptions: [],
 	meta: {
@@ -3514,7 +3736,7 @@ const noRedundantTsconfigOptions = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		messages: messages$12,
 		schema: [],
 		type: "suggestion"
 	}
@@ -3757,15 +3979,15 @@ function resolveFactory(sourceCode, node) {
 }
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$9 = "no-unnecessary-use-callback";
+const RULE_NAME$11 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$9 = {
+const messages$11 = {
 	[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 = createFlawlessRule({
-	name: RULE_NAME$9,
+	name: RULE_NAME$11,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -3781,22 +4003,22 @@ const noUnnecessaryUseCallback = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$11,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$8 = "no-unnecessary-use-memo";
+const RULE_NAME$10 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$8 = {
+const messages$10 = {
 	[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 = createFlawlessRule({
-	name: RULE_NAME$8,
+	name: RULE_NAME$10,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -3812,36 +4034,64 @@ const noUnnecessaryUseMemo = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$8,
+		messages: messages$10,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/padding-after-expect-assertions/rule.ts
-const RULE_NAME$7 = "padding-after-expect-assertions";
-const MESSAGE_ID$4 = "missingPadding";
-const messages$7 = { [MESSAGE_ID$4]: "Expected a blank line after '{{name}}'." };
+const RULE_NAME$9 = "padding-after-expect-assertions";
+const MESSAGE_ID$6 = "missingPadding";
+const messages$9 = { [MESSAGE_ID$6]: "Expected a blank line after '{{name}}'." };
+/**
+* Resolves the name an identifier refers to, mirroring how eslint-plugin-jest
+* resolves test functions. An unresolved reference is a global (vitest's
+* `globals: true` / jest's injected globals); a named import from `"vitest"` or
+* `"@jest/globals"` resolves to its imported name (so aliases work); anything
+* bound to a local variable, function, or parameter resolves to `null` and is
+* ignored.
+*
+* @param sourceCode - Provides the scope used to look up the binding.
+* @param identifier - The identifier to resolve.
+* @returns The resolved name (`expect`/...), or `null` when the identifier is a
+*   local binding rather than a test global or a vitest/jest import.
+*/
+function resolveTestGlobalName$1(sourceCode, identifier) {
+	const variable = findVariable(sourceCode.getScope(identifier), identifier);
+	if (variable === null) return identifier.name;
+	const definition = variable.defs.at(0);
+	if (definition === void 0) return identifier.name;
+	if (definition.type !== DefinitionType.ImportBinding) return null;
+	const importDefinition = definition;
+	const declaration = importDefinition.parent;
+	const source = declaration.type === AST_NODE_TYPES.ImportDeclaration && declaration.source.value;
+	if (source !== "vitest" && source !== "@jest/globals") return null;
+	const { node } = importDefinition;
+	if (node.type === AST_NODE_TYPES.ImportSpecifier && node.imported.type === AST_NODE_TYPES.Identifier) return node.imported.name;
+	return null;
+}
 /**
 * Matches a statement that declares the expected assertion count at the top of
 * a test: `expect.assertions(n)` or `expect.hasAssertions()`.
 *
-* Detection is purely syntactic (a non-computed `expect.assertions` /
-* `expect.hasAssertions` call) with no scope analysis, mirroring the deliberate
-* looseness of `@vitest/eslint-plugin`'s own padding rules. A shadowed local
-* `expect` is vanishingly rare, and the only consequence is a harmless blank
-* line.
+* The `expect` object is resolved so a locally shadowed `expect` is ignored,
+* while a global or a `"vitest"` / `"@jest/globals"` import is recognized (the
+* property access is otherwise syntactic — a non-computed `assertions` /
+* `hasAssertions`).
 *
+* @param sourceCode - Provides the scope used to resolve `expect`.
 * @param node - The expression statement to inspect.
 * @returns The matched member name (`expect.assertions` / `expect.hasAssertions`)
 *   for the message, or `undefined` when the statement is not an assertion count.
 */
-function getAssertionName({ expression }) {
+function getAssertionName(sourceCode, { expression }) {
 	if (expression.type !== AST_NODE_TYPES.CallExpression) return;
 	const { callee } = expression;
-	if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.object.name !== "expect" || callee.property.type !== AST_NODE_TYPES.Identifier) return;
+	if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.property.type !== AST_NODE_TYPES.Identifier) return;
 	const { name } = callee.property;
 	if (name !== "assertions" && name !== "hasAssertions") return;
+	if (resolveTestGlobalName$1(sourceCode, callee.object) !== "expect") return;
 	return `expect.${name}`;
 }
 /**
@@ -3896,15 +4146,15 @@ function findPaddingAnchor(sourceCode, node, nextNode) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$4(context) {
+function createOnce$6(context) {
 	return { ExpressionStatement(node) {
-		const name = getAssertionName(node);
+		const { sourceCode } = context;
+		const name = getAssertionName(sourceCode, node);
 		if (name === void 0) return;
 		const list = getContainingList(node);
 		if (list === void 0) return;
 		const nextNode = list[list.indexOf(node) + 1];
 		if (nextNode === void 0) return;
-		const { sourceCode } = context;
 		const anchor = findPaddingAnchor(sourceCode, node, nextNode);
 		if (anchor === void 0) return;
 		const { nextToken, previousToken } = anchor;
@@ -3916,13 +4166,13 @@ function createOnce$4(context) {
 				return fixer.insertTextAfter(previousToken, gap === 0 ? "\n\n" : "\n");
 			},
 			loc: node.loc,
-			messageId: MESSAGE_ID$4
+			messageId: MESSAGE_ID$6
 		});
 	} };
 }
 const paddingAfterExpectAssertions = createFlawlessRule({
-	name: RULE_NAME$7,
-	createOnce: createOnce$4,
+	name: RULE_NAME$9,
+	createOnce: createOnce$6,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -3932,16 +4182,16 @@ const paddingAfterExpectAssertions = createFlawlessRule({
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
-		messages: messages$7,
+		messages: messages$9,
 		schema: [],
 		type: "layout"
 	}
 });
 //#endregion
 //#region src/rules/prefer-destructuring-assignment/rule.ts
-const RULE_NAME$6 = "prefer-destructuring-assignment";
-const MESSAGE_ID$3 = "default";
-const messages$6 = { [MESSAGE_ID$3]: "Use destructuring assignment for component props." };
+const RULE_NAME$8 = "prefer-destructuring-assignment";
+const MESSAGE_ID$5 = "default";
+const messages$8 = { [MESSAGE_ID$5]: "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
@@ -4067,7 +4317,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 	const propertyNames = collectPropertyNames(memberReferences);
 	if (!(!hasNonMemberReference && propertyNames !== null && !wouldShadowExistingBinding(context.sourceCode, scope, propertyVariable, memberReferences))) {
 		for (const { member } of memberReferences) context.report({
-			messageId: MESSAGE_ID$3,
+			messageId: MESSAGE_ID$5,
 			node: member
 		});
 		return;
@@ -4084,7 +4334,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 				if (index === 0) return [fixer.replaceTextRange([propsParameter.range[0], nameEnd], pattern), replaceAccess];
 				return replaceAccess;
 			},
-			messageId: MESSAGE_ID$3,
+			messageId: MESSAGE_ID$5,
 			node: member
 		});
 	}
@@ -4103,7 +4353,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$3(context) {
+function createOnce$5(context) {
 	let collector = core.getFunctionComponentCollector(context);
 	const selectorKeys = Object.keys(collector.visitor);
 	const listener = {
@@ -4129,8 +4379,8 @@ function createOnce$3(context) {
 	return listener;
 }
 const preferDestructuringAssignment = createFlawlessRule({
-	name: RULE_NAME$6,
-	createOnce: createOnce$3,
+	name: RULE_NAME$8,
+	createOnce: createOnce$5,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -4140,12 +4390,293 @@ const preferDestructuringAssignment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$6,
+		messages: messages$8,
 		schema: [],
 		type: "problem"
 	}
 });
 //#endregion
+//#region src/rules/prefer-ending-with-an-expect/rule.ts
+const RULE_NAME$7 = "prefer-ending-with-an-expect";
+const MESSAGE_ID$4 = "mustEndWithExpect";
+const DEFAULTS = {
+	additionalTestBlockFunctions: [],
+	assertFunctionNames: ["expect"]
+};
+/** Callee identifiers that name a vitest test block (`describe` is excluded). */
+const TEST_BLOCK_NAMES = /* @__PURE__ */ new Set(["it", "test"]);
+const messages$7 = { [MESSAGE_ID$4]: "Test should end with an assertion." };
+const schema$2 = [{
+	additionalProperties: false,
+	properties: {
+		additionalTestBlockFunctions: {
+			description: "Callee names, besides a resolved vitest it/test, whose second argument is a test body (matched by exact dotted name).",
+			items: { type: "string" },
+			type: "array"
+		},
+		assertFunctionNames: {
+			description: "Function names, besides a resolved vitest expect, that count as an assertion (matched by name; * and ** are wildcards).",
+			items: { type: "string" },
+			type: "array"
+		}
+	},
+	type: "object"
+}];
+/**
+* Tests a dotted callee name against the `assertFunctionNames` patterns. A `*`
+* stands for a single dotted segment and `**` for any run of segments, so
+* `request.*.expect` and `request.**.expect` both match a chained assertion.
+* Ported from eslint-plugin-jest.
+*
+* @param nodeName - The dotted callee name (e.g. `expect.toBe`).
+* @param patterns - The configured assertion-name patterns.
+* @returns `true` when any pattern matches the name.
+*/
+function matchesAssertFunctionName(nodeName, patterns) {
+	return patterns.some((pattern) => {
+		return new RegExp(`^${pattern.split(".").map((segment) => {
+			if (segment === "**") return "[a-z\\d\\.]*";
+			return segment.replace(/\*/gu, "[a-z\\d]*");
+		}).join("\\.")}(\\.|$)`, "ui").test(nodeName);
+	});
+}
+/**
+* Builds the dotted name of a callee chain, unwrapping intervening calls
+* (`request(app).get("/").expect` -> `request.get.expect`) the way
+* eslint-plugin-jest's `getNodeChain` does. A computed member access yields
+* `null`, since its property is not a static name.
+*
+* @param node - The callee node.
+* @returns The dotted name, or `null` when it cannot be built statically.
+*/
+function getNodeName(node) {
+	if (node.type === AST_NODE_TYPES.Identifier) return node.name;
+	if (node.type === AST_NODE_TYPES.CallExpression) return getNodeName(node.callee);
+	if (node.type === AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
+		const objectName = getNodeName(node.object);
+		return objectName === null ? null : `${objectName}.${node.property.name}`;
+	}
+	return null;
+}
+/**
+* Walks a callee chain down to the identifier it is rooted at, stepping through
+* member accesses (`it.each` -> `it`) and intervening calls
+* (`it.each(cases)()` -> `it`).
+*
+* @param node - The callee node.
+* @returns The root identifier, or `null` when the chain is not rooted at one.
+*/
+function getRootIdentifier(node) {
+	let current = node;
+	for (;;) {
+		if (current.type === AST_NODE_TYPES.Identifier) return current;
+		if (current.type === AST_NODE_TYPES.CallExpression) {
+			current = current.callee;
+			continue;
+		}
+		if (current.type === AST_NODE_TYPES.MemberExpression) {
+			current = current.object;
+			continue;
+		}
+		return null;
+	}
+}
+/**
+* Resolves the vitest name an identifier refers to, mirroring how
+* eslint-plugin-jest resolves jest functions. An unresolved reference is a
+* global (vitest's `globals: true` / `@vitest/globals`); a named import from
+* `"vitest"` resolves to its imported name (so aliases work); anything bound to
+* a local variable, function, or parameter resolves to `null` and is ignored.
+*
+* @param sourceCode - Provides the scope used to look up the binding.
+* @param identifier - The identifier to resolve.
+* @returns The vitest name (`it`/`test`/`expect`/...), or `null` when the
+*   identifier is a local binding rather than a vitest global or import.
+*/
+function resolveVitestName(sourceCode, identifier) {
+	const variable = findVariable(sourceCode.getScope(identifier), identifier);
+	if (variable === null) return identifier.name;
+	const definition = variable.defs.at(0);
+	if (definition === void 0) return identifier.name;
+	if (definition.type !== DefinitionType.ImportBinding) return null;
+	const importDefinition = definition;
+	const declaration = importDefinition.parent;
+	if (declaration.type !== AST_NODE_TYPES.ImportDeclaration || declaration.source.value !== "vitest") return null;
+	const { node } = importDefinition;
+	if (node.type === AST_NODE_TYPES.ImportSpecifier && node.imported.type === AST_NODE_TYPES.Identifier) return node.imported.name;
+	return null;
+}
+/**
+* Returns the node that ends a test body: the last statement of a block body
+* (unwrapped to its expression when it is an expression statement), or the
+* expression of a concise arrow body. Ported from eslint-plugin-jest.
+*
+* @param func - The test callback.
+* @returns The ending node, or `null` for an empty block body.
+*/
+function getLastStatement(func) {
+	if (func.body.type !== AST_NODE_TYPES.BlockStatement) return func.body;
+	const lastStatement = func.body.body.at(-1);
+	if (lastStatement === void 0) return null;
+	if (lastStatement.type === AST_NODE_TYPES.ExpressionStatement) return lastStatement.expression;
+	return lastStatement;
+}
+/**
+* Flags a test whose last statement is not an assertion, a common sign of an
+* unfinished test. Ported from eslint-plugin-jest's
+* `prefer-ending-with-an-expect`, with vitest-aware resolution of `it`/`test`
+* and `expect`.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$4(context) {
+	let config;
+	let sourceCode;
+	/**
+	* Determines whether a call is a test block whose second argument is a body.
+	*
+	* @param node - The call to inspect.
+	* @returns `true` when the call opens a vitest (or configured) test.
+	*/
+	function isTestBlock(node) {
+		const root = getRootIdentifier(node.callee);
+		if (root !== null && TEST_BLOCK_NAMES.has(resolveVitestName(sourceCode, root) ?? "")) return true;
+		const name = getNodeName(node.callee);
+		return name !== null && config.additionalTestBlockFunctions.includes(name);
+	}
+	/**
+	* Determines whether a call is an assertion: a resolved vitest `expect`, or a
+	* call whose dotted name matches an `assertFunctionNames` pattern.
+	*
+	* @param node - The call ending the test body.
+	* @returns `true` when the call counts as an assertion.
+	*/
+	function isAssertion(node) {
+		const root = getRootIdentifier(node.callee);
+		if (root !== null && resolveVitestName(sourceCode, root) === "expect") return true;
+		return matchesAssertFunctionName(getNodeName(node.callee) ?? "", config.assertFunctionNames);
+	}
+	return {
+		before() {
+			const options = context.options[0];
+			config = {
+				additionalTestBlockFunctions: options?.additionalTestBlockFunctions ?? DEFAULTS.additionalTestBlockFunctions,
+				assertFunctionNames: options?.assertFunctionNames ?? DEFAULTS.assertFunctionNames
+			};
+			({sourceCode} = context);
+		},
+		CallExpression(node) {
+			if (!isTestBlock(node)) return;
+			const callback = node.arguments[1];
+			if (callback === void 0 || !ASTUtils.isFunction(callback)) return;
+			let lastStatement = getLastStatement(callback);
+			if (lastStatement?.type === AST_NODE_TYPES.AwaitExpression) lastStatement = lastStatement.argument;
+			if (lastStatement?.type === AST_NODE_TYPES.CallExpression && isAssertion(lastStatement)) return;
+			context.report({
+				messageId: MESSAGE_ID$4,
+				node: node.callee
+			});
+		}
+	};
+}
+const preferEndingWithAnExpect = createFlawlessRule({
+	name: RULE_NAME$7,
+	createOnce: createOnce$4,
+	defaultOptions: [DEFAULTS],
+	meta: {
+		defaultOptions: [DEFAULTS],
+		docs: {
+			description: "Prefer having the last statement in a test be an assertion",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$7,
+		schema: schema$2,
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/prefer-expect-assertions-count/rule.ts
+const RULE_NAME$6 = "prefer-expect-assertions-count";
+const MESSAGE_ID$3 = "preferCount";
+const messages$6 = { [MESSAGE_ID$3]: "Use `expect.assertions(<count>)` with an explicit count instead of `expect.hasAssertions()`." };
+/**
+* Resolves the name an identifier refers to, mirroring how eslint-plugin-jest
+* resolves test functions. An unresolved reference is a global (vitest's
+* `globals: true` / jest's injected globals); a named import from `"vitest"` or
+* `"@jest/globals"` resolves to its imported name (so aliases work); anything
+* bound to a local variable, function, or parameter resolves to `null` and is
+* ignored.
+*
+* @param sourceCode - Provides the scope used to look up the binding.
+* @param identifier - The identifier to resolve.
+* @returns The resolved name (`expect`/...), or `null` when the identifier is a
+*   local binding rather than a test global or a vitest/jest import.
+*/
+function resolveTestGlobalName(sourceCode, identifier) {
+	const variable = findVariable(sourceCode.getScope(identifier), identifier);
+	if (variable === null) return identifier.name;
+	const definition = variable.defs.at(0);
+	if (definition === void 0) return identifier.name;
+	if (definition.type !== DefinitionType.ImportBinding) return null;
+	const importDefinition = definition;
+	const declaration = importDefinition.parent;
+	const source = declaration.type === AST_NODE_TYPES.ImportDeclaration && declaration.source.value;
+	if (source !== "vitest" && source !== "@jest/globals") return null;
+	const { node } = importDefinition;
+	if (node.type === AST_NODE_TYPES.ImportSpecifier && node.imported.type === AST_NODE_TYPES.Identifier) return node.imported.name;
+	return null;
+}
+/**
+* Matches a `expect.hasAssertions()` call. The callee must be a non-computed
+* `<expect>.hasAssertions` member access whose object resolves to a vitest/jest
+* `expect` (a global or an import from `"vitest"` / `"@jest/globals"`); a locally
+* shadowed `expect` is ignored. Covers either framework, since both name the
+* global `expect`.
+*
+* @param sourceCode - Provides the scope used to resolve `expect`.
+* @param callee - The call's callee.
+* @returns `true` when the callee is a resolved `expect.hasAssertions`.
+*/
+function isExpectHasAssertions(sourceCode, callee) {
+	return callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES.Identifier && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "hasAssertions" && resolveTestGlobalName(sourceCode, callee.object) === "expect";
+}
+/**
+* Flags `expect.hasAssertions()`, which only asserts that at least one assertion
+* ran, in favour of `expect.assertions(<count>)`, which pins the exact count and
+* so catches an expectation skipped by an early return or a branch never taken.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$3(context) {
+	return { CallExpression(node) {
+		if (!isExpectHasAssertions(context.sourceCode, node.callee)) return;
+		context.report({
+			messageId: MESSAGE_ID$3,
+			node
+		});
+	} };
+}
+const preferExpectAssertionsCount = createFlawlessRule({
+	name: RULE_NAME$6,
+	createOnce: createOnce$3,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Prefer `expect.assertions(<count>)` over `expect.hasAssertions()`",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$6,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/rules/prefer-parameter-destructuring/rule.ts
 const RULE_NAME$5 = "prefer-parameter-destructuring";
 const MESSAGE_ID$2 = "default";
@@ -5823,12 +6354,15 @@ const plugin = {
 		"jsx-shorthand-fragment": jsxShorthandFragment,
 		"max-lines-per-function": maxLinesPerFunction,
 		"naming-convention": namingConvention,
+		"no-conditional-in-test": noConditionalInTest,
 		"no-export-default-arrow": noExportDefaultArrow,
 		"no-redundant-tsconfig-options": noRedundantTsconfigOptions,
 		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
 		"padding-after-expect-assertions": paddingAfterExpectAssertions,
 		"prefer-destructuring-assignment": preferDestructuringAssignment,
+		"prefer-ending-with-an-expect": preferEndingWithAnExpect,
+		"prefer-expect-assertions-count": preferExpectAssertionsCount,
 		"prefer-parameter-destructuring": preferParameterDestructuring,
 		"prefer-read-only-props": preferReadOnlyProps,
 		"purity": purity,

package/package.json

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