@pobammer-ts/small-rules 1.0.0 → 2.0.0

package/README.md

@@ -0,0 +1,35 @@
+# `@pobammer-ts/small-rules`
+
+A collection of [Oxlint](https://oxc.rs)-native rules for linting [roblox-ts](https://roblox-ts.com/) projects.
+
+## Installation
+
+```bash
+ni -D @pobammer-ts/small-rules
+```
+
+This package is an [Oxlint plugin](https://oxc.rs/docs/guide/usage/plugins) and must be used with [Oxlint](https://oxc.rs) v1.69.0 or later. It also requires TypeScript 6 and Node.js `^20.19.0` / `>=22.12.0`.
+
+## Configuration
+
+Register the plugin in your `.oxlintrc.json` and enable the rules you want:
+
+```json
+{
+  "plugins": ["@pobammer-ts/small-rules"],
+  "rules": {
+    "small-rules/no-print": "error",
+    "small-rules/no-warn": "error"
+  }
+}
+```
+
+All rules are namespaced under the `small-rules/` prefix. Pick the subset that fits your project — there is no bulk opt-in.
+
+## Rules
+
+Full rule documentation is forthcoming alongside the project docs site.
+
+## License
+
+MIT © HowManySmall

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

@@ -1230,92 +1230,25 @@ function addScore(current, addition, config, ceiling) {
 	if (!config.performanceMode) return nextScore;
 	return Math.min(nextScore, ceiling);
 }
+function addStructuralScore(current, node, depth, config, cache, depthMultiplierCache, ceiling, bonus = 0) {
+	return addScore(current, calculateStructuralComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) + bonus, config, ceiling);
+}
 function addNestedTypeAnnotationScores(current, members, depth, config, cache, depthMultiplierCache, ceiling) {
 	let score = current;
 	for (const member of members) {
 		const typeAnnotation = getNestedTypeAnnotation(member);
 		if (typeAnnotation === void 0) continue;
-		score = addScore(score, calculateStructuralComplexity(typeAnnotation, depth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
+		score = addStructuralScore(score, typeAnnotation, depth, config, cache, depthMultiplierCache, ceiling);
 	}
 	return score;
 }
 function getDepthMultiplier(depth, cache) {
 	const cached = cache.get(depth);
 	if (cached !== void 0) return cached;
-	const computed = Math.max(1, Math.log2(depth + 1));
+	const computed = Math.log2(depth + 1);
 	cache.set(depth, computed);
 	return computed;
 }
-function calculateChildComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	return calculateStructuralComplexity(node, depth, config, cache, depthMultiplierCache, ceiling);
-}
-function addChildComplexity(score, node, depth, config, cache, depthMultiplierCache, ceiling) {
-	return addScore(score, calculateChildComplexity(node, depth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
-}
-function getDefinedNodes(nodes) {
-	return nodes.filter((node) => node !== void 0);
-}
-function addChildComplexities(score, nodes, depth, config, cache, depthMultiplierCache, ceiling) {
-	let nextScore = score;
-	for (const child of nodes) nextScore = addChildComplexity(nextScore, child, depth, config, cache, depthMultiplierCache, ceiling);
-	return nextScore;
-}
-function calculateArrayTypeComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 1;
-	const elementType = getNodeValue(node, "elementType");
-	if (elementType === void 0) return 1;
-	return addScore(calculateChildComplexity(elementType, depth, config, cache, depthMultiplierCache, ceiling), 1, config, ceiling);
-}
-function calculateConditionalTypeComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 3;
-	return addChildComplexities(3, getDefinedNodes([
-		getNodeValue(node, "checkType"),
-		getNodeValue(node, "extendsType"),
-		getNodeValue(node, "trueType"),
-		getNodeValue(node, "falseType")
-	]), depth, config, cache, depthMultiplierCache, ceiling);
-}
-function calculateFunctionTypeComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 2;
-	return addChildComplexities(2, getDefinedNodes([...getNodeArrayValue(node, "params")?.map(getNestedTypeAnnotation) ?? [], getReturnTypeAnnotation$1(node)]), depth, config, cache, depthMultiplierCache, ceiling);
-}
-function calculateInterfaceComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return config.interfacePenalty;
-	const extendsLength = getNodeArrayValue(node, "extends")?.length ?? 0;
-	const body = getNodeValue(node, "body");
-	const members = body !== void 0 && isRecord$1(body) ? getNodeArrayValue(body, "body") ?? [] : [];
-	let score = config.interfacePenalty;
-	if (extendsLength > 0) score = addScore(score, extendsLength * 5, config, ceiling);
-	score = addScore(score, members.length * 2, config, ceiling);
-	return addNestedTypeAnnotationScores(score, members, depth, config, cache, depthMultiplierCache, ceiling);
-}
-function calculateTypeListComplexity(node, depth, typePenalty, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 0;
-	const types = getNodeArrayValue(node, "types") ?? [];
-	return addScore(addChildComplexities(0, types, depth, config, cache, depthMultiplierCache, ceiling), typePenalty(types.length), config, ceiling);
-}
-function calculateMappedTypeComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 5;
-	return addChildComplexities(5, getDefinedNodes([getNodeValue(node, "constraint"), getNodeValue(node, "typeAnnotation")]), depth, config, cache, depthMultiplierCache, ceiling);
-}
-function calculateTupleTypeComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 0;
-	const elementTypes = getNodeArrayValue(node, "elementTypes") ?? [];
-	return addScore(addChildComplexities(1, elementTypes.filter((element) => element.type !== "TSRestType" && element.type !== "TSOptionalType"), depth, config, cache, depthMultiplierCache, ceiling), 1.5 * elementTypes.length, config, ceiling);
-}
-function calculateTypeLiteralComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 0;
-	const members = getNodeArrayValue(node, "members") ?? [];
-	return addNestedTypeAnnotationScores(2 + members.length * .5, members, depth, config, cache, depthMultiplierCache, ceiling);
-}
-function calculateTypeReferenceComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
-	if (!isRecord$1(node)) return 2;
-	const typeArguments = getNodeValue(node, "typeArguments");
-	const parameters = typeArguments !== void 0 && isRecord$1(typeArguments) ? getNodeArrayValue(typeArguments, "params") ?? [] : [];
-	let score = 2;
-	for (const parameter of parameters) score = addScore(score, calculateChildComplexity(parameter, depth, config, cache, depthMultiplierCache, ceiling) + 2, config, ceiling);
-	return score;
-}
 function calculateStructuralComplexity(node, depth, config, cache, depthMultiplierCache, ceiling) {
 	const cached = cache.nodeCache.get(node);
 	if (cached !== void 0) return cached;
@@ -1328,7 +1261,14 @@ function calculateStructuralComplexity(node, depth, config, cache, depthMultipli
 		case "TSNeverKeyword":
 		case "TSUnknownKeyword": break;
 		case "TSArrayType":
-			score = calculateArrayTypeComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			if (isRecord$1(node)) {
+				const elementType = getNodeValue(node, "elementType");
+				if (elementType !== void 0) {
+					score = addScore(calculateStructuralComplexity(elementType, nextDepth, config, cache, depthMultiplierCache, ceiling), 1, config, ceiling);
+					break;
+				}
+			}
+			score = 1;
 			break;
 		case "TSBigIntKeyword":
 		case "TSBooleanKeyword":
@@ -1341,32 +1281,91 @@ function calculateStructuralComplexity(node, depth, config, cache, depthMultipli
 			score = 1;
 			break;
 		case "TSConditionalType":
-			score = calculateConditionalTypeComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			score = 3;
+			if (isRecord$1(node)) {
+				const checkType = getNodeValue(node, "checkType");
+				const extendsType = getNodeValue(node, "extendsType");
+				const trueType = getNodeValue(node, "trueType");
+				const falseType = getNodeValue(node, "falseType");
+				if (checkType !== void 0) score = addScore(score, calculateStructuralComplexity(checkType, nextDepth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
+				if (extendsType !== void 0) score = addScore(score, calculateStructuralComplexity(extendsType, nextDepth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
+				if (trueType !== void 0) score = addScore(score, calculateStructuralComplexity(trueType, nextDepth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
+				if (falseType !== void 0) score = addScore(score, calculateStructuralComplexity(falseType, nextDepth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
+			}
 			break;
 		case "TSFunctionType":
 		case "TSMethodSignature":
-			score = calculateFunctionTypeComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			score = 2;
+			if (isRecord$1(node)) {
+				const parameters = getNodeArrayValue(node, "params") ?? [];
+				for (const parameter of parameters) {
+					const typeAnnotation = getNestedTypeAnnotation(parameter);
+					if (typeAnnotation === void 0) continue;
+					score = addScore(score, calculateStructuralComplexity(typeAnnotation, nextDepth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
+				}
+				const returnType = getReturnTypeAnnotation$1(node);
+				if (returnType !== void 0) score = addScore(score, calculateStructuralComplexity(returnType, nextDepth, config, cache, depthMultiplierCache, ceiling), config, ceiling);
+			}
 			break;
 		case "TSInterfaceDeclaration":
-			score = calculateInterfaceComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			score = config.interfacePenalty;
+			if (isRecord$1(node)) {
+				const extendsLength = getNodeArrayValue(node, "extends")?.length;
+				if (extendsLength !== void 0 && extendsLength > 0) score = addScore(score, extendsLength * 5, config, ceiling);
+				const body = getNodeValue(node, "body");
+				const members = body !== void 0 && isRecord$1(body) ? getNodeArrayValue(body, "body") ?? [] : [];
+				score = addScore(score, members.length * 2, config, ceiling);
+				score = addNestedTypeAnnotationScores(score, members, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			}
 			break;
 		case "TSIntersectionType":
-			score = calculateTypeListComplexity(node, nextDepth, (typeCount) => 3 * typeCount, config, cache, depthMultiplierCache, ceiling);
+			if (isRecord$1(node)) {
+				const types = getNodeArrayValue(node, "types") ?? [];
+				for (const type of types) score = addStructuralScore(score, type, nextDepth, config, cache, depthMultiplierCache, ceiling);
+				score = addScore(score, 3 * types.length, config, ceiling);
+			}
 			break;
 		case "TSMappedType":
-			score = calculateMappedTypeComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			score = 5;
+			if (isRecord$1(node)) {
+				const constraint = getNodeValue(node, "constraint");
+				if (constraint !== void 0) score = addStructuralScore(score, constraint, nextDepth, config, cache, depthMultiplierCache, ceiling);
+				const typeAnnotation = getNodeValue(node, "typeAnnotation");
+				if (typeAnnotation !== void 0) score = addStructuralScore(score, typeAnnotation, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			}
 			break;
 		case "TSTupleType":
-			score = calculateTupleTypeComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			if (isRecord$1(node)) {
+				const elementTypes = getNodeArrayValue(node, "elementTypes") ?? [];
+				score = 1;
+				for (const element of elementTypes) {
+					if (element.type === "TSRestType" || element.type === "TSOptionalType") continue;
+					score = addStructuralScore(score, element, nextDepth, config, cache, depthMultiplierCache, ceiling);
+				}
+				score = addScore(score, 1.5 * elementTypes.length, config, ceiling);
+			}
 			break;
 		case "TSTypeLiteral":
-			score = calculateTypeLiteralComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			if (isRecord$1(node)) {
+				const members = getNodeArrayValue(node, "members") ?? [];
+				score = 2 + members.length * .5;
+				score = addNestedTypeAnnotationScores(score, members, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			}
 			break;
 		case "TSTypeReference":
-			score = calculateTypeReferenceComplexity(node, nextDepth, config, cache, depthMultiplierCache, ceiling);
+			score = 2;
+			if (isRecord$1(node)) {
+				const typeArguments = getNodeValue(node, "typeArguments");
+				const parameters = typeArguments !== void 0 && isRecord$1(typeArguments) ? getNodeArrayValue(typeArguments, "params") ?? [] : [];
+				for (const parameter of parameters) score = addStructuralScore(score, parameter, nextDepth, config, cache, depthMultiplierCache, ceiling, 2);
+			}
 			break;
 		case "TSUnionType":
-			score = calculateTypeListComplexity(node, nextDepth, (typeCount) => 2 * (typeCount - 1), config, cache, depthMultiplierCache, ceiling);
+			if (isRecord$1(node)) {
+				const types = getNodeArrayValue(node, "types") ?? [];
+				for (const type of types) score = addStructuralScore(score, type, nextDepth, config, cache, depthMultiplierCache, ceiling);
+				score = addScore(score, 2 * (types.length - 1), config, ceiling);
+			}
 			break;
 		default: score = 1;
 	}
@@ -20281,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;
@@ -20335,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;
 }
@@ -20449,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);
@@ -20461,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"
@@ -20477,6 +20498,10 @@ const preferExpectAssertions = defineRule({
 		schema: [{
 			additionalProperties: false,
 			properties: {
+				additionalAssertionFunctions: {
+					items: { type: "string" },
+					type: "array"
+				},
 				additionalExpectCallNames: {
 					items: { type: "string" },
 					type: "array"
@@ -20491,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();
@@ -26043,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.0.0",
+	"version": "2.0.0",
 	"description": "Various Oxlint-native rules for linting roblox-ts projects.",
 	"keywords": [
 		"lint",
@@ -106,7 +106,7 @@
 		"jiti": "2.7.0",
 		"jscpd": "5.0.7",
 		"knip": "6.16.1",
-		"oxfmt": "0.54.0",
+		"oxfmt": "0.55.0",
 		"oxlint": "1.69.0",
 		"oxlint-tsgolint": "0.23.0",
 		"package-manager-detector": "1.6.0",
@@ -118,7 +118,7 @@
 		"vitiate": "0.3.0"
 	},
 	"peerDependencies": {
-		"typescript": "6"
+		"typescript": ">=5 <8"
 	},
 	"engines": {
 		"node": "^20.19.0 || >=22.12.0"