codtracker-js/node_modules/eslint/lib/rules/require-unicode-regexp.js

/**
 * @fileoverview Rule to enforce the use of `u` or `v` flag on regular expressions.
 * @author Toru Nagashima
 */

'use strict';

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const {
  CALL,
  CONSTRUCT,
  ReferenceTracker,
  getStringIfConstant,
} = require('@eslint-community/eslint-utils');
const astUtils = require('./utils/ast-utils.js');
const { isValidWithUnicodeFlag } = require('./utils/regular-expressions');

/**
 * Checks whether the flag configuration should be treated as a missing flag.
 * @param {"u"|"v"|undefined} requireFlag A particular flag to require
 * @param {string} flags The regex flags
 * @returns {boolean} Whether the flag configuration results in a missing flag.
 */
function checkFlags(requireFlag, flags) {
  let missingFlag;

  if (requireFlag === 'v') {
    missingFlag = !flags.includes('v');
  } else if (requireFlag === 'u') {
    missingFlag = !flags.includes('u');
  } else {
    missingFlag = !flags.includes('u') && !flags.includes('v');
  }

  return missingFlag;
}

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

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
  meta: {
    type: 'suggestion',

    docs: {
      description: 'Enforce the use of `u` or `v` flag on regular expressions',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/require-unicode-regexp',
    },

    hasSuggestions: true,

    messages: {
      addUFlag: "Add the 'u' flag.",
      addVFlag: "Add the 'v' flag.",
      requireUFlag: "Use the 'u' flag.",
      requireVFlag: "Use the 'v' flag.",
    },

    schema: [
      {
        type: 'object',
        properties: {
          requireFlag: {
            enum: ['u', 'v'],
          },
        },
        additionalProperties: false,
      },
    ],
  },

  create(context) {
    const sourceCode = context.sourceCode;

    const { requireFlag } = context.options[0] ?? {};

    return {
      'Literal[regex]'(node) {
        const flags = node.regex.flags || '';

        const missingFlag = checkFlags(requireFlag, flags);

        if (missingFlag) {
          context.report({
            messageId: requireFlag === 'v' ? 'requireVFlag' : 'requireUFlag',
            node,
            suggest:
              (
                isValidWithUnicodeFlag(
                  context.languageOptions.ecmaVersion,
                  node.regex.pattern,
                  requireFlag
                )
              ) ?
                [
                  {
                    fix(fixer) {
                      const replaceFlag = requireFlag ?? 'u';
                      const regex = sourceCode.getText(node);
                      const slashPos = regex.lastIndexOf('/');

                      if (requireFlag) {
                        const flag = requireFlag === 'u' ? 'v' : 'u';

                        if (regex.includes(flag, slashPos)) {
                          return fixer.replaceText(
                            node,
                            regex.slice(0, slashPos) +
                              regex.slice(slashPos).replace(flag, requireFlag)
                          );
                        }
                      }

                      return fixer.insertTextAfter(node, replaceFlag);
                    },
                    messageId: requireFlag === 'v' ? 'addVFlag' : 'addUFlag',
                  },
                ]
              : null,
          });
        }
      },

      Program(node) {
        const scope = sourceCode.getScope(node);
        const tracker = new ReferenceTracker(scope);
        const trackMap = {
          RegExp: { [CALL]: true, [CONSTRUCT]: true },
        };

        for (const { node: refNode } of tracker.iterateGlobalReferences(
          trackMap
        )) {
          const [patternNode, flagsNode] = refNode.arguments;

          if (patternNode && patternNode.type === 'SpreadElement') {
            continue;
          }
          const pattern = getStringIfConstant(patternNode, scope);
          const flags = getStringIfConstant(flagsNode, scope);

          let missingFlag = !flagsNode;

          if (typeof flags === 'string') {
            missingFlag = checkFlags(requireFlag, flags);
          }

          if (missingFlag) {
            context.report({
              messageId: requireFlag === 'v' ? 'requireVFlag' : 'requireUFlag',
              node: refNode,
              suggest:
                (
                  typeof pattern === 'string' &&
                  isValidWithUnicodeFlag(
                    context.languageOptions.ecmaVersion,
                    pattern,
                    requireFlag
                  )
                ) ?
                  [
                    {
                      fix(fixer) {
                        const replaceFlag = requireFlag ?? 'u';

                        if (flagsNode) {
                          if (
                            (flagsNode.type === 'Literal' &&
                              typeof flagsNode.value === 'string') ||
                            flagsNode.type === 'TemplateLiteral'
                          ) {
                            const flagsNodeText = sourceCode.getText(flagsNode);
                            const flag = requireFlag === 'u' ? 'v' : 'u';

                            if (flags.includes(flag)) {
                              // Avoid replacing "u" in escapes like `\uXXXX`
                              if (
                                flagsNode.type === 'Literal' &&
                                flagsNode.raw.includes('\\')
                              ) {
                                return null;
                              }

                              // Avoid replacing "u" in expressions like "`${regularFlags}g`"
                              if (
                                flagsNode.type === 'TemplateLiteral' &&
                                (flagsNode.expressions.length ||
                                  flagsNode.quasis.some(({ value: { raw } }) =>
                                    raw.includes('\\')
                                  ))
                              ) {
                                return null;
                              }

                              return fixer.replaceText(
                                flagsNode,
                                flagsNodeText.replace(flag, replaceFlag)
                              );
                            }

                            return fixer.replaceText(
                              flagsNode,
                              [
                                flagsNodeText.slice(
                                  0,
                                  flagsNodeText.length - 1
                                ),
                                flagsNodeText.slice(flagsNodeText.length - 1),
                              ].join(replaceFlag)
                            );
                          }

                          // We intentionally don't suggest concatenating + "u" to non-literals
                          return null;
                        }

                        const penultimateToken = sourceCode.getLastToken(
                          refNode,
                          { skip: 1 }
                        ); // skip closing parenthesis

                        return fixer.insertTextAfter(
                          penultimateToken,
                          astUtils.isCommaToken(penultimateToken) ?
                            ` "${replaceFlag}",`
                          : `, "${replaceFlag}"`
                        );
                      },
                      messageId: requireFlag === 'v' ? 'addVFlag' : 'addUFlag',
                    },
                  ]
                : null,
            });
          }
        }
      },
    };
  },
};