jsx-no-leaked-zero.js

/**
 * @fileoverview Prevent zero from being rendered on numerical condition
 * @author Mario Beltrán
 */

'use strict';

const docsUrl = require('../util/docsUrl');
const report = require('../util/report');
const isParenthesized = require('../util/ast').isParenthesized;

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

const messages = {
  noPotentialNumericEvaluation: 'Potential numeric evaluation resulting in an unintentionally rendered `0`',
};

const CAST_STRATEGY = 'cast';
const TERNARY_STRATEGY = 'ternary';
const DEFAULT_VALID_FIX_STRATEGIES = [TERNARY_STRATEGY, CAST_STRATEGY];

/**
 * @type {import('eslint').Rule.RuleModule}
 */
module.exports = {
  meta: {
    docs: {
      description: 'Prevent zero from being rendered on numerical condition',
      category: 'Possible Errors',
      recommended: false,
      url: docsUrl('jsx-no-leaked-zero'),
    },

    messages,

    fixable: 'code',
    schema: [
      {
        type: 'object',
        properties: {
          validFixStrategies: {
            type: 'array',
            items: {
              enum: [
                TERNARY_STRATEGY,
                CAST_STRATEGY,
              ],
            },
            uniqueItems: true,
            default: DEFAULT_VALID_FIX_STRATEGIES,
          },
        },
        additionalProperties: false,
      },
    ],
  },

  create(context) {
    const config = context.options[0] || {};
    const validFixStrategies = config.validFixStrategies || DEFAULT_VALID_FIX_STRATEGIES;
    const fixStrategy = validFixStrategies[0];
    const areBothStrategiesValid = validFixStrategies.length === 2;

    function trimLeftNode(node) {
      // Remove double unary expression (boolean cast), so we avoid trimming valid negations
      if (node.type === 'UnaryExpression' && node.argument.type === 'UnaryExpression') {
        return trimLeftNode(node.argument.argument);
      }

      return node;
    }

    function ruleFixer(fixer, reportedNode, leftNode, rightNode) {
      const sourceCode = context.getSourceCode();
      const rightSideText = sourceCode.getText(rightNode);

      if (fixStrategy === CAST_STRATEGY) {
        let leftSideText = sourceCode.getText(leftNode);
        if (isParenthesized(context, leftNode)) {
          leftSideText = `(${leftSideText})`;
        }

        const shouldPrefixDoubleNegation = leftNode.type !== 'UnaryExpression';

        return fixer.replaceText(reportedNode, `${shouldPrefixDoubleNegation ? '!!' : ''}${leftSideText} && ${rightSideText}`);
      }

      if (fixStrategy === TERNARY_STRATEGY) {
        let leftSideText = sourceCode.getText(trimLeftNode(leftNode));
        if (isParenthesized(context, leftNode)) {
          leftSideText = `(${leftSideText})`;
        }
        return fixer.replaceText(reportedNode, `${leftSideText} ? ${rightSideText} : null`);
      }

      throw new Error('Invalid value for "fixStrategy" option');
    }

    return {
      'JSXExpressionContainer > LogicalExpression[operator="&&"]'(node) {
        const leftSide = node.left;
        const VALID_LEFT_SIDE_EXPRESSIONS = ['UnaryExpression', 'BinaryExpression', 'CallExpression'];
        const isCastStrategyValid = areBothStrategiesValid || fixStrategy === CAST_STRATEGY;

        if (isCastStrategyValid && VALID_LEFT_SIDE_EXPRESSIONS.includes(leftSide.type)) {
          return;
        }

        report(context, messages.noPotentialNumericEvaluation, 'noPotentialNumericEvaluation', {
          node,
          fix(fixer) {
            return ruleFixer(fixer, node, leftSide, node.right);
          },
        });
      },

      'JSXExpressionContainer > ConditionalExpression'(node) {
        const isTernaryStrategyValid = areBothStrategiesValid || fixStrategy === TERNARY_STRATEGY;
        if (isTernaryStrategyValid) {
          return;
        }

        report(context, messages.noPotentialNumericEvaluation, 'noPotentialNumericEvaluation', {
          node,
          fix(fixer) {
            return ruleFixer(fixer, node, node.test, node.consequent);
          },
        });
      },
    };
  },
};