@pobammer-ts/small-rules 1.1.0 → 2.0.0

package/dist/index.d.ts

@@ -680,13 +680,20 @@ declare const smallRules: import("oxlint-plugin-utilities").Plugin<{
     readonly type: "object";
   }]>;
   "prefer-expect-assertions": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly additionalAssertionFunctions?: readonly string[];
     readonly additionalExpectCallNames?: readonly string[];
     readonly onlyFunctionsWithAsyncKeyword?: boolean;
     readonly onlyFunctionsWithExpectInCallback?: boolean;
     readonly onlyFunctionsWithExpectInLoop?: boolean;
-  }], "assertionsRequiresNumberArgument" | "assertionsRequiresOneArgument" | "hasAssertionsTakesNoArguments" | "haveExpectAssertions" | "suggestAddingAssertions" | "suggestAddingHasAssertions" | "wrongAssertionCount", readonly [{
+  }], "assertionsRequiresNumberArgument" | "assertionsRequiresOneArgument" | "hasAssertionsTakesNoArguments" | "haveExpectAssertions" | "preferAssertionsCount" | "suggestAddingAssertions" | "suggestAddingHasAssertions" | "wrongAssertionCount", readonly [{
     readonly additionalProperties: false;
     readonly properties: {
+      readonly additionalAssertionFunctions: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
       readonly additionalExpectCallNames: {
         readonly items: {
           readonly type: "string";
@@ -705,20 +712,6 @@ declare const smallRules: import("oxlint-plugin-utilities").Plugin<{
     };
     readonly type: "object";
   }]>;
-  "prefer-expect-assertions-count": import("oxlint-plugin-utilities").CreateRule<readonly [{
-    readonly additionalAssertionFunctions?: readonly string[];
-  }], "preferAssertionsCount", readonly [{
-    readonly additionalProperties: false;
-    readonly properties: {
-      readonly additionalAssertionFunctions: {
-        readonly items: {
-          readonly type: "string";
-        };
-        readonly type: "array";
-      };
-    };
-    readonly type: "object";
-  }]>;
   "prefer-hoisted-jsx-elements": import("oxlint-plugin-utilities").CreateRule<readonly [{
     readonly additionalHoistableComponents?: readonly string[];
     readonly additionalStaticFactories?: readonly string[];

package/dist/index.js

@@ -20280,7 +20280,7 @@ function getExpectContext(currentParent, root) {
 	};
 	const ownContext = {
 		hasCallback: isFunction(currentParent),
-		hasIndeterminate: isFunction(currentParent) || isIndeterminateLoopNode(currentParent) || currentParent.type === "ConditionalExpression" || currentParent.type === "IfStatement" || currentParent.type === "SwitchCase" || currentParent.type === "TryStatement",
+		hasIndeterminate: isFunction(currentParent) || isIndeterminateLoopNode(currentParent) || currentParent.type === "ConditionalExpression" || currentParent.type === "IfStatement" || currentParent.type === "SwitchCase" || currentParent.type === "TryStatement" && currentParent.handler !== null,
 		hasLoop: isIndeterminateLoopNode(currentParent)
 	};
 	if (currentParent.parent === null) return ownContext;
@@ -20334,20 +20334,29 @@ function countExpectCalls(body, additionalAssertionFunctions = []) {
 }
 //#endregion
 //#region src/rules/prefer-expect-assertions.ts
+function parseStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
 function parseOptions$1(rawOptions) {
 	if (!isRecord$2(rawOptions)) return {
+		additionalAssertionFunctions: [],
 		additionalExpectCallNames: [],
 		onlyFunctionsWithAsyncKeyword: false,
 		onlyFunctionsWithExpectInCallback: false,
 		onlyFunctionsWithExpectInLoop: false
 	};
 	return {
-		additionalExpectCallNames: Array.isArray(rawOptions.additionalExpectCallNames) ? rawOptions.additionalExpectCallNames.filter((name) => typeof name === "string") : [],
+		additionalAssertionFunctions: parseStringArray(rawOptions.additionalAssertionFunctions),
+		additionalExpectCallNames: parseStringArray(rawOptions.additionalExpectCallNames),
 		onlyFunctionsWithAsyncKeyword: rawOptions.onlyFunctionsWithAsyncKeyword === true,
 		onlyFunctionsWithExpectInCallback: rawOptions.onlyFunctionsWithExpectInCallback === true,
 		onlyFunctionsWithExpectInLoop: rawOptions.onlyFunctionsWithExpectInLoop === true
 	};
 }
+function getAdditionalExpectCallNames(options) {
+	return [...new Set([...options.additionalExpectCallNames, ...options.additionalAssertionFunctions])];
+}
 function hasEnabledFilter(options) {
 	return options.onlyFunctionsWithAsyncKeyword || options.onlyFunctionsWithExpectInCallback || options.onlyFunctionsWithExpectInLoop;
 }
@@ -20448,11 +20457,22 @@ const preferExpectAssertions = defineRule({
 			if (callback === void 0) return;
 			const body = getCallbackBody(callback);
 			if (body === void 0) return;
-			const { deterministic, indeterminate, hasIndeterminate, hasExpectInCallback, hasExpectInLoop } = countExpectCalls(body, options.additionalExpectCallNames);
+			const { deterministic, indeterminate, hasIndeterminate, hasExpectInCallback, hasExpectInLoop } = countExpectCalls(body, getAdditionalExpectCallNames(options));
 			if (!shouldCheckTest(callback, options, deterministic, indeterminate, hasExpectInCallback, hasExpectInLoop)) return;
 			const assertionCall = getFirstStatementCall(callback);
 			if (assertionCall !== void 0 && (isExpectAssertionsCall(assertionCall) || isExpectHasAssertionsCall(assertionCall))) {
 				validateAssertionCall(context, assertionCall, deterministic, hasIndeterminate);
+				if (isExpectHasAssertionsCall(assertionCall) && assertionCall.arguments.length === 0 && deterministic > 0 && !hasIndeterminate) {
+					const [firstStatement] = getCallbackBlockBody(callback)?.body ?? [];
+					if (firstStatement !== void 0) context.report({
+						data: { count: String(deterministic) },
+						fix(fixer) {
+							return fixer.replaceText(firstStatement, `expect.assertions(${deterministic});`);
+						},
+						messageId: "preferAssertionsCount",
+						node: assertionCall
+					});
+				}
 				return;
 			}
 			reportMissingAssertions(context, callback, node, deterministic, hasIndeterminate);
@@ -20460,15 +20480,17 @@ const preferExpectAssertions = defineRule({
 	},
 	meta: {
 		docs: {
-			description: "Enforce expect assertion guards in Jest tests.",
+			description: "Enforce expect assertion guards in Jest tests and prefer expect.assertions(n) over expect.hasAssertions() when the count is known.",
 			recommended: true
 		},
+		fixable: "code",
 		hasSuggestions: true,
 		messages: {
 			assertionsRequiresNumberArgument: "This argument should be a number",
 			assertionsRequiresOneArgument: "`expect.assertions` expects a single argument of type number",
 			hasAssertionsTakesNoArguments: "`expect.hasAssertions` expects no arguments",
 			haveExpectAssertions: "Every test should have either `expect.assertions(<number of assertions>)` or `expect.hasAssertions()` as its first expression",
+			preferAssertionsCount: "Use `expect.assertions({{count}})` instead of `expect.hasAssertions()` when the count is known",
 			suggestAddingAssertions: "Add `expect.assertions({{count}})`",
 			suggestAddingHasAssertions: "Add `expect.hasAssertions()`",
 			wrongAssertionCount: "Expected {{expected}} assertions, but test has {{actual}} expect calls"
@@ -20476,6 +20498,10 @@ const preferExpectAssertions = defineRule({
 		schema: [{
 			additionalProperties: false,
 			properties: {
+				additionalAssertionFunctions: {
+					items: { type: "string" },
+					type: "array"
+				},
 				additionalExpectCallNames: {
 					items: { type: "string" },
 					type: "array"
@@ -20490,46 +20516,6 @@ const preferExpectAssertions = defineRule({
 	}
 });
 //#endregion
-//#region src/rules/prefer-expect-assertions-count.ts
-const preferExpectAssertionsCount = defineRule({
-	create(context) {
-		const additionalAssertionFunctions = context.options[0]?.additionalAssertionFunctions ?? [];
-		return { CallExpression(node) {
-			if (!isTestCaseCall(node)) return;
-			const callback = getTestCallback(node);
-			if (callback?.body?.type !== "BlockStatement") return;
-			const [firstStatement] = callback.body.body;
-			if (firstStatement?.type !== "ExpressionStatement" || firstStatement.expression.type !== "CallExpression" || !isExpectHasAssertionsCall(firstStatement.expression)) return;
-			const { deterministic, indeterminate, hasIndeterminate } = countExpectCalls(callback.body, additionalAssertionFunctions);
-			if (hasIndeterminate || indeterminate > 0 || deterministic === 0) return;
-			context.report({
-				data: { count: String(deterministic) },
-				fix(fixer) {
-					return fixer.replaceText(firstStatement, `expect.assertions(${deterministic});`);
-				},
-				messageId: "preferAssertionsCount",
-				node: firstStatement.expression
-			});
-		} };
-	},
-	meta: {
-		docs: {
-			description: "Prefer expect.assertions(n) over expect.hasAssertions() when the assertion count is known.",
-			recommended: true
-		},
-		fixable: "code",
-		messages: { preferAssertionsCount: "Use `expect.assertions({{count}})` instead of `expect.hasAssertions()` when the count is known" },
-		schema: [{
-			additionalProperties: false,
-			properties: { additionalAssertionFunctions: {
-				items: { type: "string" },
-				type: "array"
-			} },
-			type: "object"
-		}]
-	}
-});
-//#endregion
 //#region src/rules/prefer-hoisted-jsx-elements.ts
 function normalizeAdditionalHoistableComponents(rawOptions) {
 	if (!(isRecord$2(rawOptions) && "additionalHoistableComponents" in rawOptions)) return /* @__PURE__ */ new Set();
@@ -26042,7 +26028,6 @@ const smallRules = definePlugin({
 		"prefer-context-stack": preferContextStack,
 		"prefer-early-return": preferEarlyReturn,
 		"prefer-expect-assertions": preferExpectAssertions,
-		"prefer-expect-assertions-count": preferExpectAssertionsCount,
 		"prefer-hoisted-jsx-elements": preferHoistedJsxElements,
 		"prefer-hoisted-jsx-object-properties": preferHoistedJsxObjectProperties,
 		"prefer-idiv": preferIdiv,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pobammer-ts/small-rules",
-	"version": "1.1.0",
+	"version": "2.0.0",
 	"description": "Various Oxlint-native rules for linting roblox-ts projects.",
 	"keywords": [
 		"lint",
@@ -118,7 +118,7 @@
 		"vitiate": "0.3.0"
 	},
 	"peerDependencies": {
-		"typescript": "6"
+		"typescript": ">=5 <8"
 	},
 	"engines": {
 		"node": "^20.19.0 || >=22.12.0"