eslint-plugin-flawless 1.2.0 → 1.3.0

package/README.md

@@ -211,6 +211,7 @@ Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 | [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-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$7 = [{
   /** 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$6 = [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$5 = [MaxLinesPerFunctionOptions?];
 //#endregion
 //#region src/rules/naming-convention/utils/enums.d.ts
 declare const Selector: {
@@ -246,7 +246,7 @@ 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$4 = Array<NamingSelector>;
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.d.ts
 declare const MESSAGE_ID_DEFAULT$1 = "default";
@@ -258,6 +258,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,11 +323,11 @@ declare const plugin: {
     version: string;
   };
   rules: {
-    "arrow-return-style": FlawlessRuleModule<Options$6, MessageIds$5, Readonly<TSESLint.SourceCode>>;
+    "arrow-return-style": FlawlessRuleModule<Options$7, 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$6, MessageIds$4, Readonly<TSESLint.SourceCode>>;
+    "max-lines-per-function": FlawlessRuleModule<Options$5, "exceed", Readonly<TSESLint.SourceCode>>;
+    "naming-convention": TSESLint.RuleModule<MessageIds$3, Options$4, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
     "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<TSESLint.SourceCode>>;
@@ -320,6 +338,7 @@ 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-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<TSESLint.SourceCode>>;
     "prefer-read-only-props": TSESLint.RuleModule<"preferReadOnlyProps", [{
       fixStyle?: "modifier" | "wrap";
@@ -350,11 +369,11 @@ declare const _default: {
             version: string;
           };
           rules: {
-            "arrow-return-style": FlawlessRuleModule<Options$6, MessageIds$5, Readonly<import("${configDir}").SourceCode>>;
+            "arrow-return-style": FlawlessRuleModule<Options$7, 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$6, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
+            "max-lines-per-function": FlawlessRuleModule<Options$5, "exceed", Readonly<import("${configDir}").SourceCode>>;
+            "naming-convention": import("${configDir}").RuleModule<MessageIds$3, Options$4, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
             "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
@@ -365,6 +384,7 @@ 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-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<import("${configDir}").SourceCode>>;
             "prefer-read-only-props": import("${configDir}").RuleModule<"preferReadOnlyProps", [{
               fixStyle?: "modifier" | "wrap";
@@ -392,11 +412,11 @@ declare const _default: {
     version: string;
   };
   rules: {
-    "arrow-return-style": FlawlessRuleModule<Options$6, MessageIds$5, Readonly<import("${configDir}").SourceCode>>;
+    "arrow-return-style": FlawlessRuleModule<Options$7, 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$6, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
+    "max-lines-per-function": FlawlessRuleModule<Options$5, "exceed", Readonly<import("${configDir}").SourceCode>>;
+    "naming-convention": import("${configDir}").RuleModule<MessageIds$3, Options$4, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
     "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
@@ -407,6 +427,7 @@ 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-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-K2GOCG3Z.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-CDVxMgSG.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-K2GOCG3Z.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-CDVxMgSG.mjs";
 import { definePlugin } from "@oxlint/plugins";
 //#region src/oxlint.ts
 /**

package/dist/{plugin-K2GOCG3Z.mjs → plugin-CDVxMgSG.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.0";
+var version = "1.3.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$17 = "arrow-return-style";
 const IMPLICIT = "useImplicitReturn";
 const EXPLICIT = "useExplicitReturn";
 const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
-const DEFAULTS$1 = {
+const DEFAULTS$2 = {
 	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$17,
 	createOnce(context) {
-		let config = DEFAULTS$1;
+		let config = DEFAULTS$2;
 		let sourceCode;
 		let lines;
 		let pendingConsults;
@@ -533,7 +533,7 @@ const arrowReturnStyle = createFlawlessRule({
 			},
 			"before": function() {
 				config = {
-					...DEFAULTS$1,
+					...DEFAULTS$2,
 					...context.options[0]
 				};
 				({sourceCode} = context);
@@ -545,7 +545,7 @@ const arrowReturnStyle = createFlawlessRule({
 			}
 		};
 	},
-	defaultOptions: [DEFAULTS$1],
+	defaultOptions: [DEFAULTS$2],
 	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$16 = "jsx-shorthand-boolean";
+const MESSAGE_ID$8 = "setAttributeValue";
+const messages$16 = { [MESSAGE_ID$8]: "Set an explicit value for boolean attribute '{{name}}'." };
+function createOnce$11(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$8,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createFlawlessRule({
-	name: RULE_NAME$15,
-	createOnce: createOnce$10,
+	name: RULE_NAME$16,
+	createOnce: createOnce$11,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -624,23 +624,23 @@ const jsxShorthandBoolean = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$15,
+		messages: messages$16,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$14 = "jsx-shorthand-fragment";
+const RULE_NAME$15 = "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$15 = {
 	[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$4 = [{
 	additionalProperties: false,
 	properties: {
 		fragmentName: {
@@ -672,7 +672,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$9(context) {
+function createOnce$10(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$15,
+	createOnce: createOnce$10,
 	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$15,
+		schema: schema$4,
 		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$14 = "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$1 = {
 	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$14 = { [MESSAGE_ID_EXCEED]: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." };
+const schema$3 = [{
 	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$9(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$1.countFrom,
+				IIFEs: options?.IIFEs ?? DEFAULTS$1.IIFEs,
+				max: options?.max ?? DEFAULTS$1.max,
+				skipBlankLines: options?.skipBlankLines ?? DEFAULTS$1.skipBlankLines,
+				skipComments: options?.skipComments ?? DEFAULTS$1.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$14,
+	createOnce: createOnce$9,
+	defaultOptions: [DEFAULTS$1],
 	meta: {
-		defaultOptions: [DEFAULTS],
+		defaultOptions: [DEFAULTS$1],
 		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$14,
+		schema: schema$3,
 		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$13 = "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$13 = {
 	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$13,
 	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
@@ -2781,7 +2781,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$12,
+		messages: messages$13,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -3022,9 +3022,9 @@ function requiresQuoting(node, target) {
 }
 //#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$12 = "no-export-default-arrow";
+const MESSAGE_ID$7 = "disallowExportDefaultArrow";
+const messages$12 = { [MESSAGE_ID$7]: "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 +3102,7 @@ function createFixFunction({ arrowFunction, context, exportDeclaration, sourceCo
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$7(context) {
+function createOnce$8(context) {
 	return { ArrowFunctionExpression(node) {
 		const { parent } = node;
 		if (parent.type !== AST_NODE_TYPES.ExportDefaultDeclaration) return;
@@ -3113,14 +3113,14 @@ function createOnce$7(context) {
 				exportDeclaration: parent,
 				sourceCode: context.sourceCode
 			}),
-			messageId: MESSAGE_ID$6,
+			messageId: MESSAGE_ID$7,
 			node
 		});
 	} };
 }
 const noExportDefaultArrow = createFlawlessRule({
-	name: RULE_NAME$11,
-	createOnce: createOnce$7,
+	name: RULE_NAME$12,
+	createOnce: createOnce$8,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -3130,7 +3130,7 @@ const noExportDefaultArrow = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$11,
+		messages: messages$12,
 		schema: [],
 		type: "suggestion"
 	}
@@ -3295,8 +3295,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$11 = "no-redundant-tsconfig-options";
+const MESSAGE_ID$6 = "redundant";
 /**
 * Compiler options TypeScript resolves case-insensitively; a child that re-sets
 * one differing only in case is still redundant.
@@ -3331,7 +3331,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$11 = { [MESSAGE_ID$6]: "'{{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 +3445,7 @@ function create$3(context) {
 			},
 			fix: buildFix(property),
 			loc: property.key.loc,
-			messageId: MESSAGE_ID$5
+			messageId: MESSAGE_ID$6
 		});
 	}
 	function buildFix(property) {
@@ -3503,7 +3503,7 @@ function create$3(context) {
 	} };
 }
 const noRedundantTsconfigOptions = createEslintRule({
-	name: RULE_NAME$10,
+	name: RULE_NAME$11,
 	create: create$3,
 	defaultOptions: [],
 	meta: {
@@ -3514,7 +3514,7 @@ const noRedundantTsconfigOptions = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		messages: messages$11,
 		schema: [],
 		type: "suggestion"
 	}
@@ -3757,15 +3757,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$10 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$9 = {
+const messages$10 = {
 	[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$10,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -3781,22 +3781,22 @@ const noUnnecessaryUseCallback = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$10,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$8 = "no-unnecessary-use-memo";
+const RULE_NAME$9 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$8 = {
+const messages$9 = {
 	[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$9,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -3812,16 +3812,16 @@ const noUnnecessaryUseMemo = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$8,
+		messages: messages$9,
 		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$8 = "padding-after-expect-assertions";
+const MESSAGE_ID$5 = "missingPadding";
+const messages$8 = { [MESSAGE_ID$5]: "Expected a blank line after '{{name}}'." };
 /**
 * Matches a statement that declares the expected assertion count at the top of
 * a test: `expect.assertions(n)` or `expect.hasAssertions()`.
@@ -3896,7 +3896,7 @@ function findPaddingAnchor(sourceCode, node, nextNode) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$4(context) {
+function createOnce$5(context) {
 	return { ExpressionStatement(node) {
 		const name = getAssertionName(node);
 		if (name === void 0) return;
@@ -3916,13 +3916,13 @@ function createOnce$4(context) {
 				return fixer.insertTextAfter(previousToken, gap === 0 ? "\n\n" : "\n");
 			},
 			loc: node.loc,
-			messageId: MESSAGE_ID$4
+			messageId: MESSAGE_ID$5
 		});
 	} };
 }
 const paddingAfterExpectAssertions = createFlawlessRule({
-	name: RULE_NAME$7,
-	createOnce: createOnce$4,
+	name: RULE_NAME$8,
+	createOnce: createOnce$5,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -3932,16 +3932,16 @@ const paddingAfterExpectAssertions = createFlawlessRule({
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
-		messages: messages$7,
+		messages: messages$8,
 		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$7 = "prefer-destructuring-assignment";
+const MESSAGE_ID$4 = "default";
+const messages$7 = { [MESSAGE_ID$4]: "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 +4067,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$4,
 			node: member
 		});
 		return;
@@ -4084,7 +4084,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$4,
 			node: member
 		});
 	}
@@ -4103,7 +4103,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$3(context) {
+function createOnce$4(context) {
 	let collector = core.getFunctionComponentCollector(context);
 	const selectorKeys = Object.keys(collector.visitor);
 	const listener = {
@@ -4129,8 +4129,8 @@ function createOnce$3(context) {
 	return listener;
 }
 const preferDestructuringAssignment = createFlawlessRule({
-	name: RULE_NAME$6,
-	createOnce: createOnce$3,
+	name: RULE_NAME$7,
+	createOnce: createOnce$4,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -4140,12 +4140,214 @@ const preferDestructuringAssignment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$6,
+		messages: messages$7,
 		schema: [],
 		type: "problem"
 	}
 });
 //#endregion
+//#region src/rules/prefer-ending-with-an-expect/rule.ts
+const RULE_NAME$6 = "prefer-ending-with-an-expect";
+const MESSAGE_ID$3 = "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$6 = { [MESSAGE_ID$3]: "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$3(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$3,
+				node: node.callee
+			});
+		}
+	};
+}
+const preferEndingWithAnExpect = createFlawlessRule({
+	name: RULE_NAME$6,
+	createOnce: createOnce$3,
+	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$6,
+		schema: schema$2,
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/rules/prefer-parameter-destructuring/rule.ts
 const RULE_NAME$5 = "prefer-parameter-destructuring";
 const MESSAGE_ID$2 = "default";
@@ -5201,16 +5403,21 @@ const purity = createFlawlessRule({
 });
 //#endregion
 //#region src/rules/react-namespace/imports.ts
+/** Matches a bare npm scope (`@rbxts`) with no package segment. */
+const SCOPE_PATTERN = /^@[^/]+$/;
 /**
-* Whether a module specifier refers to the configured React import source. Matches
-* the exact source or any subpath (`@rbxts/react` and `@rbxts/react/jsx-runtime`).
+* Whether a module specifier refers to the configured React package. Matches the
+* exact package or any subpath (`@rbxts/react` and `@rbxts/react/jsx-runtime`),
+* but never a sibling package (`@rbxts/react-roblox`), because the `/` boundary
+* excludes it.
 *
 * @param value - The `source.value` of an import declaration.
 * @param importSource - The configured React import source.
 * @returns True when the specifier resolves to the React package.
 */
 function matchesSource(value, importSource) {
-	return value === importSource || value.startsWith(`${importSource}/`);
+	const reactPackage = resolveReactPackage(importSource);
+	return value === reactPackage || value.startsWith(`${reactPackage}/`);
 }
 /**
 * Collects the import declarations in a program that come from the React source.
@@ -5339,6 +5546,19 @@ function findNamedSpecifier(declarations, name) {
 	};
 	return null;
 }
+/**
+* Resolves the React package the `react-x` `importSource` setting points at. The
+* setting may be a package (`react`, `@rbxts/react`) or a bare npm scope
+* (`@rbxts`, as Roblox configs set it). A scope names no package, so treating it
+* as one claims every sibling (`@rbxts/react-roblox`, `@rbxts/flux`) as React;
+* the React package under a scope is `<scope>/react`.
+*
+* @param importSource - The configured `react-x` import source.
+* @returns The React package name to match against.
+*/
+function resolveReactPackage(importSource) {
+	return SCOPE_PATTERN.test(importSource) ? `${importSource}/react` : importSource;
+}
 function isNamedSpecifier(specifier) {
 	return specifier.type === AST_NODE_TYPES.ImportSpecifier;
 }
@@ -5811,6 +6031,7 @@ const plugin = {
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
 		"padding-after-expect-assertions": paddingAfterExpectAssertions,
 		"prefer-destructuring-assignment": preferDestructuringAssignment,
+		"prefer-ending-with-an-expect": preferEndingWithAnExpect,
 		"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.0",
+  "version": "1.3.0",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",