@pobammer-ts/small-rules 1.0.0 → 1.1.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.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;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pobammer-ts/small-rules",
-	"version": "1.0.0",
+	"version": "1.1.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",