eslint-plugin-ziloen 0.1.20 → 0.1.22

package/dist/index.d.ts

@@ -1,6 +1,3 @@
 import { ESLint } from "eslint";
-
-//#region src/index.d.ts
 declare const _default: ESLint.Plugin;
-//#endregion
 export { _default as default };

package/dist/index.js

@@ -1,11 +1,10 @@
-import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
-import { TypeFlags } from "typescript";
+import { ASTUtils, AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 
-//#region src/utils.ts
+// src/utils.ts
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-//#endregion
-//#region src/rules/generic-spacing.ts
+// src/rules/generic-spacing.ts
 const RULE_NAME$1 = "generic-spacing";
 const messageId = "genericSpacingMismatch";
 function removeSpaceAround(node, context) {
@@ -85,31 +84,14 @@ const genericSpacing = createEslintRule({
 	}
 });
 
-//#endregion
-//#region src/tsutils.ts
-function isUnionType(type) {
-	return (type.flags & TypeFlags.Union) !== 0;
-}
-/** Returns all types of a union type or an array containing `type` itself if it's no union type. */
-function unionTypeParts(type) {
-	return isUnionType(type) ? type.types : [type];
-}
-function isTypeFlagSet(type, flag) {
-	return (type.flags & flag) !== 0;
-}
-/**
-* Resolves the given node's type. Will resolve to the type's generic constraint, if it has one.
-*/
-function getConstrainedTypeAtLocation(checker, node) {
-	const nodeType = checker.getTypeAtLocation(node);
-	return checker.getBaseConstraintOfType(nodeType) ?? nodeType;
-}
-
-//#endregion
-//#region src/rules/jsx-strict-logical-expressions.ts
+// src/rules/jsx-strict-logical-expressions.ts
 /**
 * https://github.com/hluisson/eslint-plugin-jsx-expressions
 */
+const messages = {
+	conditionErrorFalseyString: "Potentially falsy string in logical AND expression. Please use a boolean.",
+	conditionErrorFalseyNumber: "Potentially falsy number or bigint in logical AND expression. Please use a boolean."
+};
 const RULE_NAME = "jsx-strict-logical-expressions";
 const jsxStrictLogicalExpressions = createEslintRule({
 	name: RULE_NAME,
@@ -118,9 +100,9 @@ const jsxStrictLogicalExpressions = createEslintRule({
 		allowNumber: false
 	}],
 	meta: {
-		docs: { description: "Forbid non-boolean falsey values in inline expressions" },
-		fixable: "code",
 		type: "problem",
+		fixable: "code",
+		docs: { description: "Forbid non-boolean falsy values in JSX logical AND expressions" },
 		schema: [{
 			type: "object",
 			properties: {
@@ -129,57 +111,102 @@ const jsxStrictLogicalExpressions = createEslintRule({
 			},
 			additionalProperties: false
 		}],
-		messages: {
-			conditionErrorFalseyString: "Potentially falsey string in logical AND expression. Please use boolean.",
-			conditionErrorFalseyNumber: "Potentially falsey number in logical AND expression. Please use boolean."
-		}
+		messages
 	},
-	create(context, [options]) {
-		const parserServices = ESLintUtils.getParserServices(context);
-		const typeChecker = parserServices.program.getTypeChecker();
-		function checkIdentifier(node) {
-			const types = unionTypeParts(getConstrainedTypeAtLocation(typeChecker, parserServices.esTreeNodeToTSNodeMap.get(node)));
-			const hasPotentiallyFalseyString = types.some((type) => isTypeFlagSet(type, TypeFlags.StringLike) && (!type.isStringLiteral() || type.value === ""));
-			if (!options.allowString && hasPotentiallyFalseyString) return "conditionErrorFalseyString";
-			const hasPotentiallyFalseyNumber = types.some((type) => isTypeFlagSet(type, TypeFlags.NumberLike | TypeFlags.BigIntLike) && (!type.isNumberLiteral() || type.value === 0));
-			if (!options.allowNumber && hasPotentiallyFalseyNumber) return "conditionErrorFalseyNumber";
-		}
-		function checkAndReportIdentifier(node, fixNode) {
-			const errorId = checkIdentifier(node);
-			if (errorId) context.report({
-				node,
-				messageId: errorId,
-				fix: (fixer) => fixer.insertTextBefore(fixNode, "!!")
-			});
-		}
-		function determineNode(originalNode) {
-			let nodeToEvaluate = originalNode;
-			if (nodeToEvaluate.type === TSESTree.AST_NODE_TYPES.ChainExpression) nodeToEvaluate = nodeToEvaluate.expression;
-			if (nodeToEvaluate.type === TSESTree.AST_NODE_TYPES.MemberExpression && nodeToEvaluate.property.type !== TSESTree.AST_NODE_TYPES.PrivateIdentifier) nodeToEvaluate = nodeToEvaluate.property;
-			return nodeToEvaluate;
+	create(context, [{ allowString = false, allowNumber = false }]) {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		const stringType = checker.getStringType();
+		const numberType = checker.getNumberType();
+		const bigintType = checker.getBigIntType();
+		/**
+		* Returns true when `value` is TypeScript's internal representation
+		* of a non-zero bigint literal.
+		*/
+		function isNonZeroBigIntLiteralValue(value) {
+			return typeof value === "object" && value !== null && "base10Value" in value && typeof value.base10Value === "string" && value.base10Value !== "0";
 		}
-		function checkLogicalExpression(expressionNode, checkRightNode) {
-			const leftNode = determineNode(expressionNode.left);
-			if (leftNode.type === TSESTree.AST_NODE_TYPES.LogicalExpression) checkLogicalExpression(leftNode, true);
-			else if (leftNode.type === TSESTree.AST_NODE_TYPES.Identifier) checkAndReportIdentifier(leftNode, expressionNode.left);
-			if (checkRightNode) {
-				const rightNode = determineNode(expressionNode.right);
-				if (rightNode.type === TSESTree.AST_NODE_TYPES.Identifier) checkAndReportIdentifier(rightNode, expressionNode.right);
+		/**
+		* Determines which diagnostic, if any, applies to a condition.
+		*/
+		function getConditionError(node) {
+			const type = getConstrainedTypeAtLocation(services, node);
+			const typeParts = type.isUnion() ? type.types : [type];
+			let hasPotentiallyFalsyString = false;
+			let hasPotentiallyFalsyNumber = false;
+			for (const typePart of typeParts) {
+				if (typePart.isStringLiteral()) {
+					hasPotentiallyFalsyString ||= typePart.value === "";
+					continue;
+				}
+				if (typePart.isNumberLiteral()) {
+					hasPotentiallyFalsyNumber ||= typePart.value === 0;
+					continue;
+				}
+				const baseType = checker.getBaseTypeOfLiteralType(typePart);
+				if (baseType === stringType) {
+					hasPotentiallyFalsyString = true;
+					continue;
+				}
+				if (baseType === numberType) {
+					hasPotentiallyFalsyNumber = true;
+					continue;
+				}
+				if (baseType === bigintType) {
+					const value = "value" in typePart ? typePart.value : void 0;
+					hasPotentiallyFalsyNumber ||= !isNonZeroBigIntLiteralValue(value);
+				}
 			}
+			if (!allowString && hasPotentiallyFalsyString) return "conditionErrorFalseyString";
+			if (!allowNumber && hasPotentiallyFalsyNumber) return "conditionErrorFalseyNumber";
 		}
-		function checkJSXExpression(node) {
-			if (node.expression.type === TSESTree.AST_NODE_TYPES.LogicalExpression && node.expression.operator === "&&") checkLogicalExpression(node.expression, false);
+		/**
+		* Flattens:
+		*
+		*     a && b && <Component />
+		*
+		* into:
+		*
+		*     [a, b, <Component />]
+		*
+		* Every operand except the final one acts as a condition.
+		*/
+		function collectAndOperands(node, operands = []) {
+			if (node.type === AST_NODE_TYPES.LogicalExpression && node.operator === "&&") {
+				collectAndOperands(node.left, operands);
+				collectAndOperands(node.right, operands);
+			} else operands.push(node);
+			return operands;
+		}
+		function reportCondition(node) {
+			const messageId = getConditionError(node);
+			if (!messageId) return;
+			context.report({
+				node,
+				messageId,
+				fix: (fixer) => {
+					if (node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.Literal || node.type === AST_NODE_TYPES.MemberExpression || node.type === AST_NODE_TYPES.CallExpression || node.type === AST_NODE_TYPES.ChainExpression) return fixer.insertTextBefore(node, "!!");
+					if (ASTUtils.isParenthesized(node, context.sourceCode)) {
+						const openingParen = context.sourceCode.getTokenBefore(node);
+						if (openingParen?.value === "(") return fixer.insertTextBefore(openingParen, "!!");
+					}
+					return [fixer.insertTextBefore(node, "!!("), fixer.insertTextAfter(node, ")")];
+				}
+			});
 		}
-		return { JSXExpressionContainer: checkJSXExpression };
+		return { JSXExpressionContainer(node) {
+			const expression = node.expression;
+			if (expression.type !== AST_NODE_TYPES.LogicalExpression || expression.operator !== "&&") return;
+			const operands = collectAndOperands(expression);
+			for (let index = 0; index < operands.length - 1; index += 1) reportCondition(operands[index]);
+		} };
 	}
 });
 
-//#endregion
-//#region src/index.ts
+// src/index.ts
 const ziloen = { rules: {
 	"generic-spacing": genericSpacing,
 	"jsx-strict-logical-expressions": jsxStrictLogicalExpressions
 } };
 
-//#endregion
 export { ziloen as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ziloen",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -14,20 +14,22 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "8.58.0"
+    "@typescript-eslint/type-utils": "^8.72.2",
+    "@typescript-eslint/utils": "8.72.2"
   },
   "devDependencies": {
     "@types/eslint": "^9.6.1",
-    "@types/node": "^24.1.0",
-    "@typescript-eslint/parser": "8.58.0",
-    "bumpp": "^11.0.1",
-    "eslint": "^10.2.0",
-    "eslint-vitest-rule-tester": "^3.1.0",
-    "tsdown": "^0.21.7",
+    "@types/node": "^26.6.6",
+    "@typescript-eslint/parser": "8.72.2",
+    "bumpp": "^12.3.0",
+    "eslint": "^10.14.0",
+    "eslint-vitest-rule-tester": "^3.2.0",
+    "tsdown": "^0.23.7",
     "typescript": "6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^5.1.0"
   },
   "peerDependencies": {
     "typescript": ">=6.0.0"
-  }
+  },
+  "packageManager": "pnpm@12.18.0+sha512.9d7882d5dc82147ecfc4e062aa34834e0ad0296710a1837a1115ae012127d36b7109e321ac1598a1dd0a65597681b1e99917e12ed0d749eae91187943363beb3"
 }